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