LLParser.cpp revision 259065
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/// ::= 'x86_64_sysvcc' 1341/// ::= 'x86_64_win64cc' 1342/// ::= 'cc' UINT 1343/// 1344bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) { 1345 switch (Lex.getKind()) { 1346 default: CC = CallingConv::C; return false; 1347 case lltok::kw_ccc: CC = CallingConv::C; break; 1348 case lltok::kw_fastcc: CC = CallingConv::Fast; break; 1349 case lltok::kw_coldcc: CC = CallingConv::Cold; break; 1350 case lltok::kw_x86_stdcallcc: CC = CallingConv::X86_StdCall; break; 1351 case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break; 1352 case lltok::kw_x86_thiscallcc: CC = CallingConv::X86_ThisCall; break; 1353 case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break; 1354 case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break; 1355 case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break; 1356 case lltok::kw_msp430_intrcc: CC = CallingConv::MSP430_INTR; break; 1357 case lltok::kw_ptx_kernel: CC = CallingConv::PTX_Kernel; break; 1358 case lltok::kw_ptx_device: CC = CallingConv::PTX_Device; break; 1359 case lltok::kw_spir_kernel: CC = CallingConv::SPIR_KERNEL; break; 1360 case lltok::kw_spir_func: CC = CallingConv::SPIR_FUNC; break; 1361 case lltok::kw_intel_ocl_bicc: CC = CallingConv::Intel_OCL_BI; break; 1362 case lltok::kw_x86_64_sysvcc: CC = CallingConv::X86_64_SysV; break; 1363 case lltok::kw_x86_64_win64cc: CC = CallingConv::X86_64_Win64; break; 1364 case lltok::kw_cc: { 1365 unsigned ArbitraryCC; 1366 Lex.Lex(); 1367 if (ParseUInt32(ArbitraryCC)) 1368 return true; 1369 CC = static_cast<CallingConv::ID>(ArbitraryCC); 1370 return false; 1371 } 1372 } 1373 1374 Lex.Lex(); 1375 return false; 1376} 1377 1378/// ParseInstructionMetadata 1379/// ::= !dbg !42 (',' !dbg !57)* 1380bool LLParser::ParseInstructionMetadata(Instruction *Inst, 1381 PerFunctionState *PFS) { 1382 do { 1383 if (Lex.getKind() != lltok::MetadataVar) 1384 return TokError("expected metadata after comma"); 1385 1386 std::string Name = Lex.getStrVal(); 1387 unsigned MDK = M->getMDKindID(Name); 1388 Lex.Lex(); 1389 1390 MDNode *Node; 1391 SMLoc Loc = Lex.getLoc(); 1392 1393 if (ParseToken(lltok::exclaim, "expected '!' here")) 1394 return true; 1395 1396 // This code is similar to that of ParseMetadataValue, however it needs to 1397 // have special-case code for a forward reference; see the comments on 1398 // ForwardRefInstMetadata for details. Also, MDStrings are not supported 1399 // at the top level here. 1400 if (Lex.getKind() == lltok::lbrace) { 1401 ValID ID; 1402 if (ParseMetadataListValue(ID, PFS)) 1403 return true; 1404 assert(ID.Kind == ValID::t_MDNode); 1405 Inst->setMetadata(MDK, ID.MDNodeVal); 1406 } else { 1407 unsigned NodeID = 0; 1408 if (ParseMDNodeID(Node, NodeID)) 1409 return true; 1410 if (Node) { 1411 // If we got the node, add it to the instruction. 1412 Inst->setMetadata(MDK, Node); 1413 } else { 1414 MDRef R = { Loc, MDK, NodeID }; 1415 // Otherwise, remember that this should be resolved later. 1416 ForwardRefInstMetadata[Inst].push_back(R); 1417 } 1418 } 1419 1420 // If this is the end of the list, we're done. 1421 } while (EatIfPresent(lltok::comma)); 1422 return false; 1423} 1424 1425/// ParseOptionalAlignment 1426/// ::= /* empty */ 1427/// ::= 'align' 4 1428bool LLParser::ParseOptionalAlignment(unsigned &Alignment) { 1429 Alignment = 0; 1430 if (!EatIfPresent(lltok::kw_align)) 1431 return false; 1432 LocTy AlignLoc = Lex.getLoc(); 1433 if (ParseUInt32(Alignment)) return true; 1434 if (!isPowerOf2_32(Alignment)) 1435 return Error(AlignLoc, "alignment is not a power of two"); 1436 if (Alignment > Value::MaximumAlignment) 1437 return Error(AlignLoc, "huge alignments are not supported yet"); 1438 return false; 1439} 1440 1441/// ParseOptionalCommaAlign 1442/// ::= 1443/// ::= ',' align 4 1444/// 1445/// This returns with AteExtraComma set to true if it ate an excess comma at the 1446/// end. 1447bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment, 1448 bool &AteExtraComma) { 1449 AteExtraComma = false; 1450 while (EatIfPresent(lltok::comma)) { 1451 // Metadata at the end is an early exit. 1452 if (Lex.getKind() == lltok::MetadataVar) { 1453 AteExtraComma = true; 1454 return false; 1455 } 1456 1457 if (Lex.getKind() != lltok::kw_align) 1458 return Error(Lex.getLoc(), "expected metadata or 'align'"); 1459 1460 if (ParseOptionalAlignment(Alignment)) return true; 1461 } 1462 1463 return false; 1464} 1465 1466/// ParseScopeAndOrdering 1467/// if isAtomic: ::= 'singlethread'? AtomicOrdering 1468/// else: ::= 1469/// 1470/// This sets Scope and Ordering to the parsed values. 1471bool LLParser::ParseScopeAndOrdering(bool isAtomic, SynchronizationScope &Scope, 1472 AtomicOrdering &Ordering) { 1473 if (!isAtomic) 1474 return false; 1475 1476 Scope = CrossThread; 1477 if (EatIfPresent(lltok::kw_singlethread)) 1478 Scope = SingleThread; 1479 switch (Lex.getKind()) { 1480 default: return TokError("Expected ordering on atomic instruction"); 1481 case lltok::kw_unordered: Ordering = Unordered; break; 1482 case lltok::kw_monotonic: Ordering = Monotonic; break; 1483 case lltok::kw_acquire: Ordering = Acquire; break; 1484 case lltok::kw_release: Ordering = Release; break; 1485 case lltok::kw_acq_rel: Ordering = AcquireRelease; break; 1486 case lltok::kw_seq_cst: Ordering = SequentiallyConsistent; break; 1487 } 1488 Lex.Lex(); 1489 return false; 1490} 1491 1492/// ParseOptionalStackAlignment 1493/// ::= /* empty */ 1494/// ::= 'alignstack' '(' 4 ')' 1495bool LLParser::ParseOptionalStackAlignment(unsigned &Alignment) { 1496 Alignment = 0; 1497 if (!EatIfPresent(lltok::kw_alignstack)) 1498 return false; 1499 LocTy ParenLoc = Lex.getLoc(); 1500 if (!EatIfPresent(lltok::lparen)) 1501 return Error(ParenLoc, "expected '('"); 1502 LocTy AlignLoc = Lex.getLoc(); 1503 if (ParseUInt32(Alignment)) return true; 1504 ParenLoc = Lex.getLoc(); 1505 if (!EatIfPresent(lltok::rparen)) 1506 return Error(ParenLoc, "expected ')'"); 1507 if (!isPowerOf2_32(Alignment)) 1508 return Error(AlignLoc, "stack alignment is not a power of two"); 1509 return false; 1510} 1511 1512/// ParseIndexList - This parses the index list for an insert/extractvalue 1513/// instruction. This sets AteExtraComma in the case where we eat an extra 1514/// comma at the end of the line and find that it is followed by metadata. 1515/// Clients that don't allow metadata can call the version of this function that 1516/// only takes one argument. 1517/// 1518/// ParseIndexList 1519/// ::= (',' uint32)+ 1520/// 1521bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices, 1522 bool &AteExtraComma) { 1523 AteExtraComma = false; 1524 1525 if (Lex.getKind() != lltok::comma) 1526 return TokError("expected ',' as start of index list"); 1527 1528 while (EatIfPresent(lltok::comma)) { 1529 if (Lex.getKind() == lltok::MetadataVar) { 1530 AteExtraComma = true; 1531 return false; 1532 } 1533 unsigned Idx = 0; 1534 if (ParseUInt32(Idx)) return true; 1535 Indices.push_back(Idx); 1536 } 1537 1538 return false; 1539} 1540 1541//===----------------------------------------------------------------------===// 1542// Type Parsing. 1543//===----------------------------------------------------------------------===// 1544 1545/// ParseType - Parse a type. 1546bool LLParser::ParseType(Type *&Result, bool AllowVoid) { 1547 SMLoc TypeLoc = Lex.getLoc(); 1548 switch (Lex.getKind()) { 1549 default: 1550 return TokError("expected type"); 1551 case lltok::Type: 1552 // Type ::= 'float' | 'void' (etc) 1553 Result = Lex.getTyVal(); 1554 Lex.Lex(); 1555 break; 1556 case lltok::lbrace: 1557 // Type ::= StructType 1558 if (ParseAnonStructType(Result, false)) 1559 return true; 1560 break; 1561 case lltok::lsquare: 1562 // Type ::= '[' ... ']' 1563 Lex.Lex(); // eat the lsquare. 1564 if (ParseArrayVectorType(Result, false)) 1565 return true; 1566 break; 1567 case lltok::less: // Either vector or packed struct. 1568 // Type ::= '<' ... '>' 1569 Lex.Lex(); 1570 if (Lex.getKind() == lltok::lbrace) { 1571 if (ParseAnonStructType(Result, true) || 1572 ParseToken(lltok::greater, "expected '>' at end of packed struct")) 1573 return true; 1574 } else if (ParseArrayVectorType(Result, true)) 1575 return true; 1576 break; 1577 case lltok::LocalVar: { 1578 // Type ::= %foo 1579 std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.getStrVal()]; 1580 1581 // If the type hasn't been defined yet, create a forward definition and 1582 // remember where that forward def'n was seen (in case it never is defined). 1583 if (Entry.first == 0) { 1584 Entry.first = StructType::create(Context, Lex.getStrVal()); 1585 Entry.second = Lex.getLoc(); 1586 } 1587 Result = Entry.first; 1588 Lex.Lex(); 1589 break; 1590 } 1591 1592 case lltok::LocalVarID: { 1593 // Type ::= %4 1594 if (Lex.getUIntVal() >= NumberedTypes.size()) 1595 NumberedTypes.resize(Lex.getUIntVal()+1); 1596 std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.getUIntVal()]; 1597 1598 // If the type hasn't been defined yet, create a forward definition and 1599 // remember where that forward def'n was seen (in case it never is defined). 1600 if (Entry.first == 0) { 1601 Entry.first = StructType::create(Context); 1602 Entry.second = Lex.getLoc(); 1603 } 1604 Result = Entry.first; 1605 Lex.Lex(); 1606 break; 1607 } 1608 } 1609 1610 // Parse the type suffixes. 1611 while (1) { 1612 switch (Lex.getKind()) { 1613 // End of type. 1614 default: 1615 if (!AllowVoid && Result->isVoidTy()) 1616 return Error(TypeLoc, "void type only allowed for function results"); 1617 return false; 1618 1619 // Type ::= Type '*' 1620 case lltok::star: 1621 if (Result->isLabelTy()) 1622 return TokError("basic block pointers are invalid"); 1623 if (Result->isVoidTy()) 1624 return TokError("pointers to void are invalid - use i8* instead"); 1625 if (!PointerType::isValidElementType(Result)) 1626 return TokError("pointer to this type is invalid"); 1627 Result = PointerType::getUnqual(Result); 1628 Lex.Lex(); 1629 break; 1630 1631 // Type ::= Type 'addrspace' '(' uint32 ')' '*' 1632 case lltok::kw_addrspace: { 1633 if (Result->isLabelTy()) 1634 return TokError("basic block pointers are invalid"); 1635 if (Result->isVoidTy()) 1636 return TokError("pointers to void are invalid; use i8* instead"); 1637 if (!PointerType::isValidElementType(Result)) 1638 return TokError("pointer to this type is invalid"); 1639 unsigned AddrSpace; 1640 if (ParseOptionalAddrSpace(AddrSpace) || 1641 ParseToken(lltok::star, "expected '*' in address space")) 1642 return true; 1643 1644 Result = PointerType::get(Result, AddrSpace); 1645 break; 1646 } 1647 1648 /// Types '(' ArgTypeListI ')' OptFuncAttrs 1649 case lltok::lparen: 1650 if (ParseFunctionType(Result)) 1651 return true; 1652 break; 1653 } 1654 } 1655} 1656 1657/// ParseParameterList 1658/// ::= '(' ')' 1659/// ::= '(' Arg (',' Arg)* ')' 1660/// Arg 1661/// ::= Type OptionalAttributes Value OptionalAttributes 1662bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList, 1663 PerFunctionState &PFS) { 1664 if (ParseToken(lltok::lparen, "expected '(' in call")) 1665 return true; 1666 1667 unsigned AttrIndex = 1; 1668 while (Lex.getKind() != lltok::rparen) { 1669 // If this isn't the first argument, we need a comma. 1670 if (!ArgList.empty() && 1671 ParseToken(lltok::comma, "expected ',' in argument list")) 1672 return true; 1673 1674 // Parse the argument. 1675 LocTy ArgLoc; 1676 Type *ArgTy = 0; 1677 AttrBuilder ArgAttrs; 1678 Value *V; 1679 if (ParseType(ArgTy, ArgLoc)) 1680 return true; 1681 1682 // Otherwise, handle normal operands. 1683 if (ParseOptionalParamAttrs(ArgAttrs) || ParseValue(ArgTy, V, PFS)) 1684 return true; 1685 ArgList.push_back(ParamInfo(ArgLoc, V, AttributeSet::get(V->getContext(), 1686 AttrIndex++, 1687 ArgAttrs))); 1688 } 1689 1690 Lex.Lex(); // Lex the ')'. 1691 return false; 1692} 1693 1694 1695 1696/// ParseArgumentList - Parse the argument list for a function type or function 1697/// prototype. 1698/// ::= '(' ArgTypeListI ')' 1699/// ArgTypeListI 1700/// ::= /*empty*/ 1701/// ::= '...' 1702/// ::= ArgTypeList ',' '...' 1703/// ::= ArgType (',' ArgType)* 1704/// 1705bool LLParser::ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, 1706 bool &isVarArg){ 1707 isVarArg = false; 1708 assert(Lex.getKind() == lltok::lparen); 1709 Lex.Lex(); // eat the (. 1710 1711 if (Lex.getKind() == lltok::rparen) { 1712 // empty 1713 } else if (Lex.getKind() == lltok::dotdotdot) { 1714 isVarArg = true; 1715 Lex.Lex(); 1716 } else { 1717 LocTy TypeLoc = Lex.getLoc(); 1718 Type *ArgTy = 0; 1719 AttrBuilder Attrs; 1720 std::string Name; 1721 1722 if (ParseType(ArgTy) || 1723 ParseOptionalParamAttrs(Attrs)) return true; 1724 1725 if (ArgTy->isVoidTy()) 1726 return Error(TypeLoc, "argument can not have void type"); 1727 1728 if (Lex.getKind() == lltok::LocalVar) { 1729 Name = Lex.getStrVal(); 1730 Lex.Lex(); 1731 } 1732 1733 if (!FunctionType::isValidArgumentType(ArgTy)) 1734 return Error(TypeLoc, "invalid type for function argument"); 1735 1736 unsigned AttrIndex = 1; 1737 ArgList.push_back(ArgInfo(TypeLoc, ArgTy, 1738 AttributeSet::get(ArgTy->getContext(), 1739 AttrIndex++, Attrs), Name)); 1740 1741 while (EatIfPresent(lltok::comma)) { 1742 // Handle ... at end of arg list. 1743 if (EatIfPresent(lltok::dotdotdot)) { 1744 isVarArg = true; 1745 break; 1746 } 1747 1748 // Otherwise must be an argument type. 1749 TypeLoc = Lex.getLoc(); 1750 if (ParseType(ArgTy) || ParseOptionalParamAttrs(Attrs)) return true; 1751 1752 if (ArgTy->isVoidTy()) 1753 return Error(TypeLoc, "argument can not have void type"); 1754 1755 if (Lex.getKind() == lltok::LocalVar) { 1756 Name = Lex.getStrVal(); 1757 Lex.Lex(); 1758 } else { 1759 Name = ""; 1760 } 1761 1762 if (!ArgTy->isFirstClassType()) 1763 return Error(TypeLoc, "invalid type for function argument"); 1764 1765 ArgList.push_back(ArgInfo(TypeLoc, ArgTy, 1766 AttributeSet::get(ArgTy->getContext(), 1767 AttrIndex++, Attrs), 1768 Name)); 1769 } 1770 } 1771 1772 return ParseToken(lltok::rparen, "expected ')' at end of argument list"); 1773} 1774 1775/// ParseFunctionType 1776/// ::= Type ArgumentList OptionalAttrs 1777bool LLParser::ParseFunctionType(Type *&Result) { 1778 assert(Lex.getKind() == lltok::lparen); 1779 1780 if (!FunctionType::isValidReturnType(Result)) 1781 return TokError("invalid function return type"); 1782 1783 SmallVector<ArgInfo, 8> ArgList; 1784 bool isVarArg; 1785 if (ParseArgumentList(ArgList, isVarArg)) 1786 return true; 1787 1788 // Reject names on the arguments lists. 1789 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 1790 if (!ArgList[i].Name.empty()) 1791 return Error(ArgList[i].Loc, "argument name invalid in function type"); 1792 if (ArgList[i].Attrs.hasAttributes(i + 1)) 1793 return Error(ArgList[i].Loc, 1794 "argument attributes invalid in function type"); 1795 } 1796 1797 SmallVector<Type*, 16> ArgListTy; 1798 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) 1799 ArgListTy.push_back(ArgList[i].Ty); 1800 1801 Result = FunctionType::get(Result, ArgListTy, isVarArg); 1802 return false; 1803} 1804 1805/// ParseAnonStructType - Parse an anonymous struct type, which is inlined into 1806/// other structs. 1807bool LLParser::ParseAnonStructType(Type *&Result, bool Packed) { 1808 SmallVector<Type*, 8> Elts; 1809 if (ParseStructBody(Elts)) return true; 1810 1811 Result = StructType::get(Context, Elts, Packed); 1812 return false; 1813} 1814 1815/// ParseStructDefinition - Parse a struct in a 'type' definition. 1816bool LLParser::ParseStructDefinition(SMLoc TypeLoc, StringRef Name, 1817 std::pair<Type*, LocTy> &Entry, 1818 Type *&ResultTy) { 1819 // If the type was already defined, diagnose the redefinition. 1820 if (Entry.first && !Entry.second.isValid()) 1821 return Error(TypeLoc, "redefinition of type"); 1822 1823 // If we have opaque, just return without filling in the definition for the 1824 // struct. This counts as a definition as far as the .ll file goes. 1825 if (EatIfPresent(lltok::kw_opaque)) { 1826 // This type is being defined, so clear the location to indicate this. 1827 Entry.second = SMLoc(); 1828 1829 // If this type number has never been uttered, create it. 1830 if (Entry.first == 0) 1831 Entry.first = StructType::create(Context, Name); 1832 ResultTy = Entry.first; 1833 return false; 1834 } 1835 1836 // If the type starts with '<', then it is either a packed struct or a vector. 1837 bool isPacked = EatIfPresent(lltok::less); 1838 1839 // If we don't have a struct, then we have a random type alias, which we 1840 // accept for compatibility with old files. These types are not allowed to be 1841 // forward referenced and not allowed to be recursive. 1842 if (Lex.getKind() != lltok::lbrace) { 1843 if (Entry.first) 1844 return Error(TypeLoc, "forward references to non-struct type"); 1845 1846 ResultTy = 0; 1847 if (isPacked) 1848 return ParseArrayVectorType(ResultTy, true); 1849 return ParseType(ResultTy); 1850 } 1851 1852 // This type is being defined, so clear the location to indicate this. 1853 Entry.second = SMLoc(); 1854 1855 // If this type number has never been uttered, create it. 1856 if (Entry.first == 0) 1857 Entry.first = StructType::create(Context, Name); 1858 1859 StructType *STy = cast<StructType>(Entry.first); 1860 1861 SmallVector<Type*, 8> Body; 1862 if (ParseStructBody(Body) || 1863 (isPacked && ParseToken(lltok::greater, "expected '>' in packed struct"))) 1864 return true; 1865 1866 STy->setBody(Body, isPacked); 1867 ResultTy = STy; 1868 return false; 1869} 1870 1871 1872/// ParseStructType: Handles packed and unpacked types. </> parsed elsewhere. 1873/// StructType 1874/// ::= '{' '}' 1875/// ::= '{' Type (',' Type)* '}' 1876/// ::= '<' '{' '}' '>' 1877/// ::= '<' '{' Type (',' Type)* '}' '>' 1878bool LLParser::ParseStructBody(SmallVectorImpl<Type*> &Body) { 1879 assert(Lex.getKind() == lltok::lbrace); 1880 Lex.Lex(); // Consume the '{' 1881 1882 // Handle the empty struct. 1883 if (EatIfPresent(lltok::rbrace)) 1884 return false; 1885 1886 LocTy EltTyLoc = Lex.getLoc(); 1887 Type *Ty = 0; 1888 if (ParseType(Ty)) return true; 1889 Body.push_back(Ty); 1890 1891 if (!StructType::isValidElementType(Ty)) 1892 return Error(EltTyLoc, "invalid element type for struct"); 1893 1894 while (EatIfPresent(lltok::comma)) { 1895 EltTyLoc = Lex.getLoc(); 1896 if (ParseType(Ty)) return true; 1897 1898 if (!StructType::isValidElementType(Ty)) 1899 return Error(EltTyLoc, "invalid element type for struct"); 1900 1901 Body.push_back(Ty); 1902 } 1903 1904 return ParseToken(lltok::rbrace, "expected '}' at end of struct"); 1905} 1906 1907/// ParseArrayVectorType - Parse an array or vector type, assuming the first 1908/// token has already been consumed. 1909/// Type 1910/// ::= '[' APSINTVAL 'x' Types ']' 1911/// ::= '<' APSINTVAL 'x' Types '>' 1912bool LLParser::ParseArrayVectorType(Type *&Result, bool isVector) { 1913 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() || 1914 Lex.getAPSIntVal().getBitWidth() > 64) 1915 return TokError("expected number in address space"); 1916 1917 LocTy SizeLoc = Lex.getLoc(); 1918 uint64_t Size = Lex.getAPSIntVal().getZExtValue(); 1919 Lex.Lex(); 1920 1921 if (ParseToken(lltok::kw_x, "expected 'x' after element count")) 1922 return true; 1923 1924 LocTy TypeLoc = Lex.getLoc(); 1925 Type *EltTy = 0; 1926 if (ParseType(EltTy)) return true; 1927 1928 if (ParseToken(isVector ? lltok::greater : lltok::rsquare, 1929 "expected end of sequential type")) 1930 return true; 1931 1932 if (isVector) { 1933 if (Size == 0) 1934 return Error(SizeLoc, "zero element vector is illegal"); 1935 if ((unsigned)Size != Size) 1936 return Error(SizeLoc, "size too large for vector"); 1937 if (!VectorType::isValidElementType(EltTy)) 1938 return Error(TypeLoc, "invalid vector element type"); 1939 Result = VectorType::get(EltTy, unsigned(Size)); 1940 } else { 1941 if (!ArrayType::isValidElementType(EltTy)) 1942 return Error(TypeLoc, "invalid array element type"); 1943 Result = ArrayType::get(EltTy, Size); 1944 } 1945 return false; 1946} 1947 1948//===----------------------------------------------------------------------===// 1949// Function Semantic Analysis. 1950//===----------------------------------------------------------------------===// 1951 1952LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f, 1953 int functionNumber) 1954 : P(p), F(f), FunctionNumber(functionNumber) { 1955 1956 // Insert unnamed arguments into the NumberedVals list. 1957 for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 1958 AI != E; ++AI) 1959 if (!AI->hasName()) 1960 NumberedVals.push_back(AI); 1961} 1962 1963LLParser::PerFunctionState::~PerFunctionState() { 1964 // If there were any forward referenced non-basicblock values, delete them. 1965 for (std::map<std::string, std::pair<Value*, LocTy> >::iterator 1966 I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I) 1967 if (!isa<BasicBlock>(I->second.first)) { 1968 I->second.first->replaceAllUsesWith( 1969 UndefValue::get(I->second.first->getType())); 1970 delete I->second.first; 1971 I->second.first = 0; 1972 } 1973 1974 for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator 1975 I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I) 1976 if (!isa<BasicBlock>(I->second.first)) { 1977 I->second.first->replaceAllUsesWith( 1978 UndefValue::get(I->second.first->getType())); 1979 delete I->second.first; 1980 I->second.first = 0; 1981 } 1982} 1983 1984bool LLParser::PerFunctionState::FinishFunction() { 1985 // Check to see if someone took the address of labels in this block. 1986 if (!P.ForwardRefBlockAddresses.empty()) { 1987 ValID FunctionID; 1988 if (!F.getName().empty()) { 1989 FunctionID.Kind = ValID::t_GlobalName; 1990 FunctionID.StrVal = F.getName(); 1991 } else { 1992 FunctionID.Kind = ValID::t_GlobalID; 1993 FunctionID.UIntVal = FunctionNumber; 1994 } 1995 1996 std::map<ValID, std::vector<std::pair<ValID, GlobalValue*> > >::iterator 1997 FRBAI = P.ForwardRefBlockAddresses.find(FunctionID); 1998 if (FRBAI != P.ForwardRefBlockAddresses.end()) { 1999 // Resolve all these references. 2000 if (P.ResolveForwardRefBlockAddresses(&F, FRBAI->second, this)) 2001 return true; 2002 2003 P.ForwardRefBlockAddresses.erase(FRBAI); 2004 } 2005 } 2006 2007 if (!ForwardRefVals.empty()) 2008 return P.Error(ForwardRefVals.begin()->second.second, 2009 "use of undefined value '%" + ForwardRefVals.begin()->first + 2010 "'"); 2011 if (!ForwardRefValIDs.empty()) 2012 return P.Error(ForwardRefValIDs.begin()->second.second, 2013 "use of undefined value '%" + 2014 Twine(ForwardRefValIDs.begin()->first) + "'"); 2015 return false; 2016} 2017 2018 2019/// GetVal - Get a value with the specified name or ID, creating a 2020/// forward reference record if needed. This can return null if the value 2021/// exists but does not have the right type. 2022Value *LLParser::PerFunctionState::GetVal(const std::string &Name, 2023 Type *Ty, LocTy Loc) { 2024 // Look this name up in the normal function symbol table. 2025 Value *Val = F.getValueSymbolTable().lookup(Name); 2026 2027 // If this is a forward reference for the value, see if we already created a 2028 // forward ref record. 2029 if (Val == 0) { 2030 std::map<std::string, std::pair<Value*, LocTy> >::iterator 2031 I = ForwardRefVals.find(Name); 2032 if (I != ForwardRefVals.end()) 2033 Val = I->second.first; 2034 } 2035 2036 // If we have the value in the symbol table or fwd-ref table, return it. 2037 if (Val) { 2038 if (Val->getType() == Ty) return Val; 2039 if (Ty->isLabelTy()) 2040 P.Error(Loc, "'%" + Name + "' is not a basic block"); 2041 else 2042 P.Error(Loc, "'%" + Name + "' defined with type '" + 2043 getTypeString(Val->getType()) + "'"); 2044 return 0; 2045 } 2046 2047 // Don't make placeholders with invalid type. 2048 if (!Ty->isFirstClassType() && !Ty->isLabelTy()) { 2049 P.Error(Loc, "invalid use of a non-first-class type"); 2050 return 0; 2051 } 2052 2053 // Otherwise, create a new forward reference for this value and remember it. 2054 Value *FwdVal; 2055 if (Ty->isLabelTy()) 2056 FwdVal = BasicBlock::Create(F.getContext(), Name, &F); 2057 else 2058 FwdVal = new Argument(Ty, Name); 2059 2060 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc); 2061 return FwdVal; 2062} 2063 2064Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty, 2065 LocTy Loc) { 2066 // Look this name up in the normal function symbol table. 2067 Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0; 2068 2069 // If this is a forward reference for the value, see if we already created a 2070 // forward ref record. 2071 if (Val == 0) { 2072 std::map<unsigned, std::pair<Value*, LocTy> >::iterator 2073 I = ForwardRefValIDs.find(ID); 2074 if (I != ForwardRefValIDs.end()) 2075 Val = I->second.first; 2076 } 2077 2078 // If we have the value in the symbol table or fwd-ref table, return it. 2079 if (Val) { 2080 if (Val->getType() == Ty) return Val; 2081 if (Ty->isLabelTy()) 2082 P.Error(Loc, "'%" + Twine(ID) + "' is not a basic block"); 2083 else 2084 P.Error(Loc, "'%" + Twine(ID) + "' defined with type '" + 2085 getTypeString(Val->getType()) + "'"); 2086 return 0; 2087 } 2088 2089 if (!Ty->isFirstClassType() && !Ty->isLabelTy()) { 2090 P.Error(Loc, "invalid use of a non-first-class type"); 2091 return 0; 2092 } 2093 2094 // Otherwise, create a new forward reference for this value and remember it. 2095 Value *FwdVal; 2096 if (Ty->isLabelTy()) 2097 FwdVal = BasicBlock::Create(F.getContext(), "", &F); 2098 else 2099 FwdVal = new Argument(Ty); 2100 2101 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc); 2102 return FwdVal; 2103} 2104 2105/// SetInstName - After an instruction is parsed and inserted into its 2106/// basic block, this installs its name. 2107bool LLParser::PerFunctionState::SetInstName(int NameID, 2108 const std::string &NameStr, 2109 LocTy NameLoc, Instruction *Inst) { 2110 // If this instruction has void type, it cannot have a name or ID specified. 2111 if (Inst->getType()->isVoidTy()) { 2112 if (NameID != -1 || !NameStr.empty()) 2113 return P.Error(NameLoc, "instructions returning void cannot have a name"); 2114 return false; 2115 } 2116 2117 // If this was a numbered instruction, verify that the instruction is the 2118 // expected value and resolve any forward references. 2119 if (NameStr.empty()) { 2120 // If neither a name nor an ID was specified, just use the next ID. 2121 if (NameID == -1) 2122 NameID = NumberedVals.size(); 2123 2124 if (unsigned(NameID) != NumberedVals.size()) 2125 return P.Error(NameLoc, "instruction expected to be numbered '%" + 2126 Twine(NumberedVals.size()) + "'"); 2127 2128 std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI = 2129 ForwardRefValIDs.find(NameID); 2130 if (FI != ForwardRefValIDs.end()) { 2131 if (FI->second.first->getType() != Inst->getType()) 2132 return P.Error(NameLoc, "instruction forward referenced with type '" + 2133 getTypeString(FI->second.first->getType()) + "'"); 2134 FI->second.first->replaceAllUsesWith(Inst); 2135 delete FI->second.first; 2136 ForwardRefValIDs.erase(FI); 2137 } 2138 2139 NumberedVals.push_back(Inst); 2140 return false; 2141 } 2142 2143 // Otherwise, the instruction had a name. Resolve forward refs and set it. 2144 std::map<std::string, std::pair<Value*, LocTy> >::iterator 2145 FI = ForwardRefVals.find(NameStr); 2146 if (FI != ForwardRefVals.end()) { 2147 if (FI->second.first->getType() != Inst->getType()) 2148 return P.Error(NameLoc, "instruction forward referenced with type '" + 2149 getTypeString(FI->second.first->getType()) + "'"); 2150 FI->second.first->replaceAllUsesWith(Inst); 2151 delete FI->second.first; 2152 ForwardRefVals.erase(FI); 2153 } 2154 2155 // Set the name on the instruction. 2156 Inst->setName(NameStr); 2157 2158 if (Inst->getName() != NameStr) 2159 return P.Error(NameLoc, "multiple definition of local value named '" + 2160 NameStr + "'"); 2161 return false; 2162} 2163 2164/// GetBB - Get a basic block with the specified name or ID, creating a 2165/// forward reference record if needed. 2166BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name, 2167 LocTy Loc) { 2168 return cast_or_null<BasicBlock>(GetVal(Name, 2169 Type::getLabelTy(F.getContext()), Loc)); 2170} 2171 2172BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) { 2173 return cast_or_null<BasicBlock>(GetVal(ID, 2174 Type::getLabelTy(F.getContext()), Loc)); 2175} 2176 2177/// DefineBB - Define the specified basic block, which is either named or 2178/// unnamed. If there is an error, this returns null otherwise it returns 2179/// the block being defined. 2180BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name, 2181 LocTy Loc) { 2182 BasicBlock *BB; 2183 if (Name.empty()) 2184 BB = GetBB(NumberedVals.size(), Loc); 2185 else 2186 BB = GetBB(Name, Loc); 2187 if (BB == 0) return 0; // Already diagnosed error. 2188 2189 // Move the block to the end of the function. Forward ref'd blocks are 2190 // inserted wherever they happen to be referenced. 2191 F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB); 2192 2193 // Remove the block from forward ref sets. 2194 if (Name.empty()) { 2195 ForwardRefValIDs.erase(NumberedVals.size()); 2196 NumberedVals.push_back(BB); 2197 } else { 2198 // BB forward references are already in the function symbol table. 2199 ForwardRefVals.erase(Name); 2200 } 2201 2202 return BB; 2203} 2204 2205//===----------------------------------------------------------------------===// 2206// Constants. 2207//===----------------------------------------------------------------------===// 2208 2209/// ParseValID - Parse an abstract value that doesn't necessarily have a 2210/// type implied. For example, if we parse "4" we don't know what integer type 2211/// it has. The value will later be combined with its type and checked for 2212/// sanity. PFS is used to convert function-local operands of metadata (since 2213/// metadata operands are not just parsed here but also converted to values). 2214/// PFS can be null when we are not parsing metadata values inside a function. 2215bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) { 2216 ID.Loc = Lex.getLoc(); 2217 switch (Lex.getKind()) { 2218 default: return TokError("expected value token"); 2219 case lltok::GlobalID: // @42 2220 ID.UIntVal = Lex.getUIntVal(); 2221 ID.Kind = ValID::t_GlobalID; 2222 break; 2223 case lltok::GlobalVar: // @foo 2224 ID.StrVal = Lex.getStrVal(); 2225 ID.Kind = ValID::t_GlobalName; 2226 break; 2227 case lltok::LocalVarID: // %42 2228 ID.UIntVal = Lex.getUIntVal(); 2229 ID.Kind = ValID::t_LocalID; 2230 break; 2231 case lltok::LocalVar: // %foo 2232 ID.StrVal = Lex.getStrVal(); 2233 ID.Kind = ValID::t_LocalName; 2234 break; 2235 case lltok::exclaim: // !42, !{...}, or !"foo" 2236 return ParseMetadataValue(ID, PFS); 2237 case lltok::APSInt: 2238 ID.APSIntVal = Lex.getAPSIntVal(); 2239 ID.Kind = ValID::t_APSInt; 2240 break; 2241 case lltok::APFloat: 2242 ID.APFloatVal = Lex.getAPFloatVal(); 2243 ID.Kind = ValID::t_APFloat; 2244 break; 2245 case lltok::kw_true: 2246 ID.ConstantVal = ConstantInt::getTrue(Context); 2247 ID.Kind = ValID::t_Constant; 2248 break; 2249 case lltok::kw_false: 2250 ID.ConstantVal = ConstantInt::getFalse(Context); 2251 ID.Kind = ValID::t_Constant; 2252 break; 2253 case lltok::kw_null: ID.Kind = ValID::t_Null; break; 2254 case lltok::kw_undef: ID.Kind = ValID::t_Undef; break; 2255 case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break; 2256 2257 case lltok::lbrace: { 2258 // ValID ::= '{' ConstVector '}' 2259 Lex.Lex(); 2260 SmallVector<Constant*, 16> Elts; 2261 if (ParseGlobalValueVector(Elts) || 2262 ParseToken(lltok::rbrace, "expected end of struct constant")) 2263 return true; 2264 2265 ID.ConstantStructElts = new Constant*[Elts.size()]; 2266 ID.UIntVal = Elts.size(); 2267 memcpy(ID.ConstantStructElts, Elts.data(), Elts.size()*sizeof(Elts[0])); 2268 ID.Kind = ValID::t_ConstantStruct; 2269 return false; 2270 } 2271 case lltok::less: { 2272 // ValID ::= '<' ConstVector '>' --> Vector. 2273 // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct. 2274 Lex.Lex(); 2275 bool isPackedStruct = EatIfPresent(lltok::lbrace); 2276 2277 SmallVector<Constant*, 16> Elts; 2278 LocTy FirstEltLoc = Lex.getLoc(); 2279 if (ParseGlobalValueVector(Elts) || 2280 (isPackedStruct && 2281 ParseToken(lltok::rbrace, "expected end of packed struct")) || 2282 ParseToken(lltok::greater, "expected end of constant")) 2283 return true; 2284 2285 if (isPackedStruct) { 2286 ID.ConstantStructElts = new Constant*[Elts.size()]; 2287 memcpy(ID.ConstantStructElts, Elts.data(), Elts.size()*sizeof(Elts[0])); 2288 ID.UIntVal = Elts.size(); 2289 ID.Kind = ValID::t_PackedConstantStruct; 2290 return false; 2291 } 2292 2293 if (Elts.empty()) 2294 return Error(ID.Loc, "constant vector must not be empty"); 2295 2296 if (!Elts[0]->getType()->isIntegerTy() && 2297 !Elts[0]->getType()->isFloatingPointTy() && 2298 !Elts[0]->getType()->isPointerTy()) 2299 return Error(FirstEltLoc, 2300 "vector elements must have integer, pointer or floating point type"); 2301 2302 // Verify that all the vector elements have the same type. 2303 for (unsigned i = 1, e = Elts.size(); i != e; ++i) 2304 if (Elts[i]->getType() != Elts[0]->getType()) 2305 return Error(FirstEltLoc, 2306 "vector element #" + Twine(i) + 2307 " is not of type '" + getTypeString(Elts[0]->getType())); 2308 2309 ID.ConstantVal = ConstantVector::get(Elts); 2310 ID.Kind = ValID::t_Constant; 2311 return false; 2312 } 2313 case lltok::lsquare: { // Array Constant 2314 Lex.Lex(); 2315 SmallVector<Constant*, 16> Elts; 2316 LocTy FirstEltLoc = Lex.getLoc(); 2317 if (ParseGlobalValueVector(Elts) || 2318 ParseToken(lltok::rsquare, "expected end of array constant")) 2319 return true; 2320 2321 // Handle empty element. 2322 if (Elts.empty()) { 2323 // Use undef instead of an array because it's inconvenient to determine 2324 // the element type at this point, there being no elements to examine. 2325 ID.Kind = ValID::t_EmptyArray; 2326 return false; 2327 } 2328 2329 if (!Elts[0]->getType()->isFirstClassType()) 2330 return Error(FirstEltLoc, "invalid array element type: " + 2331 getTypeString(Elts[0]->getType())); 2332 2333 ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size()); 2334 2335 // Verify all elements are correct type! 2336 for (unsigned i = 0, e = Elts.size(); i != e; ++i) { 2337 if (Elts[i]->getType() != Elts[0]->getType()) 2338 return Error(FirstEltLoc, 2339 "array element #" + Twine(i) + 2340 " is not of type '" + getTypeString(Elts[0]->getType())); 2341 } 2342 2343 ID.ConstantVal = ConstantArray::get(ATy, Elts); 2344 ID.Kind = ValID::t_Constant; 2345 return false; 2346 } 2347 case lltok::kw_c: // c "foo" 2348 Lex.Lex(); 2349 ID.ConstantVal = ConstantDataArray::getString(Context, Lex.getStrVal(), 2350 false); 2351 if (ParseToken(lltok::StringConstant, "expected string")) return true; 2352 ID.Kind = ValID::t_Constant; 2353 return false; 2354 2355 case lltok::kw_asm: { 2356 // ValID ::= 'asm' SideEffect? AlignStack? IntelDialect? STRINGCONSTANT ',' 2357 // STRINGCONSTANT 2358 bool HasSideEffect, AlignStack, AsmDialect; 2359 Lex.Lex(); 2360 if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) || 2361 ParseOptionalToken(lltok::kw_alignstack, AlignStack) || 2362 ParseOptionalToken(lltok::kw_inteldialect, AsmDialect) || 2363 ParseStringConstant(ID.StrVal) || 2364 ParseToken(lltok::comma, "expected comma in inline asm expression") || 2365 ParseToken(lltok::StringConstant, "expected constraint string")) 2366 return true; 2367 ID.StrVal2 = Lex.getStrVal(); 2368 ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1) | 2369 (unsigned(AsmDialect)<<2); 2370 ID.Kind = ValID::t_InlineAsm; 2371 return false; 2372 } 2373 2374 case lltok::kw_blockaddress: { 2375 // ValID ::= 'blockaddress' '(' @foo ',' %bar ')' 2376 Lex.Lex(); 2377 2378 ValID Fn, Label; 2379 LocTy FnLoc, LabelLoc; 2380 2381 if (ParseToken(lltok::lparen, "expected '(' in block address expression") || 2382 ParseValID(Fn) || 2383 ParseToken(lltok::comma, "expected comma in block address expression")|| 2384 ParseValID(Label) || 2385 ParseToken(lltok::rparen, "expected ')' in block address expression")) 2386 return true; 2387 2388 if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName) 2389 return Error(Fn.Loc, "expected function name in blockaddress"); 2390 if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName) 2391 return Error(Label.Loc, "expected basic block name in blockaddress"); 2392 2393 // Make a global variable as a placeholder for this reference. 2394 GlobalVariable *FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), 2395 false, GlobalValue::InternalLinkage, 2396 0, ""); 2397 ForwardRefBlockAddresses[Fn].push_back(std::make_pair(Label, FwdRef)); 2398 ID.ConstantVal = FwdRef; 2399 ID.Kind = ValID::t_Constant; 2400 return false; 2401 } 2402 2403 case lltok::kw_trunc: 2404 case lltok::kw_zext: 2405 case lltok::kw_sext: 2406 case lltok::kw_fptrunc: 2407 case lltok::kw_fpext: 2408 case lltok::kw_bitcast: 2409 case lltok::kw_uitofp: 2410 case lltok::kw_sitofp: 2411 case lltok::kw_fptoui: 2412 case lltok::kw_fptosi: 2413 case lltok::kw_inttoptr: 2414 case lltok::kw_ptrtoint: { 2415 unsigned Opc = Lex.getUIntVal(); 2416 Type *DestTy = 0; 2417 Constant *SrcVal; 2418 Lex.Lex(); 2419 if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") || 2420 ParseGlobalTypeAndValue(SrcVal) || 2421 ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") || 2422 ParseType(DestTy) || 2423 ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast")) 2424 return true; 2425 if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy)) 2426 return Error(ID.Loc, "invalid cast opcode for cast from '" + 2427 getTypeString(SrcVal->getType()) + "' to '" + 2428 getTypeString(DestTy) + "'"); 2429 ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc, 2430 SrcVal, DestTy); 2431 ID.Kind = ValID::t_Constant; 2432 return false; 2433 } 2434 case lltok::kw_extractvalue: { 2435 Lex.Lex(); 2436 Constant *Val; 2437 SmallVector<unsigned, 4> Indices; 2438 if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")|| 2439 ParseGlobalTypeAndValue(Val) || 2440 ParseIndexList(Indices) || 2441 ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr")) 2442 return true; 2443 2444 if (!Val->getType()->isAggregateType()) 2445 return Error(ID.Loc, "extractvalue operand must be aggregate type"); 2446 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices)) 2447 return Error(ID.Loc, "invalid indices for extractvalue"); 2448 ID.ConstantVal = ConstantExpr::getExtractValue(Val, Indices); 2449 ID.Kind = ValID::t_Constant; 2450 return false; 2451 } 2452 case lltok::kw_insertvalue: { 2453 Lex.Lex(); 2454 Constant *Val0, *Val1; 2455 SmallVector<unsigned, 4> Indices; 2456 if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")|| 2457 ParseGlobalTypeAndValue(Val0) || 2458 ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")|| 2459 ParseGlobalTypeAndValue(Val1) || 2460 ParseIndexList(Indices) || 2461 ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr")) 2462 return true; 2463 if (!Val0->getType()->isAggregateType()) 2464 return Error(ID.Loc, "insertvalue operand must be aggregate type"); 2465 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices)) 2466 return Error(ID.Loc, "invalid indices for insertvalue"); 2467 ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, Indices); 2468 ID.Kind = ValID::t_Constant; 2469 return false; 2470 } 2471 case lltok::kw_icmp: 2472 case lltok::kw_fcmp: { 2473 unsigned PredVal, Opc = Lex.getUIntVal(); 2474 Constant *Val0, *Val1; 2475 Lex.Lex(); 2476 if (ParseCmpPredicate(PredVal, Opc) || 2477 ParseToken(lltok::lparen, "expected '(' in compare constantexpr") || 2478 ParseGlobalTypeAndValue(Val0) || 2479 ParseToken(lltok::comma, "expected comma in compare constantexpr") || 2480 ParseGlobalTypeAndValue(Val1) || 2481 ParseToken(lltok::rparen, "expected ')' in compare constantexpr")) 2482 return true; 2483 2484 if (Val0->getType() != Val1->getType()) 2485 return Error(ID.Loc, "compare operands must have the same type"); 2486 2487 CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal; 2488 2489 if (Opc == Instruction::FCmp) { 2490 if (!Val0->getType()->isFPOrFPVectorTy()) 2491 return Error(ID.Loc, "fcmp requires floating point operands"); 2492 ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1); 2493 } else { 2494 assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!"); 2495 if (!Val0->getType()->isIntOrIntVectorTy() && 2496 !Val0->getType()->getScalarType()->isPointerTy()) 2497 return Error(ID.Loc, "icmp requires pointer or integer operands"); 2498 ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1); 2499 } 2500 ID.Kind = ValID::t_Constant; 2501 return false; 2502 } 2503 2504 // Binary Operators. 2505 case lltok::kw_add: 2506 case lltok::kw_fadd: 2507 case lltok::kw_sub: 2508 case lltok::kw_fsub: 2509 case lltok::kw_mul: 2510 case lltok::kw_fmul: 2511 case lltok::kw_udiv: 2512 case lltok::kw_sdiv: 2513 case lltok::kw_fdiv: 2514 case lltok::kw_urem: 2515 case lltok::kw_srem: 2516 case lltok::kw_frem: 2517 case lltok::kw_shl: 2518 case lltok::kw_lshr: 2519 case lltok::kw_ashr: { 2520 bool NUW = false; 2521 bool NSW = false; 2522 bool Exact = false; 2523 unsigned Opc = Lex.getUIntVal(); 2524 Constant *Val0, *Val1; 2525 Lex.Lex(); 2526 LocTy ModifierLoc = Lex.getLoc(); 2527 if (Opc == Instruction::Add || Opc == Instruction::Sub || 2528 Opc == Instruction::Mul || Opc == Instruction::Shl) { 2529 if (EatIfPresent(lltok::kw_nuw)) 2530 NUW = true; 2531 if (EatIfPresent(lltok::kw_nsw)) { 2532 NSW = true; 2533 if (EatIfPresent(lltok::kw_nuw)) 2534 NUW = true; 2535 } 2536 } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv || 2537 Opc == Instruction::LShr || Opc == Instruction::AShr) { 2538 if (EatIfPresent(lltok::kw_exact)) 2539 Exact = true; 2540 } 2541 if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") || 2542 ParseGlobalTypeAndValue(Val0) || 2543 ParseToken(lltok::comma, "expected comma in binary constantexpr") || 2544 ParseGlobalTypeAndValue(Val1) || 2545 ParseToken(lltok::rparen, "expected ')' in binary constantexpr")) 2546 return true; 2547 if (Val0->getType() != Val1->getType()) 2548 return Error(ID.Loc, "operands of constexpr must have same type"); 2549 if (!Val0->getType()->isIntOrIntVectorTy()) { 2550 if (NUW) 2551 return Error(ModifierLoc, "nuw only applies to integer operations"); 2552 if (NSW) 2553 return Error(ModifierLoc, "nsw only applies to integer operations"); 2554 } 2555 // Check that the type is valid for the operator. 2556 switch (Opc) { 2557 case Instruction::Add: 2558 case Instruction::Sub: 2559 case Instruction::Mul: 2560 case Instruction::UDiv: 2561 case Instruction::SDiv: 2562 case Instruction::URem: 2563 case Instruction::SRem: 2564 case Instruction::Shl: 2565 case Instruction::AShr: 2566 case Instruction::LShr: 2567 if (!Val0->getType()->isIntOrIntVectorTy()) 2568 return Error(ID.Loc, "constexpr requires integer operands"); 2569 break; 2570 case Instruction::FAdd: 2571 case Instruction::FSub: 2572 case Instruction::FMul: 2573 case Instruction::FDiv: 2574 case Instruction::FRem: 2575 if (!Val0->getType()->isFPOrFPVectorTy()) 2576 return Error(ID.Loc, "constexpr requires fp operands"); 2577 break; 2578 default: llvm_unreachable("Unknown binary operator!"); 2579 } 2580 unsigned Flags = 0; 2581 if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 2582 if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap; 2583 if (Exact) Flags |= PossiblyExactOperator::IsExact; 2584 Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags); 2585 ID.ConstantVal = C; 2586 ID.Kind = ValID::t_Constant; 2587 return false; 2588 } 2589 2590 // Logical Operations 2591 case lltok::kw_and: 2592 case lltok::kw_or: 2593 case lltok::kw_xor: { 2594 unsigned Opc = Lex.getUIntVal(); 2595 Constant *Val0, *Val1; 2596 Lex.Lex(); 2597 if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") || 2598 ParseGlobalTypeAndValue(Val0) || 2599 ParseToken(lltok::comma, "expected comma in logical constantexpr") || 2600 ParseGlobalTypeAndValue(Val1) || 2601 ParseToken(lltok::rparen, "expected ')' in logical constantexpr")) 2602 return true; 2603 if (Val0->getType() != Val1->getType()) 2604 return Error(ID.Loc, "operands of constexpr must have same type"); 2605 if (!Val0->getType()->isIntOrIntVectorTy()) 2606 return Error(ID.Loc, 2607 "constexpr requires integer or integer vector operands"); 2608 ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1); 2609 ID.Kind = ValID::t_Constant; 2610 return false; 2611 } 2612 2613 case lltok::kw_getelementptr: 2614 case lltok::kw_shufflevector: 2615 case lltok::kw_insertelement: 2616 case lltok::kw_extractelement: 2617 case lltok::kw_select: { 2618 unsigned Opc = Lex.getUIntVal(); 2619 SmallVector<Constant*, 16> Elts; 2620 bool InBounds = false; 2621 Lex.Lex(); 2622 if (Opc == Instruction::GetElementPtr) 2623 InBounds = EatIfPresent(lltok::kw_inbounds); 2624 if (ParseToken(lltok::lparen, "expected '(' in constantexpr") || 2625 ParseGlobalValueVector(Elts) || 2626 ParseToken(lltok::rparen, "expected ')' in constantexpr")) 2627 return true; 2628 2629 if (Opc == Instruction::GetElementPtr) { 2630 if (Elts.size() == 0 || 2631 !Elts[0]->getType()->getScalarType()->isPointerTy()) 2632 return Error(ID.Loc, "getelementptr requires pointer operand"); 2633 2634 ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); 2635 if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(), Indices)) 2636 return Error(ID.Loc, "invalid indices for getelementptr"); 2637 ID.ConstantVal = ConstantExpr::getGetElementPtr(Elts[0], Indices, 2638 InBounds); 2639 } else if (Opc == Instruction::Select) { 2640 if (Elts.size() != 3) 2641 return Error(ID.Loc, "expected three operands to select"); 2642 if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1], 2643 Elts[2])) 2644 return Error(ID.Loc, Reason); 2645 ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]); 2646 } else if (Opc == Instruction::ShuffleVector) { 2647 if (Elts.size() != 3) 2648 return Error(ID.Loc, "expected three operands to shufflevector"); 2649 if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2])) 2650 return Error(ID.Loc, "invalid operands to shufflevector"); 2651 ID.ConstantVal = 2652 ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]); 2653 } else if (Opc == Instruction::ExtractElement) { 2654 if (Elts.size() != 2) 2655 return Error(ID.Loc, "expected two operands to extractelement"); 2656 if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1])) 2657 return Error(ID.Loc, "invalid extractelement operands"); 2658 ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]); 2659 } else { 2660 assert(Opc == Instruction::InsertElement && "Unknown opcode"); 2661 if (Elts.size() != 3) 2662 return Error(ID.Loc, "expected three operands to insertelement"); 2663 if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2])) 2664 return Error(ID.Loc, "invalid insertelement operands"); 2665 ID.ConstantVal = 2666 ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]); 2667 } 2668 2669 ID.Kind = ValID::t_Constant; 2670 return false; 2671 } 2672 } 2673 2674 Lex.Lex(); 2675 return false; 2676} 2677 2678/// ParseGlobalValue - Parse a global value with the specified type. 2679bool LLParser::ParseGlobalValue(Type *Ty, Constant *&C) { 2680 C = 0; 2681 ValID ID; 2682 Value *V = NULL; 2683 bool Parsed = ParseValID(ID) || 2684 ConvertValIDToValue(Ty, ID, V, NULL); 2685 if (V && !(C = dyn_cast<Constant>(V))) 2686 return Error(ID.Loc, "global values must be constants"); 2687 return Parsed; 2688} 2689 2690bool LLParser::ParseGlobalTypeAndValue(Constant *&V) { 2691 Type *Ty = 0; 2692 return ParseType(Ty) || 2693 ParseGlobalValue(Ty, V); 2694} 2695 2696/// ParseGlobalValueVector 2697/// ::= /*empty*/ 2698/// ::= TypeAndValue (',' TypeAndValue)* 2699bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts) { 2700 // Empty list. 2701 if (Lex.getKind() == lltok::rbrace || 2702 Lex.getKind() == lltok::rsquare || 2703 Lex.getKind() == lltok::greater || 2704 Lex.getKind() == lltok::rparen) 2705 return false; 2706 2707 Constant *C; 2708 if (ParseGlobalTypeAndValue(C)) return true; 2709 Elts.push_back(C); 2710 2711 while (EatIfPresent(lltok::comma)) { 2712 if (ParseGlobalTypeAndValue(C)) return true; 2713 Elts.push_back(C); 2714 } 2715 2716 return false; 2717} 2718 2719bool LLParser::ParseMetadataListValue(ValID &ID, PerFunctionState *PFS) { 2720 assert(Lex.getKind() == lltok::lbrace); 2721 Lex.Lex(); 2722 2723 SmallVector<Value*, 16> Elts; 2724 if (ParseMDNodeVector(Elts, PFS) || 2725 ParseToken(lltok::rbrace, "expected end of metadata node")) 2726 return true; 2727 2728 ID.MDNodeVal = MDNode::get(Context, Elts); 2729 ID.Kind = ValID::t_MDNode; 2730 return false; 2731} 2732 2733/// ParseMetadataValue 2734/// ::= !42 2735/// ::= !{...} 2736/// ::= !"string" 2737bool LLParser::ParseMetadataValue(ValID &ID, PerFunctionState *PFS) { 2738 assert(Lex.getKind() == lltok::exclaim); 2739 Lex.Lex(); 2740 2741 // MDNode: 2742 // !{ ... } 2743 if (Lex.getKind() == lltok::lbrace) 2744 return ParseMetadataListValue(ID, PFS); 2745 2746 // Standalone metadata reference 2747 // !42 2748 if (Lex.getKind() == lltok::APSInt) { 2749 if (ParseMDNodeID(ID.MDNodeVal)) return true; 2750 ID.Kind = ValID::t_MDNode; 2751 return false; 2752 } 2753 2754 // MDString: 2755 // ::= '!' STRINGCONSTANT 2756 if (ParseMDString(ID.MDStringVal)) return true; 2757 ID.Kind = ValID::t_MDString; 2758 return false; 2759} 2760 2761 2762//===----------------------------------------------------------------------===// 2763// Function Parsing. 2764//===----------------------------------------------------------------------===// 2765 2766bool LLParser::ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V, 2767 PerFunctionState *PFS) { 2768 if (Ty->isFunctionTy()) 2769 return Error(ID.Loc, "functions are not values, refer to them as pointers"); 2770 2771 switch (ID.Kind) { 2772 case ValID::t_LocalID: 2773 if (!PFS) return Error(ID.Loc, "invalid use of function-local name"); 2774 V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc); 2775 return (V == 0); 2776 case ValID::t_LocalName: 2777 if (!PFS) return Error(ID.Loc, "invalid use of function-local name"); 2778 V = PFS->GetVal(ID.StrVal, Ty, ID.Loc); 2779 return (V == 0); 2780 case ValID::t_InlineAsm: { 2781 PointerType *PTy = dyn_cast<PointerType>(Ty); 2782 FunctionType *FTy = 2783 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0; 2784 if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2)) 2785 return Error(ID.Loc, "invalid type for inline asm constraint string"); 2786 V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1, 2787 (ID.UIntVal>>1)&1, (InlineAsm::AsmDialect(ID.UIntVal>>2))); 2788 return false; 2789 } 2790 case ValID::t_MDNode: 2791 if (!Ty->isMetadataTy()) 2792 return Error(ID.Loc, "metadata value must have metadata type"); 2793 V = ID.MDNodeVal; 2794 return false; 2795 case ValID::t_MDString: 2796 if (!Ty->isMetadataTy()) 2797 return Error(ID.Loc, "metadata value must have metadata type"); 2798 V = ID.MDStringVal; 2799 return false; 2800 case ValID::t_GlobalName: 2801 V = GetGlobalVal(ID.StrVal, Ty, ID.Loc); 2802 return V == 0; 2803 case ValID::t_GlobalID: 2804 V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc); 2805 return V == 0; 2806 case ValID::t_APSInt: 2807 if (!Ty->isIntegerTy()) 2808 return Error(ID.Loc, "integer constant must have integer type"); 2809 ID.APSIntVal = ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits()); 2810 V = ConstantInt::get(Context, ID.APSIntVal); 2811 return false; 2812 case ValID::t_APFloat: 2813 if (!Ty->isFloatingPointTy() || 2814 !ConstantFP::isValueValidForType(Ty, ID.APFloatVal)) 2815 return Error(ID.Loc, "floating point constant invalid for type"); 2816 2817 // The lexer has no type info, so builds all half, float, and double FP 2818 // constants as double. Fix this here. Long double does not need this. 2819 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble) { 2820 bool Ignored; 2821 if (Ty->isHalfTy()) 2822 ID.APFloatVal.convert(APFloat::IEEEhalf, APFloat::rmNearestTiesToEven, 2823 &Ignored); 2824 else if (Ty->isFloatTy()) 2825 ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, 2826 &Ignored); 2827 } 2828 V = ConstantFP::get(Context, ID.APFloatVal); 2829 2830 if (V->getType() != Ty) 2831 return Error(ID.Loc, "floating point constant does not have type '" + 2832 getTypeString(Ty) + "'"); 2833 2834 return false; 2835 case ValID::t_Null: 2836 if (!Ty->isPointerTy()) 2837 return Error(ID.Loc, "null must be a pointer type"); 2838 V = ConstantPointerNull::get(cast<PointerType>(Ty)); 2839 return false; 2840 case ValID::t_Undef: 2841 // FIXME: LabelTy should not be a first-class type. 2842 if (!Ty->isFirstClassType() || Ty->isLabelTy()) 2843 return Error(ID.Loc, "invalid type for undef constant"); 2844 V = UndefValue::get(Ty); 2845 return false; 2846 case ValID::t_EmptyArray: 2847 if (!Ty->isArrayTy() || cast<ArrayType>(Ty)->getNumElements() != 0) 2848 return Error(ID.Loc, "invalid empty array initializer"); 2849 V = UndefValue::get(Ty); 2850 return false; 2851 case ValID::t_Zero: 2852 // FIXME: LabelTy should not be a first-class type. 2853 if (!Ty->isFirstClassType() || Ty->isLabelTy()) 2854 return Error(ID.Loc, "invalid type for null constant"); 2855 V = Constant::getNullValue(Ty); 2856 return false; 2857 case ValID::t_Constant: 2858 if (ID.ConstantVal->getType() != Ty) 2859 return Error(ID.Loc, "constant expression type mismatch"); 2860 2861 V = ID.ConstantVal; 2862 return false; 2863 case ValID::t_ConstantStruct: 2864 case ValID::t_PackedConstantStruct: 2865 if (StructType *ST = dyn_cast<StructType>(Ty)) { 2866 if (ST->getNumElements() != ID.UIntVal) 2867 return Error(ID.Loc, 2868 "initializer with struct type has wrong # elements"); 2869 if (ST->isPacked() != (ID.Kind == ValID::t_PackedConstantStruct)) 2870 return Error(ID.Loc, "packed'ness of initializer and type don't match"); 2871 2872 // Verify that the elements are compatible with the structtype. 2873 for (unsigned i = 0, e = ID.UIntVal; i != e; ++i) 2874 if (ID.ConstantStructElts[i]->getType() != ST->getElementType(i)) 2875 return Error(ID.Loc, "element " + Twine(i) + 2876 " of struct initializer doesn't match struct element type"); 2877 2878 V = ConstantStruct::get(ST, makeArrayRef(ID.ConstantStructElts, 2879 ID.UIntVal)); 2880 } else 2881 return Error(ID.Loc, "constant expression type mismatch"); 2882 return false; 2883 } 2884 llvm_unreachable("Invalid ValID"); 2885} 2886 2887bool LLParser::ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS) { 2888 V = 0; 2889 ValID ID; 2890 return ParseValID(ID, PFS) || 2891 ConvertValIDToValue(Ty, ID, V, PFS); 2892} 2893 2894bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState *PFS) { 2895 Type *Ty = 0; 2896 return ParseType(Ty) || 2897 ParseValue(Ty, V, PFS); 2898} 2899 2900bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc, 2901 PerFunctionState &PFS) { 2902 Value *V; 2903 Loc = Lex.getLoc(); 2904 if (ParseTypeAndValue(V, PFS)) return true; 2905 if (!isa<BasicBlock>(V)) 2906 return Error(Loc, "expected a basic block"); 2907 BB = cast<BasicBlock>(V); 2908 return false; 2909} 2910 2911 2912/// FunctionHeader 2913/// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs 2914/// OptUnnamedAddr Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection 2915/// OptionalAlign OptGC 2916bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { 2917 // Parse the linkage. 2918 LocTy LinkageLoc = Lex.getLoc(); 2919 unsigned Linkage; 2920 2921 unsigned Visibility; 2922 AttrBuilder RetAttrs; 2923 CallingConv::ID CC; 2924 Type *RetType = 0; 2925 LocTy RetTypeLoc = Lex.getLoc(); 2926 if (ParseOptionalLinkage(Linkage) || 2927 ParseOptionalVisibility(Visibility) || 2928 ParseOptionalCallingConv(CC) || 2929 ParseOptionalReturnAttrs(RetAttrs) || 2930 ParseType(RetType, RetTypeLoc, true /*void allowed*/)) 2931 return true; 2932 2933 // Verify that the linkage is ok. 2934 switch ((GlobalValue::LinkageTypes)Linkage) { 2935 case GlobalValue::ExternalLinkage: 2936 break; // always ok. 2937 case GlobalValue::DLLImportLinkage: 2938 case GlobalValue::ExternalWeakLinkage: 2939 if (isDefine) 2940 return Error(LinkageLoc, "invalid linkage for function definition"); 2941 break; 2942 case GlobalValue::PrivateLinkage: 2943 case GlobalValue::LinkerPrivateLinkage: 2944 case GlobalValue::LinkerPrivateWeakLinkage: 2945 case GlobalValue::InternalLinkage: 2946 case GlobalValue::AvailableExternallyLinkage: 2947 case GlobalValue::LinkOnceAnyLinkage: 2948 case GlobalValue::LinkOnceODRLinkage: 2949 case GlobalValue::LinkOnceODRAutoHideLinkage: 2950 case GlobalValue::WeakAnyLinkage: 2951 case GlobalValue::WeakODRLinkage: 2952 case GlobalValue::DLLExportLinkage: 2953 if (!isDefine) 2954 return Error(LinkageLoc, "invalid linkage for function declaration"); 2955 break; 2956 case GlobalValue::AppendingLinkage: 2957 case GlobalValue::CommonLinkage: 2958 return Error(LinkageLoc, "invalid function linkage type"); 2959 } 2960 2961 if (!FunctionType::isValidReturnType(RetType)) 2962 return Error(RetTypeLoc, "invalid function return type"); 2963 2964 LocTy NameLoc = Lex.getLoc(); 2965 2966 std::string FunctionName; 2967 if (Lex.getKind() == lltok::GlobalVar) { 2968 FunctionName = Lex.getStrVal(); 2969 } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok. 2970 unsigned NameID = Lex.getUIntVal(); 2971 2972 if (NameID != NumberedVals.size()) 2973 return TokError("function expected to be numbered '%" + 2974 Twine(NumberedVals.size()) + "'"); 2975 } else { 2976 return TokError("expected function name"); 2977 } 2978 2979 Lex.Lex(); 2980 2981 if (Lex.getKind() != lltok::lparen) 2982 return TokError("expected '(' in function argument list"); 2983 2984 SmallVector<ArgInfo, 8> ArgList; 2985 bool isVarArg; 2986 AttrBuilder FuncAttrs; 2987 std::vector<unsigned> FwdRefAttrGrps; 2988 LocTy NoBuiltinLoc; 2989 std::string Section; 2990 unsigned Alignment; 2991 std::string GC; 2992 bool UnnamedAddr; 2993 LocTy UnnamedAddrLoc; 2994 2995 if (ParseArgumentList(ArgList, isVarArg) || 2996 ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr, 2997 &UnnamedAddrLoc) || 2998 ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false, 2999 NoBuiltinLoc) || 3000 (EatIfPresent(lltok::kw_section) && 3001 ParseStringConstant(Section)) || 3002 ParseOptionalAlignment(Alignment) || 3003 (EatIfPresent(lltok::kw_gc) && 3004 ParseStringConstant(GC))) 3005 return true; 3006 3007 if (FuncAttrs.contains(Attribute::NoBuiltin)) 3008 return Error(NoBuiltinLoc, "'nobuiltin' attribute not valid on function"); 3009 3010 // If the alignment was parsed as an attribute, move to the alignment field. 3011 if (FuncAttrs.hasAlignmentAttr()) { 3012 Alignment = FuncAttrs.getAlignment(); 3013 FuncAttrs.removeAttribute(Attribute::Alignment); 3014 } 3015 3016 // Okay, if we got here, the function is syntactically valid. Convert types 3017 // and do semantic checks. 3018 std::vector<Type*> ParamTypeList; 3019 SmallVector<AttributeSet, 8> Attrs; 3020 3021 if (RetAttrs.hasAttributes()) 3022 Attrs.push_back(AttributeSet::get(RetType->getContext(), 3023 AttributeSet::ReturnIndex, 3024 RetAttrs)); 3025 3026 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 3027 ParamTypeList.push_back(ArgList[i].Ty); 3028 if (ArgList[i].Attrs.hasAttributes(i + 1)) { 3029 AttrBuilder B(ArgList[i].Attrs, i + 1); 3030 Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B)); 3031 } 3032 } 3033 3034 if (FuncAttrs.hasAttributes()) 3035 Attrs.push_back(AttributeSet::get(RetType->getContext(), 3036 AttributeSet::FunctionIndex, 3037 FuncAttrs)); 3038 3039 AttributeSet PAL = AttributeSet::get(Context, Attrs); 3040 3041 if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy()) 3042 return Error(RetTypeLoc, "functions with 'sret' argument must return void"); 3043 3044 FunctionType *FT = 3045 FunctionType::get(RetType, ParamTypeList, isVarArg); 3046 PointerType *PFT = PointerType::getUnqual(FT); 3047 3048 Fn = 0; 3049 if (!FunctionName.empty()) { 3050 // If this was a definition of a forward reference, remove the definition 3051 // from the forward reference table and fill in the forward ref. 3052 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator FRVI = 3053 ForwardRefVals.find(FunctionName); 3054 if (FRVI != ForwardRefVals.end()) { 3055 Fn = M->getFunction(FunctionName); 3056 if (!Fn) 3057 return Error(FRVI->second.second, "invalid forward reference to " 3058 "function as global value!"); 3059 if (Fn->getType() != PFT) 3060 return Error(FRVI->second.second, "invalid forward reference to " 3061 "function '" + FunctionName + "' with wrong type!"); 3062 3063 ForwardRefVals.erase(FRVI); 3064 } else if ((Fn = M->getFunction(FunctionName))) { 3065 // Reject redefinitions. 3066 return Error(NameLoc, "invalid redefinition of function '" + 3067 FunctionName + "'"); 3068 } else if (M->getNamedValue(FunctionName)) { 3069 return Error(NameLoc, "redefinition of function '@" + FunctionName + "'"); 3070 } 3071 3072 } else { 3073 // If this is a definition of a forward referenced function, make sure the 3074 // types agree. 3075 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator I 3076 = ForwardRefValIDs.find(NumberedVals.size()); 3077 if (I != ForwardRefValIDs.end()) { 3078 Fn = cast<Function>(I->second.first); 3079 if (Fn->getType() != PFT) 3080 return Error(NameLoc, "type of definition and forward reference of '@" + 3081 Twine(NumberedVals.size()) + "' disagree"); 3082 ForwardRefValIDs.erase(I); 3083 } 3084 } 3085 3086 if (Fn == 0) 3087 Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M); 3088 else // Move the forward-reference to the correct spot in the module. 3089 M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn); 3090 3091 if (FunctionName.empty()) 3092 NumberedVals.push_back(Fn); 3093 3094 Fn->setLinkage((GlobalValue::LinkageTypes)Linkage); 3095 Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility); 3096 Fn->setCallingConv(CC); 3097 Fn->setAttributes(PAL); 3098 Fn->setUnnamedAddr(UnnamedAddr); 3099 Fn->setAlignment(Alignment); 3100 Fn->setSection(Section); 3101 if (!GC.empty()) Fn->setGC(GC.c_str()); 3102 ForwardRefAttrGroups[Fn] = FwdRefAttrGrps; 3103 3104 // Add all of the arguments we parsed to the function. 3105 Function::arg_iterator ArgIt = Fn->arg_begin(); 3106 for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) { 3107 // If the argument has a name, insert it into the argument symbol table. 3108 if (ArgList[i].Name.empty()) continue; 3109 3110 // Set the name, if it conflicted, it will be auto-renamed. 3111 ArgIt->setName(ArgList[i].Name); 3112 3113 if (ArgIt->getName() != ArgList[i].Name) 3114 return Error(ArgList[i].Loc, "redefinition of argument '%" + 3115 ArgList[i].Name + "'"); 3116 } 3117 3118 return false; 3119} 3120 3121 3122/// ParseFunctionBody 3123/// ::= '{' BasicBlock+ '}' 3124/// 3125bool LLParser::ParseFunctionBody(Function &Fn) { 3126 if (Lex.getKind() != lltok::lbrace) 3127 return TokError("expected '{' in function body"); 3128 Lex.Lex(); // eat the {. 3129 3130 int FunctionNumber = -1; 3131 if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1; 3132 3133 PerFunctionState PFS(*this, Fn, FunctionNumber); 3134 3135 // We need at least one basic block. 3136 if (Lex.getKind() == lltok::rbrace) 3137 return TokError("function body requires at least one basic block"); 3138 3139 while (Lex.getKind() != lltok::rbrace) 3140 if (ParseBasicBlock(PFS)) return true; 3141 3142 // Eat the }. 3143 Lex.Lex(); 3144 3145 // Verify function is ok. 3146 return PFS.FinishFunction(); 3147} 3148 3149/// ParseBasicBlock 3150/// ::= LabelStr? Instruction* 3151bool LLParser::ParseBasicBlock(PerFunctionState &PFS) { 3152 // If this basic block starts out with a name, remember it. 3153 std::string Name; 3154 LocTy NameLoc = Lex.getLoc(); 3155 if (Lex.getKind() == lltok::LabelStr) { 3156 Name = Lex.getStrVal(); 3157 Lex.Lex(); 3158 } 3159 3160 BasicBlock *BB = PFS.DefineBB(Name, NameLoc); 3161 if (BB == 0) return true; 3162 3163 std::string NameStr; 3164 3165 // Parse the instructions in this block until we get a terminator. 3166 Instruction *Inst; 3167 SmallVector<std::pair<unsigned, MDNode *>, 4> MetadataOnInst; 3168 do { 3169 // This instruction may have three possibilities for a name: a) none 3170 // specified, b) name specified "%foo =", c) number specified: "%4 =". 3171 LocTy NameLoc = Lex.getLoc(); 3172 int NameID = -1; 3173 NameStr = ""; 3174 3175 if (Lex.getKind() == lltok::LocalVarID) { 3176 NameID = Lex.getUIntVal(); 3177 Lex.Lex(); 3178 if (ParseToken(lltok::equal, "expected '=' after instruction id")) 3179 return true; 3180 } else if (Lex.getKind() == lltok::LocalVar) { 3181 NameStr = Lex.getStrVal(); 3182 Lex.Lex(); 3183 if (ParseToken(lltok::equal, "expected '=' after instruction name")) 3184 return true; 3185 } 3186 3187 switch (ParseInstruction(Inst, BB, PFS)) { 3188 default: llvm_unreachable("Unknown ParseInstruction result!"); 3189 case InstError: return true; 3190 case InstNormal: 3191 BB->getInstList().push_back(Inst); 3192 3193 // With a normal result, we check to see if the instruction is followed by 3194 // a comma and metadata. 3195 if (EatIfPresent(lltok::comma)) 3196 if (ParseInstructionMetadata(Inst, &PFS)) 3197 return true; 3198 break; 3199 case InstExtraComma: 3200 BB->getInstList().push_back(Inst); 3201 3202 // If the instruction parser ate an extra comma at the end of it, it 3203 // *must* be followed by metadata. 3204 if (ParseInstructionMetadata(Inst, &PFS)) 3205 return true; 3206 break; 3207 } 3208 3209 // Set the name on the instruction. 3210 if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true; 3211 } while (!isa<TerminatorInst>(Inst)); 3212 3213 return false; 3214} 3215 3216//===----------------------------------------------------------------------===// 3217// Instruction Parsing. 3218//===----------------------------------------------------------------------===// 3219 3220/// ParseInstruction - Parse one of the many different instructions. 3221/// 3222int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, 3223 PerFunctionState &PFS) { 3224 lltok::Kind Token = Lex.getKind(); 3225 if (Token == lltok::Eof) 3226 return TokError("found end of file when expecting more instructions"); 3227 LocTy Loc = Lex.getLoc(); 3228 unsigned KeywordVal = Lex.getUIntVal(); 3229 Lex.Lex(); // Eat the keyword. 3230 3231 switch (Token) { 3232 default: return Error(Loc, "expected instruction opcode"); 3233 // Terminator Instructions. 3234 case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false; 3235 case lltok::kw_ret: return ParseRet(Inst, BB, PFS); 3236 case lltok::kw_br: return ParseBr(Inst, PFS); 3237 case lltok::kw_switch: return ParseSwitch(Inst, PFS); 3238 case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS); 3239 case lltok::kw_invoke: return ParseInvoke(Inst, PFS); 3240 case lltok::kw_resume: return ParseResume(Inst, PFS); 3241 // Binary Operators. 3242 case lltok::kw_add: 3243 case lltok::kw_sub: 3244 case lltok::kw_mul: 3245 case lltok::kw_shl: { 3246 bool NUW = EatIfPresent(lltok::kw_nuw); 3247 bool NSW = EatIfPresent(lltok::kw_nsw); 3248 if (!NUW) NUW = EatIfPresent(lltok::kw_nuw); 3249 3250 if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true; 3251 3252 if (NUW) cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true); 3253 if (NSW) cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true); 3254 return false; 3255 } 3256 case lltok::kw_fadd: 3257 case lltok::kw_fsub: 3258 case lltok::kw_fmul: 3259 case lltok::kw_fdiv: 3260 case lltok::kw_frem: { 3261 FastMathFlags FMF = EatFastMathFlagsIfPresent(); 3262 int Res = ParseArithmetic(Inst, PFS, KeywordVal, 2); 3263 if (Res != 0) 3264 return Res; 3265 if (FMF.any()) 3266 Inst->setFastMathFlags(FMF); 3267 return 0; 3268 } 3269 3270 case lltok::kw_sdiv: 3271 case lltok::kw_udiv: 3272 case lltok::kw_lshr: 3273 case lltok::kw_ashr: { 3274 bool Exact = EatIfPresent(lltok::kw_exact); 3275 3276 if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true; 3277 if (Exact) cast<BinaryOperator>(Inst)->setIsExact(true); 3278 return false; 3279 } 3280 3281 case lltok::kw_urem: 3282 case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1); 3283 case lltok::kw_and: 3284 case lltok::kw_or: 3285 case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal); 3286 case lltok::kw_icmp: 3287 case lltok::kw_fcmp: return ParseCompare(Inst, PFS, KeywordVal); 3288 // Casts. 3289 case lltok::kw_trunc: 3290 case lltok::kw_zext: 3291 case lltok::kw_sext: 3292 case lltok::kw_fptrunc: 3293 case lltok::kw_fpext: 3294 case lltok::kw_bitcast: 3295 case lltok::kw_uitofp: 3296 case lltok::kw_sitofp: 3297 case lltok::kw_fptoui: 3298 case lltok::kw_fptosi: 3299 case lltok::kw_inttoptr: 3300 case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal); 3301 // Other. 3302 case lltok::kw_select: return ParseSelect(Inst, PFS); 3303 case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS); 3304 case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS); 3305 case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS); 3306 case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS); 3307 case lltok::kw_phi: return ParsePHI(Inst, PFS); 3308 case lltok::kw_landingpad: return ParseLandingPad(Inst, PFS); 3309 case lltok::kw_call: return ParseCall(Inst, PFS, false); 3310 case lltok::kw_tail: return ParseCall(Inst, PFS, true); 3311 // Memory. 3312 case lltok::kw_alloca: return ParseAlloc(Inst, PFS); 3313 case lltok::kw_load: return ParseLoad(Inst, PFS); 3314 case lltok::kw_store: return ParseStore(Inst, PFS); 3315 case lltok::kw_cmpxchg: return ParseCmpXchg(Inst, PFS); 3316 case lltok::kw_atomicrmw: return ParseAtomicRMW(Inst, PFS); 3317 case lltok::kw_fence: return ParseFence(Inst, PFS); 3318 case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS); 3319 case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS); 3320 case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS); 3321 } 3322} 3323 3324/// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind. 3325bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) { 3326 if (Opc == Instruction::FCmp) { 3327 switch (Lex.getKind()) { 3328 default: return TokError("expected fcmp predicate (e.g. 'oeq')"); 3329 case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break; 3330 case lltok::kw_one: P = CmpInst::FCMP_ONE; break; 3331 case lltok::kw_olt: P = CmpInst::FCMP_OLT; break; 3332 case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break; 3333 case lltok::kw_ole: P = CmpInst::FCMP_OLE; break; 3334 case lltok::kw_oge: P = CmpInst::FCMP_OGE; break; 3335 case lltok::kw_ord: P = CmpInst::FCMP_ORD; break; 3336 case lltok::kw_uno: P = CmpInst::FCMP_UNO; break; 3337 case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break; 3338 case lltok::kw_une: P = CmpInst::FCMP_UNE; break; 3339 case lltok::kw_ult: P = CmpInst::FCMP_ULT; break; 3340 case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break; 3341 case lltok::kw_ule: P = CmpInst::FCMP_ULE; break; 3342 case lltok::kw_uge: P = CmpInst::FCMP_UGE; break; 3343 case lltok::kw_true: P = CmpInst::FCMP_TRUE; break; 3344 case lltok::kw_false: P = CmpInst::FCMP_FALSE; break; 3345 } 3346 } else { 3347 switch (Lex.getKind()) { 3348 default: return TokError("expected icmp predicate (e.g. 'eq')"); 3349 case lltok::kw_eq: P = CmpInst::ICMP_EQ; break; 3350 case lltok::kw_ne: P = CmpInst::ICMP_NE; break; 3351 case lltok::kw_slt: P = CmpInst::ICMP_SLT; break; 3352 case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break; 3353 case lltok::kw_sle: P = CmpInst::ICMP_SLE; break; 3354 case lltok::kw_sge: P = CmpInst::ICMP_SGE; break; 3355 case lltok::kw_ult: P = CmpInst::ICMP_ULT; break; 3356 case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break; 3357 case lltok::kw_ule: P = CmpInst::ICMP_ULE; break; 3358 case lltok::kw_uge: P = CmpInst::ICMP_UGE; break; 3359 } 3360 } 3361 Lex.Lex(); 3362 return false; 3363} 3364 3365//===----------------------------------------------------------------------===// 3366// Terminator Instructions. 3367//===----------------------------------------------------------------------===// 3368 3369/// ParseRet - Parse a return instruction. 3370/// ::= 'ret' void (',' !dbg, !1)* 3371/// ::= 'ret' TypeAndValue (',' !dbg, !1)* 3372bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB, 3373 PerFunctionState &PFS) { 3374 SMLoc TypeLoc = Lex.getLoc(); 3375 Type *Ty = 0; 3376 if (ParseType(Ty, true /*void allowed*/)) return true; 3377 3378 Type *ResType = PFS.getFunction().getReturnType(); 3379 3380 if (Ty->isVoidTy()) { 3381 if (!ResType->isVoidTy()) 3382 return Error(TypeLoc, "value doesn't match function result type '" + 3383 getTypeString(ResType) + "'"); 3384 3385 Inst = ReturnInst::Create(Context); 3386 return false; 3387 } 3388 3389 Value *RV; 3390 if (ParseValue(Ty, RV, PFS)) return true; 3391 3392 if (ResType != RV->getType()) 3393 return Error(TypeLoc, "value doesn't match function result type '" + 3394 getTypeString(ResType) + "'"); 3395 3396 Inst = ReturnInst::Create(Context, RV); 3397 return false; 3398} 3399 3400 3401/// ParseBr 3402/// ::= 'br' TypeAndValue 3403/// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3404bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) { 3405 LocTy Loc, Loc2; 3406 Value *Op0; 3407 BasicBlock *Op1, *Op2; 3408 if (ParseTypeAndValue(Op0, Loc, PFS)) return true; 3409 3410 if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) { 3411 Inst = BranchInst::Create(BB); 3412 return false; 3413 } 3414 3415 if (Op0->getType() != Type::getInt1Ty(Context)) 3416 return Error(Loc, "branch condition must have 'i1' type"); 3417 3418 if (ParseToken(lltok::comma, "expected ',' after branch condition") || 3419 ParseTypeAndBasicBlock(Op1, Loc, PFS) || 3420 ParseToken(lltok::comma, "expected ',' after true destination") || 3421 ParseTypeAndBasicBlock(Op2, Loc2, PFS)) 3422 return true; 3423 3424 Inst = BranchInst::Create(Op1, Op2, Op0); 3425 return false; 3426} 3427 3428/// ParseSwitch 3429/// Instruction 3430/// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']' 3431/// JumpTable 3432/// ::= (TypeAndValue ',' TypeAndValue)* 3433bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) { 3434 LocTy CondLoc, BBLoc; 3435 Value *Cond; 3436 BasicBlock *DefaultBB; 3437 if (ParseTypeAndValue(Cond, CondLoc, PFS) || 3438 ParseToken(lltok::comma, "expected ',' after switch condition") || 3439 ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) || 3440 ParseToken(lltok::lsquare, "expected '[' with switch table")) 3441 return true; 3442 3443 if (!Cond->getType()->isIntegerTy()) 3444 return Error(CondLoc, "switch condition must have integer type"); 3445 3446 // Parse the jump table pairs. 3447 SmallPtrSet<Value*, 32> SeenCases; 3448 SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table; 3449 while (Lex.getKind() != lltok::rsquare) { 3450 Value *Constant; 3451 BasicBlock *DestBB; 3452 3453 if (ParseTypeAndValue(Constant, CondLoc, PFS) || 3454 ParseToken(lltok::comma, "expected ',' after case value") || 3455 ParseTypeAndBasicBlock(DestBB, PFS)) 3456 return true; 3457 3458 if (!SeenCases.insert(Constant)) 3459 return Error(CondLoc, "duplicate case value in switch"); 3460 if (!isa<ConstantInt>(Constant)) 3461 return Error(CondLoc, "case value is not a constant integer"); 3462 3463 Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB)); 3464 } 3465 3466 Lex.Lex(); // Eat the ']'. 3467 3468 SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size()); 3469 for (unsigned i = 0, e = Table.size(); i != e; ++i) 3470 SI->addCase(Table[i].first, Table[i].second); 3471 Inst = SI; 3472 return false; 3473} 3474 3475/// ParseIndirectBr 3476/// Instruction 3477/// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']' 3478bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) { 3479 LocTy AddrLoc; 3480 Value *Address; 3481 if (ParseTypeAndValue(Address, AddrLoc, PFS) || 3482 ParseToken(lltok::comma, "expected ',' after indirectbr address") || 3483 ParseToken(lltok::lsquare, "expected '[' with indirectbr")) 3484 return true; 3485 3486 if (!Address->getType()->isPointerTy()) 3487 return Error(AddrLoc, "indirectbr address must have pointer type"); 3488 3489 // Parse the destination list. 3490 SmallVector<BasicBlock*, 16> DestList; 3491 3492 if (Lex.getKind() != lltok::rsquare) { 3493 BasicBlock *DestBB; 3494 if (ParseTypeAndBasicBlock(DestBB, PFS)) 3495 return true; 3496 DestList.push_back(DestBB); 3497 3498 while (EatIfPresent(lltok::comma)) { 3499 if (ParseTypeAndBasicBlock(DestBB, PFS)) 3500 return true; 3501 DestList.push_back(DestBB); 3502 } 3503 } 3504 3505 if (ParseToken(lltok::rsquare, "expected ']' at end of block list")) 3506 return true; 3507 3508 IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size()); 3509 for (unsigned i = 0, e = DestList.size(); i != e; ++i) 3510 IBI->addDestination(DestList[i]); 3511 Inst = IBI; 3512 return false; 3513} 3514 3515 3516/// ParseInvoke 3517/// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList 3518/// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue 3519bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { 3520 LocTy CallLoc = Lex.getLoc(); 3521 AttrBuilder RetAttrs, FnAttrs; 3522 std::vector<unsigned> FwdRefAttrGrps; 3523 LocTy NoBuiltinLoc; 3524 CallingConv::ID CC; 3525 Type *RetType = 0; 3526 LocTy RetTypeLoc; 3527 ValID CalleeID; 3528 SmallVector<ParamInfo, 16> ArgList; 3529 3530 BasicBlock *NormalBB, *UnwindBB; 3531 if (ParseOptionalCallingConv(CC) || 3532 ParseOptionalReturnAttrs(RetAttrs) || 3533 ParseType(RetType, RetTypeLoc, true /*void allowed*/) || 3534 ParseValID(CalleeID) || 3535 ParseParameterList(ArgList, PFS) || 3536 ParseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false, 3537 NoBuiltinLoc) || 3538 ParseToken(lltok::kw_to, "expected 'to' in invoke") || 3539 ParseTypeAndBasicBlock(NormalBB, PFS) || 3540 ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") || 3541 ParseTypeAndBasicBlock(UnwindBB, PFS)) 3542 return true; 3543 3544 // If RetType is a non-function pointer type, then this is the short syntax 3545 // for the call, which means that RetType is just the return type. Infer the 3546 // rest of the function argument types from the arguments that are present. 3547 PointerType *PFTy = 0; 3548 FunctionType *Ty = 0; 3549 if (!(PFTy = dyn_cast<PointerType>(RetType)) || 3550 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { 3551 // Pull out the types of all of the arguments... 3552 std::vector<Type*> ParamTypes; 3553 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) 3554 ParamTypes.push_back(ArgList[i].V->getType()); 3555 3556 if (!FunctionType::isValidReturnType(RetType)) 3557 return Error(RetTypeLoc, "Invalid result type for LLVM function"); 3558 3559 Ty = FunctionType::get(RetType, ParamTypes, false); 3560 PFTy = PointerType::getUnqual(Ty); 3561 } 3562 3563 // Look up the callee. 3564 Value *Callee; 3565 if (ConvertValIDToValue(PFTy, CalleeID, Callee, &PFS)) return true; 3566 3567 // Set up the Attribute for the function. 3568 SmallVector<AttributeSet, 8> Attrs; 3569 if (RetAttrs.hasAttributes()) 3570 Attrs.push_back(AttributeSet::get(RetType->getContext(), 3571 AttributeSet::ReturnIndex, 3572 RetAttrs)); 3573 3574 SmallVector<Value*, 8> Args; 3575 3576 // Loop through FunctionType's arguments and ensure they are specified 3577 // correctly. Also, gather any parameter attributes. 3578 FunctionType::param_iterator I = Ty->param_begin(); 3579 FunctionType::param_iterator E = Ty->param_end(); 3580 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 3581 Type *ExpectedTy = 0; 3582 if (I != E) { 3583 ExpectedTy = *I++; 3584 } else if (!Ty->isVarArg()) { 3585 return Error(ArgList[i].Loc, "too many arguments specified"); 3586 } 3587 3588 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) 3589 return Error(ArgList[i].Loc, "argument is not of expected type '" + 3590 getTypeString(ExpectedTy) + "'"); 3591 Args.push_back(ArgList[i].V); 3592 if (ArgList[i].Attrs.hasAttributes(i + 1)) { 3593 AttrBuilder B(ArgList[i].Attrs, i + 1); 3594 Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B)); 3595 } 3596 } 3597 3598 if (I != E) 3599 return Error(CallLoc, "not enough parameters specified for call"); 3600 3601 if (FnAttrs.hasAttributes()) 3602 Attrs.push_back(AttributeSet::get(RetType->getContext(), 3603 AttributeSet::FunctionIndex, 3604 FnAttrs)); 3605 3606 // Finish off the Attribute and check them 3607 AttributeSet PAL = AttributeSet::get(Context, Attrs); 3608 3609 InvokeInst *II = InvokeInst::Create(Callee, NormalBB, UnwindBB, Args); 3610 II->setCallingConv(CC); 3611 II->setAttributes(PAL); 3612 ForwardRefAttrGroups[II] = FwdRefAttrGrps; 3613 Inst = II; 3614 return false; 3615} 3616 3617/// ParseResume 3618/// ::= 'resume' TypeAndValue 3619bool LLParser::ParseResume(Instruction *&Inst, PerFunctionState &PFS) { 3620 Value *Exn; LocTy ExnLoc; 3621 if (ParseTypeAndValue(Exn, ExnLoc, PFS)) 3622 return true; 3623 3624 ResumeInst *RI = ResumeInst::Create(Exn); 3625 Inst = RI; 3626 return false; 3627} 3628 3629//===----------------------------------------------------------------------===// 3630// Binary Operators. 3631//===----------------------------------------------------------------------===// 3632 3633/// ParseArithmetic 3634/// ::= ArithmeticOps TypeAndValue ',' Value 3635/// 3636/// If OperandType is 0, then any FP or integer operand is allowed. If it is 1, 3637/// then any integer operand is allowed, if it is 2, any fp operand is allowed. 3638bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, 3639 unsigned Opc, unsigned OperandType) { 3640 LocTy Loc; Value *LHS, *RHS; 3641 if (ParseTypeAndValue(LHS, Loc, PFS) || 3642 ParseToken(lltok::comma, "expected ',' in arithmetic operation") || 3643 ParseValue(LHS->getType(), RHS, PFS)) 3644 return true; 3645 3646 bool Valid; 3647 switch (OperandType) { 3648 default: llvm_unreachable("Unknown operand type!"); 3649 case 0: // int or FP. 3650 Valid = LHS->getType()->isIntOrIntVectorTy() || 3651 LHS->getType()->isFPOrFPVectorTy(); 3652 break; 3653 case 1: Valid = LHS->getType()->isIntOrIntVectorTy(); break; 3654 case 2: Valid = LHS->getType()->isFPOrFPVectorTy(); break; 3655 } 3656 3657 if (!Valid) 3658 return Error(Loc, "invalid operand type for instruction"); 3659 3660 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 3661 return false; 3662} 3663 3664/// ParseLogical 3665/// ::= ArithmeticOps TypeAndValue ',' Value { 3666bool LLParser::ParseLogical(Instruction *&Inst, PerFunctionState &PFS, 3667 unsigned Opc) { 3668 LocTy Loc; Value *LHS, *RHS; 3669 if (ParseTypeAndValue(LHS, Loc, PFS) || 3670 ParseToken(lltok::comma, "expected ',' in logical operation") || 3671 ParseValue(LHS->getType(), RHS, PFS)) 3672 return true; 3673 3674 if (!LHS->getType()->isIntOrIntVectorTy()) 3675 return Error(Loc,"instruction requires integer or integer vector operands"); 3676 3677 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 3678 return false; 3679} 3680 3681 3682/// ParseCompare 3683/// ::= 'icmp' IPredicates TypeAndValue ',' Value 3684/// ::= 'fcmp' FPredicates TypeAndValue ',' Value 3685bool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS, 3686 unsigned Opc) { 3687 // Parse the integer/fp comparison predicate. 3688 LocTy Loc; 3689 unsigned Pred; 3690 Value *LHS, *RHS; 3691 if (ParseCmpPredicate(Pred, Opc) || 3692 ParseTypeAndValue(LHS, Loc, PFS) || 3693 ParseToken(lltok::comma, "expected ',' after compare value") || 3694 ParseValue(LHS->getType(), RHS, PFS)) 3695 return true; 3696 3697 if (Opc == Instruction::FCmp) { 3698 if (!LHS->getType()->isFPOrFPVectorTy()) 3699 return Error(Loc, "fcmp requires floating point operands"); 3700 Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS); 3701 } else { 3702 assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!"); 3703 if (!LHS->getType()->isIntOrIntVectorTy() && 3704 !LHS->getType()->getScalarType()->isPointerTy()) 3705 return Error(Loc, "icmp requires integer operands"); 3706 Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS); 3707 } 3708 return false; 3709} 3710 3711//===----------------------------------------------------------------------===// 3712// Other Instructions. 3713//===----------------------------------------------------------------------===// 3714 3715 3716/// ParseCast 3717/// ::= CastOpc TypeAndValue 'to' Type 3718bool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS, 3719 unsigned Opc) { 3720 LocTy Loc; 3721 Value *Op; 3722 Type *DestTy = 0; 3723 if (ParseTypeAndValue(Op, Loc, PFS) || 3724 ParseToken(lltok::kw_to, "expected 'to' after cast value") || 3725 ParseType(DestTy)) 3726 return true; 3727 3728 if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) { 3729 CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy); 3730 return Error(Loc, "invalid cast opcode for cast from '" + 3731 getTypeString(Op->getType()) + "' to '" + 3732 getTypeString(DestTy) + "'"); 3733 } 3734 Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy); 3735 return false; 3736} 3737 3738/// ParseSelect 3739/// ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3740bool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) { 3741 LocTy Loc; 3742 Value *Op0, *Op1, *Op2; 3743 if (ParseTypeAndValue(Op0, Loc, PFS) || 3744 ParseToken(lltok::comma, "expected ',' after select condition") || 3745 ParseTypeAndValue(Op1, PFS) || 3746 ParseToken(lltok::comma, "expected ',' after select value") || 3747 ParseTypeAndValue(Op2, PFS)) 3748 return true; 3749 3750 if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2)) 3751 return Error(Loc, Reason); 3752 3753 Inst = SelectInst::Create(Op0, Op1, Op2); 3754 return false; 3755} 3756 3757/// ParseVA_Arg 3758/// ::= 'va_arg' TypeAndValue ',' Type 3759bool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) { 3760 Value *Op; 3761 Type *EltTy = 0; 3762 LocTy TypeLoc; 3763 if (ParseTypeAndValue(Op, PFS) || 3764 ParseToken(lltok::comma, "expected ',' after vaarg operand") || 3765 ParseType(EltTy, TypeLoc)) 3766 return true; 3767 3768 if (!EltTy->isFirstClassType()) 3769 return Error(TypeLoc, "va_arg requires operand with first class type"); 3770 3771 Inst = new VAArgInst(Op, EltTy); 3772 return false; 3773} 3774 3775/// ParseExtractElement 3776/// ::= 'extractelement' TypeAndValue ',' TypeAndValue 3777bool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) { 3778 LocTy Loc; 3779 Value *Op0, *Op1; 3780 if (ParseTypeAndValue(Op0, Loc, PFS) || 3781 ParseToken(lltok::comma, "expected ',' after extract value") || 3782 ParseTypeAndValue(Op1, PFS)) 3783 return true; 3784 3785 if (!ExtractElementInst::isValidOperands(Op0, Op1)) 3786 return Error(Loc, "invalid extractelement operands"); 3787 3788 Inst = ExtractElementInst::Create(Op0, Op1); 3789 return false; 3790} 3791 3792/// ParseInsertElement 3793/// ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3794bool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) { 3795 LocTy Loc; 3796 Value *Op0, *Op1, *Op2; 3797 if (ParseTypeAndValue(Op0, Loc, PFS) || 3798 ParseToken(lltok::comma, "expected ',' after insertelement value") || 3799 ParseTypeAndValue(Op1, PFS) || 3800 ParseToken(lltok::comma, "expected ',' after insertelement value") || 3801 ParseTypeAndValue(Op2, PFS)) 3802 return true; 3803 3804 if (!InsertElementInst::isValidOperands(Op0, Op1, Op2)) 3805 return Error(Loc, "invalid insertelement operands"); 3806 3807 Inst = InsertElementInst::Create(Op0, Op1, Op2); 3808 return false; 3809} 3810 3811/// ParseShuffleVector 3812/// ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3813bool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) { 3814 LocTy Loc; 3815 Value *Op0, *Op1, *Op2; 3816 if (ParseTypeAndValue(Op0, Loc, PFS) || 3817 ParseToken(lltok::comma, "expected ',' after shuffle mask") || 3818 ParseTypeAndValue(Op1, PFS) || 3819 ParseToken(lltok::comma, "expected ',' after shuffle value") || 3820 ParseTypeAndValue(Op2, PFS)) 3821 return true; 3822 3823 if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2)) 3824 return Error(Loc, "invalid shufflevector operands"); 3825 3826 Inst = new ShuffleVectorInst(Op0, Op1, Op2); 3827 return false; 3828} 3829 3830/// ParsePHI 3831/// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')* 3832int LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) { 3833 Type *Ty = 0; LocTy TypeLoc; 3834 Value *Op0, *Op1; 3835 3836 if (ParseType(Ty, TypeLoc) || 3837 ParseToken(lltok::lsquare, "expected '[' in phi value list") || 3838 ParseValue(Ty, Op0, PFS) || 3839 ParseToken(lltok::comma, "expected ',' after insertelement value") || 3840 ParseValue(Type::getLabelTy(Context), Op1, PFS) || 3841 ParseToken(lltok::rsquare, "expected ']' in phi value list")) 3842 return true; 3843 3844 bool AteExtraComma = false; 3845 SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals; 3846 while (1) { 3847 PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1))); 3848 3849 if (!EatIfPresent(lltok::comma)) 3850 break; 3851 3852 if (Lex.getKind() == lltok::MetadataVar) { 3853 AteExtraComma = true; 3854 break; 3855 } 3856 3857 if (ParseToken(lltok::lsquare, "expected '[' in phi value list") || 3858 ParseValue(Ty, Op0, PFS) || 3859 ParseToken(lltok::comma, "expected ',' after insertelement value") || 3860 ParseValue(Type::getLabelTy(Context), Op1, PFS) || 3861 ParseToken(lltok::rsquare, "expected ']' in phi value list")) 3862 return true; 3863 } 3864 3865 if (!Ty->isFirstClassType()) 3866 return Error(TypeLoc, "phi node must have first class type"); 3867 3868 PHINode *PN = PHINode::Create(Ty, PHIVals.size()); 3869 for (unsigned i = 0, e = PHIVals.size(); i != e; ++i) 3870 PN->addIncoming(PHIVals[i].first, PHIVals[i].second); 3871 Inst = PN; 3872 return AteExtraComma ? InstExtraComma : InstNormal; 3873} 3874 3875/// ParseLandingPad 3876/// ::= 'landingpad' Type 'personality' TypeAndValue 'cleanup'? Clause+ 3877/// Clause 3878/// ::= 'catch' TypeAndValue 3879/// ::= 'filter' 3880/// ::= 'filter' TypeAndValue ( ',' TypeAndValue )* 3881bool LLParser::ParseLandingPad(Instruction *&Inst, PerFunctionState &PFS) { 3882 Type *Ty = 0; LocTy TyLoc; 3883 Value *PersFn; LocTy PersFnLoc; 3884 3885 if (ParseType(Ty, TyLoc) || 3886 ParseToken(lltok::kw_personality, "expected 'personality'") || 3887 ParseTypeAndValue(PersFn, PersFnLoc, PFS)) 3888 return true; 3889 3890 LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, 0); 3891 LP->setCleanup(EatIfPresent(lltok::kw_cleanup)); 3892 3893 while (Lex.getKind() == lltok::kw_catch || Lex.getKind() == lltok::kw_filter){ 3894 LandingPadInst::ClauseType CT; 3895 if (EatIfPresent(lltok::kw_catch)) 3896 CT = LandingPadInst::Catch; 3897 else if (EatIfPresent(lltok::kw_filter)) 3898 CT = LandingPadInst::Filter; 3899 else 3900 return TokError("expected 'catch' or 'filter' clause type"); 3901 3902 Value *V; LocTy VLoc; 3903 if (ParseTypeAndValue(V, VLoc, PFS)) { 3904 delete LP; 3905 return true; 3906 } 3907 3908 // A 'catch' type expects a non-array constant. A filter clause expects an 3909 // array constant. 3910 if (CT == LandingPadInst::Catch) { 3911 if (isa<ArrayType>(V->getType())) 3912 Error(VLoc, "'catch' clause has an invalid type"); 3913 } else { 3914 if (!isa<ArrayType>(V->getType())) 3915 Error(VLoc, "'filter' clause has an invalid type"); 3916 } 3917 3918 LP->addClause(V); 3919 } 3920 3921 Inst = LP; 3922 return false; 3923} 3924 3925/// ParseCall 3926/// ::= 'tail'? 'call' OptionalCallingConv OptionalAttrs Type Value 3927/// ParameterList OptionalAttrs 3928bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, 3929 bool isTail) { 3930 AttrBuilder RetAttrs, FnAttrs; 3931 std::vector<unsigned> FwdRefAttrGrps; 3932 LocTy NoBuiltinLoc; 3933 CallingConv::ID CC; 3934 Type *RetType = 0; 3935 LocTy RetTypeLoc; 3936 ValID CalleeID; 3937 SmallVector<ParamInfo, 16> ArgList; 3938 LocTy CallLoc = Lex.getLoc(); 3939 3940 if ((isTail && ParseToken(lltok::kw_call, "expected 'tail call'")) || 3941 ParseOptionalCallingConv(CC) || 3942 ParseOptionalReturnAttrs(RetAttrs) || 3943 ParseType(RetType, RetTypeLoc, true /*void allowed*/) || 3944 ParseValID(CalleeID) || 3945 ParseParameterList(ArgList, PFS) || 3946 ParseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false, 3947 NoBuiltinLoc)) 3948 return true; 3949 3950 // If RetType is a non-function pointer type, then this is the short syntax 3951 // for the call, which means that RetType is just the return type. Infer the 3952 // rest of the function argument types from the arguments that are present. 3953 PointerType *PFTy = 0; 3954 FunctionType *Ty = 0; 3955 if (!(PFTy = dyn_cast<PointerType>(RetType)) || 3956 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { 3957 // Pull out the types of all of the arguments... 3958 std::vector<Type*> ParamTypes; 3959 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) 3960 ParamTypes.push_back(ArgList[i].V->getType()); 3961 3962 if (!FunctionType::isValidReturnType(RetType)) 3963 return Error(RetTypeLoc, "Invalid result type for LLVM function"); 3964 3965 Ty = FunctionType::get(RetType, ParamTypes, false); 3966 PFTy = PointerType::getUnqual(Ty); 3967 } 3968 3969 // Look up the callee. 3970 Value *Callee; 3971 if (ConvertValIDToValue(PFTy, CalleeID, Callee, &PFS)) return true; 3972 3973 // Set up the Attribute for the function. 3974 SmallVector<AttributeSet, 8> Attrs; 3975 if (RetAttrs.hasAttributes()) 3976 Attrs.push_back(AttributeSet::get(RetType->getContext(), 3977 AttributeSet::ReturnIndex, 3978 RetAttrs)); 3979 3980 SmallVector<Value*, 8> Args; 3981 3982 // Loop through FunctionType's arguments and ensure they are specified 3983 // correctly. Also, gather any parameter attributes. 3984 FunctionType::param_iterator I = Ty->param_begin(); 3985 FunctionType::param_iterator E = Ty->param_end(); 3986 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 3987 Type *ExpectedTy = 0; 3988 if (I != E) { 3989 ExpectedTy = *I++; 3990 } else if (!Ty->isVarArg()) { 3991 return Error(ArgList[i].Loc, "too many arguments specified"); 3992 } 3993 3994 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) 3995 return Error(ArgList[i].Loc, "argument is not of expected type '" + 3996 getTypeString(ExpectedTy) + "'"); 3997 Args.push_back(ArgList[i].V); 3998 if (ArgList[i].Attrs.hasAttributes(i + 1)) { 3999 AttrBuilder B(ArgList[i].Attrs, i + 1); 4000 Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B)); 4001 } 4002 } 4003 4004 if (I != E) 4005 return Error(CallLoc, "not enough parameters specified for call"); 4006 4007 if (FnAttrs.hasAttributes()) 4008 Attrs.push_back(AttributeSet::get(RetType->getContext(), 4009 AttributeSet::FunctionIndex, 4010 FnAttrs)); 4011 4012 // Finish off the Attribute and check them 4013 AttributeSet PAL = AttributeSet::get(Context, Attrs); 4014 4015 CallInst *CI = CallInst::Create(Callee, Args); 4016 CI->setTailCall(isTail); 4017 CI->setCallingConv(CC); 4018 CI->setAttributes(PAL); 4019 ForwardRefAttrGroups[CI] = FwdRefAttrGrps; 4020 Inst = CI; 4021 return false; 4022} 4023 4024//===----------------------------------------------------------------------===// 4025// Memory Instructions. 4026//===----------------------------------------------------------------------===// 4027 4028/// ParseAlloc 4029/// ::= 'alloca' Type (',' TypeAndValue)? (',' OptionalInfo)? 4030int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS) { 4031 Value *Size = 0; 4032 LocTy SizeLoc; 4033 unsigned Alignment = 0; 4034 Type *Ty = 0; 4035 if (ParseType(Ty)) return true; 4036 4037 bool AteExtraComma = false; 4038 if (EatIfPresent(lltok::comma)) { 4039 if (Lex.getKind() == lltok::kw_align) { 4040 if (ParseOptionalAlignment(Alignment)) return true; 4041 } else if (Lex.getKind() == lltok::MetadataVar) { 4042 AteExtraComma = true; 4043 } else { 4044 if (ParseTypeAndValue(Size, SizeLoc, PFS) || 4045 ParseOptionalCommaAlign(Alignment, AteExtraComma)) 4046 return true; 4047 } 4048 } 4049 4050 if (Size && !Size->getType()->isIntegerTy()) 4051 return Error(SizeLoc, "element count must have integer type"); 4052 4053 Inst = new AllocaInst(Ty, Size, Alignment); 4054 return AteExtraComma ? InstExtraComma : InstNormal; 4055} 4056 4057/// ParseLoad 4058/// ::= 'load' 'volatile'? TypeAndValue (',' 'align' i32)? 4059/// ::= 'load' 'atomic' 'volatile'? TypeAndValue 4060/// 'singlethread'? AtomicOrdering (',' 'align' i32)? 4061int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS) { 4062 Value *Val; LocTy Loc; 4063 unsigned Alignment = 0; 4064 bool AteExtraComma = false; 4065 bool isAtomic = false; 4066 AtomicOrdering Ordering = NotAtomic; 4067 SynchronizationScope Scope = CrossThread; 4068 4069 if (Lex.getKind() == lltok::kw_atomic) { 4070 isAtomic = true; 4071 Lex.Lex(); 4072 } 4073 4074 bool isVolatile = false; 4075 if (Lex.getKind() == lltok::kw_volatile) { 4076 isVolatile = true; 4077 Lex.Lex(); 4078 } 4079 4080 if (ParseTypeAndValue(Val, Loc, PFS) || 4081 ParseScopeAndOrdering(isAtomic, Scope, Ordering) || 4082 ParseOptionalCommaAlign(Alignment, AteExtraComma)) 4083 return true; 4084 4085 if (!Val->getType()->isPointerTy() || 4086 !cast<PointerType>(Val->getType())->getElementType()->isFirstClassType()) 4087 return Error(Loc, "load operand must be a pointer to a first class type"); 4088 if (isAtomic && !Alignment) 4089 return Error(Loc, "atomic load must have explicit non-zero alignment"); 4090 if (Ordering == Release || Ordering == AcquireRelease) 4091 return Error(Loc, "atomic load cannot use Release ordering"); 4092 4093 Inst = new LoadInst(Val, "", isVolatile, Alignment, Ordering, Scope); 4094 return AteExtraComma ? InstExtraComma : InstNormal; 4095} 4096 4097/// ParseStore 4098 4099/// ::= 'store' 'volatile'? TypeAndValue ',' TypeAndValue (',' 'align' i32)? 4100/// ::= 'store' 'atomic' 'volatile'? TypeAndValue ',' TypeAndValue 4101/// 'singlethread'? AtomicOrdering (',' 'align' i32)? 4102int LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS) { 4103 Value *Val, *Ptr; LocTy Loc, PtrLoc; 4104 unsigned Alignment = 0; 4105 bool AteExtraComma = false; 4106 bool isAtomic = false; 4107 AtomicOrdering Ordering = NotAtomic; 4108 SynchronizationScope Scope = CrossThread; 4109 4110 if (Lex.getKind() == lltok::kw_atomic) { 4111 isAtomic = true; 4112 Lex.Lex(); 4113 } 4114 4115 bool isVolatile = false; 4116 if (Lex.getKind() == lltok::kw_volatile) { 4117 isVolatile = true; 4118 Lex.Lex(); 4119 } 4120 4121 if (ParseTypeAndValue(Val, Loc, PFS) || 4122 ParseToken(lltok::comma, "expected ',' after store operand") || 4123 ParseTypeAndValue(Ptr, PtrLoc, PFS) || 4124 ParseScopeAndOrdering(isAtomic, Scope, Ordering) || 4125 ParseOptionalCommaAlign(Alignment, AteExtraComma)) 4126 return true; 4127 4128 if (!Ptr->getType()->isPointerTy()) 4129 return Error(PtrLoc, "store operand must be a pointer"); 4130 if (!Val->getType()->isFirstClassType()) 4131 return Error(Loc, "store operand must be a first class value"); 4132 if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType()) 4133 return Error(Loc, "stored value and pointer type do not match"); 4134 if (isAtomic && !Alignment) 4135 return Error(Loc, "atomic store must have explicit non-zero alignment"); 4136 if (Ordering == Acquire || Ordering == AcquireRelease) 4137 return Error(Loc, "atomic store cannot use Acquire ordering"); 4138 4139 Inst = new StoreInst(Val, Ptr, isVolatile, Alignment, Ordering, Scope); 4140 return AteExtraComma ? InstExtraComma : InstNormal; 4141} 4142 4143/// ParseCmpXchg 4144/// ::= 'cmpxchg' 'volatile'? TypeAndValue ',' TypeAndValue ',' TypeAndValue 4145/// 'singlethread'? AtomicOrdering 4146int LLParser::ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) { 4147 Value *Ptr, *Cmp, *New; LocTy PtrLoc, CmpLoc, NewLoc; 4148 bool AteExtraComma = false; 4149 AtomicOrdering Ordering = NotAtomic; 4150 SynchronizationScope Scope = CrossThread; 4151 bool isVolatile = false; 4152 4153 if (EatIfPresent(lltok::kw_volatile)) 4154 isVolatile = true; 4155 4156 if (ParseTypeAndValue(Ptr, PtrLoc, PFS) || 4157 ParseToken(lltok::comma, "expected ',' after cmpxchg address") || 4158 ParseTypeAndValue(Cmp, CmpLoc, PFS) || 4159 ParseToken(lltok::comma, "expected ',' after cmpxchg cmp operand") || 4160 ParseTypeAndValue(New, NewLoc, PFS) || 4161 ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering)) 4162 return true; 4163 4164 if (Ordering == Unordered) 4165 return TokError("cmpxchg cannot be unordered"); 4166 if (!Ptr->getType()->isPointerTy()) 4167 return Error(PtrLoc, "cmpxchg operand must be a pointer"); 4168 if (cast<PointerType>(Ptr->getType())->getElementType() != Cmp->getType()) 4169 return Error(CmpLoc, "compare value and pointer type do not match"); 4170 if (cast<PointerType>(Ptr->getType())->getElementType() != New->getType()) 4171 return Error(NewLoc, "new value and pointer type do not match"); 4172 if (!New->getType()->isIntegerTy()) 4173 return Error(NewLoc, "cmpxchg operand must be an integer"); 4174 unsigned Size = New->getType()->getPrimitiveSizeInBits(); 4175 if (Size < 8 || (Size & (Size - 1))) 4176 return Error(NewLoc, "cmpxchg operand must be power-of-two byte-sized" 4177 " integer"); 4178 4179 AtomicCmpXchgInst *CXI = 4180 new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, Scope); 4181 CXI->setVolatile(isVolatile); 4182 Inst = CXI; 4183 return AteExtraComma ? InstExtraComma : InstNormal; 4184} 4185 4186/// ParseAtomicRMW 4187/// ::= 'atomicrmw' 'volatile'? BinOp TypeAndValue ',' TypeAndValue 4188/// 'singlethread'? AtomicOrdering 4189int LLParser::ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) { 4190 Value *Ptr, *Val; LocTy PtrLoc, ValLoc; 4191 bool AteExtraComma = false; 4192 AtomicOrdering Ordering = NotAtomic; 4193 SynchronizationScope Scope = CrossThread; 4194 bool isVolatile = false; 4195 AtomicRMWInst::BinOp Operation; 4196 4197 if (EatIfPresent(lltok::kw_volatile)) 4198 isVolatile = true; 4199 4200 switch (Lex.getKind()) { 4201 default: return TokError("expected binary operation in atomicrmw"); 4202 case lltok::kw_xchg: Operation = AtomicRMWInst::Xchg; break; 4203 case lltok::kw_add: Operation = AtomicRMWInst::Add; break; 4204 case lltok::kw_sub: Operation = AtomicRMWInst::Sub; break; 4205 case lltok::kw_and: Operation = AtomicRMWInst::And; break; 4206 case lltok::kw_nand: Operation = AtomicRMWInst::Nand; break; 4207 case lltok::kw_or: Operation = AtomicRMWInst::Or; break; 4208 case lltok::kw_xor: Operation = AtomicRMWInst::Xor; break; 4209 case lltok::kw_max: Operation = AtomicRMWInst::Max; break; 4210 case lltok::kw_min: Operation = AtomicRMWInst::Min; break; 4211 case lltok::kw_umax: Operation = AtomicRMWInst::UMax; break; 4212 case lltok::kw_umin: Operation = AtomicRMWInst::UMin; break; 4213 } 4214 Lex.Lex(); // Eat the operation. 4215 4216 if (ParseTypeAndValue(Ptr, PtrLoc, PFS) || 4217 ParseToken(lltok::comma, "expected ',' after atomicrmw address") || 4218 ParseTypeAndValue(Val, ValLoc, PFS) || 4219 ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering)) 4220 return true; 4221 4222 if (Ordering == Unordered) 4223 return TokError("atomicrmw cannot be unordered"); 4224 if (!Ptr->getType()->isPointerTy()) 4225 return Error(PtrLoc, "atomicrmw operand must be a pointer"); 4226 if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType()) 4227 return Error(ValLoc, "atomicrmw value and pointer type do not match"); 4228 if (!Val->getType()->isIntegerTy()) 4229 return Error(ValLoc, "atomicrmw operand must be an integer"); 4230 unsigned Size = Val->getType()->getPrimitiveSizeInBits(); 4231 if (Size < 8 || (Size & (Size - 1))) 4232 return Error(ValLoc, "atomicrmw operand must be power-of-two byte-sized" 4233 " integer"); 4234 4235 AtomicRMWInst *RMWI = 4236 new AtomicRMWInst(Operation, Ptr, Val, Ordering, Scope); 4237 RMWI->setVolatile(isVolatile); 4238 Inst = RMWI; 4239 return AteExtraComma ? InstExtraComma : InstNormal; 4240} 4241 4242/// ParseFence 4243/// ::= 'fence' 'singlethread'? AtomicOrdering 4244int LLParser::ParseFence(Instruction *&Inst, PerFunctionState &PFS) { 4245 AtomicOrdering Ordering = NotAtomic; 4246 SynchronizationScope Scope = CrossThread; 4247 if (ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering)) 4248 return true; 4249 4250 if (Ordering == Unordered) 4251 return TokError("fence cannot be unordered"); 4252 if (Ordering == Monotonic) 4253 return TokError("fence cannot be monotonic"); 4254 4255 Inst = new FenceInst(Context, Ordering, Scope); 4256 return InstNormal; 4257} 4258 4259/// ParseGetElementPtr 4260/// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)* 4261int LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) { 4262 Value *Ptr = 0; 4263 Value *Val = 0; 4264 LocTy Loc, EltLoc; 4265 4266 bool InBounds = EatIfPresent(lltok::kw_inbounds); 4267 4268 if (ParseTypeAndValue(Ptr, Loc, PFS)) return true; 4269 4270 Type *BaseType = Ptr->getType(); 4271 PointerType *BasePointerType = dyn_cast<PointerType>(BaseType->getScalarType()); 4272 if (!BasePointerType) 4273 return Error(Loc, "base of getelementptr must be a pointer"); 4274 4275 SmallVector<Value*, 16> Indices; 4276 bool AteExtraComma = false; 4277 while (EatIfPresent(lltok::comma)) { 4278 if (Lex.getKind() == lltok::MetadataVar) { 4279 AteExtraComma = true; 4280 break; 4281 } 4282 if (ParseTypeAndValue(Val, EltLoc, PFS)) return true; 4283 if (!Val->getType()->getScalarType()->isIntegerTy()) 4284 return Error(EltLoc, "getelementptr index must be an integer"); 4285 if (Val->getType()->isVectorTy() != Ptr->getType()->isVectorTy()) 4286 return Error(EltLoc, "getelementptr index type missmatch"); 4287 if (Val->getType()->isVectorTy()) { 4288 unsigned ValNumEl = cast<VectorType>(Val->getType())->getNumElements(); 4289 unsigned PtrNumEl = cast<VectorType>(Ptr->getType())->getNumElements(); 4290 if (ValNumEl != PtrNumEl) 4291 return Error(EltLoc, 4292 "getelementptr vector index has a wrong number of elements"); 4293 } 4294 Indices.push_back(Val); 4295 } 4296 4297 if (!Indices.empty() && !BasePointerType->getElementType()->isSized()) 4298 return Error(Loc, "base element of getelementptr must be sized"); 4299 4300 if (!GetElementPtrInst::getIndexedType(BaseType, Indices)) 4301 return Error(Loc, "invalid getelementptr indices"); 4302 Inst = GetElementPtrInst::Create(Ptr, Indices); 4303 if (InBounds) 4304 cast<GetElementPtrInst>(Inst)->setIsInBounds(true); 4305 return AteExtraComma ? InstExtraComma : InstNormal; 4306} 4307 4308/// ParseExtractValue 4309/// ::= 'extractvalue' TypeAndValue (',' uint32)+ 4310int LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) { 4311 Value *Val; LocTy Loc; 4312 SmallVector<unsigned, 4> Indices; 4313 bool AteExtraComma; 4314 if (ParseTypeAndValue(Val, Loc, PFS) || 4315 ParseIndexList(Indices, AteExtraComma)) 4316 return true; 4317 4318 if (!Val->getType()->isAggregateType()) 4319 return Error(Loc, "extractvalue operand must be aggregate type"); 4320 4321 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices)) 4322 return Error(Loc, "invalid indices for extractvalue"); 4323 Inst = ExtractValueInst::Create(Val, Indices); 4324 return AteExtraComma ? InstExtraComma : InstNormal; 4325} 4326 4327/// ParseInsertValue 4328/// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+ 4329int LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) { 4330 Value *Val0, *Val1; LocTy Loc0, Loc1; 4331 SmallVector<unsigned, 4> Indices; 4332 bool AteExtraComma; 4333 if (ParseTypeAndValue(Val0, Loc0, PFS) || 4334 ParseToken(lltok::comma, "expected comma after insertvalue operand") || 4335 ParseTypeAndValue(Val1, Loc1, PFS) || 4336 ParseIndexList(Indices, AteExtraComma)) 4337 return true; 4338 4339 if (!Val0->getType()->isAggregateType()) 4340 return Error(Loc0, "insertvalue operand must be aggregate type"); 4341 4342 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices)) 4343 return Error(Loc0, "invalid indices for insertvalue"); 4344 Inst = InsertValueInst::Create(Val0, Val1, Indices); 4345 return AteExtraComma ? InstExtraComma : InstNormal; 4346} 4347 4348//===----------------------------------------------------------------------===// 4349// Embedded metadata. 4350//===----------------------------------------------------------------------===// 4351 4352/// ParseMDNodeVector 4353/// ::= Element (',' Element)* 4354/// Element 4355/// ::= 'null' | TypeAndValue 4356bool LLParser::ParseMDNodeVector(SmallVectorImpl<Value*> &Elts, 4357 PerFunctionState *PFS) { 4358 // Check for an empty list. 4359 if (Lex.getKind() == lltok::rbrace) 4360 return false; 4361 4362 do { 4363 // Null is a special case since it is typeless. 4364 if (EatIfPresent(lltok::kw_null)) { 4365 Elts.push_back(0); 4366 continue; 4367 } 4368 4369 Value *V = 0; 4370 if (ParseTypeAndValue(V, PFS)) return true; 4371 Elts.push_back(V); 4372 } while (EatIfPresent(lltok::comma)); 4373 4374 return false; 4375} 4376