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