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