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