LLParser.cpp revision e30e678865b8dc1b69ef1c26e7567ffd1300553c
1//===-- LLParser.cpp - Parser Class ---------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines the parser class for .ll files. 11// 12//===----------------------------------------------------------------------===// 13 14#include "LLParser.h" 15#include "llvm/AutoUpgrade.h" 16#include "llvm/CallingConv.h" 17#include "llvm/Constants.h" 18#include "llvm/DerivedTypes.h" 19#include "llvm/InlineAsm.h" 20#include "llvm/Instructions.h" 21#include "llvm/LLVMContext.h" 22#include "llvm/Metadata.h" 23#include "llvm/Module.h" 24#include "llvm/Operator.h" 25#include "llvm/ValueSymbolTable.h" 26#include "llvm/ADT/SmallPtrSet.h" 27#include "llvm/ADT/StringExtras.h" 28#include "llvm/Support/ErrorHandling.h" 29#include "llvm/Support/raw_ostream.h" 30using namespace llvm; 31 32namespace llvm { 33 /// ValID - Represents a reference of a definition of some sort with no type. 34 /// There are several cases where we have to parse the value but where the 35 /// type can depend on later context. This may either be a numeric reference 36 /// or a symbolic (%var) reference. This is just a discriminated union. 37 struct ValID { 38 enum { 39 t_LocalID, t_GlobalID, // ID in UIntVal. 40 t_LocalName, t_GlobalName, // Name in StrVal. 41 t_APSInt, t_APFloat, // Value in APSIntVal/APFloatVal. 42 t_Null, t_Undef, t_Zero, // No value. 43 t_EmptyArray, // No value: [] 44 t_Constant, // Value in ConstantVal. 45 t_InlineAsm, // Value in StrVal/StrVal2/UIntVal. 46 t_Metadata // Value in MetadataVal. 47 } Kind; 48 49 LLParser::LocTy Loc; 50 unsigned UIntVal; 51 std::string StrVal, StrVal2; 52 APSInt APSIntVal; 53 APFloat APFloatVal; 54 Constant *ConstantVal; 55 MetadataBase *MetadataVal; 56 ValID() : APFloatVal(0.0) {} 57 }; 58} 59 60/// Run: module ::= toplevelentity* 61bool LLParser::Run() { 62 // Prime the lexer. 63 Lex.Lex(); 64 65 return ParseTopLevelEntities() || 66 ValidateEndOfModule(); 67} 68 69/// ValidateEndOfModule - Do final validity and sanity checks at the end of the 70/// module. 71bool LLParser::ValidateEndOfModule() { 72 if (!ForwardRefTypes.empty()) 73 return Error(ForwardRefTypes.begin()->second.second, 74 "use of undefined type named '" + 75 ForwardRefTypes.begin()->first + "'"); 76 if (!ForwardRefTypeIDs.empty()) 77 return Error(ForwardRefTypeIDs.begin()->second.second, 78 "use of undefined type '%" + 79 utostr(ForwardRefTypeIDs.begin()->first) + "'"); 80 81 if (!ForwardRefVals.empty()) 82 return Error(ForwardRefVals.begin()->second.second, 83 "use of undefined value '@" + ForwardRefVals.begin()->first + 84 "'"); 85 86 if (!ForwardRefValIDs.empty()) 87 return Error(ForwardRefValIDs.begin()->second.second, 88 "use of undefined value '@" + 89 utostr(ForwardRefValIDs.begin()->first) + "'"); 90 91 if (!ForwardRefMDNodes.empty()) 92 return Error(ForwardRefMDNodes.begin()->second.second, 93 "use of undefined metadata '!" + 94 utostr(ForwardRefMDNodes.begin()->first) + "'"); 95 96 97 // Look for intrinsic functions and CallInst that need to be upgraded 98 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ) 99 UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove 100 101 // Check debug info intrinsics. 102 CheckDebugInfoIntrinsics(M); 103 return false; 104} 105 106//===----------------------------------------------------------------------===// 107// Top-Level Entities 108//===----------------------------------------------------------------------===// 109 110bool LLParser::ParseTopLevelEntities() { 111 while (1) { 112 switch (Lex.getKind()) { 113 default: return TokError("expected top-level entity"); 114 case lltok::Eof: return false; 115 //case lltok::kw_define: 116 case lltok::kw_declare: if (ParseDeclare()) return true; break; 117 case lltok::kw_define: if (ParseDefine()) return true; break; 118 case lltok::kw_module: if (ParseModuleAsm()) return true; break; 119 case lltok::kw_target: if (ParseTargetDefinition()) return true; break; 120 case lltok::kw_deplibs: if (ParseDepLibs()) return true; break; 121 case lltok::kw_type: if (ParseUnnamedType()) return true; break; 122 case lltok::LocalVarID: if (ParseUnnamedType()) return true; break; 123 case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0 124 case lltok::LocalVar: if (ParseNamedType()) return true; break; 125 case lltok::GlobalID: if (ParseUnnamedGlobal()) return true; break; 126 case lltok::GlobalVar: if (ParseNamedGlobal()) return true; break; 127 case lltok::Metadata: if (ParseStandaloneMetadata()) return true; break; 128 case lltok::NamedMD: if (ParseNamedMetadata()) return true; break; 129 130 // The Global variable production with no name can have many different 131 // optional leading prefixes, the production is: 132 // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalThreadLocal 133 // OptionalAddrSpace ('constant'|'global') ... 134 case lltok::kw_private : // OptionalLinkage 135 case lltok::kw_linker_private: // OptionalLinkage 136 case lltok::kw_internal: // OptionalLinkage 137 case lltok::kw_weak: // OptionalLinkage 138 case lltok::kw_weak_odr: // OptionalLinkage 139 case lltok::kw_linkonce: // OptionalLinkage 140 case lltok::kw_linkonce_odr: // OptionalLinkage 141 case lltok::kw_appending: // OptionalLinkage 142 case lltok::kw_dllexport: // OptionalLinkage 143 case lltok::kw_common: // OptionalLinkage 144 case lltok::kw_dllimport: // OptionalLinkage 145 case lltok::kw_extern_weak: // OptionalLinkage 146 case lltok::kw_external: { // OptionalLinkage 147 unsigned Linkage, Visibility; 148 if (ParseOptionalLinkage(Linkage) || 149 ParseOptionalVisibility(Visibility) || 150 ParseGlobal("", SMLoc(), Linkage, true, Visibility)) 151 return true; 152 break; 153 } 154 case lltok::kw_default: // OptionalVisibility 155 case lltok::kw_hidden: // OptionalVisibility 156 case lltok::kw_protected: { // OptionalVisibility 157 unsigned Visibility; 158 if (ParseOptionalVisibility(Visibility) || 159 ParseGlobal("", SMLoc(), 0, false, Visibility)) 160 return true; 161 break; 162 } 163 164 case lltok::kw_thread_local: // OptionalThreadLocal 165 case lltok::kw_addrspace: // OptionalAddrSpace 166 case lltok::kw_constant: // GlobalType 167 case lltok::kw_global: // GlobalType 168 if (ParseGlobal("", SMLoc(), 0, false, 0)) return true; 169 break; 170 } 171 } 172} 173 174 175/// toplevelentity 176/// ::= 'module' 'asm' STRINGCONSTANT 177bool LLParser::ParseModuleAsm() { 178 assert(Lex.getKind() == lltok::kw_module); 179 Lex.Lex(); 180 181 std::string AsmStr; 182 if (ParseToken(lltok::kw_asm, "expected 'module asm'") || 183 ParseStringConstant(AsmStr)) return true; 184 185 const std::string &AsmSoFar = M->getModuleInlineAsm(); 186 if (AsmSoFar.empty()) 187 M->setModuleInlineAsm(AsmStr); 188 else 189 M->setModuleInlineAsm(AsmSoFar+"\n"+AsmStr); 190 return false; 191} 192 193/// toplevelentity 194/// ::= 'target' 'triple' '=' STRINGCONSTANT 195/// ::= 'target' 'datalayout' '=' STRINGCONSTANT 196bool LLParser::ParseTargetDefinition() { 197 assert(Lex.getKind() == lltok::kw_target); 198 std::string Str; 199 switch (Lex.Lex()) { 200 default: return TokError("unknown target property"); 201 case lltok::kw_triple: 202 Lex.Lex(); 203 if (ParseToken(lltok::equal, "expected '=' after target triple") || 204 ParseStringConstant(Str)) 205 return true; 206 M->setTargetTriple(Str); 207 return false; 208 case lltok::kw_datalayout: 209 Lex.Lex(); 210 if (ParseToken(lltok::equal, "expected '=' after target datalayout") || 211 ParseStringConstant(Str)) 212 return true; 213 M->setDataLayout(Str); 214 return false; 215 } 216} 217 218/// toplevelentity 219/// ::= 'deplibs' '=' '[' ']' 220/// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']' 221bool LLParser::ParseDepLibs() { 222 assert(Lex.getKind() == lltok::kw_deplibs); 223 Lex.Lex(); 224 if (ParseToken(lltok::equal, "expected '=' after deplibs") || 225 ParseToken(lltok::lsquare, "expected '=' after deplibs")) 226 return true; 227 228 if (EatIfPresent(lltok::rsquare)) 229 return false; 230 231 std::string Str; 232 if (ParseStringConstant(Str)) return true; 233 M->addLibrary(Str); 234 235 while (EatIfPresent(lltok::comma)) { 236 if (ParseStringConstant(Str)) return true; 237 M->addLibrary(Str); 238 } 239 240 return ParseToken(lltok::rsquare, "expected ']' at end of list"); 241} 242 243/// ParseUnnamedType: 244/// ::= 'type' type 245/// ::= LocalVarID '=' 'type' type 246bool LLParser::ParseUnnamedType() { 247 unsigned TypeID = NumberedTypes.size(); 248 249 // Handle the LocalVarID form. 250 if (Lex.getKind() == lltok::LocalVarID) { 251 if (Lex.getUIntVal() != TypeID) 252 return Error(Lex.getLoc(), "type expected to be numbered '%" + 253 utostr(TypeID) + "'"); 254 Lex.Lex(); // eat LocalVarID; 255 256 if (ParseToken(lltok::equal, "expected '=' after name")) 257 return true; 258 } 259 260 assert(Lex.getKind() == lltok::kw_type); 261 LocTy TypeLoc = Lex.getLoc(); 262 Lex.Lex(); // eat kw_type 263 264 PATypeHolder Ty(Type::getVoidTy(Context)); 265 if (ParseType(Ty)) return true; 266 267 // See if this type was previously referenced. 268 std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator 269 FI = ForwardRefTypeIDs.find(TypeID); 270 if (FI != ForwardRefTypeIDs.end()) { 271 if (FI->second.first.get() == Ty) 272 return Error(TypeLoc, "self referential type is invalid"); 273 274 cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty); 275 Ty = FI->second.first.get(); 276 ForwardRefTypeIDs.erase(FI); 277 } 278 279 NumberedTypes.push_back(Ty); 280 281 return false; 282} 283 284/// toplevelentity 285/// ::= LocalVar '=' 'type' type 286bool LLParser::ParseNamedType() { 287 std::string Name = Lex.getStrVal(); 288 LocTy NameLoc = Lex.getLoc(); 289 Lex.Lex(); // eat LocalVar. 290 291 PATypeHolder Ty(Type::getVoidTy(Context)); 292 293 if (ParseToken(lltok::equal, "expected '=' after name") || 294 ParseToken(lltok::kw_type, "expected 'type' after name") || 295 ParseType(Ty)) 296 return true; 297 298 // Set the type name, checking for conflicts as we do so. 299 bool AlreadyExists = M->addTypeName(Name, Ty); 300 if (!AlreadyExists) return false; 301 302 // See if this type is a forward reference. We need to eagerly resolve 303 // types to allow recursive type redefinitions below. 304 std::map<std::string, std::pair<PATypeHolder, LocTy> >::iterator 305 FI = ForwardRefTypes.find(Name); 306 if (FI != ForwardRefTypes.end()) { 307 if (FI->second.first.get() == Ty) 308 return Error(NameLoc, "self referential type is invalid"); 309 310 cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty); 311 Ty = FI->second.first.get(); 312 ForwardRefTypes.erase(FI); 313 } 314 315 // Inserting a name that is already defined, get the existing name. 316 const Type *Existing = M->getTypeByName(Name); 317 assert(Existing && "Conflict but no matching type?!"); 318 319 // Otherwise, this is an attempt to redefine a type. That's okay if 320 // the redefinition is identical to the original. 321 // FIXME: REMOVE REDEFINITIONS IN LLVM 3.0 322 if (Existing == Ty) return false; 323 324 // Any other kind of (non-equivalent) redefinition is an error. 325 return Error(NameLoc, "redefinition of type named '" + Name + "' of type '" + 326 Ty->getDescription() + "'"); 327} 328 329 330/// toplevelentity 331/// ::= 'declare' FunctionHeader 332bool LLParser::ParseDeclare() { 333 assert(Lex.getKind() == lltok::kw_declare); 334 Lex.Lex(); 335 336 Function *F; 337 return ParseFunctionHeader(F, false); 338} 339 340/// toplevelentity 341/// ::= 'define' FunctionHeader '{' ... 342bool LLParser::ParseDefine() { 343 assert(Lex.getKind() == lltok::kw_define); 344 Lex.Lex(); 345 346 Function *F; 347 return ParseFunctionHeader(F, true) || 348 ParseFunctionBody(*F); 349} 350 351/// ParseGlobalType 352/// ::= 'constant' 353/// ::= 'global' 354bool LLParser::ParseGlobalType(bool &IsConstant) { 355 if (Lex.getKind() == lltok::kw_constant) 356 IsConstant = true; 357 else if (Lex.getKind() == lltok::kw_global) 358 IsConstant = false; 359 else { 360 IsConstant = false; 361 return TokError("expected 'global' or 'constant'"); 362 } 363 Lex.Lex(); 364 return false; 365} 366 367/// ParseUnnamedGlobal: 368/// OptionalVisibility ALIAS ... 369/// OptionalLinkage OptionalVisibility ... -> global variable 370/// GlobalID '=' OptionalVisibility ALIAS ... 371/// GlobalID '=' OptionalLinkage OptionalVisibility ... -> global variable 372bool LLParser::ParseUnnamedGlobal() { 373 unsigned VarID = NumberedVals.size(); 374 std::string Name; 375 LocTy NameLoc = Lex.getLoc(); 376 377 // Handle the GlobalID form. 378 if (Lex.getKind() == lltok::GlobalID) { 379 if (Lex.getUIntVal() != VarID) 380 return Error(Lex.getLoc(), "variable expected to be numbered '%" + 381 utostr(VarID) + "'"); 382 Lex.Lex(); // eat GlobalID; 383 384 if (ParseToken(lltok::equal, "expected '=' after name")) 385 return true; 386 } 387 388 bool HasLinkage; 389 unsigned Linkage, Visibility; 390 if (ParseOptionalLinkage(Linkage, HasLinkage) || 391 ParseOptionalVisibility(Visibility)) 392 return true; 393 394 if (HasLinkage || Lex.getKind() != lltok::kw_alias) 395 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility); 396 return ParseAlias(Name, NameLoc, Visibility); 397} 398 399/// ParseNamedGlobal: 400/// GlobalVar '=' OptionalVisibility ALIAS ... 401/// GlobalVar '=' OptionalLinkage OptionalVisibility ... -> global variable 402bool LLParser::ParseNamedGlobal() { 403 assert(Lex.getKind() == lltok::GlobalVar); 404 LocTy NameLoc = Lex.getLoc(); 405 std::string Name = Lex.getStrVal(); 406 Lex.Lex(); 407 408 bool HasLinkage; 409 unsigned Linkage, Visibility; 410 if (ParseToken(lltok::equal, "expected '=' in global variable") || 411 ParseOptionalLinkage(Linkage, HasLinkage) || 412 ParseOptionalVisibility(Visibility)) 413 return true; 414 415 if (HasLinkage || Lex.getKind() != lltok::kw_alias) 416 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility); 417 return ParseAlias(Name, NameLoc, Visibility); 418} 419 420// MDString: 421// ::= '!' STRINGCONSTANT 422bool LLParser::ParseMDString(MetadataBase *&MDS) { 423 std::string Str; 424 if (ParseStringConstant(Str)) return true; 425 MDS = MDString::get(Context, Str); 426 return false; 427} 428 429// MDNode: 430// ::= '!' MDNodeNumber 431bool LLParser::ParseMDNode(MetadataBase *&Node) { 432 // !{ ..., !42, ... } 433 unsigned MID = 0; 434 if (ParseUInt32(MID)) return true; 435 436 // Check existing MDNode. 437 std::map<unsigned, MetadataBase *>::iterator I = MetadataCache.find(MID); 438 if (I != MetadataCache.end()) { 439 Node = I->second; 440 return false; 441 } 442 443 // Check known forward references. 444 std::map<unsigned, std::pair<MetadataBase *, LocTy> >::iterator 445 FI = ForwardRefMDNodes.find(MID); 446 if (FI != ForwardRefMDNodes.end()) { 447 Node = FI->second.first; 448 return false; 449 } 450 451 // Create MDNode forward reference 452 SmallVector<Value *, 1> Elts; 453 std::string FwdRefName = "llvm.mdnode.fwdref." + utostr(MID); 454 Elts.push_back(MDString::get(Context, FwdRefName)); 455 MDNode *FwdNode = MDNode::get(Context, Elts.data(), Elts.size()); 456 ForwardRefMDNodes[MID] = std::make_pair(FwdNode, Lex.getLoc()); 457 Node = FwdNode; 458 return false; 459} 460 461///ParseNamedMetadata: 462/// !foo = !{ !1, !2 } 463bool LLParser::ParseNamedMetadata() { 464 assert(Lex.getKind() == lltok::NamedMD); 465 Lex.Lex(); 466 std::string Name = Lex.getStrVal(); 467 468 if (ParseToken(lltok::equal, "expected '=' here")) 469 return true; 470 471 if (Lex.getKind() != lltok::Metadata) 472 return TokError("Expected '!' here"); 473 Lex.Lex(); 474 475 if (Lex.getKind() != lltok::lbrace) 476 return TokError("Expected '{' here"); 477 Lex.Lex(); 478 SmallVector<MetadataBase *, 8> Elts; 479 do { 480 if (Lex.getKind() != lltok::Metadata) 481 return TokError("Expected '!' here"); 482 Lex.Lex(); 483 MetadataBase *N = 0; 484 if (ParseMDNode(N)) return true; 485 Elts.push_back(N); 486 } while (EatIfPresent(lltok::comma)); 487 488 if (ParseToken(lltok::rbrace, "expected end of metadata node")) 489 return true; 490 491 NamedMDNode::Create(Context, Name, Elts.data(), Elts.size(), M); 492 return false; 493} 494 495/// ParseStandaloneMetadata: 496/// !42 = !{...} 497bool LLParser::ParseStandaloneMetadata() { 498 assert(Lex.getKind() == lltok::Metadata); 499 Lex.Lex(); 500 unsigned MetadataID = 0; 501 if (ParseUInt32(MetadataID)) 502 return true; 503 if (MetadataCache.find(MetadataID) != MetadataCache.end()) 504 return TokError("Metadata id is already used"); 505 if (ParseToken(lltok::equal, "expected '=' here")) 506 return true; 507 508 LocTy TyLoc; 509 PATypeHolder Ty(Type::getVoidTy(Context)); 510 if (ParseType(Ty, TyLoc)) 511 return true; 512 513 if (Lex.getKind() != lltok::Metadata) 514 return TokError("Expected metadata here"); 515 516 Lex.Lex(); 517 if (Lex.getKind() != lltok::lbrace) 518 return TokError("Expected '{' here"); 519 520 SmallVector<Value *, 16> Elts; 521 if (ParseMDNodeVector(Elts) 522 || ParseToken(lltok::rbrace, "expected end of metadata node")) 523 return true; 524 525 MDNode *Init = MDNode::get(Context, Elts.data(), Elts.size()); 526 MetadataCache[MetadataID] = Init; 527 std::map<unsigned, std::pair<MetadataBase *, LocTy> >::iterator 528 FI = ForwardRefMDNodes.find(MetadataID); 529 if (FI != ForwardRefMDNodes.end()) { 530 MDNode *FwdNode = cast<MDNode>(FI->second.first); 531 FwdNode->replaceAllUsesWith(Init); 532 ForwardRefMDNodes.erase(FI); 533 } 534 535 return false; 536} 537 538/// ParseAlias: 539/// ::= GlobalVar '=' OptionalVisibility 'alias' OptionalLinkage Aliasee 540/// Aliasee 541/// ::= TypeAndValue 542/// ::= 'bitcast' '(' TypeAndValue 'to' Type ')' 543/// ::= 'getelementptr' 'inbounds'? '(' ... ')' 544/// 545/// Everything through visibility has already been parsed. 546/// 547bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, 548 unsigned Visibility) { 549 assert(Lex.getKind() == lltok::kw_alias); 550 Lex.Lex(); 551 unsigned Linkage; 552 LocTy LinkageLoc = Lex.getLoc(); 553 if (ParseOptionalLinkage(Linkage)) 554 return true; 555 556 if (Linkage != GlobalValue::ExternalLinkage && 557 Linkage != GlobalValue::WeakAnyLinkage && 558 Linkage != GlobalValue::WeakODRLinkage && 559 Linkage != GlobalValue::InternalLinkage && 560 Linkage != GlobalValue::PrivateLinkage && 561 Linkage != GlobalValue::LinkerPrivateLinkage) 562 return Error(LinkageLoc, "invalid linkage type for alias"); 563 564 Constant *Aliasee; 565 LocTy AliaseeLoc = Lex.getLoc(); 566 if (Lex.getKind() != lltok::kw_bitcast && 567 Lex.getKind() != lltok::kw_getelementptr) { 568 if (ParseGlobalTypeAndValue(Aliasee)) return true; 569 } else { 570 // The bitcast dest type is not present, it is implied by the dest type. 571 ValID ID; 572 if (ParseValID(ID)) return true; 573 if (ID.Kind != ValID::t_Constant) 574 return Error(AliaseeLoc, "invalid aliasee"); 575 Aliasee = ID.ConstantVal; 576 } 577 578 if (!isa<PointerType>(Aliasee->getType())) 579 return Error(AliaseeLoc, "alias must have pointer type"); 580 581 // Okay, create the alias but do not insert it into the module yet. 582 GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), 583 (GlobalValue::LinkageTypes)Linkage, Name, 584 Aliasee); 585 GA->setVisibility((GlobalValue::VisibilityTypes)Visibility); 586 587 // See if this value already exists in the symbol table. If so, it is either 588 // a redefinition or a definition of a forward reference. 589 if (GlobalValue *Val = 590 cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name))) { 591 // See if this was a redefinition. If so, there is no entry in 592 // ForwardRefVals. 593 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator 594 I = ForwardRefVals.find(Name); 595 if (I == ForwardRefVals.end()) 596 return Error(NameLoc, "redefinition of global named '@" + Name + "'"); 597 598 // Otherwise, this was a definition of forward ref. Verify that types 599 // agree. 600 if (Val->getType() != GA->getType()) 601 return Error(NameLoc, 602 "forward reference and definition of alias have different types"); 603 604 // If they agree, just RAUW the old value with the alias and remove the 605 // forward ref info. 606 Val->replaceAllUsesWith(GA); 607 Val->eraseFromParent(); 608 ForwardRefVals.erase(I); 609 } 610 611 // Insert into the module, we know its name won't collide now. 612 M->getAliasList().push_back(GA); 613 assert(GA->getNameStr() == Name && "Should not be a name conflict!"); 614 615 return false; 616} 617 618/// ParseGlobal 619/// ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalThreadLocal 620/// OptionalAddrSpace GlobalType Type Const 621/// ::= OptionalLinkage OptionalVisibility OptionalThreadLocal 622/// OptionalAddrSpace GlobalType Type Const 623/// 624/// Everything through visibility has been parsed already. 625/// 626bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc, 627 unsigned Linkage, bool HasLinkage, 628 unsigned Visibility) { 629 unsigned AddrSpace; 630 bool ThreadLocal, IsConstant; 631 LocTy TyLoc; 632 633 PATypeHolder Ty(Type::getVoidTy(Context)); 634 if (ParseOptionalToken(lltok::kw_thread_local, ThreadLocal) || 635 ParseOptionalAddrSpace(AddrSpace) || 636 ParseGlobalType(IsConstant) || 637 ParseType(Ty, TyLoc)) 638 return true; 639 640 // If the linkage is specified and is external, then no initializer is 641 // present. 642 Constant *Init = 0; 643 if (!HasLinkage || (Linkage != GlobalValue::DLLImportLinkage && 644 Linkage != GlobalValue::ExternalWeakLinkage && 645 Linkage != GlobalValue::ExternalLinkage)) { 646 if (ParseGlobalValue(Ty, Init)) 647 return true; 648 } 649 650 if (isa<FunctionType>(Ty) || Ty == Type::getLabelTy(Context)) 651 return Error(TyLoc, "invalid type for global variable"); 652 653 GlobalVariable *GV = 0; 654 655 // See if the global was forward referenced, if so, use the global. 656 if (!Name.empty()) { 657 if ((GV = M->getGlobalVariable(Name, true)) && 658 !ForwardRefVals.erase(Name)) 659 return Error(NameLoc, "redefinition of global '@" + Name + "'"); 660 } else { 661 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator 662 I = ForwardRefValIDs.find(NumberedVals.size()); 663 if (I != ForwardRefValIDs.end()) { 664 GV = cast<GlobalVariable>(I->second.first); 665 ForwardRefValIDs.erase(I); 666 } 667 } 668 669 if (GV == 0) { 670 GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, 0, 671 Name, 0, false, AddrSpace); 672 } else { 673 if (GV->getType()->getElementType() != Ty) 674 return Error(TyLoc, 675 "forward reference and definition of global have different types"); 676 677 // Move the forward-reference to the correct spot in the module. 678 M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV); 679 } 680 681 if (Name.empty()) 682 NumberedVals.push_back(GV); 683 684 // Set the parsed properties on the global. 685 if (Init) 686 GV->setInitializer(Init); 687 GV->setConstant(IsConstant); 688 GV->setLinkage((GlobalValue::LinkageTypes)Linkage); 689 GV->setVisibility((GlobalValue::VisibilityTypes)Visibility); 690 GV->setThreadLocal(ThreadLocal); 691 692 // Parse attributes on the global. 693 while (Lex.getKind() == lltok::comma) { 694 Lex.Lex(); 695 696 if (Lex.getKind() == lltok::kw_section) { 697 Lex.Lex(); 698 GV->setSection(Lex.getStrVal()); 699 if (ParseToken(lltok::StringConstant, "expected global section string")) 700 return true; 701 } else if (Lex.getKind() == lltok::kw_align) { 702 unsigned Alignment; 703 if (ParseOptionalAlignment(Alignment)) return true; 704 GV->setAlignment(Alignment); 705 } else { 706 TokError("unknown global variable property!"); 707 } 708 } 709 710 return false; 711} 712 713 714//===----------------------------------------------------------------------===// 715// GlobalValue Reference/Resolution Routines. 716//===----------------------------------------------------------------------===// 717 718/// GetGlobalVal - Get a value with the specified name or ID, creating a 719/// forward reference record if needed. This can return null if the value 720/// exists but does not have the right type. 721GlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty, 722 LocTy Loc) { 723 const PointerType *PTy = dyn_cast<PointerType>(Ty); 724 if (PTy == 0) { 725 Error(Loc, "global variable reference must have pointer type"); 726 return 0; 727 } 728 729 // Look this name up in the normal function symbol table. 730 GlobalValue *Val = 731 cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name)); 732 733 // If this is a forward reference for the value, see if we already created a 734 // forward ref record. 735 if (Val == 0) { 736 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator 737 I = ForwardRefVals.find(Name); 738 if (I != ForwardRefVals.end()) 739 Val = I->second.first; 740 } 741 742 // If we have the value in the symbol table or fwd-ref table, return it. 743 if (Val) { 744 if (Val->getType() == Ty) return Val; 745 Error(Loc, "'@" + Name + "' defined with type '" + 746 Val->getType()->getDescription() + "'"); 747 return 0; 748 } 749 750 // Otherwise, create a new forward reference for this value and remember it. 751 GlobalValue *FwdVal; 752 if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) { 753 // Function types can return opaque but functions can't. 754 if (isa<OpaqueType>(FT->getReturnType())) { 755 Error(Loc, "function may not return opaque type"); 756 return 0; 757 } 758 759 FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M); 760 } else { 761 FwdVal = new GlobalVariable(*M, PTy->getElementType(), false, 762 GlobalValue::ExternalWeakLinkage, 0, Name); 763 } 764 765 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc); 766 return FwdVal; 767} 768 769GlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) { 770 const PointerType *PTy = dyn_cast<PointerType>(Ty); 771 if (PTy == 0) { 772 Error(Loc, "global variable reference must have pointer type"); 773 return 0; 774 } 775 776 GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0; 777 778 // If this is a forward reference for the value, see if we already created a 779 // forward ref record. 780 if (Val == 0) { 781 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator 782 I = ForwardRefValIDs.find(ID); 783 if (I != ForwardRefValIDs.end()) 784 Val = I->second.first; 785 } 786 787 // If we have the value in the symbol table or fwd-ref table, return it. 788 if (Val) { 789 if (Val->getType() == Ty) return Val; 790 Error(Loc, "'@" + utostr(ID) + "' defined with type '" + 791 Val->getType()->getDescription() + "'"); 792 return 0; 793 } 794 795 // Otherwise, create a new forward reference for this value and remember it. 796 GlobalValue *FwdVal; 797 if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) { 798 // Function types can return opaque but functions can't. 799 if (isa<OpaqueType>(FT->getReturnType())) { 800 Error(Loc, "function may not return opaque type"); 801 return 0; 802 } 803 FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, "", M); 804 } else { 805 FwdVal = new GlobalVariable(*M, PTy->getElementType(), false, 806 GlobalValue::ExternalWeakLinkage, 0, ""); 807 } 808 809 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc); 810 return FwdVal; 811} 812 813 814//===----------------------------------------------------------------------===// 815// Helper Routines. 816//===----------------------------------------------------------------------===// 817 818/// ParseToken - If the current token has the specified kind, eat it and return 819/// success. Otherwise, emit the specified error and return failure. 820bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) { 821 if (Lex.getKind() != T) 822 return TokError(ErrMsg); 823 Lex.Lex(); 824 return false; 825} 826 827/// ParseStringConstant 828/// ::= StringConstant 829bool LLParser::ParseStringConstant(std::string &Result) { 830 if (Lex.getKind() != lltok::StringConstant) 831 return TokError("expected string constant"); 832 Result = Lex.getStrVal(); 833 Lex.Lex(); 834 return false; 835} 836 837/// ParseUInt32 838/// ::= uint32 839bool LLParser::ParseUInt32(unsigned &Val) { 840 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned()) 841 return TokError("expected integer"); 842 uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1); 843 if (Val64 != unsigned(Val64)) 844 return TokError("expected 32-bit integer (too large)"); 845 Val = Val64; 846 Lex.Lex(); 847 return false; 848} 849 850 851/// ParseOptionalAddrSpace 852/// := /*empty*/ 853/// := 'addrspace' '(' uint32 ')' 854bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) { 855 AddrSpace = 0; 856 if (!EatIfPresent(lltok::kw_addrspace)) 857 return false; 858 return ParseToken(lltok::lparen, "expected '(' in address space") || 859 ParseUInt32(AddrSpace) || 860 ParseToken(lltok::rparen, "expected ')' in address space"); 861} 862 863/// ParseOptionalAttrs - Parse a potentially empty attribute list. AttrKind 864/// indicates what kind of attribute list this is: 0: function arg, 1: result, 865/// 2: function attr. 866/// 3: function arg after value: FIXME: REMOVE IN LLVM 3.0 867bool LLParser::ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind) { 868 Attrs = Attribute::None; 869 LocTy AttrLoc = Lex.getLoc(); 870 871 while (1) { 872 switch (Lex.getKind()) { 873 case lltok::kw_sext: 874 case lltok::kw_zext: 875 // Treat these as signext/zeroext if they occur in the argument list after 876 // the value, as in "call i8 @foo(i8 10 sext)". If they occur before the 877 // value, as in "call i8 @foo(i8 sext (" then it is part of a constant 878 // expr. 879 // FIXME: REMOVE THIS IN LLVM 3.0 880 if (AttrKind == 3) { 881 if (Lex.getKind() == lltok::kw_sext) 882 Attrs |= Attribute::SExt; 883 else 884 Attrs |= Attribute::ZExt; 885 break; 886 } 887 // FALL THROUGH. 888 default: // End of attributes. 889 if (AttrKind != 2 && (Attrs & Attribute::FunctionOnly)) 890 return Error(AttrLoc, "invalid use of function-only attribute"); 891 892 if (AttrKind != 0 && AttrKind != 3 && (Attrs & Attribute::ParameterOnly)) 893 return Error(AttrLoc, "invalid use of parameter-only attribute"); 894 895 return false; 896 case lltok::kw_zeroext: Attrs |= Attribute::ZExt; break; 897 case lltok::kw_signext: Attrs |= Attribute::SExt; break; 898 case lltok::kw_inreg: Attrs |= Attribute::InReg; break; 899 case lltok::kw_sret: Attrs |= Attribute::StructRet; break; 900 case lltok::kw_noalias: Attrs |= Attribute::NoAlias; break; 901 case lltok::kw_nocapture: Attrs |= Attribute::NoCapture; break; 902 case lltok::kw_byval: Attrs |= Attribute::ByVal; break; 903 case lltok::kw_nest: Attrs |= Attribute::Nest; break; 904 905 case lltok::kw_noreturn: Attrs |= Attribute::NoReturn; break; 906 case lltok::kw_nounwind: Attrs |= Attribute::NoUnwind; break; 907 case lltok::kw_noinline: Attrs |= Attribute::NoInline; break; 908 case lltok::kw_readnone: Attrs |= Attribute::ReadNone; break; 909 case lltok::kw_readonly: Attrs |= Attribute::ReadOnly; break; 910 case lltok::kw_inlinehint: Attrs |= Attribute::InlineHint; break; 911 case lltok::kw_alwaysinline: Attrs |= Attribute::AlwaysInline; break; 912 case lltok::kw_optsize: Attrs |= Attribute::OptimizeForSize; break; 913 case lltok::kw_ssp: Attrs |= Attribute::StackProtect; break; 914 case lltok::kw_sspreq: Attrs |= Attribute::StackProtectReq; break; 915 case lltok::kw_noredzone: Attrs |= Attribute::NoRedZone; break; 916 case lltok::kw_noimplicitfloat: Attrs |= Attribute::NoImplicitFloat; break; 917 case lltok::kw_naked: Attrs |= Attribute::Naked; break; 918 919 case lltok::kw_align: { 920 unsigned Alignment; 921 if (ParseOptionalAlignment(Alignment)) 922 return true; 923 Attrs |= Attribute::constructAlignmentFromInt(Alignment); 924 continue; 925 } 926 } 927 Lex.Lex(); 928 } 929} 930 931/// ParseOptionalLinkage 932/// ::= /*empty*/ 933/// ::= 'private' 934/// ::= 'linker_private' 935/// ::= 'internal' 936/// ::= 'weak' 937/// ::= 'weak_odr' 938/// ::= 'linkonce' 939/// ::= 'linkonce_odr' 940/// ::= 'appending' 941/// ::= 'dllexport' 942/// ::= 'common' 943/// ::= 'dllimport' 944/// ::= 'extern_weak' 945/// ::= 'external' 946bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) { 947 HasLinkage = false; 948 switch (Lex.getKind()) { 949 default: Res=GlobalValue::ExternalLinkage; return false; 950 case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break; 951 case lltok::kw_linker_private: Res = GlobalValue::LinkerPrivateLinkage; break; 952 case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break; 953 case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break; 954 case lltok::kw_weak_odr: Res = GlobalValue::WeakODRLinkage; break; 955 case lltok::kw_linkonce: Res = GlobalValue::LinkOnceAnyLinkage; break; 956 case lltok::kw_linkonce_odr: Res = GlobalValue::LinkOnceODRLinkage; break; 957 case lltok::kw_available_externally: 958 Res = GlobalValue::AvailableExternallyLinkage; 959 break; 960 case lltok::kw_appending: Res = GlobalValue::AppendingLinkage; break; 961 case lltok::kw_dllexport: Res = GlobalValue::DLLExportLinkage; break; 962 case lltok::kw_common: Res = GlobalValue::CommonLinkage; break; 963 case lltok::kw_dllimport: Res = GlobalValue::DLLImportLinkage; break; 964 case lltok::kw_extern_weak: Res = GlobalValue::ExternalWeakLinkage; break; 965 case lltok::kw_external: Res = GlobalValue::ExternalLinkage; break; 966 } 967 Lex.Lex(); 968 HasLinkage = true; 969 return false; 970} 971 972/// ParseOptionalVisibility 973/// ::= /*empty*/ 974/// ::= 'default' 975/// ::= 'hidden' 976/// ::= 'protected' 977/// 978bool LLParser::ParseOptionalVisibility(unsigned &Res) { 979 switch (Lex.getKind()) { 980 default: Res = GlobalValue::DefaultVisibility; return false; 981 case lltok::kw_default: Res = GlobalValue::DefaultVisibility; break; 982 case lltok::kw_hidden: Res = GlobalValue::HiddenVisibility; break; 983 case lltok::kw_protected: Res = GlobalValue::ProtectedVisibility; break; 984 } 985 Lex.Lex(); 986 return false; 987} 988 989/// ParseOptionalCallingConv 990/// ::= /*empty*/ 991/// ::= 'ccc' 992/// ::= 'fastcc' 993/// ::= 'coldcc' 994/// ::= 'x86_stdcallcc' 995/// ::= 'x86_fastcallcc' 996/// ::= 'arm_apcscc' 997/// ::= 'arm_aapcscc' 998/// ::= 'arm_aapcs_vfpcc' 999/// ::= 'cc' UINT 1000/// 1001bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) { 1002 switch (Lex.getKind()) { 1003 default: CC = CallingConv::C; return false; 1004 case lltok::kw_ccc: CC = CallingConv::C; break; 1005 case lltok::kw_fastcc: CC = CallingConv::Fast; break; 1006 case lltok::kw_coldcc: CC = CallingConv::Cold; break; 1007 case lltok::kw_x86_stdcallcc: CC = CallingConv::X86_StdCall; break; 1008 case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break; 1009 case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break; 1010 case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break; 1011 case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break; 1012 case lltok::kw_cc: { 1013 unsigned ArbitraryCC; 1014 Lex.Lex(); 1015 if (ParseUInt32(ArbitraryCC)) { 1016 return true; 1017 } else 1018 CC = static_cast<CallingConv::ID>(ArbitraryCC); 1019 return false; 1020 } 1021 break; 1022 } 1023 1024 Lex.Lex(); 1025 return false; 1026} 1027 1028/// ParseOptionalDbgInfo 1029/// ::= /* empty */ 1030/// ::= 'dbg' !42 1031bool LLParser::ParseOptionalDbgInfo() { 1032 1033 if (!EatIfPresent(lltok::kw_dbg)) 1034 return false; 1035 if (Lex.getKind() != lltok::Metadata) 1036 return TokError("Expected '!' here"); 1037 Lex.Lex(); 1038 MetadataBase *Node; 1039 if (ParseMDNode(Node)) return true; 1040 1041 MetadataContext &TheMetadata = M->getContext().getMetadata(); 1042 unsigned MDDbgKind = TheMetadata.getMDKind("dbg"); 1043 if (!MDDbgKind) 1044 MDDbgKind = TheMetadata.RegisterMDKind("dbg"); 1045 MDsOnInst.push_back(std::make_pair(MDDbgKind, cast<MDNode>(Node))); 1046 1047 return false; 1048} 1049 1050/// ParseOptionalAlignment 1051/// ::= /* empty */ 1052/// ::= 'align' 4 1053bool LLParser::ParseOptionalAlignment(unsigned &Alignment) { 1054 Alignment = 0; 1055 if (!EatIfPresent(lltok::kw_align)) 1056 return false; 1057 LocTy AlignLoc = Lex.getLoc(); 1058 if (ParseUInt32(Alignment)) return true; 1059 if (!isPowerOf2_32(Alignment)) 1060 return Error(AlignLoc, "alignment is not a power of two"); 1061 return false; 1062} 1063 1064/// ParseOptionalInfo 1065/// ::= OptionalInfo (',' OptionalInfo)+ 1066bool LLParser::ParseOptionalInfo(unsigned &Alignment) { 1067 1068 // FIXME: Handle customized metadata info attached with an instruction. 1069 do { 1070 if (Lex.getKind() == lltok::kw_dbg) { 1071 if (ParseOptionalDbgInfo()) return true; 1072 } else if (Lex.getKind() == lltok::kw_align) { 1073 if (ParseOptionalAlignment(Alignment)) return true; 1074 } else 1075 return true; 1076 } while (EatIfPresent(lltok::comma)); 1077 1078 return false; 1079} 1080 1081 1082/// ParseIndexList 1083/// ::= (',' uint32)+ 1084bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices) { 1085 if (Lex.getKind() != lltok::comma) 1086 return TokError("expected ',' as start of index list"); 1087 1088 while (EatIfPresent(lltok::comma)) { 1089 unsigned Idx; 1090 if (ParseUInt32(Idx)) return true; 1091 Indices.push_back(Idx); 1092 } 1093 1094 return false; 1095} 1096 1097//===----------------------------------------------------------------------===// 1098// Type Parsing. 1099//===----------------------------------------------------------------------===// 1100 1101/// ParseType - Parse and resolve a full type. 1102bool LLParser::ParseType(PATypeHolder &Result, bool AllowVoid) { 1103 LocTy TypeLoc = Lex.getLoc(); 1104 if (ParseTypeRec(Result)) return true; 1105 1106 // Verify no unresolved uprefs. 1107 if (!UpRefs.empty()) 1108 return Error(UpRefs.back().Loc, "invalid unresolved type up reference"); 1109 1110 if (!AllowVoid && Result.get() == Type::getVoidTy(Context)) 1111 return Error(TypeLoc, "void type only allowed for function results"); 1112 1113 return false; 1114} 1115 1116/// HandleUpRefs - Every time we finish a new layer of types, this function is 1117/// called. It loops through the UpRefs vector, which is a list of the 1118/// currently active types. For each type, if the up-reference is contained in 1119/// the newly completed type, we decrement the level count. When the level 1120/// count reaches zero, the up-referenced type is the type that is passed in: 1121/// thus we can complete the cycle. 1122/// 1123PATypeHolder LLParser::HandleUpRefs(const Type *ty) { 1124 // If Ty isn't abstract, or if there are no up-references in it, then there is 1125 // nothing to resolve here. 1126 if (!ty->isAbstract() || UpRefs.empty()) return ty; 1127 1128 PATypeHolder Ty(ty); 1129#if 0 1130 errs() << "Type '" << Ty->getDescription() 1131 << "' newly formed. Resolving upreferences.\n" 1132 << UpRefs.size() << " upreferences active!\n"; 1133#endif 1134 1135 // If we find any resolvable upreferences (i.e., those whose NestingLevel goes 1136 // to zero), we resolve them all together before we resolve them to Ty. At 1137 // the end of the loop, if there is anything to resolve to Ty, it will be in 1138 // this variable. 1139 OpaqueType *TypeToResolve = 0; 1140 1141 for (unsigned i = 0; i != UpRefs.size(); ++i) { 1142 // Determine if 'Ty' directly contains this up-references 'LastContainedTy'. 1143 bool ContainsType = 1144 std::find(Ty->subtype_begin(), Ty->subtype_end(), 1145 UpRefs[i].LastContainedTy) != Ty->subtype_end(); 1146 1147#if 0 1148 errs() << " UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " 1149 << UpRefs[i].LastContainedTy->getDescription() << ") = " 1150 << (ContainsType ? "true" : "false") 1151 << " level=" << UpRefs[i].NestingLevel << "\n"; 1152#endif 1153 if (!ContainsType) 1154 continue; 1155 1156 // Decrement level of upreference 1157 unsigned Level = --UpRefs[i].NestingLevel; 1158 UpRefs[i].LastContainedTy = Ty; 1159 1160 // If the Up-reference has a non-zero level, it shouldn't be resolved yet. 1161 if (Level != 0) 1162 continue; 1163 1164#if 0 1165 errs() << " * Resolving upreference for " << UpRefs[i].UpRefTy << "\n"; 1166#endif 1167 if (!TypeToResolve) 1168 TypeToResolve = UpRefs[i].UpRefTy; 1169 else 1170 UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve); 1171 UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list. 1172 --i; // Do not skip the next element. 1173 } 1174 1175 if (TypeToResolve) 1176 TypeToResolve->refineAbstractTypeTo(Ty); 1177 1178 return Ty; 1179} 1180 1181 1182/// ParseTypeRec - The recursive function used to process the internal 1183/// implementation details of types. 1184bool LLParser::ParseTypeRec(PATypeHolder &Result) { 1185 switch (Lex.getKind()) { 1186 default: 1187 return TokError("expected type"); 1188 case lltok::Type: 1189 // TypeRec ::= 'float' | 'void' (etc) 1190 Result = Lex.getTyVal(); 1191 Lex.Lex(); 1192 break; 1193 case lltok::kw_opaque: 1194 // TypeRec ::= 'opaque' 1195 Result = OpaqueType::get(Context); 1196 Lex.Lex(); 1197 break; 1198 case lltok::lbrace: 1199 // TypeRec ::= '{' ... '}' 1200 if (ParseStructType(Result, false)) 1201 return true; 1202 break; 1203 case lltok::lsquare: 1204 // TypeRec ::= '[' ... ']' 1205 Lex.Lex(); // eat the lsquare. 1206 if (ParseArrayVectorType(Result, false)) 1207 return true; 1208 break; 1209 case lltok::less: // Either vector or packed struct. 1210 // TypeRec ::= '<' ... '>' 1211 Lex.Lex(); 1212 if (Lex.getKind() == lltok::lbrace) { 1213 if (ParseStructType(Result, true) || 1214 ParseToken(lltok::greater, "expected '>' at end of packed struct")) 1215 return true; 1216 } else if (ParseArrayVectorType(Result, true)) 1217 return true; 1218 break; 1219 case lltok::LocalVar: 1220 case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0 1221 // TypeRec ::= %foo 1222 if (const Type *T = M->getTypeByName(Lex.getStrVal())) { 1223 Result = T; 1224 } else { 1225 Result = OpaqueType::get(Context); 1226 ForwardRefTypes.insert(std::make_pair(Lex.getStrVal(), 1227 std::make_pair(Result, 1228 Lex.getLoc()))); 1229 M->addTypeName(Lex.getStrVal(), Result.get()); 1230 } 1231 Lex.Lex(); 1232 break; 1233 1234 case lltok::LocalVarID: 1235 // TypeRec ::= %4 1236 if (Lex.getUIntVal() < NumberedTypes.size()) 1237 Result = NumberedTypes[Lex.getUIntVal()]; 1238 else { 1239 std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator 1240 I = ForwardRefTypeIDs.find(Lex.getUIntVal()); 1241 if (I != ForwardRefTypeIDs.end()) 1242 Result = I->second.first; 1243 else { 1244 Result = OpaqueType::get(Context); 1245 ForwardRefTypeIDs.insert(std::make_pair(Lex.getUIntVal(), 1246 std::make_pair(Result, 1247 Lex.getLoc()))); 1248 } 1249 } 1250 Lex.Lex(); 1251 break; 1252 case lltok::backslash: { 1253 // TypeRec ::= '\' 4 1254 Lex.Lex(); 1255 unsigned Val; 1256 if (ParseUInt32(Val)) return true; 1257 OpaqueType *OT = OpaqueType::get(Context); //Use temporary placeholder. 1258 UpRefs.push_back(UpRefRecord(Lex.getLoc(), Val, OT)); 1259 Result = OT; 1260 break; 1261 } 1262 } 1263 1264 // Parse the type suffixes. 1265 while (1) { 1266 switch (Lex.getKind()) { 1267 // End of type. 1268 default: return false; 1269 1270 // TypeRec ::= TypeRec '*' 1271 case lltok::star: 1272 if (Result.get() == Type::getLabelTy(Context)) 1273 return TokError("basic block pointers are invalid"); 1274 if (Result.get() == Type::getVoidTy(Context)) 1275 return TokError("pointers to void are invalid; use i8* instead"); 1276 if (!PointerType::isValidElementType(Result.get())) 1277 return TokError("pointer to this type is invalid"); 1278 Result = HandleUpRefs(PointerType::getUnqual(Result.get())); 1279 Lex.Lex(); 1280 break; 1281 1282 // TypeRec ::= TypeRec 'addrspace' '(' uint32 ')' '*' 1283 case lltok::kw_addrspace: { 1284 if (Result.get() == Type::getLabelTy(Context)) 1285 return TokError("basic block pointers are invalid"); 1286 if (Result.get() == Type::getVoidTy(Context)) 1287 return TokError("pointers to void are invalid; use i8* instead"); 1288 if (!PointerType::isValidElementType(Result.get())) 1289 return TokError("pointer to this type is invalid"); 1290 unsigned AddrSpace; 1291 if (ParseOptionalAddrSpace(AddrSpace) || 1292 ParseToken(lltok::star, "expected '*' in address space")) 1293 return true; 1294 1295 Result = HandleUpRefs(PointerType::get(Result.get(), AddrSpace)); 1296 break; 1297 } 1298 1299 /// Types '(' ArgTypeListI ')' OptFuncAttrs 1300 case lltok::lparen: 1301 if (ParseFunctionType(Result)) 1302 return true; 1303 break; 1304 } 1305 } 1306} 1307 1308/// ParseParameterList 1309/// ::= '(' ')' 1310/// ::= '(' Arg (',' Arg)* ')' 1311/// Arg 1312/// ::= Type OptionalAttributes Value OptionalAttributes 1313bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList, 1314 PerFunctionState &PFS) { 1315 if (ParseToken(lltok::lparen, "expected '(' in call")) 1316 return true; 1317 1318 while (Lex.getKind() != lltok::rparen) { 1319 // If this isn't the first argument, we need a comma. 1320 if (!ArgList.empty() && 1321 ParseToken(lltok::comma, "expected ',' in argument list")) 1322 return true; 1323 1324 // Parse the argument. 1325 LocTy ArgLoc; 1326 PATypeHolder ArgTy(Type::getVoidTy(Context)); 1327 unsigned ArgAttrs1, ArgAttrs2; 1328 Value *V; 1329 if (ParseType(ArgTy, ArgLoc) || 1330 ParseOptionalAttrs(ArgAttrs1, 0) || 1331 ParseValue(ArgTy, V, PFS) || 1332 // FIXME: Should not allow attributes after the argument, remove this in 1333 // LLVM 3.0. 1334 ParseOptionalAttrs(ArgAttrs2, 3)) 1335 return true; 1336 ArgList.push_back(ParamInfo(ArgLoc, V, ArgAttrs1|ArgAttrs2)); 1337 } 1338 1339 Lex.Lex(); // Lex the ')'. 1340 return false; 1341} 1342 1343 1344 1345/// ParseArgumentList - Parse the argument list for a function type or function 1346/// prototype. If 'inType' is true then we are parsing a FunctionType. 1347/// ::= '(' ArgTypeListI ')' 1348/// ArgTypeListI 1349/// ::= /*empty*/ 1350/// ::= '...' 1351/// ::= ArgTypeList ',' '...' 1352/// ::= ArgType (',' ArgType)* 1353/// 1354bool LLParser::ParseArgumentList(std::vector<ArgInfo> &ArgList, 1355 bool &isVarArg, bool inType) { 1356 isVarArg = false; 1357 assert(Lex.getKind() == lltok::lparen); 1358 Lex.Lex(); // eat the (. 1359 1360 if (Lex.getKind() == lltok::rparen) { 1361 // empty 1362 } else if (Lex.getKind() == lltok::dotdotdot) { 1363 isVarArg = true; 1364 Lex.Lex(); 1365 } else { 1366 LocTy TypeLoc = Lex.getLoc(); 1367 PATypeHolder ArgTy(Type::getVoidTy(Context)); 1368 unsigned Attrs; 1369 std::string Name; 1370 1371 // If we're parsing a type, use ParseTypeRec, because we allow recursive 1372 // types (such as a function returning a pointer to itself). If parsing a 1373 // function prototype, we require fully resolved types. 1374 if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) || 1375 ParseOptionalAttrs(Attrs, 0)) return true; 1376 1377 if (ArgTy == Type::getVoidTy(Context)) 1378 return Error(TypeLoc, "argument can not have void type"); 1379 1380 if (Lex.getKind() == lltok::LocalVar || 1381 Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0 1382 Name = Lex.getStrVal(); 1383 Lex.Lex(); 1384 } 1385 1386 if (!FunctionType::isValidArgumentType(ArgTy)) 1387 return Error(TypeLoc, "invalid type for function argument"); 1388 1389 ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name)); 1390 1391 while (EatIfPresent(lltok::comma)) { 1392 // Handle ... at end of arg list. 1393 if (EatIfPresent(lltok::dotdotdot)) { 1394 isVarArg = true; 1395 break; 1396 } 1397 1398 // Otherwise must be an argument type. 1399 TypeLoc = Lex.getLoc(); 1400 if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) || 1401 ParseOptionalAttrs(Attrs, 0)) return true; 1402 1403 if (ArgTy == Type::getVoidTy(Context)) 1404 return Error(TypeLoc, "argument can not have void type"); 1405 1406 if (Lex.getKind() == lltok::LocalVar || 1407 Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0 1408 Name = Lex.getStrVal(); 1409 Lex.Lex(); 1410 } else { 1411 Name = ""; 1412 } 1413 1414 if (!ArgTy->isFirstClassType() && !isa<OpaqueType>(ArgTy)) 1415 return Error(TypeLoc, "invalid type for function argument"); 1416 1417 ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name)); 1418 } 1419 } 1420 1421 return ParseToken(lltok::rparen, "expected ')' at end of argument list"); 1422} 1423 1424/// ParseFunctionType 1425/// ::= Type ArgumentList OptionalAttrs 1426bool LLParser::ParseFunctionType(PATypeHolder &Result) { 1427 assert(Lex.getKind() == lltok::lparen); 1428 1429 if (!FunctionType::isValidReturnType(Result)) 1430 return TokError("invalid function return type"); 1431 1432 std::vector<ArgInfo> ArgList; 1433 bool isVarArg; 1434 unsigned Attrs; 1435 if (ParseArgumentList(ArgList, isVarArg, true) || 1436 // FIXME: Allow, but ignore attributes on function types! 1437 // FIXME: Remove in LLVM 3.0 1438 ParseOptionalAttrs(Attrs, 2)) 1439 return true; 1440 1441 // Reject names on the arguments lists. 1442 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 1443 if (!ArgList[i].Name.empty()) 1444 return Error(ArgList[i].Loc, "argument name invalid in function type"); 1445 if (!ArgList[i].Attrs != 0) { 1446 // Allow but ignore attributes on function types; this permits 1447 // auto-upgrade. 1448 // FIXME: REJECT ATTRIBUTES ON FUNCTION TYPES in LLVM 3.0 1449 } 1450 } 1451 1452 std::vector<const Type*> ArgListTy; 1453 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) 1454 ArgListTy.push_back(ArgList[i].Type); 1455 1456 Result = HandleUpRefs(FunctionType::get(Result.get(), 1457 ArgListTy, isVarArg)); 1458 return false; 1459} 1460 1461/// ParseStructType: Handles packed and unpacked types. </> parsed elsewhere. 1462/// TypeRec 1463/// ::= '{' '}' 1464/// ::= '{' TypeRec (',' TypeRec)* '}' 1465/// ::= '<' '{' '}' '>' 1466/// ::= '<' '{' TypeRec (',' TypeRec)* '}' '>' 1467bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) { 1468 assert(Lex.getKind() == lltok::lbrace); 1469 Lex.Lex(); // Consume the '{' 1470 1471 if (EatIfPresent(lltok::rbrace)) { 1472 Result = StructType::get(Context, Packed); 1473 return false; 1474 } 1475 1476 std::vector<PATypeHolder> ParamsList; 1477 LocTy EltTyLoc = Lex.getLoc(); 1478 if (ParseTypeRec(Result)) return true; 1479 ParamsList.push_back(Result); 1480 1481 if (Result == Type::getVoidTy(Context)) 1482 return Error(EltTyLoc, "struct element can not have void type"); 1483 if (!StructType::isValidElementType(Result)) 1484 return Error(EltTyLoc, "invalid element type for struct"); 1485 1486 while (EatIfPresent(lltok::comma)) { 1487 EltTyLoc = Lex.getLoc(); 1488 if (ParseTypeRec(Result)) return true; 1489 1490 if (Result == Type::getVoidTy(Context)) 1491 return Error(EltTyLoc, "struct element can not have void type"); 1492 if (!StructType::isValidElementType(Result)) 1493 return Error(EltTyLoc, "invalid element type for struct"); 1494 1495 ParamsList.push_back(Result); 1496 } 1497 1498 if (ParseToken(lltok::rbrace, "expected '}' at end of struct")) 1499 return true; 1500 1501 std::vector<const Type*> ParamsListTy; 1502 for (unsigned i = 0, e = ParamsList.size(); i != e; ++i) 1503 ParamsListTy.push_back(ParamsList[i].get()); 1504 Result = HandleUpRefs(StructType::get(Context, ParamsListTy, Packed)); 1505 return false; 1506} 1507 1508/// ParseArrayVectorType - Parse an array or vector type, assuming the first 1509/// token has already been consumed. 1510/// TypeRec 1511/// ::= '[' APSINTVAL 'x' Types ']' 1512/// ::= '<' APSINTVAL 'x' Types '>' 1513bool LLParser::ParseArrayVectorType(PATypeHolder &Result, bool isVector) { 1514 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() || 1515 Lex.getAPSIntVal().getBitWidth() > 64) 1516 return TokError("expected number in address space"); 1517 1518 LocTy SizeLoc = Lex.getLoc(); 1519 uint64_t Size = Lex.getAPSIntVal().getZExtValue(); 1520 Lex.Lex(); 1521 1522 if (ParseToken(lltok::kw_x, "expected 'x' after element count")) 1523 return true; 1524 1525 LocTy TypeLoc = Lex.getLoc(); 1526 PATypeHolder EltTy(Type::getVoidTy(Context)); 1527 if (ParseTypeRec(EltTy)) return true; 1528 1529 if (EltTy == Type::getVoidTy(Context)) 1530 return Error(TypeLoc, "array and vector element type cannot be void"); 1531 1532 if (ParseToken(isVector ? lltok::greater : lltok::rsquare, 1533 "expected end of sequential type")) 1534 return true; 1535 1536 if (isVector) { 1537 if (Size == 0) 1538 return Error(SizeLoc, "zero element vector is illegal"); 1539 if ((unsigned)Size != Size) 1540 return Error(SizeLoc, "size too large for vector"); 1541 if (!VectorType::isValidElementType(EltTy)) 1542 return Error(TypeLoc, "vector element type must be fp or integer"); 1543 Result = VectorType::get(EltTy, unsigned(Size)); 1544 } else { 1545 if (!ArrayType::isValidElementType(EltTy)) 1546 return Error(TypeLoc, "invalid array element type"); 1547 Result = HandleUpRefs(ArrayType::get(EltTy, Size)); 1548 } 1549 return false; 1550} 1551 1552//===----------------------------------------------------------------------===// 1553// Function Semantic Analysis. 1554//===----------------------------------------------------------------------===// 1555 1556LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f) 1557 : P(p), F(f) { 1558 1559 // Insert unnamed arguments into the NumberedVals list. 1560 for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 1561 AI != E; ++AI) 1562 if (!AI->hasName()) 1563 NumberedVals.push_back(AI); 1564} 1565 1566LLParser::PerFunctionState::~PerFunctionState() { 1567 // If there were any forward referenced non-basicblock values, delete them. 1568 for (std::map<std::string, std::pair<Value*, LocTy> >::iterator 1569 I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I) 1570 if (!isa<BasicBlock>(I->second.first)) { 1571 I->second.first->replaceAllUsesWith( 1572 UndefValue::get(I->second.first->getType())); 1573 delete I->second.first; 1574 I->second.first = 0; 1575 } 1576 1577 for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator 1578 I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I) 1579 if (!isa<BasicBlock>(I->second.first)) { 1580 I->second.first->replaceAllUsesWith( 1581 UndefValue::get(I->second.first->getType())); 1582 delete I->second.first; 1583 I->second.first = 0; 1584 } 1585} 1586 1587bool LLParser::PerFunctionState::VerifyFunctionComplete() { 1588 if (!ForwardRefVals.empty()) 1589 return P.Error(ForwardRefVals.begin()->second.second, 1590 "use of undefined value '%" + ForwardRefVals.begin()->first + 1591 "'"); 1592 if (!ForwardRefValIDs.empty()) 1593 return P.Error(ForwardRefValIDs.begin()->second.second, 1594 "use of undefined value '%" + 1595 utostr(ForwardRefValIDs.begin()->first) + "'"); 1596 return false; 1597} 1598 1599 1600/// GetVal - Get a value with the specified name or ID, creating a 1601/// forward reference record if needed. This can return null if the value 1602/// exists but does not have the right type. 1603Value *LLParser::PerFunctionState::GetVal(const std::string &Name, 1604 const Type *Ty, LocTy Loc) { 1605 // Look this name up in the normal function symbol table. 1606 Value *Val = F.getValueSymbolTable().lookup(Name); 1607 1608 // If this is a forward reference for the value, see if we already created a 1609 // forward ref record. 1610 if (Val == 0) { 1611 std::map<std::string, std::pair<Value*, LocTy> >::iterator 1612 I = ForwardRefVals.find(Name); 1613 if (I != ForwardRefVals.end()) 1614 Val = I->second.first; 1615 } 1616 1617 // If we have the value in the symbol table or fwd-ref table, return it. 1618 if (Val) { 1619 if (Val->getType() == Ty) return Val; 1620 if (Ty == Type::getLabelTy(F.getContext())) 1621 P.Error(Loc, "'%" + Name + "' is not a basic block"); 1622 else 1623 P.Error(Loc, "'%" + Name + "' defined with type '" + 1624 Val->getType()->getDescription() + "'"); 1625 return 0; 1626 } 1627 1628 // Don't make placeholders with invalid type. 1629 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) && 1630 Ty != Type::getLabelTy(F.getContext())) { 1631 P.Error(Loc, "invalid use of a non-first-class type"); 1632 return 0; 1633 } 1634 1635 // Otherwise, create a new forward reference for this value and remember it. 1636 Value *FwdVal; 1637 if (Ty == Type::getLabelTy(F.getContext())) 1638 FwdVal = BasicBlock::Create(F.getContext(), Name, &F); 1639 else 1640 FwdVal = new Argument(Ty, Name); 1641 1642 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc); 1643 return FwdVal; 1644} 1645 1646Value *LLParser::PerFunctionState::GetVal(unsigned ID, const Type *Ty, 1647 LocTy Loc) { 1648 // Look this name up in the normal function symbol table. 1649 Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0; 1650 1651 // If this is a forward reference for the value, see if we already created a 1652 // forward ref record. 1653 if (Val == 0) { 1654 std::map<unsigned, std::pair<Value*, LocTy> >::iterator 1655 I = ForwardRefValIDs.find(ID); 1656 if (I != ForwardRefValIDs.end()) 1657 Val = I->second.first; 1658 } 1659 1660 // If we have the value in the symbol table or fwd-ref table, return it. 1661 if (Val) { 1662 if (Val->getType() == Ty) return Val; 1663 if (Ty == Type::getLabelTy(F.getContext())) 1664 P.Error(Loc, "'%" + utostr(ID) + "' is not a basic block"); 1665 else 1666 P.Error(Loc, "'%" + utostr(ID) + "' defined with type '" + 1667 Val->getType()->getDescription() + "'"); 1668 return 0; 1669 } 1670 1671 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) && 1672 Ty != Type::getLabelTy(F.getContext())) { 1673 P.Error(Loc, "invalid use of a non-first-class type"); 1674 return 0; 1675 } 1676 1677 // Otherwise, create a new forward reference for this value and remember it. 1678 Value *FwdVal; 1679 if (Ty == Type::getLabelTy(F.getContext())) 1680 FwdVal = BasicBlock::Create(F.getContext(), "", &F); 1681 else 1682 FwdVal = new Argument(Ty); 1683 1684 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc); 1685 return FwdVal; 1686} 1687 1688/// SetInstName - After an instruction is parsed and inserted into its 1689/// basic block, this installs its name. 1690bool LLParser::PerFunctionState::SetInstName(int NameID, 1691 const std::string &NameStr, 1692 LocTy NameLoc, Instruction *Inst) { 1693 // If this instruction has void type, it cannot have a name or ID specified. 1694 if (Inst->getType() == Type::getVoidTy(F.getContext())) { 1695 if (NameID != -1 || !NameStr.empty()) 1696 return P.Error(NameLoc, "instructions returning void cannot have a name"); 1697 return false; 1698 } 1699 1700 // If this was a numbered instruction, verify that the instruction is the 1701 // expected value and resolve any forward references. 1702 if (NameStr.empty()) { 1703 // If neither a name nor an ID was specified, just use the next ID. 1704 if (NameID == -1) 1705 NameID = NumberedVals.size(); 1706 1707 if (unsigned(NameID) != NumberedVals.size()) 1708 return P.Error(NameLoc, "instruction expected to be numbered '%" + 1709 utostr(NumberedVals.size()) + "'"); 1710 1711 std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI = 1712 ForwardRefValIDs.find(NameID); 1713 if (FI != ForwardRefValIDs.end()) { 1714 if (FI->second.first->getType() != Inst->getType()) 1715 return P.Error(NameLoc, "instruction forward referenced with type '" + 1716 FI->second.first->getType()->getDescription() + "'"); 1717 FI->second.first->replaceAllUsesWith(Inst); 1718 delete FI->second.first; 1719 ForwardRefValIDs.erase(FI); 1720 } 1721 1722 NumberedVals.push_back(Inst); 1723 return false; 1724 } 1725 1726 // Otherwise, the instruction had a name. Resolve forward refs and set it. 1727 std::map<std::string, std::pair<Value*, LocTy> >::iterator 1728 FI = ForwardRefVals.find(NameStr); 1729 if (FI != ForwardRefVals.end()) { 1730 if (FI->second.first->getType() != Inst->getType()) 1731 return P.Error(NameLoc, "instruction forward referenced with type '" + 1732 FI->second.first->getType()->getDescription() + "'"); 1733 FI->second.first->replaceAllUsesWith(Inst); 1734 delete FI->second.first; 1735 ForwardRefVals.erase(FI); 1736 } 1737 1738 // Set the name on the instruction. 1739 Inst->setName(NameStr); 1740 1741 if (Inst->getNameStr() != NameStr) 1742 return P.Error(NameLoc, "multiple definition of local value named '" + 1743 NameStr + "'"); 1744 return false; 1745} 1746 1747/// GetBB - Get a basic block with the specified name or ID, creating a 1748/// forward reference record if needed. 1749BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name, 1750 LocTy Loc) { 1751 return cast_or_null<BasicBlock>(GetVal(Name, 1752 Type::getLabelTy(F.getContext()), Loc)); 1753} 1754 1755BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) { 1756 return cast_or_null<BasicBlock>(GetVal(ID, 1757 Type::getLabelTy(F.getContext()), Loc)); 1758} 1759 1760/// DefineBB - Define the specified basic block, which is either named or 1761/// unnamed. If there is an error, this returns null otherwise it returns 1762/// the block being defined. 1763BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name, 1764 LocTy Loc) { 1765 BasicBlock *BB; 1766 if (Name.empty()) 1767 BB = GetBB(NumberedVals.size(), Loc); 1768 else 1769 BB = GetBB(Name, Loc); 1770 if (BB == 0) return 0; // Already diagnosed error. 1771 1772 // Move the block to the end of the function. Forward ref'd blocks are 1773 // inserted wherever they happen to be referenced. 1774 F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB); 1775 1776 // Remove the block from forward ref sets. 1777 if (Name.empty()) { 1778 ForwardRefValIDs.erase(NumberedVals.size()); 1779 NumberedVals.push_back(BB); 1780 } else { 1781 // BB forward references are already in the function symbol table. 1782 ForwardRefVals.erase(Name); 1783 } 1784 1785 return BB; 1786} 1787 1788//===----------------------------------------------------------------------===// 1789// Constants. 1790//===----------------------------------------------------------------------===// 1791 1792/// ParseValID - Parse an abstract value that doesn't necessarily have a 1793/// type implied. For example, if we parse "4" we don't know what integer type 1794/// it has. The value will later be combined with its type and checked for 1795/// sanity. 1796bool LLParser::ParseValID(ValID &ID) { 1797 ID.Loc = Lex.getLoc(); 1798 switch (Lex.getKind()) { 1799 default: return TokError("expected value token"); 1800 case lltok::GlobalID: // @42 1801 ID.UIntVal = Lex.getUIntVal(); 1802 ID.Kind = ValID::t_GlobalID; 1803 break; 1804 case lltok::GlobalVar: // @foo 1805 ID.StrVal = Lex.getStrVal(); 1806 ID.Kind = ValID::t_GlobalName; 1807 break; 1808 case lltok::LocalVarID: // %42 1809 ID.UIntVal = Lex.getUIntVal(); 1810 ID.Kind = ValID::t_LocalID; 1811 break; 1812 case lltok::LocalVar: // %foo 1813 case lltok::StringConstant: // "foo" - FIXME: REMOVE IN LLVM 3.0 1814 ID.StrVal = Lex.getStrVal(); 1815 ID.Kind = ValID::t_LocalName; 1816 break; 1817 case lltok::Metadata: { // !{...} MDNode, !"foo" MDString 1818 ID.Kind = ValID::t_Metadata; 1819 Lex.Lex(); 1820 if (Lex.getKind() == lltok::lbrace) { 1821 SmallVector<Value*, 16> Elts; 1822 if (ParseMDNodeVector(Elts) || 1823 ParseToken(lltok::rbrace, "expected end of metadata node")) 1824 return true; 1825 1826 ID.MetadataVal = MDNode::get(Context, Elts.data(), Elts.size()); 1827 return false; 1828 } 1829 1830 // Standalone metadata reference 1831 // !{ ..., !42, ... } 1832 if (!ParseMDNode(ID.MetadataVal)) 1833 return false; 1834 1835 // MDString: 1836 // ::= '!' STRINGCONSTANT 1837 if (ParseMDString(ID.MetadataVal)) return true; 1838 ID.Kind = ValID::t_Metadata; 1839 return false; 1840 } 1841 case lltok::APSInt: 1842 ID.APSIntVal = Lex.getAPSIntVal(); 1843 ID.Kind = ValID::t_APSInt; 1844 break; 1845 case lltok::APFloat: 1846 ID.APFloatVal = Lex.getAPFloatVal(); 1847 ID.Kind = ValID::t_APFloat; 1848 break; 1849 case lltok::kw_true: 1850 ID.ConstantVal = ConstantInt::getTrue(Context); 1851 ID.Kind = ValID::t_Constant; 1852 break; 1853 case lltok::kw_false: 1854 ID.ConstantVal = ConstantInt::getFalse(Context); 1855 ID.Kind = ValID::t_Constant; 1856 break; 1857 case lltok::kw_null: ID.Kind = ValID::t_Null; break; 1858 case lltok::kw_undef: ID.Kind = ValID::t_Undef; break; 1859 case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break; 1860 1861 case lltok::lbrace: { 1862 // ValID ::= '{' ConstVector '}' 1863 Lex.Lex(); 1864 SmallVector<Constant*, 16> Elts; 1865 if (ParseGlobalValueVector(Elts) || 1866 ParseToken(lltok::rbrace, "expected end of struct constant")) 1867 return true; 1868 1869 ID.ConstantVal = ConstantStruct::get(Context, Elts.data(), 1870 Elts.size(), false); 1871 ID.Kind = ValID::t_Constant; 1872 return false; 1873 } 1874 case lltok::less: { 1875 // ValID ::= '<' ConstVector '>' --> Vector. 1876 // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct. 1877 Lex.Lex(); 1878 bool isPackedStruct = EatIfPresent(lltok::lbrace); 1879 1880 SmallVector<Constant*, 16> Elts; 1881 LocTy FirstEltLoc = Lex.getLoc(); 1882 if (ParseGlobalValueVector(Elts) || 1883 (isPackedStruct && 1884 ParseToken(lltok::rbrace, "expected end of packed struct")) || 1885 ParseToken(lltok::greater, "expected end of constant")) 1886 return true; 1887 1888 if (isPackedStruct) { 1889 ID.ConstantVal = 1890 ConstantStruct::get(Context, Elts.data(), Elts.size(), true); 1891 ID.Kind = ValID::t_Constant; 1892 return false; 1893 } 1894 1895 if (Elts.empty()) 1896 return Error(ID.Loc, "constant vector must not be empty"); 1897 1898 if (!Elts[0]->getType()->isInteger() && 1899 !Elts[0]->getType()->isFloatingPoint()) 1900 return Error(FirstEltLoc, 1901 "vector elements must have integer or floating point type"); 1902 1903 // Verify that all the vector elements have the same type. 1904 for (unsigned i = 1, e = Elts.size(); i != e; ++i) 1905 if (Elts[i]->getType() != Elts[0]->getType()) 1906 return Error(FirstEltLoc, 1907 "vector element #" + utostr(i) + 1908 " is not of type '" + Elts[0]->getType()->getDescription()); 1909 1910 ID.ConstantVal = ConstantVector::get(Elts.data(), Elts.size()); 1911 ID.Kind = ValID::t_Constant; 1912 return false; 1913 } 1914 case lltok::lsquare: { // Array Constant 1915 Lex.Lex(); 1916 SmallVector<Constant*, 16> Elts; 1917 LocTy FirstEltLoc = Lex.getLoc(); 1918 if (ParseGlobalValueVector(Elts) || 1919 ParseToken(lltok::rsquare, "expected end of array constant")) 1920 return true; 1921 1922 // Handle empty element. 1923 if (Elts.empty()) { 1924 // Use undef instead of an array because it's inconvenient to determine 1925 // the element type at this point, there being no elements to examine. 1926 ID.Kind = ValID::t_EmptyArray; 1927 return false; 1928 } 1929 1930 if (!Elts[0]->getType()->isFirstClassType()) 1931 return Error(FirstEltLoc, "invalid array element type: " + 1932 Elts[0]->getType()->getDescription()); 1933 1934 ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size()); 1935 1936 // Verify all elements are correct type! 1937 for (unsigned i = 0, e = Elts.size(); i != e; ++i) { 1938 if (Elts[i]->getType() != Elts[0]->getType()) 1939 return Error(FirstEltLoc, 1940 "array element #" + utostr(i) + 1941 " is not of type '" +Elts[0]->getType()->getDescription()); 1942 } 1943 1944 ID.ConstantVal = ConstantArray::get(ATy, Elts.data(), Elts.size()); 1945 ID.Kind = ValID::t_Constant; 1946 return false; 1947 } 1948 case lltok::kw_c: // c "foo" 1949 Lex.Lex(); 1950 ID.ConstantVal = ConstantArray::get(Context, Lex.getStrVal(), false); 1951 if (ParseToken(lltok::StringConstant, "expected string")) return true; 1952 ID.Kind = ValID::t_Constant; 1953 return false; 1954 1955 case lltok::kw_asm: { 1956 // ValID ::= 'asm' SideEffect? STRINGCONSTANT ',' STRINGCONSTANT 1957 bool HasSideEffect; 1958 Lex.Lex(); 1959 if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) || 1960 ParseStringConstant(ID.StrVal) || 1961 ParseToken(lltok::comma, "expected comma in inline asm expression") || 1962 ParseToken(lltok::StringConstant, "expected constraint string")) 1963 return true; 1964 ID.StrVal2 = Lex.getStrVal(); 1965 ID.UIntVal = HasSideEffect; 1966 ID.Kind = ValID::t_InlineAsm; 1967 return false; 1968 } 1969 1970 case lltok::kw_trunc: 1971 case lltok::kw_zext: 1972 case lltok::kw_sext: 1973 case lltok::kw_fptrunc: 1974 case lltok::kw_fpext: 1975 case lltok::kw_bitcast: 1976 case lltok::kw_uitofp: 1977 case lltok::kw_sitofp: 1978 case lltok::kw_fptoui: 1979 case lltok::kw_fptosi: 1980 case lltok::kw_inttoptr: 1981 case lltok::kw_ptrtoint: { 1982 unsigned Opc = Lex.getUIntVal(); 1983 PATypeHolder DestTy(Type::getVoidTy(Context)); 1984 Constant *SrcVal; 1985 Lex.Lex(); 1986 if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") || 1987 ParseGlobalTypeAndValue(SrcVal) || 1988 ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") || 1989 ParseType(DestTy) || 1990 ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast")) 1991 return true; 1992 if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy)) 1993 return Error(ID.Loc, "invalid cast opcode for cast from '" + 1994 SrcVal->getType()->getDescription() + "' to '" + 1995 DestTy->getDescription() + "'"); 1996 ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc, 1997 SrcVal, DestTy); 1998 ID.Kind = ValID::t_Constant; 1999 return false; 2000 } 2001 case lltok::kw_extractvalue: { 2002 Lex.Lex(); 2003 Constant *Val; 2004 SmallVector<unsigned, 4> Indices; 2005 if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")|| 2006 ParseGlobalTypeAndValue(Val) || 2007 ParseIndexList(Indices) || 2008 ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr")) 2009 return true; 2010 if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType())) 2011 return Error(ID.Loc, "extractvalue operand must be array or struct"); 2012 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(), 2013 Indices.end())) 2014 return Error(ID.Loc, "invalid indices for extractvalue"); 2015 ID.ConstantVal = 2016 ConstantExpr::getExtractValue(Val, Indices.data(), Indices.size()); 2017 ID.Kind = ValID::t_Constant; 2018 return false; 2019 } 2020 case lltok::kw_insertvalue: { 2021 Lex.Lex(); 2022 Constant *Val0, *Val1; 2023 SmallVector<unsigned, 4> Indices; 2024 if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")|| 2025 ParseGlobalTypeAndValue(Val0) || 2026 ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")|| 2027 ParseGlobalTypeAndValue(Val1) || 2028 ParseIndexList(Indices) || 2029 ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr")) 2030 return true; 2031 if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType())) 2032 return Error(ID.Loc, "extractvalue operand must be array or struct"); 2033 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(), 2034 Indices.end())) 2035 return Error(ID.Loc, "invalid indices for insertvalue"); 2036 ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, 2037 Indices.data(), Indices.size()); 2038 ID.Kind = ValID::t_Constant; 2039 return false; 2040 } 2041 case lltok::kw_icmp: 2042 case lltok::kw_fcmp: { 2043 unsigned PredVal, Opc = Lex.getUIntVal(); 2044 Constant *Val0, *Val1; 2045 Lex.Lex(); 2046 if (ParseCmpPredicate(PredVal, Opc) || 2047 ParseToken(lltok::lparen, "expected '(' in compare constantexpr") || 2048 ParseGlobalTypeAndValue(Val0) || 2049 ParseToken(lltok::comma, "expected comma in compare constantexpr") || 2050 ParseGlobalTypeAndValue(Val1) || 2051 ParseToken(lltok::rparen, "expected ')' in compare constantexpr")) 2052 return true; 2053 2054 if (Val0->getType() != Val1->getType()) 2055 return Error(ID.Loc, "compare operands must have the same type"); 2056 2057 CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal; 2058 2059 if (Opc == Instruction::FCmp) { 2060 if (!Val0->getType()->isFPOrFPVector()) 2061 return Error(ID.Loc, "fcmp requires floating point operands"); 2062 ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1); 2063 } else { 2064 assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!"); 2065 if (!Val0->getType()->isIntOrIntVector() && 2066 !isa<PointerType>(Val0->getType())) 2067 return Error(ID.Loc, "icmp requires pointer or integer operands"); 2068 ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1); 2069 } 2070 ID.Kind = ValID::t_Constant; 2071 return false; 2072 } 2073 2074 // Binary Operators. 2075 case lltok::kw_add: 2076 case lltok::kw_fadd: 2077 case lltok::kw_sub: 2078 case lltok::kw_fsub: 2079 case lltok::kw_mul: 2080 case lltok::kw_fmul: 2081 case lltok::kw_udiv: 2082 case lltok::kw_sdiv: 2083 case lltok::kw_fdiv: 2084 case lltok::kw_urem: 2085 case lltok::kw_srem: 2086 case lltok::kw_frem: { 2087 bool NUW = false; 2088 bool NSW = false; 2089 bool Exact = false; 2090 unsigned Opc = Lex.getUIntVal(); 2091 Constant *Val0, *Val1; 2092 Lex.Lex(); 2093 LocTy ModifierLoc = Lex.getLoc(); 2094 if (Opc == Instruction::Add || 2095 Opc == Instruction::Sub || 2096 Opc == Instruction::Mul) { 2097 if (EatIfPresent(lltok::kw_nuw)) 2098 NUW = true; 2099 if (EatIfPresent(lltok::kw_nsw)) { 2100 NSW = true; 2101 if (EatIfPresent(lltok::kw_nuw)) 2102 NUW = true; 2103 } 2104 } else if (Opc == Instruction::SDiv) { 2105 if (EatIfPresent(lltok::kw_exact)) 2106 Exact = true; 2107 } 2108 if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") || 2109 ParseGlobalTypeAndValue(Val0) || 2110 ParseToken(lltok::comma, "expected comma in binary constantexpr") || 2111 ParseGlobalTypeAndValue(Val1) || 2112 ParseToken(lltok::rparen, "expected ')' in binary constantexpr")) 2113 return true; 2114 if (Val0->getType() != Val1->getType()) 2115 return Error(ID.Loc, "operands of constexpr must have same type"); 2116 if (!Val0->getType()->isIntOrIntVector()) { 2117 if (NUW) 2118 return Error(ModifierLoc, "nuw only applies to integer operations"); 2119 if (NSW) 2120 return Error(ModifierLoc, "nsw only applies to integer operations"); 2121 } 2122 // API compatibility: Accept either integer or floating-point types with 2123 // add, sub, and mul. 2124 if (!Val0->getType()->isIntOrIntVector() && 2125 !Val0->getType()->isFPOrFPVector()) 2126 return Error(ID.Loc,"constexpr requires integer, fp, or vector operands"); 2127 unsigned Flags = 0; 2128 if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 2129 if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap; 2130 if (Exact) Flags |= SDivOperator::IsExact; 2131 Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags); 2132 ID.ConstantVal = C; 2133 ID.Kind = ValID::t_Constant; 2134 return false; 2135 } 2136 2137 // Logical Operations 2138 case lltok::kw_shl: 2139 case lltok::kw_lshr: 2140 case lltok::kw_ashr: 2141 case lltok::kw_and: 2142 case lltok::kw_or: 2143 case lltok::kw_xor: { 2144 unsigned Opc = Lex.getUIntVal(); 2145 Constant *Val0, *Val1; 2146 Lex.Lex(); 2147 if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") || 2148 ParseGlobalTypeAndValue(Val0) || 2149 ParseToken(lltok::comma, "expected comma in logical constantexpr") || 2150 ParseGlobalTypeAndValue(Val1) || 2151 ParseToken(lltok::rparen, "expected ')' in logical constantexpr")) 2152 return true; 2153 if (Val0->getType() != Val1->getType()) 2154 return Error(ID.Loc, "operands of constexpr must have same type"); 2155 if (!Val0->getType()->isIntOrIntVector()) 2156 return Error(ID.Loc, 2157 "constexpr requires integer or integer vector operands"); 2158 ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1); 2159 ID.Kind = ValID::t_Constant; 2160 return false; 2161 } 2162 2163 case lltok::kw_getelementptr: 2164 case lltok::kw_shufflevector: 2165 case lltok::kw_insertelement: 2166 case lltok::kw_extractelement: 2167 case lltok::kw_select: { 2168 unsigned Opc = Lex.getUIntVal(); 2169 SmallVector<Constant*, 16> Elts; 2170 bool InBounds = false; 2171 Lex.Lex(); 2172 if (Opc == Instruction::GetElementPtr) 2173 InBounds = EatIfPresent(lltok::kw_inbounds); 2174 if (ParseToken(lltok::lparen, "expected '(' in constantexpr") || 2175 ParseGlobalValueVector(Elts) || 2176 ParseToken(lltok::rparen, "expected ')' in constantexpr")) 2177 return true; 2178 2179 if (Opc == Instruction::GetElementPtr) { 2180 if (Elts.size() == 0 || !isa<PointerType>(Elts[0]->getType())) 2181 return Error(ID.Loc, "getelementptr requires pointer operand"); 2182 2183 if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(), 2184 (Value**)(Elts.data() + 1), 2185 Elts.size() - 1)) 2186 return Error(ID.Loc, "invalid indices for getelementptr"); 2187 ID.ConstantVal = InBounds ? 2188 ConstantExpr::getInBoundsGetElementPtr(Elts[0], 2189 Elts.data() + 1, 2190 Elts.size() - 1) : 2191 ConstantExpr::getGetElementPtr(Elts[0], 2192 Elts.data() + 1, Elts.size() - 1); 2193 } else if (Opc == Instruction::Select) { 2194 if (Elts.size() != 3) 2195 return Error(ID.Loc, "expected three operands to select"); 2196 if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1], 2197 Elts[2])) 2198 return Error(ID.Loc, Reason); 2199 ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]); 2200 } else if (Opc == Instruction::ShuffleVector) { 2201 if (Elts.size() != 3) 2202 return Error(ID.Loc, "expected three operands to shufflevector"); 2203 if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2])) 2204 return Error(ID.Loc, "invalid operands to shufflevector"); 2205 ID.ConstantVal = 2206 ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]); 2207 } else if (Opc == Instruction::ExtractElement) { 2208 if (Elts.size() != 2) 2209 return Error(ID.Loc, "expected two operands to extractelement"); 2210 if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1])) 2211 return Error(ID.Loc, "invalid extractelement operands"); 2212 ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]); 2213 } else { 2214 assert(Opc == Instruction::InsertElement && "Unknown opcode"); 2215 if (Elts.size() != 3) 2216 return Error(ID.Loc, "expected three operands to insertelement"); 2217 if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2])) 2218 return Error(ID.Loc, "invalid insertelement operands"); 2219 ID.ConstantVal = 2220 ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]); 2221 } 2222 2223 ID.Kind = ValID::t_Constant; 2224 return false; 2225 } 2226 } 2227 2228 Lex.Lex(); 2229 return false; 2230} 2231 2232/// ParseGlobalValue - Parse a global value with the specified type. 2233bool LLParser::ParseGlobalValue(const Type *Ty, Constant *&V) { 2234 V = 0; 2235 ValID ID; 2236 return ParseValID(ID) || 2237 ConvertGlobalValIDToValue(Ty, ID, V); 2238} 2239 2240/// ConvertGlobalValIDToValue - Apply a type to a ValID to get a fully resolved 2241/// constant. 2242bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, 2243 Constant *&V) { 2244 if (isa<FunctionType>(Ty)) 2245 return Error(ID.Loc, "functions are not values, refer to them as pointers"); 2246 2247 switch (ID.Kind) { 2248 default: llvm_unreachable("Unknown ValID!"); 2249 case ValID::t_Metadata: 2250 return Error(ID.Loc, "invalid use of metadata"); 2251 case ValID::t_LocalID: 2252 case ValID::t_LocalName: 2253 return Error(ID.Loc, "invalid use of function-local name"); 2254 case ValID::t_InlineAsm: 2255 return Error(ID.Loc, "inline asm can only be an operand of call/invoke"); 2256 case ValID::t_GlobalName: 2257 V = GetGlobalVal(ID.StrVal, Ty, ID.Loc); 2258 return V == 0; 2259 case ValID::t_GlobalID: 2260 V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc); 2261 return V == 0; 2262 case ValID::t_APSInt: 2263 if (!isa<IntegerType>(Ty)) 2264 return Error(ID.Loc, "integer constant must have integer type"); 2265 ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits()); 2266 V = ConstantInt::get(Context, ID.APSIntVal); 2267 return false; 2268 case ValID::t_APFloat: 2269 if (!Ty->isFloatingPoint() || 2270 !ConstantFP::isValueValidForType(Ty, ID.APFloatVal)) 2271 return Error(ID.Loc, "floating point constant invalid for type"); 2272 2273 // The lexer has no type info, so builds all float and double FP constants 2274 // as double. Fix this here. Long double does not need this. 2275 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble && 2276 Ty == Type::getFloatTy(Context)) { 2277 bool Ignored; 2278 ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, 2279 &Ignored); 2280 } 2281 V = ConstantFP::get(Context, ID.APFloatVal); 2282 2283 if (V->getType() != Ty) 2284 return Error(ID.Loc, "floating point constant does not have type '" + 2285 Ty->getDescription() + "'"); 2286 2287 return false; 2288 case ValID::t_Null: 2289 if (!isa<PointerType>(Ty)) 2290 return Error(ID.Loc, "null must be a pointer type"); 2291 V = ConstantPointerNull::get(cast<PointerType>(Ty)); 2292 return false; 2293 case ValID::t_Undef: 2294 // FIXME: LabelTy should not be a first-class type. 2295 if ((!Ty->isFirstClassType() || Ty == Type::getLabelTy(Context)) && 2296 !isa<OpaqueType>(Ty)) 2297 return Error(ID.Loc, "invalid type for undef constant"); 2298 V = UndefValue::get(Ty); 2299 return false; 2300 case ValID::t_EmptyArray: 2301 if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0) 2302 return Error(ID.Loc, "invalid empty array initializer"); 2303 V = UndefValue::get(Ty); 2304 return false; 2305 case ValID::t_Zero: 2306 // FIXME: LabelTy should not be a first-class type. 2307 if (!Ty->isFirstClassType() || Ty == Type::getLabelTy(Context)) 2308 return Error(ID.Loc, "invalid type for null constant"); 2309 V = Constant::getNullValue(Ty); 2310 return false; 2311 case ValID::t_Constant: 2312 if (ID.ConstantVal->getType() != Ty) 2313 return Error(ID.Loc, "constant expression type mismatch"); 2314 V = ID.ConstantVal; 2315 return false; 2316 } 2317} 2318 2319bool LLParser::ParseGlobalTypeAndValue(Constant *&V) { 2320 PATypeHolder Type(Type::getVoidTy(Context)); 2321 return ParseType(Type) || 2322 ParseGlobalValue(Type, V); 2323} 2324 2325/// ParseGlobalValueVector 2326/// ::= /*empty*/ 2327/// ::= TypeAndValue (',' TypeAndValue)* 2328bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts) { 2329 // Empty list. 2330 if (Lex.getKind() == lltok::rbrace || 2331 Lex.getKind() == lltok::rsquare || 2332 Lex.getKind() == lltok::greater || 2333 Lex.getKind() == lltok::rparen) 2334 return false; 2335 2336 Constant *C; 2337 if (ParseGlobalTypeAndValue(C)) return true; 2338 Elts.push_back(C); 2339 2340 while (EatIfPresent(lltok::comma)) { 2341 if (ParseGlobalTypeAndValue(C)) return true; 2342 Elts.push_back(C); 2343 } 2344 2345 return false; 2346} 2347 2348 2349//===----------------------------------------------------------------------===// 2350// Function Parsing. 2351//===----------------------------------------------------------------------===// 2352 2353bool LLParser::ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V, 2354 PerFunctionState &PFS) { 2355 if (ID.Kind == ValID::t_LocalID) 2356 V = PFS.GetVal(ID.UIntVal, Ty, ID.Loc); 2357 else if (ID.Kind == ValID::t_LocalName) 2358 V = PFS.GetVal(ID.StrVal, Ty, ID.Loc); 2359 else if (ID.Kind == ValID::t_InlineAsm) { 2360 const PointerType *PTy = dyn_cast<PointerType>(Ty); 2361 const FunctionType *FTy = 2362 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0; 2363 if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2)) 2364 return Error(ID.Loc, "invalid type for inline asm constraint string"); 2365 V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal); 2366 return false; 2367 } else if (ID.Kind == ValID::t_Metadata) { 2368 V = ID.MetadataVal; 2369 } else { 2370 Constant *C; 2371 if (ConvertGlobalValIDToValue(Ty, ID, C)) return true; 2372 V = C; 2373 return false; 2374 } 2375 2376 return V == 0; 2377} 2378 2379bool LLParser::ParseValue(const Type *Ty, Value *&V, PerFunctionState &PFS) { 2380 V = 0; 2381 ValID ID; 2382 return ParseValID(ID) || 2383 ConvertValIDToValue(Ty, ID, V, PFS); 2384} 2385 2386bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState &PFS) { 2387 PATypeHolder T(Type::getVoidTy(Context)); 2388 return ParseType(T) || 2389 ParseValue(T, V, PFS); 2390} 2391 2392/// FunctionHeader 2393/// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs 2394/// Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection 2395/// OptionalAlign OptGC 2396bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { 2397 // Parse the linkage. 2398 LocTy LinkageLoc = Lex.getLoc(); 2399 unsigned Linkage; 2400 2401 unsigned Visibility, RetAttrs; 2402 CallingConv::ID CC; 2403 PATypeHolder RetType(Type::getVoidTy(Context)); 2404 LocTy RetTypeLoc = Lex.getLoc(); 2405 if (ParseOptionalLinkage(Linkage) || 2406 ParseOptionalVisibility(Visibility) || 2407 ParseOptionalCallingConv(CC) || 2408 ParseOptionalAttrs(RetAttrs, 1) || 2409 ParseType(RetType, RetTypeLoc, true /*void allowed*/)) 2410 return true; 2411 2412 // Verify that the linkage is ok. 2413 switch ((GlobalValue::LinkageTypes)Linkage) { 2414 case GlobalValue::ExternalLinkage: 2415 break; // always ok. 2416 case GlobalValue::DLLImportLinkage: 2417 case GlobalValue::ExternalWeakLinkage: 2418 if (isDefine) 2419 return Error(LinkageLoc, "invalid linkage for function definition"); 2420 break; 2421 case GlobalValue::PrivateLinkage: 2422 case GlobalValue::LinkerPrivateLinkage: 2423 case GlobalValue::InternalLinkage: 2424 case GlobalValue::AvailableExternallyLinkage: 2425 case GlobalValue::LinkOnceAnyLinkage: 2426 case GlobalValue::LinkOnceODRLinkage: 2427 case GlobalValue::WeakAnyLinkage: 2428 case GlobalValue::WeakODRLinkage: 2429 case GlobalValue::DLLExportLinkage: 2430 if (!isDefine) 2431 return Error(LinkageLoc, "invalid linkage for function declaration"); 2432 break; 2433 case GlobalValue::AppendingLinkage: 2434 case GlobalValue::GhostLinkage: 2435 case GlobalValue::CommonLinkage: 2436 return Error(LinkageLoc, "invalid function linkage type"); 2437 } 2438 2439 if (!FunctionType::isValidReturnType(RetType) || 2440 isa<OpaqueType>(RetType)) 2441 return Error(RetTypeLoc, "invalid function return type"); 2442 2443 LocTy NameLoc = Lex.getLoc(); 2444 2445 std::string FunctionName; 2446 if (Lex.getKind() == lltok::GlobalVar) { 2447 FunctionName = Lex.getStrVal(); 2448 } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok. 2449 unsigned NameID = Lex.getUIntVal(); 2450 2451 if (NameID != NumberedVals.size()) 2452 return TokError("function expected to be numbered '%" + 2453 utostr(NumberedVals.size()) + "'"); 2454 } else { 2455 return TokError("expected function name"); 2456 } 2457 2458 Lex.Lex(); 2459 2460 if (Lex.getKind() != lltok::lparen) 2461 return TokError("expected '(' in function argument list"); 2462 2463 std::vector<ArgInfo> ArgList; 2464 bool isVarArg; 2465 unsigned FuncAttrs; 2466 std::string Section; 2467 unsigned Alignment; 2468 std::string GC; 2469 2470 if (ParseArgumentList(ArgList, isVarArg, false) || 2471 ParseOptionalAttrs(FuncAttrs, 2) || 2472 (EatIfPresent(lltok::kw_section) && 2473 ParseStringConstant(Section)) || 2474 ParseOptionalAlignment(Alignment) || 2475 (EatIfPresent(lltok::kw_gc) && 2476 ParseStringConstant(GC))) 2477 return true; 2478 2479 // If the alignment was parsed as an attribute, move to the alignment field. 2480 if (FuncAttrs & Attribute::Alignment) { 2481 Alignment = Attribute::getAlignmentFromAttrs(FuncAttrs); 2482 FuncAttrs &= ~Attribute::Alignment; 2483 } 2484 2485 // Okay, if we got here, the function is syntactically valid. Convert types 2486 // and do semantic checks. 2487 std::vector<const Type*> ParamTypeList; 2488 SmallVector<AttributeWithIndex, 8> Attrs; 2489 // FIXME : In 3.0, stop accepting zext, sext and inreg as optional function 2490 // attributes. 2491 unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; 2492 if (FuncAttrs & ObsoleteFuncAttrs) { 2493 RetAttrs |= FuncAttrs & ObsoleteFuncAttrs; 2494 FuncAttrs &= ~ObsoleteFuncAttrs; 2495 } 2496 2497 if (RetAttrs != Attribute::None) 2498 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); 2499 2500 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 2501 ParamTypeList.push_back(ArgList[i].Type); 2502 if (ArgList[i].Attrs != Attribute::None) 2503 Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); 2504 } 2505 2506 if (FuncAttrs != Attribute::None) 2507 Attrs.push_back(AttributeWithIndex::get(~0, FuncAttrs)); 2508 2509 AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); 2510 2511 if (PAL.paramHasAttr(1, Attribute::StructRet) && 2512 RetType != Type::getVoidTy(Context)) 2513 return Error(RetTypeLoc, "functions with 'sret' argument must return void"); 2514 2515 const FunctionType *FT = 2516 FunctionType::get(RetType, ParamTypeList, isVarArg); 2517 const PointerType *PFT = PointerType::getUnqual(FT); 2518 2519 Fn = 0; 2520 if (!FunctionName.empty()) { 2521 // If this was a definition of a forward reference, remove the definition 2522 // from the forward reference table and fill in the forward ref. 2523 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator FRVI = 2524 ForwardRefVals.find(FunctionName); 2525 if (FRVI != ForwardRefVals.end()) { 2526 Fn = M->getFunction(FunctionName); 2527 ForwardRefVals.erase(FRVI); 2528 } else if ((Fn = M->getFunction(FunctionName))) { 2529 // If this function already exists in the symbol table, then it is 2530 // multiply defined. We accept a few cases for old backwards compat. 2531 // FIXME: Remove this stuff for LLVM 3.0. 2532 if (Fn->getType() != PFT || Fn->getAttributes() != PAL || 2533 (!Fn->isDeclaration() && isDefine)) { 2534 // If the redefinition has different type or different attributes, 2535 // reject it. If both have bodies, reject it. 2536 return Error(NameLoc, "invalid redefinition of function '" + 2537 FunctionName + "'"); 2538 } else if (Fn->isDeclaration()) { 2539 // Make sure to strip off any argument names so we can't get conflicts. 2540 for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end(); 2541 AI != AE; ++AI) 2542 AI->setName(""); 2543 } 2544 } 2545 2546 } else { 2547 // If this is a definition of a forward referenced function, make sure the 2548 // types agree. 2549 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator I 2550 = ForwardRefValIDs.find(NumberedVals.size()); 2551 if (I != ForwardRefValIDs.end()) { 2552 Fn = cast<Function>(I->second.first); 2553 if (Fn->getType() != PFT) 2554 return Error(NameLoc, "type of definition and forward reference of '@" + 2555 utostr(NumberedVals.size()) +"' disagree"); 2556 ForwardRefValIDs.erase(I); 2557 } 2558 } 2559 2560 if (Fn == 0) 2561 Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M); 2562 else // Move the forward-reference to the correct spot in the module. 2563 M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn); 2564 2565 if (FunctionName.empty()) 2566 NumberedVals.push_back(Fn); 2567 2568 Fn->setLinkage((GlobalValue::LinkageTypes)Linkage); 2569 Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility); 2570 Fn->setCallingConv(CC); 2571 Fn->setAttributes(PAL); 2572 Fn->setAlignment(Alignment); 2573 Fn->setSection(Section); 2574 if (!GC.empty()) Fn->setGC(GC.c_str()); 2575 2576 // Add all of the arguments we parsed to the function. 2577 Function::arg_iterator ArgIt = Fn->arg_begin(); 2578 for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) { 2579 // If the argument has a name, insert it into the argument symbol table. 2580 if (ArgList[i].Name.empty()) continue; 2581 2582 // Set the name, if it conflicted, it will be auto-renamed. 2583 ArgIt->setName(ArgList[i].Name); 2584 2585 if (ArgIt->getNameStr() != ArgList[i].Name) 2586 return Error(ArgList[i].Loc, "redefinition of argument '%" + 2587 ArgList[i].Name + "'"); 2588 } 2589 2590 return false; 2591} 2592 2593 2594/// ParseFunctionBody 2595/// ::= '{' BasicBlock+ '}' 2596/// ::= 'begin' BasicBlock+ 'end' // FIXME: remove in LLVM 3.0 2597/// 2598bool LLParser::ParseFunctionBody(Function &Fn) { 2599 if (Lex.getKind() != lltok::lbrace && Lex.getKind() != lltok::kw_begin) 2600 return TokError("expected '{' in function body"); 2601 Lex.Lex(); // eat the {. 2602 2603 PerFunctionState PFS(*this, Fn); 2604 2605 while (Lex.getKind() != lltok::rbrace && Lex.getKind() != lltok::kw_end) 2606 if (ParseBasicBlock(PFS)) return true; 2607 2608 // Eat the }. 2609 Lex.Lex(); 2610 2611 // Verify function is ok. 2612 return PFS.VerifyFunctionComplete(); 2613} 2614 2615/// ParseBasicBlock 2616/// ::= LabelStr? Instruction* 2617bool LLParser::ParseBasicBlock(PerFunctionState &PFS) { 2618 // If this basic block starts out with a name, remember it. 2619 std::string Name; 2620 LocTy NameLoc = Lex.getLoc(); 2621 if (Lex.getKind() == lltok::LabelStr) { 2622 Name = Lex.getStrVal(); 2623 Lex.Lex(); 2624 } 2625 2626 BasicBlock *BB = PFS.DefineBB(Name, NameLoc); 2627 if (BB == 0) return true; 2628 2629 std::string NameStr; 2630 2631 // Parse the instructions in this block until we get a terminator. 2632 Instruction *Inst; 2633 do { 2634 // This instruction may have three possibilities for a name: a) none 2635 // specified, b) name specified "%foo =", c) number specified: "%4 =". 2636 LocTy NameLoc = Lex.getLoc(); 2637 int NameID = -1; 2638 NameStr = ""; 2639 2640 if (Lex.getKind() == lltok::LocalVarID) { 2641 NameID = Lex.getUIntVal(); 2642 Lex.Lex(); 2643 if (ParseToken(lltok::equal, "expected '=' after instruction id")) 2644 return true; 2645 } else if (Lex.getKind() == lltok::LocalVar || 2646 // FIXME: REMOVE IN LLVM 3.0 2647 Lex.getKind() == lltok::StringConstant) { 2648 NameStr = Lex.getStrVal(); 2649 Lex.Lex(); 2650 if (ParseToken(lltok::equal, "expected '=' after instruction name")) 2651 return true; 2652 } 2653 2654 if (ParseInstruction(Inst, BB, PFS)) return true; 2655 if (EatIfPresent(lltok::comma)) 2656 ParseOptionalDbgInfo(); 2657 2658 // Set metadata attached with this instruction. 2659 MetadataContext &TheMetadata = M->getContext().getMetadata(); 2660 for (SmallVector<std::pair<unsigned, MDNode *>, 2>::iterator 2661 MDI = MDsOnInst.begin(), MDE = MDsOnInst.end(); MDI != MDE; ++MDI) 2662 TheMetadata.setMD(MDI->first, MDI->second, Inst); 2663 MDsOnInst.clear(); 2664 2665 BB->getInstList().push_back(Inst); 2666 2667 // Set the name on the instruction. 2668 if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true; 2669 } while (!isa<TerminatorInst>(Inst)); 2670 2671 return false; 2672} 2673 2674//===----------------------------------------------------------------------===// 2675// Instruction Parsing. 2676//===----------------------------------------------------------------------===// 2677 2678/// ParseInstruction - Parse one of the many different instructions. 2679/// 2680bool LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, 2681 PerFunctionState &PFS) { 2682 lltok::Kind Token = Lex.getKind(); 2683 if (Token == lltok::Eof) 2684 return TokError("found end of file when expecting more instructions"); 2685 LocTy Loc = Lex.getLoc(); 2686 unsigned KeywordVal = Lex.getUIntVal(); 2687 Lex.Lex(); // Eat the keyword. 2688 2689 switch (Token) { 2690 default: return Error(Loc, "expected instruction opcode"); 2691 // Terminator Instructions. 2692 case lltok::kw_unwind: Inst = new UnwindInst(Context); return false; 2693 case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false; 2694 case lltok::kw_ret: return ParseRet(Inst, BB, PFS); 2695 case lltok::kw_br: return ParseBr(Inst, PFS); 2696 case lltok::kw_switch: return ParseSwitch(Inst, PFS); 2697 case lltok::kw_invoke: return ParseInvoke(Inst, PFS); 2698 // Binary Operators. 2699 case lltok::kw_add: 2700 case lltok::kw_sub: 2701 case lltok::kw_mul: { 2702 bool NUW = false; 2703 bool NSW = false; 2704 LocTy ModifierLoc = Lex.getLoc(); 2705 if (EatIfPresent(lltok::kw_nuw)) 2706 NUW = true; 2707 if (EatIfPresent(lltok::kw_nsw)) { 2708 NSW = true; 2709 if (EatIfPresent(lltok::kw_nuw)) 2710 NUW = true; 2711 } 2712 // API compatibility: Accept either integer or floating-point types. 2713 bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 0); 2714 if (!Result) { 2715 if (!Inst->getType()->isIntOrIntVector()) { 2716 if (NUW) 2717 return Error(ModifierLoc, "nuw only applies to integer operations"); 2718 if (NSW) 2719 return Error(ModifierLoc, "nsw only applies to integer operations"); 2720 } 2721 if (NUW) 2722 cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true); 2723 if (NSW) 2724 cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true); 2725 } 2726 return Result; 2727 } 2728 case lltok::kw_fadd: 2729 case lltok::kw_fsub: 2730 case lltok::kw_fmul: return ParseArithmetic(Inst, PFS, KeywordVal, 2); 2731 2732 case lltok::kw_sdiv: { 2733 bool Exact = false; 2734 if (EatIfPresent(lltok::kw_exact)) 2735 Exact = true; 2736 bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 1); 2737 if (!Result) 2738 if (Exact) 2739 cast<BinaryOperator>(Inst)->setIsExact(true); 2740 return Result; 2741 } 2742 2743 case lltok::kw_udiv: 2744 case lltok::kw_urem: 2745 case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1); 2746 case lltok::kw_fdiv: 2747 case lltok::kw_frem: return ParseArithmetic(Inst, PFS, KeywordVal, 2); 2748 case lltok::kw_shl: 2749 case lltok::kw_lshr: 2750 case lltok::kw_ashr: 2751 case lltok::kw_and: 2752 case lltok::kw_or: 2753 case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal); 2754 case lltok::kw_icmp: 2755 case lltok::kw_fcmp: return ParseCompare(Inst, PFS, KeywordVal); 2756 // Casts. 2757 case lltok::kw_trunc: 2758 case lltok::kw_zext: 2759 case lltok::kw_sext: 2760 case lltok::kw_fptrunc: 2761 case lltok::kw_fpext: 2762 case lltok::kw_bitcast: 2763 case lltok::kw_uitofp: 2764 case lltok::kw_sitofp: 2765 case lltok::kw_fptoui: 2766 case lltok::kw_fptosi: 2767 case lltok::kw_inttoptr: 2768 case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal); 2769 // Other. 2770 case lltok::kw_select: return ParseSelect(Inst, PFS); 2771 case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS); 2772 case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS); 2773 case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS); 2774 case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS); 2775 case lltok::kw_phi: return ParsePHI(Inst, PFS); 2776 case lltok::kw_call: return ParseCall(Inst, PFS, false); 2777 case lltok::kw_tail: return ParseCall(Inst, PFS, true); 2778 // Memory. 2779 case lltok::kw_alloca: 2780 case lltok::kw_malloc: return ParseAlloc(Inst, PFS, KeywordVal); 2781 case lltok::kw_free: return ParseFree(Inst, PFS); 2782 case lltok::kw_load: return ParseLoad(Inst, PFS, false); 2783 case lltok::kw_store: return ParseStore(Inst, PFS, false); 2784 case lltok::kw_volatile: 2785 if (EatIfPresent(lltok::kw_load)) 2786 return ParseLoad(Inst, PFS, true); 2787 else if (EatIfPresent(lltok::kw_store)) 2788 return ParseStore(Inst, PFS, true); 2789 else 2790 return TokError("expected 'load' or 'store'"); 2791 case lltok::kw_getresult: return ParseGetResult(Inst, PFS); 2792 case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS); 2793 case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS); 2794 case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS); 2795 } 2796} 2797 2798/// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind. 2799bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) { 2800 if (Opc == Instruction::FCmp) { 2801 switch (Lex.getKind()) { 2802 default: TokError("expected fcmp predicate (e.g. 'oeq')"); 2803 case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break; 2804 case lltok::kw_one: P = CmpInst::FCMP_ONE; break; 2805 case lltok::kw_olt: P = CmpInst::FCMP_OLT; break; 2806 case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break; 2807 case lltok::kw_ole: P = CmpInst::FCMP_OLE; break; 2808 case lltok::kw_oge: P = CmpInst::FCMP_OGE; break; 2809 case lltok::kw_ord: P = CmpInst::FCMP_ORD; break; 2810 case lltok::kw_uno: P = CmpInst::FCMP_UNO; break; 2811 case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break; 2812 case lltok::kw_une: P = CmpInst::FCMP_UNE; break; 2813 case lltok::kw_ult: P = CmpInst::FCMP_ULT; break; 2814 case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break; 2815 case lltok::kw_ule: P = CmpInst::FCMP_ULE; break; 2816 case lltok::kw_uge: P = CmpInst::FCMP_UGE; break; 2817 case lltok::kw_true: P = CmpInst::FCMP_TRUE; break; 2818 case lltok::kw_false: P = CmpInst::FCMP_FALSE; break; 2819 } 2820 } else { 2821 switch (Lex.getKind()) { 2822 default: TokError("expected icmp predicate (e.g. 'eq')"); 2823 case lltok::kw_eq: P = CmpInst::ICMP_EQ; break; 2824 case lltok::kw_ne: P = CmpInst::ICMP_NE; break; 2825 case lltok::kw_slt: P = CmpInst::ICMP_SLT; break; 2826 case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break; 2827 case lltok::kw_sle: P = CmpInst::ICMP_SLE; break; 2828 case lltok::kw_sge: P = CmpInst::ICMP_SGE; break; 2829 case lltok::kw_ult: P = CmpInst::ICMP_ULT; break; 2830 case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break; 2831 case lltok::kw_ule: P = CmpInst::ICMP_ULE; break; 2832 case lltok::kw_uge: P = CmpInst::ICMP_UGE; break; 2833 } 2834 } 2835 Lex.Lex(); 2836 return false; 2837} 2838 2839//===----------------------------------------------------------------------===// 2840// Terminator Instructions. 2841//===----------------------------------------------------------------------===// 2842 2843/// ParseRet - Parse a return instruction. 2844/// ::= 'ret' void (',' 'dbg' !1) 2845/// ::= 'ret' TypeAndValue (',' 'dbg' !1) 2846/// ::= 'ret' TypeAndValue (',' TypeAndValue)+ (',' 'dbg' !1) 2847/// [[obsolete: LLVM 3.0]] 2848bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB, 2849 PerFunctionState &PFS) { 2850 PATypeHolder Ty(Type::getVoidTy(Context)); 2851 if (ParseType(Ty, true /*void allowed*/)) return true; 2852 2853 if (Ty == Type::getVoidTy(Context)) { 2854 if (EatIfPresent(lltok::comma)) 2855 if (ParseOptionalDbgInfo()) return true; 2856 Inst = ReturnInst::Create(Context); 2857 return false; 2858 } 2859 2860 Value *RV; 2861 if (ParseValue(Ty, RV, PFS)) return true; 2862 2863 if (EatIfPresent(lltok::comma)) { 2864 // Parse optional 'dbg' 2865 if (Lex.getKind() == lltok::kw_dbg) { 2866 if (ParseOptionalDbgInfo()) return true; 2867 } else { 2868 // The normal case is one return value. 2869 // FIXME: LLVM 3.0 remove MRV support for 'ret i32 1, i32 2', requiring use 2870 // of 'ret {i32,i32} {i32 1, i32 2}' 2871 SmallVector<Value*, 8> RVs; 2872 RVs.push_back(RV); 2873 2874 do { 2875 // If optional 'dbg' is seen then this is the end of MRV. 2876 if (Lex.getKind() == lltok::kw_dbg) 2877 break; 2878 if (ParseTypeAndValue(RV, PFS)) return true; 2879 RVs.push_back(RV); 2880 } while (EatIfPresent(lltok::comma)); 2881 2882 RV = UndefValue::get(PFS.getFunction().getReturnType()); 2883 for (unsigned i = 0, e = RVs.size(); i != e; ++i) { 2884 Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv"); 2885 BB->getInstList().push_back(I); 2886 RV = I; 2887 } 2888 } 2889 } 2890 if (EatIfPresent(lltok::comma)) 2891 if (ParseOptionalDbgInfo()) return true; 2892 2893 Inst = ReturnInst::Create(Context, RV); 2894 return false; 2895} 2896 2897 2898/// ParseBr 2899/// ::= 'br' TypeAndValue 2900/// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue 2901bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) { 2902 LocTy Loc, Loc2; 2903 Value *Op0, *Op1, *Op2; 2904 if (ParseTypeAndValue(Op0, Loc, PFS)) return true; 2905 2906 if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) { 2907 Inst = BranchInst::Create(BB); 2908 return false; 2909 } 2910 2911 if (Op0->getType() != Type::getInt1Ty(Context)) 2912 return Error(Loc, "branch condition must have 'i1' type"); 2913 2914 if (ParseToken(lltok::comma, "expected ',' after branch condition") || 2915 ParseTypeAndValue(Op1, Loc, PFS) || 2916 ParseToken(lltok::comma, "expected ',' after true destination") || 2917 ParseTypeAndValue(Op2, Loc2, PFS)) 2918 return true; 2919 2920 if (!isa<BasicBlock>(Op1)) 2921 return Error(Loc, "true destination of branch must be a basic block"); 2922 if (!isa<BasicBlock>(Op2)) 2923 return Error(Loc2, "true destination of branch must be a basic block"); 2924 2925 Inst = BranchInst::Create(cast<BasicBlock>(Op1), cast<BasicBlock>(Op2), Op0); 2926 return false; 2927} 2928 2929/// ParseSwitch 2930/// Instruction 2931/// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']' 2932/// JumpTable 2933/// ::= (TypeAndValue ',' TypeAndValue)* 2934bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) { 2935 LocTy CondLoc, BBLoc; 2936 Value *Cond, *DefaultBB; 2937 if (ParseTypeAndValue(Cond, CondLoc, PFS) || 2938 ParseToken(lltok::comma, "expected ',' after switch condition") || 2939 ParseTypeAndValue(DefaultBB, BBLoc, PFS) || 2940 ParseToken(lltok::lsquare, "expected '[' with switch table")) 2941 return true; 2942 2943 if (!isa<IntegerType>(Cond->getType())) 2944 return Error(CondLoc, "switch condition must have integer type"); 2945 if (!isa<BasicBlock>(DefaultBB)) 2946 return Error(BBLoc, "default destination must be a basic block"); 2947 2948 // Parse the jump table pairs. 2949 SmallPtrSet<Value*, 32> SeenCases; 2950 SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table; 2951 while (Lex.getKind() != lltok::rsquare) { 2952 Value *Constant, *DestBB; 2953 2954 if (ParseTypeAndValue(Constant, CondLoc, PFS) || 2955 ParseToken(lltok::comma, "expected ',' after case value") || 2956 ParseTypeAndValue(DestBB, BBLoc, PFS)) 2957 return true; 2958 2959 if (!SeenCases.insert(Constant)) 2960 return Error(CondLoc, "duplicate case value in switch"); 2961 if (!isa<ConstantInt>(Constant)) 2962 return Error(CondLoc, "case value is not a constant integer"); 2963 if (!isa<BasicBlock>(DestBB)) 2964 return Error(BBLoc, "case destination is not a basic block"); 2965 2966 Table.push_back(std::make_pair(cast<ConstantInt>(Constant), 2967 cast<BasicBlock>(DestBB))); 2968 } 2969 2970 Lex.Lex(); // Eat the ']'. 2971 2972 SwitchInst *SI = SwitchInst::Create(Cond, cast<BasicBlock>(DefaultBB), 2973 Table.size()); 2974 for (unsigned i = 0, e = Table.size(); i != e; ++i) 2975 SI->addCase(Table[i].first, Table[i].second); 2976 Inst = SI; 2977 return false; 2978} 2979 2980/// ParseInvoke 2981/// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList 2982/// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue 2983bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { 2984 LocTy CallLoc = Lex.getLoc(); 2985 unsigned RetAttrs, FnAttrs; 2986 CallingConv::ID CC; 2987 PATypeHolder RetType(Type::getVoidTy(Context)); 2988 LocTy RetTypeLoc; 2989 ValID CalleeID; 2990 SmallVector<ParamInfo, 16> ArgList; 2991 2992 Value *NormalBB, *UnwindBB; 2993 if (ParseOptionalCallingConv(CC) || 2994 ParseOptionalAttrs(RetAttrs, 1) || 2995 ParseType(RetType, RetTypeLoc, true /*void allowed*/) || 2996 ParseValID(CalleeID) || 2997 ParseParameterList(ArgList, PFS) || 2998 ParseOptionalAttrs(FnAttrs, 2) || 2999 ParseToken(lltok::kw_to, "expected 'to' in invoke") || 3000 ParseTypeAndValue(NormalBB, PFS) || 3001 ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") || 3002 ParseTypeAndValue(UnwindBB, PFS)) 3003 return true; 3004 3005 if (!isa<BasicBlock>(NormalBB)) 3006 return Error(CallLoc, "normal destination is not a basic block"); 3007 if (!isa<BasicBlock>(UnwindBB)) 3008 return Error(CallLoc, "unwind destination is not a basic block"); 3009 3010 // If RetType is a non-function pointer type, then this is the short syntax 3011 // for the call, which means that RetType is just the return type. Infer the 3012 // rest of the function argument types from the arguments that are present. 3013 const PointerType *PFTy = 0; 3014 const FunctionType *Ty = 0; 3015 if (!(PFTy = dyn_cast<PointerType>(RetType)) || 3016 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { 3017 // Pull out the types of all of the arguments... 3018 std::vector<const Type*> ParamTypes; 3019 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) 3020 ParamTypes.push_back(ArgList[i].V->getType()); 3021 3022 if (!FunctionType::isValidReturnType(RetType)) 3023 return Error(RetTypeLoc, "Invalid result type for LLVM function"); 3024 3025 Ty = FunctionType::get(RetType, ParamTypes, false); 3026 PFTy = PointerType::getUnqual(Ty); 3027 } 3028 3029 // Look up the callee. 3030 Value *Callee; 3031 if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true; 3032 3033 // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional 3034 // function attributes. 3035 unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; 3036 if (FnAttrs & ObsoleteFuncAttrs) { 3037 RetAttrs |= FnAttrs & ObsoleteFuncAttrs; 3038 FnAttrs &= ~ObsoleteFuncAttrs; 3039 } 3040 3041 // Set up the Attributes for the function. 3042 SmallVector<AttributeWithIndex, 8> Attrs; 3043 if (RetAttrs != Attribute::None) 3044 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); 3045 3046 SmallVector<Value*, 8> Args; 3047 3048 // Loop through FunctionType's arguments and ensure they are specified 3049 // correctly. Also, gather any parameter attributes. 3050 FunctionType::param_iterator I = Ty->param_begin(); 3051 FunctionType::param_iterator E = Ty->param_end(); 3052 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 3053 const Type *ExpectedTy = 0; 3054 if (I != E) { 3055 ExpectedTy = *I++; 3056 } else if (!Ty->isVarArg()) { 3057 return Error(ArgList[i].Loc, "too many arguments specified"); 3058 } 3059 3060 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) 3061 return Error(ArgList[i].Loc, "argument is not of expected type '" + 3062 ExpectedTy->getDescription() + "'"); 3063 Args.push_back(ArgList[i].V); 3064 if (ArgList[i].Attrs != Attribute::None) 3065 Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); 3066 } 3067 3068 if (I != E) 3069 return Error(CallLoc, "not enough parameters specified for call"); 3070 3071 if (FnAttrs != Attribute::None) 3072 Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs)); 3073 3074 // Finish off the Attributes and check them 3075 AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); 3076 3077 InvokeInst *II = InvokeInst::Create(Callee, cast<BasicBlock>(NormalBB), 3078 cast<BasicBlock>(UnwindBB), 3079 Args.begin(), Args.end()); 3080 II->setCallingConv(CC); 3081 II->setAttributes(PAL); 3082 Inst = II; 3083 return false; 3084} 3085 3086 3087 3088//===----------------------------------------------------------------------===// 3089// Binary Operators. 3090//===----------------------------------------------------------------------===// 3091 3092/// ParseArithmetic 3093/// ::= ArithmeticOps TypeAndValue ',' Value 3094/// 3095/// If OperandType is 0, then any FP or integer operand is allowed. If it is 1, 3096/// then any integer operand is allowed, if it is 2, any fp operand is allowed. 3097bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, 3098 unsigned Opc, unsigned OperandType) { 3099 LocTy Loc; Value *LHS, *RHS; 3100 if (ParseTypeAndValue(LHS, Loc, PFS) || 3101 ParseToken(lltok::comma, "expected ',' in arithmetic operation") || 3102 ParseValue(LHS->getType(), RHS, PFS)) 3103 return true; 3104 3105 bool Valid; 3106 switch (OperandType) { 3107 default: llvm_unreachable("Unknown operand type!"); 3108 case 0: // int or FP. 3109 Valid = LHS->getType()->isIntOrIntVector() || 3110 LHS->getType()->isFPOrFPVector(); 3111 break; 3112 case 1: Valid = LHS->getType()->isIntOrIntVector(); break; 3113 case 2: Valid = LHS->getType()->isFPOrFPVector(); break; 3114 } 3115 3116 if (!Valid) 3117 return Error(Loc, "invalid operand type for instruction"); 3118 3119 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 3120 return false; 3121} 3122 3123/// ParseLogical 3124/// ::= ArithmeticOps TypeAndValue ',' Value { 3125bool LLParser::ParseLogical(Instruction *&Inst, PerFunctionState &PFS, 3126 unsigned Opc) { 3127 LocTy Loc; Value *LHS, *RHS; 3128 if (ParseTypeAndValue(LHS, Loc, PFS) || 3129 ParseToken(lltok::comma, "expected ',' in logical operation") || 3130 ParseValue(LHS->getType(), RHS, PFS)) 3131 return true; 3132 3133 if (!LHS->getType()->isIntOrIntVector()) 3134 return Error(Loc,"instruction requires integer or integer vector operands"); 3135 3136 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 3137 return false; 3138} 3139 3140 3141/// ParseCompare 3142/// ::= 'icmp' IPredicates TypeAndValue ',' Value 3143/// ::= 'fcmp' FPredicates TypeAndValue ',' Value 3144bool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS, 3145 unsigned Opc) { 3146 // Parse the integer/fp comparison predicate. 3147 LocTy Loc; 3148 unsigned Pred; 3149 Value *LHS, *RHS; 3150 if (ParseCmpPredicate(Pred, Opc) || 3151 ParseTypeAndValue(LHS, Loc, PFS) || 3152 ParseToken(lltok::comma, "expected ',' after compare value") || 3153 ParseValue(LHS->getType(), RHS, PFS)) 3154 return true; 3155 3156 if (Opc == Instruction::FCmp) { 3157 if (!LHS->getType()->isFPOrFPVector()) 3158 return Error(Loc, "fcmp requires floating point operands"); 3159 Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS); 3160 } else { 3161 assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!"); 3162 if (!LHS->getType()->isIntOrIntVector() && 3163 !isa<PointerType>(LHS->getType())) 3164 return Error(Loc, "icmp requires integer operands"); 3165 Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS); 3166 } 3167 return false; 3168} 3169 3170//===----------------------------------------------------------------------===// 3171// Other Instructions. 3172//===----------------------------------------------------------------------===// 3173 3174 3175/// ParseCast 3176/// ::= CastOpc TypeAndValue 'to' Type 3177bool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS, 3178 unsigned Opc) { 3179 LocTy Loc; Value *Op; 3180 PATypeHolder DestTy(Type::getVoidTy(Context)); 3181 if (ParseTypeAndValue(Op, Loc, PFS) || 3182 ParseToken(lltok::kw_to, "expected 'to' after cast value") || 3183 ParseType(DestTy)) 3184 return true; 3185 3186 if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) { 3187 CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy); 3188 return Error(Loc, "invalid cast opcode for cast from '" + 3189 Op->getType()->getDescription() + "' to '" + 3190 DestTy->getDescription() + "'"); 3191 } 3192 Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy); 3193 return false; 3194} 3195 3196/// ParseSelect 3197/// ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3198bool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) { 3199 LocTy Loc; 3200 Value *Op0, *Op1, *Op2; 3201 if (ParseTypeAndValue(Op0, Loc, PFS) || 3202 ParseToken(lltok::comma, "expected ',' after select condition") || 3203 ParseTypeAndValue(Op1, PFS) || 3204 ParseToken(lltok::comma, "expected ',' after select value") || 3205 ParseTypeAndValue(Op2, PFS)) 3206 return true; 3207 3208 if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2)) 3209 return Error(Loc, Reason); 3210 3211 Inst = SelectInst::Create(Op0, Op1, Op2); 3212 return false; 3213} 3214 3215/// ParseVA_Arg 3216/// ::= 'va_arg' TypeAndValue ',' Type 3217bool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) { 3218 Value *Op; 3219 PATypeHolder EltTy(Type::getVoidTy(Context)); 3220 LocTy TypeLoc; 3221 if (ParseTypeAndValue(Op, PFS) || 3222 ParseToken(lltok::comma, "expected ',' after vaarg operand") || 3223 ParseType(EltTy, TypeLoc)) 3224 return true; 3225 3226 if (!EltTy->isFirstClassType()) 3227 return Error(TypeLoc, "va_arg requires operand with first class type"); 3228 3229 Inst = new VAArgInst(Op, EltTy); 3230 return false; 3231} 3232 3233/// ParseExtractElement 3234/// ::= 'extractelement' TypeAndValue ',' TypeAndValue 3235bool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) { 3236 LocTy Loc; 3237 Value *Op0, *Op1; 3238 if (ParseTypeAndValue(Op0, Loc, PFS) || 3239 ParseToken(lltok::comma, "expected ',' after extract value") || 3240 ParseTypeAndValue(Op1, PFS)) 3241 return true; 3242 3243 if (!ExtractElementInst::isValidOperands(Op0, Op1)) 3244 return Error(Loc, "invalid extractelement operands"); 3245 3246 Inst = ExtractElementInst::Create(Op0, Op1); 3247 return false; 3248} 3249 3250/// ParseInsertElement 3251/// ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3252bool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) { 3253 LocTy Loc; 3254 Value *Op0, *Op1, *Op2; 3255 if (ParseTypeAndValue(Op0, Loc, PFS) || 3256 ParseToken(lltok::comma, "expected ',' after insertelement value") || 3257 ParseTypeAndValue(Op1, PFS) || 3258 ParseToken(lltok::comma, "expected ',' after insertelement value") || 3259 ParseTypeAndValue(Op2, PFS)) 3260 return true; 3261 3262 if (!InsertElementInst::isValidOperands(Op0, Op1, Op2)) 3263 return Error(Loc, "invalid insertelement operands"); 3264 3265 Inst = InsertElementInst::Create(Op0, Op1, Op2); 3266 return false; 3267} 3268 3269/// ParseShuffleVector 3270/// ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3271bool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) { 3272 LocTy Loc; 3273 Value *Op0, *Op1, *Op2; 3274 if (ParseTypeAndValue(Op0, Loc, PFS) || 3275 ParseToken(lltok::comma, "expected ',' after shuffle mask") || 3276 ParseTypeAndValue(Op1, PFS) || 3277 ParseToken(lltok::comma, "expected ',' after shuffle value") || 3278 ParseTypeAndValue(Op2, PFS)) 3279 return true; 3280 3281 if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2)) 3282 return Error(Loc, "invalid extractelement operands"); 3283 3284 Inst = new ShuffleVectorInst(Op0, Op1, Op2); 3285 return false; 3286} 3287 3288/// ParsePHI 3289/// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Valueß ']')* 3290bool LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) { 3291 PATypeHolder Ty(Type::getVoidTy(Context)); 3292 Value *Op0, *Op1; 3293 LocTy TypeLoc = Lex.getLoc(); 3294 3295 if (ParseType(Ty) || 3296 ParseToken(lltok::lsquare, "expected '[' in phi value list") || 3297 ParseValue(Ty, Op0, PFS) || 3298 ParseToken(lltok::comma, "expected ',' after insertelement value") || 3299 ParseValue(Type::getLabelTy(Context), Op1, PFS) || 3300 ParseToken(lltok::rsquare, "expected ']' in phi value list")) 3301 return true; 3302 3303 SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals; 3304 while (1) { 3305 PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1))); 3306 3307 if (!EatIfPresent(lltok::comma)) 3308 break; 3309 3310 if (ParseToken(lltok::lsquare, "expected '[' in phi value list") || 3311 ParseValue(Ty, Op0, PFS) || 3312 ParseToken(lltok::comma, "expected ',' after insertelement value") || 3313 ParseValue(Type::getLabelTy(Context), Op1, PFS) || 3314 ParseToken(lltok::rsquare, "expected ']' in phi value list")) 3315 return true; 3316 } 3317 3318 if (!Ty->isFirstClassType()) 3319 return Error(TypeLoc, "phi node must have first class type"); 3320 3321 PHINode *PN = PHINode::Create(Ty); 3322 PN->reserveOperandSpace(PHIVals.size()); 3323 for (unsigned i = 0, e = PHIVals.size(); i != e; ++i) 3324 PN->addIncoming(PHIVals[i].first, PHIVals[i].second); 3325 Inst = PN; 3326 return false; 3327} 3328 3329/// ParseCall 3330/// ::= 'tail'? 'call' OptionalCallingConv OptionalAttrs Type Value 3331/// ParameterList OptionalAttrs 3332bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, 3333 bool isTail) { 3334 unsigned RetAttrs, FnAttrs; 3335 CallingConv::ID CC; 3336 PATypeHolder RetType(Type::getVoidTy(Context)); 3337 LocTy RetTypeLoc; 3338 ValID CalleeID; 3339 SmallVector<ParamInfo, 16> ArgList; 3340 LocTy CallLoc = Lex.getLoc(); 3341 3342 if ((isTail && ParseToken(lltok::kw_call, "expected 'tail call'")) || 3343 ParseOptionalCallingConv(CC) || 3344 ParseOptionalAttrs(RetAttrs, 1) || 3345 ParseType(RetType, RetTypeLoc, true /*void allowed*/) || 3346 ParseValID(CalleeID) || 3347 ParseParameterList(ArgList, PFS) || 3348 ParseOptionalAttrs(FnAttrs, 2)) 3349 return true; 3350 3351 // If RetType is a non-function pointer type, then this is the short syntax 3352 // for the call, which means that RetType is just the return type. Infer the 3353 // rest of the function argument types from the arguments that are present. 3354 const PointerType *PFTy = 0; 3355 const FunctionType *Ty = 0; 3356 if (!(PFTy = dyn_cast<PointerType>(RetType)) || 3357 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { 3358 // Pull out the types of all of the arguments... 3359 std::vector<const Type*> ParamTypes; 3360 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) 3361 ParamTypes.push_back(ArgList[i].V->getType()); 3362 3363 if (!FunctionType::isValidReturnType(RetType)) 3364 return Error(RetTypeLoc, "Invalid result type for LLVM function"); 3365 3366 Ty = FunctionType::get(RetType, ParamTypes, false); 3367 PFTy = PointerType::getUnqual(Ty); 3368 } 3369 3370 // Look up the callee. 3371 Value *Callee; 3372 if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true; 3373 3374 // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional 3375 // function attributes. 3376 unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; 3377 if (FnAttrs & ObsoleteFuncAttrs) { 3378 RetAttrs |= FnAttrs & ObsoleteFuncAttrs; 3379 FnAttrs &= ~ObsoleteFuncAttrs; 3380 } 3381 3382 // Set up the Attributes for the function. 3383 SmallVector<AttributeWithIndex, 8> Attrs; 3384 if (RetAttrs != Attribute::None) 3385 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); 3386 3387 SmallVector<Value*, 8> Args; 3388 3389 // Loop through FunctionType's arguments and ensure they are specified 3390 // correctly. Also, gather any parameter attributes. 3391 FunctionType::param_iterator I = Ty->param_begin(); 3392 FunctionType::param_iterator E = Ty->param_end(); 3393 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 3394 const Type *ExpectedTy = 0; 3395 if (I != E) { 3396 ExpectedTy = *I++; 3397 } else if (!Ty->isVarArg()) { 3398 return Error(ArgList[i].Loc, "too many arguments specified"); 3399 } 3400 3401 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) 3402 return Error(ArgList[i].Loc, "argument is not of expected type '" + 3403 ExpectedTy->getDescription() + "'"); 3404 Args.push_back(ArgList[i].V); 3405 if (ArgList[i].Attrs != Attribute::None) 3406 Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); 3407 } 3408 3409 if (I != E) 3410 return Error(CallLoc, "not enough parameters specified for call"); 3411 3412 if (FnAttrs != Attribute::None) 3413 Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs)); 3414 3415 // Finish off the Attributes and check them 3416 AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); 3417 3418 CallInst *CI = CallInst::Create(Callee, Args.begin(), Args.end()); 3419 CI->setTailCall(isTail); 3420 CI->setCallingConv(CC); 3421 CI->setAttributes(PAL); 3422 Inst = CI; 3423 return false; 3424} 3425 3426//===----------------------------------------------------------------------===// 3427// Memory Instructions. 3428//===----------------------------------------------------------------------===// 3429 3430/// ParseAlloc 3431/// ::= 'malloc' Type (',' TypeAndValue)? (',' OptionalInfo)? 3432/// ::= 'alloca' Type (',' TypeAndValue)? (',' OptionalInfo)? 3433bool LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS, 3434 unsigned Opc) { 3435 PATypeHolder Ty(Type::getVoidTy(Context)); 3436 Value *Size = 0; 3437 LocTy SizeLoc; 3438 unsigned Alignment = 0; 3439 if (ParseType(Ty)) return true; 3440 3441 if (EatIfPresent(lltok::comma)) { 3442 if (Lex.getKind() == lltok::kw_align || Lex.getKind() == lltok::kw_dbg) { 3443 if (ParseOptionalInfo(Alignment)) return true; 3444 } else { 3445 if (ParseTypeAndValue(Size, SizeLoc, PFS)) return true; 3446 if (EatIfPresent(lltok::comma)) 3447 if (ParseOptionalInfo(Alignment)) return true; 3448 } 3449 } 3450 3451 if (Size && Size->getType() != Type::getInt32Ty(Context)) 3452 return Error(SizeLoc, "element count must be i32"); 3453 3454 if (Opc == Instruction::Malloc) 3455 Inst = new MallocInst(Ty, Size, Alignment); 3456 else 3457 Inst = new AllocaInst(Ty, Size, Alignment); 3458 return false; 3459} 3460 3461/// ParseFree 3462/// ::= 'free' TypeAndValue 3463bool LLParser::ParseFree(Instruction *&Inst, PerFunctionState &PFS) { 3464 Value *Val; LocTy Loc; 3465 if (ParseTypeAndValue(Val, Loc, PFS)) return true; 3466 if (!isa<PointerType>(Val->getType())) 3467 return Error(Loc, "operand to free must be a pointer"); 3468 Inst = new FreeInst(Val); 3469 return false; 3470} 3471 3472/// ParseLoad 3473/// ::= 'volatile'? 'load' TypeAndValue (',' OptionalInfo)? 3474bool LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS, 3475 bool isVolatile) { 3476 Value *Val; LocTy Loc; 3477 unsigned Alignment = 0; 3478 if (ParseTypeAndValue(Val, Loc, PFS)) return true; 3479 3480 if (EatIfPresent(lltok::comma)) 3481 if (ParseOptionalInfo(Alignment)) return true; 3482 3483 if (!isa<PointerType>(Val->getType()) || 3484 !cast<PointerType>(Val->getType())->getElementType()->isFirstClassType()) 3485 return Error(Loc, "load operand must be a pointer to a first class type"); 3486 3487 Inst = new LoadInst(Val, "", isVolatile, Alignment); 3488 return false; 3489} 3490 3491/// ParseStore 3492/// ::= 'volatile'? 'store' TypeAndValue ',' TypeAndValue (',' 'align' i32)? 3493bool LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS, 3494 bool isVolatile) { 3495 Value *Val, *Ptr; LocTy Loc, PtrLoc; 3496 unsigned Alignment = 0; 3497 if (ParseTypeAndValue(Val, Loc, PFS) || 3498 ParseToken(lltok::comma, "expected ',' after store operand") || 3499 ParseTypeAndValue(Ptr, PtrLoc, PFS)) 3500 return true; 3501 3502 if (EatIfPresent(lltok::comma)) 3503 if (ParseOptionalInfo(Alignment)) return true; 3504 3505 if (!isa<PointerType>(Ptr->getType())) 3506 return Error(PtrLoc, "store operand must be a pointer"); 3507 if (!Val->getType()->isFirstClassType()) 3508 return Error(Loc, "store operand must be a first class value"); 3509 if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType()) 3510 return Error(Loc, "stored value and pointer type do not match"); 3511 3512 Inst = new StoreInst(Val, Ptr, isVolatile, Alignment); 3513 return false; 3514} 3515 3516/// ParseGetResult 3517/// ::= 'getresult' TypeAndValue ',' i32 3518/// FIXME: Remove support for getresult in LLVM 3.0 3519bool LLParser::ParseGetResult(Instruction *&Inst, PerFunctionState &PFS) { 3520 Value *Val; LocTy ValLoc, EltLoc; 3521 unsigned Element; 3522 if (ParseTypeAndValue(Val, ValLoc, PFS) || 3523 ParseToken(lltok::comma, "expected ',' after getresult operand") || 3524 ParseUInt32(Element, EltLoc)) 3525 return true; 3526 3527 if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType())) 3528 return Error(ValLoc, "getresult inst requires an aggregate operand"); 3529 if (!ExtractValueInst::getIndexedType(Val->getType(), Element)) 3530 return Error(EltLoc, "invalid getresult index for value"); 3531 Inst = ExtractValueInst::Create(Val, Element); 3532 return false; 3533} 3534 3535/// ParseGetElementPtr 3536/// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)* 3537bool LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) { 3538 Value *Ptr, *Val; LocTy Loc, EltLoc; 3539 3540 bool InBounds = EatIfPresent(lltok::kw_inbounds); 3541 3542 if (ParseTypeAndValue(Ptr, Loc, PFS)) return true; 3543 3544 if (!isa<PointerType>(Ptr->getType())) 3545 return Error(Loc, "base of getelementptr must be a pointer"); 3546 3547 SmallVector<Value*, 16> Indices; 3548 while (EatIfPresent(lltok::comma)) { 3549 if (ParseTypeAndValue(Val, EltLoc, PFS)) return true; 3550 if (!isa<IntegerType>(Val->getType())) 3551 return Error(EltLoc, "getelementptr index must be an integer"); 3552 Indices.push_back(Val); 3553 } 3554 3555 if (!GetElementPtrInst::getIndexedType(Ptr->getType(), 3556 Indices.begin(), Indices.end())) 3557 return Error(Loc, "invalid getelementptr indices"); 3558 Inst = GetElementPtrInst::Create(Ptr, Indices.begin(), Indices.end()); 3559 if (InBounds) 3560 cast<GetElementPtrInst>(Inst)->setIsInBounds(true); 3561 return false; 3562} 3563 3564/// ParseExtractValue 3565/// ::= 'extractvalue' TypeAndValue (',' uint32)+ 3566bool LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) { 3567 Value *Val; LocTy Loc; 3568 SmallVector<unsigned, 4> Indices; 3569 if (ParseTypeAndValue(Val, Loc, PFS) || 3570 ParseIndexList(Indices)) 3571 return true; 3572 3573 if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType())) 3574 return Error(Loc, "extractvalue operand must be array or struct"); 3575 3576 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(), 3577 Indices.end())) 3578 return Error(Loc, "invalid indices for extractvalue"); 3579 Inst = ExtractValueInst::Create(Val, Indices.begin(), Indices.end()); 3580 return false; 3581} 3582 3583/// ParseInsertValue 3584/// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+ 3585bool LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) { 3586 Value *Val0, *Val1; LocTy Loc0, Loc1; 3587 SmallVector<unsigned, 4> Indices; 3588 if (ParseTypeAndValue(Val0, Loc0, PFS) || 3589 ParseToken(lltok::comma, "expected comma after insertvalue operand") || 3590 ParseTypeAndValue(Val1, Loc1, PFS) || 3591 ParseIndexList(Indices)) 3592 return true; 3593 3594 if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType())) 3595 return Error(Loc0, "extractvalue operand must be array or struct"); 3596 3597 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(), 3598 Indices.end())) 3599 return Error(Loc0, "invalid indices for insertvalue"); 3600 Inst = InsertValueInst::Create(Val0, Val1, Indices.begin(), Indices.end()); 3601 return false; 3602} 3603 3604//===----------------------------------------------------------------------===// 3605// Embedded metadata. 3606//===----------------------------------------------------------------------===// 3607 3608/// ParseMDNodeVector 3609/// ::= Element (',' Element)* 3610/// Element 3611/// ::= 'null' | TypeAndValue 3612bool LLParser::ParseMDNodeVector(SmallVectorImpl<Value*> &Elts) { 3613 assert(Lex.getKind() == lltok::lbrace); 3614 Lex.Lex(); 3615 do { 3616 Value *V = 0; 3617 if (Lex.getKind() == lltok::kw_null) { 3618 Lex.Lex(); 3619 V = 0; 3620 } else { 3621 PATypeHolder Ty(Type::getVoidTy(Context)); 3622 if (ParseType(Ty)) return true; 3623 if (Lex.getKind() == lltok::Metadata) { 3624 Lex.Lex(); 3625 MetadataBase *Node = 0; 3626 if (!ParseMDNode(Node)) 3627 V = Node; 3628 else { 3629 MetadataBase *MDS = 0; 3630 if (ParseMDString(MDS)) return true; 3631 V = MDS; 3632 } 3633 } else { 3634 Constant *C; 3635 if (ParseGlobalValue(Ty, C)) return true; 3636 V = C; 3637 } 3638 } 3639 Elts.push_back(V); 3640 } while (EatIfPresent(lltok::comma)); 3641 3642 return false; 3643} 3644