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