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