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