1 //===-- LLParser.cpp - Parser Class ---------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the parser class for .ll files.
12 //===----------------------------------------------------------------------===//
15 #include "llvm/ADT/SmallPtrSet.h"
16 #include "llvm/AutoUpgrade.h"
17 #include "llvm/IR/CallingConv.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/DerivedTypes.h"
20 #include "llvm/IR/InlineAsm.h"
21 #include "llvm/IR/Instructions.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/IR/Operator.h"
24 #include "llvm/IR/ValueSymbolTable.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/Support/raw_ostream.h"
29 static std::string getTypeString(Type *T) {
31 raw_string_ostream Tmp(Result);
36 /// Run: module ::= toplevelentity*
37 bool LLParser::Run() {
41 return ParseTopLevelEntities() ||
42 ValidateEndOfModule();
45 /// ValidateEndOfModule - Do final validity and sanity checks at the end of the
47 bool LLParser::ValidateEndOfModule() {
48 // Handle any instruction metadata forward references.
49 if (!ForwardRefInstMetadata.empty()) {
50 for (DenseMap<Instruction*, std::vector<MDRef> >::iterator
51 I = ForwardRefInstMetadata.begin(), E = ForwardRefInstMetadata.end();
53 Instruction *Inst = I->first;
54 const std::vector<MDRef> &MDList = I->second;
56 for (unsigned i = 0, e = MDList.size(); i != e; ++i) {
57 unsigned SlotNo = MDList[i].MDSlot;
59 if (SlotNo >= NumberedMetadata.size() || NumberedMetadata[SlotNo] == 0)
60 return Error(MDList[i].Loc, "use of undefined metadata '!" +
62 Inst->setMetadata(MDList[i].MDKind, NumberedMetadata[SlotNo]);
65 ForwardRefInstMetadata.clear();
69 // If there are entries in ForwardRefBlockAddresses at this point, they are
70 // references after the function was defined. Resolve those now.
71 while (!ForwardRefBlockAddresses.empty()) {
72 // Okay, we are referencing an already-parsed function, resolve them now.
74 const ValID &Fn = ForwardRefBlockAddresses.begin()->first;
75 if (Fn.Kind == ValID::t_GlobalName)
76 TheFn = M->getFunction(Fn.StrVal);
77 else if (Fn.UIntVal < NumberedVals.size())
78 TheFn = dyn_cast<Function>(NumberedVals[Fn.UIntVal]);
81 return Error(Fn.Loc, "unknown function referenced by blockaddress");
83 // Resolve all these references.
84 if (ResolveForwardRefBlockAddresses(TheFn,
85 ForwardRefBlockAddresses.begin()->second,
89 ForwardRefBlockAddresses.erase(ForwardRefBlockAddresses.begin());
92 for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i)
93 if (NumberedTypes[i].second.isValid())
94 return Error(NumberedTypes[i].second,
95 "use of undefined type '%" + Twine(i) + "'");
97 for (StringMap<std::pair<Type*, LocTy> >::iterator I =
98 NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I)
99 if (I->second.second.isValid())
100 return Error(I->second.second,
101 "use of undefined type named '" + I->getKey() + "'");
103 if (!ForwardRefVals.empty())
104 return Error(ForwardRefVals.begin()->second.second,
105 "use of undefined value '@" + ForwardRefVals.begin()->first +
108 if (!ForwardRefValIDs.empty())
109 return Error(ForwardRefValIDs.begin()->second.second,
110 "use of undefined value '@" +
111 Twine(ForwardRefValIDs.begin()->first) + "'");
113 if (!ForwardRefMDNodes.empty())
114 return Error(ForwardRefMDNodes.begin()->second.second,
115 "use of undefined metadata '!" +
116 Twine(ForwardRefMDNodes.begin()->first) + "'");
119 // Look for intrinsic functions and CallInst that need to be upgraded
120 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
121 UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
126 bool LLParser::ResolveForwardRefBlockAddresses(Function *TheFn,
127 std::vector<std::pair<ValID, GlobalValue*> > &Refs,
128 PerFunctionState *PFS) {
129 // Loop over all the references, resolving them.
130 for (unsigned i = 0, e = Refs.size(); i != e; ++i) {
133 if (Refs[i].first.Kind == ValID::t_LocalName)
134 Res = PFS->GetBB(Refs[i].first.StrVal, Refs[i].first.Loc);
136 Res = PFS->GetBB(Refs[i].first.UIntVal, Refs[i].first.Loc);
137 } else if (Refs[i].first.Kind == ValID::t_LocalID) {
138 return Error(Refs[i].first.Loc,
139 "cannot take address of numeric label after the function is defined");
141 Res = dyn_cast_or_null<BasicBlock>(
142 TheFn->getValueSymbolTable().lookup(Refs[i].first.StrVal));
146 return Error(Refs[i].first.Loc,
147 "referenced value is not a basic block");
149 // Get the BlockAddress for this and update references to use it.
150 BlockAddress *BA = BlockAddress::get(TheFn, Res);
151 Refs[i].second->replaceAllUsesWith(BA);
152 Refs[i].second->eraseFromParent();
158 //===----------------------------------------------------------------------===//
159 // Top-Level Entities
160 //===----------------------------------------------------------------------===//
162 bool LLParser::ParseTopLevelEntities() {
164 switch (Lex.getKind()) {
165 default: return TokError("expected top-level entity");
166 case lltok::Eof: return false;
167 case lltok::kw_declare: if (ParseDeclare()) return true; break;
168 case lltok::kw_define: if (ParseDefine()) return true; break;
169 case lltok::kw_module: if (ParseModuleAsm()) return true; break;
170 case lltok::kw_target: if (ParseTargetDefinition()) return true; break;
171 case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
172 case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
173 case lltok::LocalVar: if (ParseNamedType()) return true; break;
174 case lltok::GlobalID: if (ParseUnnamedGlobal()) return true; break;
175 case lltok::GlobalVar: if (ParseNamedGlobal()) return true; break;
176 case lltok::exclaim: if (ParseStandaloneMetadata()) return true; break;
177 case lltok::MetadataVar:if (ParseNamedMetadata()) return true; break;
178 case lltok::AttrGrpID: if (ParseUnnamedAttrGrp()) return true; break;
180 // The Global variable production with no name can have many different
181 // optional leading prefixes, the production is:
182 // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalThreadLocal
183 // OptionalAddrSpace OptionalUnNammedAddr
184 // ('constant'|'global') ...
185 case lltok::kw_private: // OptionalLinkage
186 case lltok::kw_linker_private: // OptionalLinkage
187 case lltok::kw_linker_private_weak: // OptionalLinkage
188 case lltok::kw_linker_private_weak_def_auto: // FIXME: backwards compat.
189 case lltok::kw_internal: // OptionalLinkage
190 case lltok::kw_weak: // OptionalLinkage
191 case lltok::kw_weak_odr: // OptionalLinkage
192 case lltok::kw_linkonce: // OptionalLinkage
193 case lltok::kw_linkonce_odr: // OptionalLinkage
194 case lltok::kw_linkonce_odr_auto_hide: // OptionalLinkage
195 case lltok::kw_appending: // OptionalLinkage
196 case lltok::kw_dllexport: // OptionalLinkage
197 case lltok::kw_common: // OptionalLinkage
198 case lltok::kw_dllimport: // OptionalLinkage
199 case lltok::kw_extern_weak: // OptionalLinkage
200 case lltok::kw_external: { // OptionalLinkage
201 unsigned Linkage, Visibility;
202 if (ParseOptionalLinkage(Linkage) ||
203 ParseOptionalVisibility(Visibility) ||
204 ParseGlobal("", SMLoc(), Linkage, true, Visibility))
208 case lltok::kw_default: // OptionalVisibility
209 case lltok::kw_hidden: // OptionalVisibility
210 case lltok::kw_protected: { // OptionalVisibility
212 if (ParseOptionalVisibility(Visibility) ||
213 ParseGlobal("", SMLoc(), 0, false, Visibility))
218 case lltok::kw_thread_local: // OptionalThreadLocal
219 case lltok::kw_addrspace: // OptionalAddrSpace
220 case lltok::kw_constant: // GlobalType
221 case lltok::kw_global: // GlobalType
222 if (ParseGlobal("", SMLoc(), 0, false, 0)) return true;
230 /// ::= 'module' 'asm' STRINGCONSTANT
231 bool LLParser::ParseModuleAsm() {
232 assert(Lex.getKind() == lltok::kw_module);
236 if (ParseToken(lltok::kw_asm, "expected 'module asm'") ||
237 ParseStringConstant(AsmStr)) return true;
239 M->appendModuleInlineAsm(AsmStr);
244 /// ::= 'target' 'triple' '=' STRINGCONSTANT
245 /// ::= 'target' 'datalayout' '=' STRINGCONSTANT
246 bool LLParser::ParseTargetDefinition() {
247 assert(Lex.getKind() == lltok::kw_target);
250 default: return TokError("unknown target property");
251 case lltok::kw_triple:
253 if (ParseToken(lltok::equal, "expected '=' after target triple") ||
254 ParseStringConstant(Str))
256 M->setTargetTriple(Str);
258 case lltok::kw_datalayout:
260 if (ParseToken(lltok::equal, "expected '=' after target datalayout") ||
261 ParseStringConstant(Str))
263 M->setDataLayout(Str);
269 /// ::= 'deplibs' '=' '[' ']'
270 /// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
271 /// FIXME: Remove in 4.0. Currently parse, but ignore.
272 bool LLParser::ParseDepLibs() {
273 assert(Lex.getKind() == lltok::kw_deplibs);
275 if (ParseToken(lltok::equal, "expected '=' after deplibs") ||
276 ParseToken(lltok::lsquare, "expected '=' after deplibs"))
279 if (EatIfPresent(lltok::rsquare))
284 if (ParseStringConstant(Str)) return true;
285 } while (EatIfPresent(lltok::comma));
287 return ParseToken(lltok::rsquare, "expected ']' at end of list");
290 /// ParseUnnamedType:
291 /// ::= LocalVarID '=' 'type' type
292 bool LLParser::ParseUnnamedType() {
293 LocTy TypeLoc = Lex.getLoc();
294 unsigned TypeID = Lex.getUIntVal();
295 Lex.Lex(); // eat LocalVarID;
297 if (ParseToken(lltok::equal, "expected '=' after name") ||
298 ParseToken(lltok::kw_type, "expected 'type' after '='"))
301 if (TypeID >= NumberedTypes.size())
302 NumberedTypes.resize(TypeID+1);
305 if (ParseStructDefinition(TypeLoc, "",
306 NumberedTypes[TypeID], Result)) return true;
308 if (!isa<StructType>(Result)) {
309 std::pair<Type*, LocTy> &Entry = NumberedTypes[TypeID];
311 return Error(TypeLoc, "non-struct types may not be recursive");
312 Entry.first = Result;
313 Entry.second = SMLoc();
321 /// ::= LocalVar '=' 'type' type
322 bool LLParser::ParseNamedType() {
323 std::string Name = Lex.getStrVal();
324 LocTy NameLoc = Lex.getLoc();
325 Lex.Lex(); // eat LocalVar.
327 if (ParseToken(lltok::equal, "expected '=' after name") ||
328 ParseToken(lltok::kw_type, "expected 'type' after name"))
332 if (ParseStructDefinition(NameLoc, Name,
333 NamedTypes[Name], Result)) return true;
335 if (!isa<StructType>(Result)) {
336 std::pair<Type*, LocTy> &Entry = NamedTypes[Name];
338 return Error(NameLoc, "non-struct types may not be recursive");
339 Entry.first = Result;
340 Entry.second = SMLoc();
348 /// ::= 'declare' FunctionHeader
349 bool LLParser::ParseDeclare() {
350 assert(Lex.getKind() == lltok::kw_declare);
354 return ParseFunctionHeader(F, false);
358 /// ::= 'define' FunctionHeader '{' ...
359 bool LLParser::ParseDefine() {
360 assert(Lex.getKind() == lltok::kw_define);
364 return ParseFunctionHeader(F, true) ||
365 ParseFunctionBody(*F);
371 bool LLParser::ParseGlobalType(bool &IsConstant) {
372 if (Lex.getKind() == lltok::kw_constant)
374 else if (Lex.getKind() == lltok::kw_global)
378 return TokError("expected 'global' or 'constant'");
384 /// ParseUnnamedGlobal:
385 /// OptionalVisibility ALIAS ...
386 /// OptionalLinkage OptionalVisibility ... -> global variable
387 /// GlobalID '=' OptionalVisibility ALIAS ...
388 /// GlobalID '=' OptionalLinkage OptionalVisibility ... -> global variable
389 bool LLParser::ParseUnnamedGlobal() {
390 unsigned VarID = NumberedVals.size();
392 LocTy NameLoc = Lex.getLoc();
394 // Handle the GlobalID form.
395 if (Lex.getKind() == lltok::GlobalID) {
396 if (Lex.getUIntVal() != VarID)
397 return Error(Lex.getLoc(), "variable expected to be numbered '%" +
399 Lex.Lex(); // eat GlobalID;
401 if (ParseToken(lltok::equal, "expected '=' after name"))
406 unsigned Linkage, Visibility;
407 if (ParseOptionalLinkage(Linkage, HasLinkage) ||
408 ParseOptionalVisibility(Visibility))
411 if (HasLinkage || Lex.getKind() != lltok::kw_alias)
412 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility);
413 return ParseAlias(Name, NameLoc, Visibility);
416 /// ParseNamedGlobal:
417 /// GlobalVar '=' OptionalVisibility ALIAS ...
418 /// GlobalVar '=' OptionalLinkage OptionalVisibility ... -> global variable
419 bool LLParser::ParseNamedGlobal() {
420 assert(Lex.getKind() == lltok::GlobalVar);
421 LocTy NameLoc = Lex.getLoc();
422 std::string Name = Lex.getStrVal();
426 unsigned Linkage, Visibility;
427 if (ParseToken(lltok::equal, "expected '=' in global variable") ||
428 ParseOptionalLinkage(Linkage, HasLinkage) ||
429 ParseOptionalVisibility(Visibility))
432 if (HasLinkage || Lex.getKind() != lltok::kw_alias)
433 return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility);
434 return ParseAlias(Name, NameLoc, Visibility);
438 // ::= '!' STRINGCONSTANT
439 bool LLParser::ParseMDString(MDString *&Result) {
441 if (ParseStringConstant(Str)) return true;
442 Result = MDString::get(Context, Str);
447 // ::= '!' MDNodeNumber
449 /// This version of ParseMDNodeID returns the slot number and null in the case
450 /// of a forward reference.
451 bool LLParser::ParseMDNodeID(MDNode *&Result, unsigned &SlotNo) {
452 // !{ ..., !42, ... }
453 if (ParseUInt32(SlotNo)) return true;
455 // Check existing MDNode.
456 if (SlotNo < NumberedMetadata.size() && NumberedMetadata[SlotNo] != 0)
457 Result = NumberedMetadata[SlotNo];
463 bool LLParser::ParseMDNodeID(MDNode *&Result) {
464 // !{ ..., !42, ... }
466 if (ParseMDNodeID(Result, MID)) return true;
468 // If not a forward reference, just return it now.
469 if (Result) return false;
471 // Otherwise, create MDNode forward reference.
472 MDNode *FwdNode = MDNode::getTemporary(Context, ArrayRef<Value*>());
473 ForwardRefMDNodes[MID] = std::make_pair(FwdNode, Lex.getLoc());
475 if (NumberedMetadata.size() <= MID)
476 NumberedMetadata.resize(MID+1);
477 NumberedMetadata[MID] = FwdNode;
482 /// ParseNamedMetadata:
483 /// !foo = !{ !1, !2 }
484 bool LLParser::ParseNamedMetadata() {
485 assert(Lex.getKind() == lltok::MetadataVar);
486 std::string Name = Lex.getStrVal();
489 if (ParseToken(lltok::equal, "expected '=' here") ||
490 ParseToken(lltok::exclaim, "Expected '!' here") ||
491 ParseToken(lltok::lbrace, "Expected '{' here"))
494 NamedMDNode *NMD = M->getOrInsertNamedMetadata(Name);
495 if (Lex.getKind() != lltok::rbrace)
497 if (ParseToken(lltok::exclaim, "Expected '!' here"))
501 if (ParseMDNodeID(N)) return true;
503 } while (EatIfPresent(lltok::comma));
505 if (ParseToken(lltok::rbrace, "expected end of metadata node"))
511 /// ParseStandaloneMetadata:
513 bool LLParser::ParseStandaloneMetadata() {
514 assert(Lex.getKind() == lltok::exclaim);
516 unsigned MetadataID = 0;
520 SmallVector<Value *, 16> Elts;
521 if (ParseUInt32(MetadataID) ||
522 ParseToken(lltok::equal, "expected '=' here") ||
523 ParseType(Ty, TyLoc) ||
524 ParseToken(lltok::exclaim, "Expected '!' here") ||
525 ParseToken(lltok::lbrace, "Expected '{' here") ||
526 ParseMDNodeVector(Elts, NULL) ||
527 ParseToken(lltok::rbrace, "expected end of metadata node"))
530 MDNode *Init = MDNode::get(Context, Elts);
532 // See if this was forward referenced, if so, handle it.
533 std::map<unsigned, std::pair<TrackingVH<MDNode>, LocTy> >::iterator
534 FI = ForwardRefMDNodes.find(MetadataID);
535 if (FI != ForwardRefMDNodes.end()) {
536 MDNode *Temp = FI->second.first;
537 Temp->replaceAllUsesWith(Init);
538 MDNode::deleteTemporary(Temp);
539 ForwardRefMDNodes.erase(FI);
541 assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work");
543 if (MetadataID >= NumberedMetadata.size())
544 NumberedMetadata.resize(MetadataID+1);
546 if (NumberedMetadata[MetadataID] != 0)
547 return TokError("Metadata id is already used");
548 NumberedMetadata[MetadataID] = Init;
555 /// ::= GlobalVar '=' OptionalVisibility 'alias' OptionalLinkage Aliasee
558 /// ::= 'bitcast' '(' TypeAndValue 'to' Type ')'
559 /// ::= 'getelementptr' 'inbounds'? '(' ... ')'
561 /// Everything through visibility has already been parsed.
563 bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc,
564 unsigned Visibility) {
565 assert(Lex.getKind() == lltok::kw_alias);
568 LocTy LinkageLoc = Lex.getLoc();
569 if (ParseOptionalLinkage(Linkage))
572 if (Linkage != GlobalValue::ExternalLinkage &&
573 Linkage != GlobalValue::WeakAnyLinkage &&
574 Linkage != GlobalValue::WeakODRLinkage &&
575 Linkage != GlobalValue::InternalLinkage &&
576 Linkage != GlobalValue::PrivateLinkage &&
577 Linkage != GlobalValue::LinkerPrivateLinkage &&
578 Linkage != GlobalValue::LinkerPrivateWeakLinkage)
579 return Error(LinkageLoc, "invalid linkage type for alias");
582 LocTy AliaseeLoc = Lex.getLoc();
583 if (Lex.getKind() != lltok::kw_bitcast &&
584 Lex.getKind() != lltok::kw_getelementptr) {
585 if (ParseGlobalTypeAndValue(Aliasee)) return true;
587 // The bitcast dest type is not present, it is implied by the dest type.
589 if (ParseValID(ID)) return true;
590 if (ID.Kind != ValID::t_Constant)
591 return Error(AliaseeLoc, "invalid aliasee");
592 Aliasee = ID.ConstantVal;
595 if (!Aliasee->getType()->isPointerTy())
596 return Error(AliaseeLoc, "alias must have pointer type");
598 // Okay, create the alias but do not insert it into the module yet.
599 GlobalAlias* GA = new GlobalAlias(Aliasee->getType(),
600 (GlobalValue::LinkageTypes)Linkage, Name,
602 GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
604 // See if this value already exists in the symbol table. If so, it is either
605 // a redefinition or a definition of a forward reference.
606 if (GlobalValue *Val = M->getNamedValue(Name)) {
607 // See if this was a redefinition. If so, there is no entry in
609 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
610 I = ForwardRefVals.find(Name);
611 if (I == ForwardRefVals.end())
612 return Error(NameLoc, "redefinition of global named '@" + Name + "'");
614 // Otherwise, this was a definition of forward ref. Verify that types
616 if (Val->getType() != GA->getType())
617 return Error(NameLoc,
618 "forward reference and definition of alias have different types");
620 // If they agree, just RAUW the old value with the alias and remove the
622 Val->replaceAllUsesWith(GA);
623 Val->eraseFromParent();
624 ForwardRefVals.erase(I);
627 // Insert into the module, we know its name won't collide now.
628 M->getAliasList().push_back(GA);
629 assert(GA->getName() == Name && "Should not be a name conflict!");
635 /// ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalThreadLocal
636 /// OptionalAddrSpace OptionalUnNammedAddr
637 /// OptionalExternallyInitialized GlobalType Type Const
638 /// ::= OptionalLinkage OptionalVisibility OptionalThreadLocal
639 /// OptionalAddrSpace OptionalUnNammedAddr
640 /// OptionalExternallyInitialized GlobalType Type Const
642 /// Everything through visibility has been parsed already.
644 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
645 unsigned Linkage, bool HasLinkage,
646 unsigned Visibility) {
648 bool IsConstant, UnnamedAddr, IsExternallyInitialized;
649 GlobalVariable::ThreadLocalMode TLM;
650 LocTy UnnamedAddrLoc;
651 LocTy IsExternallyInitializedLoc;
655 if (ParseOptionalThreadLocal(TLM) ||
656 ParseOptionalAddrSpace(AddrSpace) ||
657 ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr,
659 ParseOptionalToken(lltok::kw_externally_initialized,
660 IsExternallyInitialized,
661 &IsExternallyInitializedLoc) ||
662 ParseGlobalType(IsConstant) ||
663 ParseType(Ty, TyLoc))
666 // If the linkage is specified and is external, then no initializer is
669 if (!HasLinkage || (Linkage != GlobalValue::DLLImportLinkage &&
670 Linkage != GlobalValue::ExternalWeakLinkage &&
671 Linkage != GlobalValue::ExternalLinkage)) {
672 if (ParseGlobalValue(Ty, Init))
676 if (Ty->isFunctionTy() || Ty->isLabelTy())
677 return Error(TyLoc, "invalid type for global variable");
679 GlobalVariable *GV = 0;
681 // See if the global was forward referenced, if so, use the global.
683 if (GlobalValue *GVal = M->getNamedValue(Name)) {
684 if (!ForwardRefVals.erase(Name) || !isa<GlobalValue>(GVal))
685 return Error(NameLoc, "redefinition of global '@" + Name + "'");
686 GV = cast<GlobalVariable>(GVal);
689 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
690 I = ForwardRefValIDs.find(NumberedVals.size());
691 if (I != ForwardRefValIDs.end()) {
692 GV = cast<GlobalVariable>(I->second.first);
693 ForwardRefValIDs.erase(I);
698 GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, 0,
699 Name, 0, GlobalVariable::NotThreadLocal,
702 if (GV->getType()->getElementType() != Ty)
704 "forward reference and definition of global have different types");
706 // Move the forward-reference to the correct spot in the module.
707 M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV);
711 NumberedVals.push_back(GV);
713 // Set the parsed properties on the global.
715 GV->setInitializer(Init);
716 GV->setConstant(IsConstant);
717 GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
718 GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
719 GV->setExternallyInitialized(IsExternallyInitialized);
720 GV->setThreadLocalMode(TLM);
721 GV->setUnnamedAddr(UnnamedAddr);
723 // Parse attributes on the global.
724 while (Lex.getKind() == lltok::comma) {
727 if (Lex.getKind() == lltok::kw_section) {
729 GV->setSection(Lex.getStrVal());
730 if (ParseToken(lltok::StringConstant, "expected global section string"))
732 } else if (Lex.getKind() == lltok::kw_align) {
734 if (ParseOptionalAlignment(Alignment)) return true;
735 GV->setAlignment(Alignment);
737 TokError("unknown global variable property!");
744 /// ParseUnnamedAttrGrp
745 /// ::= AttrGrpID '=' '{' AttrValPair+ '}'
746 bool LLParser::ParseUnnamedAttrGrp() {
747 assert(Lex.getKind() == lltok::AttrGrpID);
748 LocTy AttrGrpLoc = Lex.getLoc();
749 unsigned VarID = Lex.getUIntVal();
752 if (ParseToken(lltok::equal, "expected '=' here") ||
753 ParseToken(lltok::kw_attributes, "expected 'attributes' keyword here") ||
754 ParseToken(lltok::lbrace, "expected '{' here") ||
755 ParseFnAttributeValuePairs(ForwardRefAttrBuilder[VarID], true) ||
756 ParseToken(lltok::rbrace, "expected end of attribute group"))
759 if (!ForwardRefAttrBuilder[VarID].hasAttributes())
760 return Error(AttrGrpLoc, "attribute group has no attributes");
765 /// ParseFnAttributeValuePairs
766 /// ::= <attr> | <attr> '=' <value>
767 bool LLParser::ParseFnAttributeValuePairs(AttrBuilder &B, bool inAttrGrp) {
768 bool HaveError = false;
773 lltok::Kind Token = Lex.getKind();
776 if (!inAttrGrp) return HaveError;
777 return Error(Lex.getLoc(), "unterminated attribute group");
782 // Target-dependent attributes:
783 case lltok::StringConstant: {
784 std::string Attr = Lex.getStrVal();
787 if (EatIfPresent(lltok::equal) &&
788 ParseStringConstant(Val))
791 B.addAttribute(Attr, Val);
795 // Target-independent attributes:
796 case lltok::kw_align: {
797 // As a hack, we allow "align 2" on functions as a synonym for "alignstack
801 if (ParseToken(lltok::equal, "expected '=' here") ||
802 ParseUInt32(Alignment))
805 if (ParseOptionalAlignment(Alignment))
808 B.addAlignmentAttr(Alignment);
811 case lltok::kw_alignstack: {
814 if (ParseToken(lltok::equal, "expected '=' here") ||
815 ParseUInt32(Alignment))
818 if (ParseOptionalStackAlignment(Alignment))
821 B.addStackAlignmentAttr(Alignment);
824 case lltok::kw_address_safety: B.addAttribute(Attribute::AddressSafety); break;
825 case lltok::kw_alwaysinline: B.addAttribute(Attribute::AlwaysInline); break;
826 case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;
827 case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;
828 case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;
829 case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
830 case lltok::kw_noimplicitfloat: B.addAttribute(Attribute::NoImplicitFloat); break;
831 case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;
832 case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
833 case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
834 case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
835 case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break;
836 case lltok::kw_optsize: B.addAttribute(Attribute::OptimizeForSize); break;
837 case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
838 case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
839 case lltok::kw_returns_twice: B.addAttribute(Attribute::ReturnsTwice); break;
840 case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break;
841 case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break;
842 case lltok::kw_sspstrong: B.addAttribute(Attribute::StackProtectStrong); break;
843 case lltok::kw_uwtable: B.addAttribute(Attribute::UWTable); break;
846 case lltok::kw_inreg:
847 case lltok::kw_signext:
848 case lltok::kw_zeroext:
851 "invalid use of attribute on a function");
853 case lltok::kw_byval:
855 case lltok::kw_noalias:
856 case lltok::kw_nocapture:
860 "invalid use of parameter-only attribute on a function");
868 //===----------------------------------------------------------------------===//
869 // GlobalValue Reference/Resolution Routines.
870 //===----------------------------------------------------------------------===//
872 /// GetGlobalVal - Get a value with the specified name or ID, creating a
873 /// forward reference record if needed. This can return null if the value
874 /// exists but does not have the right type.
875 GlobalValue *LLParser::GetGlobalVal(const std::string &Name, Type *Ty,
877 PointerType *PTy = dyn_cast<PointerType>(Ty);
879 Error(Loc, "global variable reference must have pointer type");
883 // Look this name up in the normal function symbol table.
885 cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name));
887 // If this is a forward reference for the value, see if we already created a
888 // forward ref record.
890 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
891 I = ForwardRefVals.find(Name);
892 if (I != ForwardRefVals.end())
893 Val = I->second.first;
896 // If we have the value in the symbol table or fwd-ref table, return it.
898 if (Val->getType() == Ty) return Val;
899 Error(Loc, "'@" + Name + "' defined with type '" +
900 getTypeString(Val->getType()) + "'");
904 // Otherwise, create a new forward reference for this value and remember it.
906 if (FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType()))
907 FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M);
909 FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
910 GlobalValue::ExternalWeakLinkage, 0, Name,
911 0, GlobalVariable::NotThreadLocal,
912 PTy->getAddressSpace());
914 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
918 GlobalValue *LLParser::GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc) {
919 PointerType *PTy = dyn_cast<PointerType>(Ty);
921 Error(Loc, "global variable reference must have pointer type");
925 GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0;
927 // If this is a forward reference for the value, see if we already created a
928 // forward ref record.
930 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
931 I = ForwardRefValIDs.find(ID);
932 if (I != ForwardRefValIDs.end())
933 Val = I->second.first;
936 // If we have the value in the symbol table or fwd-ref table, return it.
938 if (Val->getType() == Ty) return Val;
939 Error(Loc, "'@" + Twine(ID) + "' defined with type '" +
940 getTypeString(Val->getType()) + "'");
944 // Otherwise, create a new forward reference for this value and remember it.
946 if (FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType()))
947 FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, "", M);
949 FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
950 GlobalValue::ExternalWeakLinkage, 0, "");
952 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
957 //===----------------------------------------------------------------------===//
959 //===----------------------------------------------------------------------===//
961 /// ParseToken - If the current token has the specified kind, eat it and return
962 /// success. Otherwise, emit the specified error and return failure.
963 bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) {
964 if (Lex.getKind() != T)
965 return TokError(ErrMsg);
970 /// ParseStringConstant
971 /// ::= StringConstant
972 bool LLParser::ParseStringConstant(std::string &Result) {
973 if (Lex.getKind() != lltok::StringConstant)
974 return TokError("expected string constant");
975 Result = Lex.getStrVal();
982 bool LLParser::ParseUInt32(unsigned &Val) {
983 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
984 return TokError("expected integer");
985 uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1);
986 if (Val64 != unsigned(Val64))
987 return TokError("expected 32-bit integer (too large)");
994 /// := 'localdynamic'
997 bool LLParser::ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM) {
998 switch (Lex.getKind()) {
1000 return TokError("expected localdynamic, initialexec or localexec");
1001 case lltok::kw_localdynamic:
1002 TLM = GlobalVariable::LocalDynamicTLSModel;
1004 case lltok::kw_initialexec:
1005 TLM = GlobalVariable::InitialExecTLSModel;
1007 case lltok::kw_localexec:
1008 TLM = GlobalVariable::LocalExecTLSModel;
1016 /// ParseOptionalThreadLocal
1018 /// := 'thread_local'
1019 /// := 'thread_local' '(' tlsmodel ')'
1020 bool LLParser::ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM) {
1021 TLM = GlobalVariable::NotThreadLocal;
1022 if (!EatIfPresent(lltok::kw_thread_local))
1025 TLM = GlobalVariable::GeneralDynamicTLSModel;
1026 if (Lex.getKind() == lltok::lparen) {
1028 return ParseTLSModel(TLM) ||
1029 ParseToken(lltok::rparen, "expected ')' after thread local model");
1034 /// ParseOptionalAddrSpace
1036 /// := 'addrspace' '(' uint32 ')'
1037 bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) {
1039 if (!EatIfPresent(lltok::kw_addrspace))
1041 return ParseToken(lltok::lparen, "expected '(' in address space") ||
1042 ParseUInt32(AddrSpace) ||
1043 ParseToken(lltok::rparen, "expected ')' in address space");
1046 /// ParseOptionalParamAttrs - Parse a potentially empty list of parameter attributes.
1047 bool LLParser::ParseOptionalParamAttrs(AttrBuilder &B) {
1048 bool HaveError = false;
1053 lltok::Kind Token = Lex.getKind();
1055 default: // End of attributes.
1057 case lltok::kw_align: {
1059 if (ParseOptionalAlignment(Alignment))
1061 B.addAlignmentAttr(Alignment);
1064 case lltok::kw_byval: B.addAttribute(Attribute::ByVal); break;
1065 case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break;
1066 case lltok::kw_nest: B.addAttribute(Attribute::Nest); break;
1067 case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break;
1068 case lltok::kw_nocapture: B.addAttribute(Attribute::NoCapture); break;
1069 case lltok::kw_signext: B.addAttribute(Attribute::SExt); break;
1070 case lltok::kw_sret: B.addAttribute(Attribute::StructRet); break;
1071 case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
1073 case lltok::kw_noreturn: case lltok::kw_nounwind:
1074 case lltok::kw_uwtable: case lltok::kw_returns_twice:
1075 case lltok::kw_noinline: case lltok::kw_readnone:
1076 case lltok::kw_readonly: case lltok::kw_inlinehint:
1077 case lltok::kw_alwaysinline: case lltok::kw_optsize:
1078 case lltok::kw_ssp: case lltok::kw_sspreq:
1079 case lltok::kw_noredzone: case lltok::kw_noimplicitfloat:
1080 case lltok::kw_naked: case lltok::kw_nonlazybind:
1081 case lltok::kw_address_safety: case lltok::kw_minsize:
1082 case lltok::kw_alignstack:
1083 HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
1091 /// ParseOptionalReturnAttrs - Parse a potentially empty list of return attributes.
1092 bool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
1093 bool HaveError = false;
1098 lltok::Kind Token = Lex.getKind();
1100 default: // End of attributes.
1102 case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break;
1103 case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break;
1104 case lltok::kw_signext: B.addAttribute(Attribute::SExt); break;
1105 case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
1108 case lltok::kw_sret: case lltok::kw_nocapture:
1109 case lltok::kw_byval: case lltok::kw_nest:
1110 HaveError |= Error(Lex.getLoc(), "invalid use of parameter-only attribute");
1113 case lltok::kw_noreturn: case lltok::kw_nounwind:
1114 case lltok::kw_uwtable: case lltok::kw_returns_twice:
1115 case lltok::kw_noinline: case lltok::kw_readnone:
1116 case lltok::kw_readonly: case lltok::kw_inlinehint:
1117 case lltok::kw_alwaysinline: case lltok::kw_optsize:
1118 case lltok::kw_ssp: case lltok::kw_sspreq:
1119 case lltok::kw_sspstrong: case lltok::kw_noimplicitfloat:
1120 case lltok::kw_noredzone: case lltok::kw_naked:
1121 case lltok::kw_nonlazybind: case lltok::kw_address_safety:
1122 case lltok::kw_minsize: case lltok::kw_alignstack:
1123 case lltok::kw_align: case lltok::kw_noduplicate:
1124 HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
1132 /// ParseOptionalLinkage
1135 /// ::= 'linker_private'
1136 /// ::= 'linker_private_weak'
1141 /// ::= 'linkonce_odr'
1142 /// ::= 'linkonce_odr_auto_hide'
1143 /// ::= 'available_externally'
1148 /// ::= 'extern_weak'
1150 bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {
1152 switch (Lex.getKind()) {
1153 default: Res=GlobalValue::ExternalLinkage; return false;
1154 case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break;
1155 case lltok::kw_linker_private: Res = GlobalValue::LinkerPrivateLinkage; break;
1156 case lltok::kw_linker_private_weak:
1157 Res = GlobalValue::LinkerPrivateWeakLinkage;
1159 case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break;
1160 case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break;
1161 case lltok::kw_weak_odr: Res = GlobalValue::WeakODRLinkage; break;
1162 case lltok::kw_linkonce: Res = GlobalValue::LinkOnceAnyLinkage; break;
1163 case lltok::kw_linkonce_odr: Res = GlobalValue::LinkOnceODRLinkage; break;
1164 case lltok::kw_linkonce_odr_auto_hide:
1165 case lltok::kw_linker_private_weak_def_auto: // FIXME: For backwards compat.
1166 Res = GlobalValue::LinkOnceODRAutoHideLinkage;
1168 case lltok::kw_available_externally:
1169 Res = GlobalValue::AvailableExternallyLinkage;
1171 case lltok::kw_appending: Res = GlobalValue::AppendingLinkage; break;
1172 case lltok::kw_dllexport: Res = GlobalValue::DLLExportLinkage; break;
1173 case lltok::kw_common: Res = GlobalValue::CommonLinkage; break;
1174 case lltok::kw_dllimport: Res = GlobalValue::DLLImportLinkage; break;
1175 case lltok::kw_extern_weak: Res = GlobalValue::ExternalWeakLinkage; break;
1176 case lltok::kw_external: Res = GlobalValue::ExternalLinkage; break;
1183 /// ParseOptionalVisibility
1189 bool LLParser::ParseOptionalVisibility(unsigned &Res) {
1190 switch (Lex.getKind()) {
1191 default: Res = GlobalValue::DefaultVisibility; return false;
1192 case lltok::kw_default: Res = GlobalValue::DefaultVisibility; break;
1193 case lltok::kw_hidden: Res = GlobalValue::HiddenVisibility; break;
1194 case lltok::kw_protected: Res = GlobalValue::ProtectedVisibility; break;
1200 /// ParseOptionalCallingConv
1204 /// ::= 'kw_intel_ocl_bicc'
1206 /// ::= 'x86_stdcallcc'
1207 /// ::= 'x86_fastcallcc'
1208 /// ::= 'x86_thiscallcc'
1209 /// ::= 'arm_apcscc'
1210 /// ::= 'arm_aapcscc'
1211 /// ::= 'arm_aapcs_vfpcc'
1212 /// ::= 'msp430_intrcc'
1213 /// ::= 'ptx_kernel'
1214 /// ::= 'ptx_device'
1216 /// ::= 'spir_kernel'
1219 bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) {
1220 switch (Lex.getKind()) {
1221 default: CC = CallingConv::C; return false;
1222 case lltok::kw_ccc: CC = CallingConv::C; break;
1223 case lltok::kw_fastcc: CC = CallingConv::Fast; break;
1224 case lltok::kw_coldcc: CC = CallingConv::Cold; break;
1225 case lltok::kw_x86_stdcallcc: CC = CallingConv::X86_StdCall; break;
1226 case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break;
1227 case lltok::kw_x86_thiscallcc: CC = CallingConv::X86_ThisCall; break;
1228 case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break;
1229 case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break;
1230 case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break;
1231 case lltok::kw_msp430_intrcc: CC = CallingConv::MSP430_INTR; break;
1232 case lltok::kw_ptx_kernel: CC = CallingConv::PTX_Kernel; break;
1233 case lltok::kw_ptx_device: CC = CallingConv::PTX_Device; break;
1234 case lltok::kw_spir_kernel: CC = CallingConv::SPIR_KERNEL; break;
1235 case lltok::kw_spir_func: CC = CallingConv::SPIR_FUNC; break;
1236 case lltok::kw_intel_ocl_bicc: CC = CallingConv::Intel_OCL_BI; break;
1237 case lltok::kw_cc: {
1238 unsigned ArbitraryCC;
1240 if (ParseUInt32(ArbitraryCC))
1242 CC = static_cast<CallingConv::ID>(ArbitraryCC);
1251 /// ParseInstructionMetadata
1252 /// ::= !dbg !42 (',' !dbg !57)*
1253 bool LLParser::ParseInstructionMetadata(Instruction *Inst,
1254 PerFunctionState *PFS) {
1256 if (Lex.getKind() != lltok::MetadataVar)
1257 return TokError("expected metadata after comma");
1259 std::string Name = Lex.getStrVal();
1260 unsigned MDK = M->getMDKindID(Name);
1264 SMLoc Loc = Lex.getLoc();
1266 if (ParseToken(lltok::exclaim, "expected '!' here"))
1269 // This code is similar to that of ParseMetadataValue, however it needs to
1270 // have special-case code for a forward reference; see the comments on
1271 // ForwardRefInstMetadata for details. Also, MDStrings are not supported
1272 // at the top level here.
1273 if (Lex.getKind() == lltok::lbrace) {
1275 if (ParseMetadataListValue(ID, PFS))
1277 assert(ID.Kind == ValID::t_MDNode);
1278 Inst->setMetadata(MDK, ID.MDNodeVal);
1280 unsigned NodeID = 0;
1281 if (ParseMDNodeID(Node, NodeID))
1284 // If we got the node, add it to the instruction.
1285 Inst->setMetadata(MDK, Node);
1287 MDRef R = { Loc, MDK, NodeID };
1288 // Otherwise, remember that this should be resolved later.
1289 ForwardRefInstMetadata[Inst].push_back(R);
1293 // If this is the end of the list, we're done.
1294 } while (EatIfPresent(lltok::comma));
1298 /// ParseOptionalAlignment
1301 bool LLParser::ParseOptionalAlignment(unsigned &Alignment) {
1303 if (!EatIfPresent(lltok::kw_align))
1305 LocTy AlignLoc = Lex.getLoc();
1306 if (ParseUInt32(Alignment)) return true;
1307 if (!isPowerOf2_32(Alignment))
1308 return Error(AlignLoc, "alignment is not a power of two");
1309 if (Alignment > Value::MaximumAlignment)
1310 return Error(AlignLoc, "huge alignments are not supported yet");
1314 /// ParseOptionalCommaAlign
1318 /// This returns with AteExtraComma set to true if it ate an excess comma at the
1320 bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment,
1321 bool &AteExtraComma) {
1322 AteExtraComma = false;
1323 while (EatIfPresent(lltok::comma)) {
1324 // Metadata at the end is an early exit.
1325 if (Lex.getKind() == lltok::MetadataVar) {
1326 AteExtraComma = true;
1330 if (Lex.getKind() != lltok::kw_align)
1331 return Error(Lex.getLoc(), "expected metadata or 'align'");
1333 if (ParseOptionalAlignment(Alignment)) return true;
1339 /// ParseScopeAndOrdering
1340 /// if isAtomic: ::= 'singlethread'? AtomicOrdering
1343 /// This sets Scope and Ordering to the parsed values.
1344 bool LLParser::ParseScopeAndOrdering(bool isAtomic, SynchronizationScope &Scope,
1345 AtomicOrdering &Ordering) {
1349 Scope = CrossThread;
1350 if (EatIfPresent(lltok::kw_singlethread))
1351 Scope = SingleThread;
1352 switch (Lex.getKind()) {
1353 default: return TokError("Expected ordering on atomic instruction");
1354 case lltok::kw_unordered: Ordering = Unordered; break;
1355 case lltok::kw_monotonic: Ordering = Monotonic; break;
1356 case lltok::kw_acquire: Ordering = Acquire; break;
1357 case lltok::kw_release: Ordering = Release; break;
1358 case lltok::kw_acq_rel: Ordering = AcquireRelease; break;
1359 case lltok::kw_seq_cst: Ordering = SequentiallyConsistent; break;
1365 /// ParseOptionalStackAlignment
1367 /// ::= 'alignstack' '(' 4 ')'
1368 bool LLParser::ParseOptionalStackAlignment(unsigned &Alignment) {
1370 if (!EatIfPresent(lltok::kw_alignstack))
1372 LocTy ParenLoc = Lex.getLoc();
1373 if (!EatIfPresent(lltok::lparen))
1374 return Error(ParenLoc, "expected '('");
1375 LocTy AlignLoc = Lex.getLoc();
1376 if (ParseUInt32(Alignment)) return true;
1377 ParenLoc = Lex.getLoc();
1378 if (!EatIfPresent(lltok::rparen))
1379 return Error(ParenLoc, "expected ')'");
1380 if (!isPowerOf2_32(Alignment))
1381 return Error(AlignLoc, "stack alignment is not a power of two");
1385 /// ParseIndexList - This parses the index list for an insert/extractvalue
1386 /// instruction. This sets AteExtraComma in the case where we eat an extra
1387 /// comma at the end of the line and find that it is followed by metadata.
1388 /// Clients that don't allow metadata can call the version of this function that
1389 /// only takes one argument.
1392 /// ::= (',' uint32)+
1394 bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices,
1395 bool &AteExtraComma) {
1396 AteExtraComma = false;
1398 if (Lex.getKind() != lltok::comma)
1399 return TokError("expected ',' as start of index list");
1401 while (EatIfPresent(lltok::comma)) {
1402 if (Lex.getKind() == lltok::MetadataVar) {
1403 AteExtraComma = true;
1407 if (ParseUInt32(Idx)) return true;
1408 Indices.push_back(Idx);
1414 //===----------------------------------------------------------------------===//
1416 //===----------------------------------------------------------------------===//
1418 /// ParseType - Parse a type.
1419 bool LLParser::ParseType(Type *&Result, bool AllowVoid) {
1420 SMLoc TypeLoc = Lex.getLoc();
1421 switch (Lex.getKind()) {
1423 return TokError("expected type");
1425 // Type ::= 'float' | 'void' (etc)
1426 Result = Lex.getTyVal();
1430 // Type ::= StructType
1431 if (ParseAnonStructType(Result, false))
1434 case lltok::lsquare:
1435 // Type ::= '[' ... ']'
1436 Lex.Lex(); // eat the lsquare.
1437 if (ParseArrayVectorType(Result, false))
1440 case lltok::less: // Either vector or packed struct.
1441 // Type ::= '<' ... '>'
1443 if (Lex.getKind() == lltok::lbrace) {
1444 if (ParseAnonStructType(Result, true) ||
1445 ParseToken(lltok::greater, "expected '>' at end of packed struct"))
1447 } else if (ParseArrayVectorType(Result, true))
1450 case lltok::LocalVar: {
1452 std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.getStrVal()];
1454 // If the type hasn't been defined yet, create a forward definition and
1455 // remember where that forward def'n was seen (in case it never is defined).
1456 if (Entry.first == 0) {
1457 Entry.first = StructType::create(Context, Lex.getStrVal());
1458 Entry.second = Lex.getLoc();
1460 Result = Entry.first;
1465 case lltok::LocalVarID: {
1467 if (Lex.getUIntVal() >= NumberedTypes.size())
1468 NumberedTypes.resize(Lex.getUIntVal()+1);
1469 std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.getUIntVal()];
1471 // If the type hasn't been defined yet, create a forward definition and
1472 // remember where that forward def'n was seen (in case it never is defined).
1473 if (Entry.first == 0) {
1474 Entry.first = StructType::create(Context);
1475 Entry.second = Lex.getLoc();
1477 Result = Entry.first;
1483 // Parse the type suffixes.
1485 switch (Lex.getKind()) {
1488 if (!AllowVoid && Result->isVoidTy())
1489 return Error(TypeLoc, "void type only allowed for function results");
1492 // Type ::= Type '*'
1494 if (Result->isLabelTy())
1495 return TokError("basic block pointers are invalid");
1496 if (Result->isVoidTy())
1497 return TokError("pointers to void are invalid - use i8* instead");
1498 if (!PointerType::isValidElementType(Result))
1499 return TokError("pointer to this type is invalid");
1500 Result = PointerType::getUnqual(Result);
1504 // Type ::= Type 'addrspace' '(' uint32 ')' '*'
1505 case lltok::kw_addrspace: {
1506 if (Result->isLabelTy())
1507 return TokError("basic block pointers are invalid");
1508 if (Result->isVoidTy())
1509 return TokError("pointers to void are invalid; use i8* instead");
1510 if (!PointerType::isValidElementType(Result))
1511 return TokError("pointer to this type is invalid");
1513 if (ParseOptionalAddrSpace(AddrSpace) ||
1514 ParseToken(lltok::star, "expected '*' in address space"))
1517 Result = PointerType::get(Result, AddrSpace);
1521 /// Types '(' ArgTypeListI ')' OptFuncAttrs
1523 if (ParseFunctionType(Result))
1530 /// ParseParameterList
1532 /// ::= '(' Arg (',' Arg)* ')'
1534 /// ::= Type OptionalAttributes Value OptionalAttributes
1535 bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
1536 PerFunctionState &PFS) {
1537 if (ParseToken(lltok::lparen, "expected '(' in call"))
1540 unsigned AttrIndex = 1;
1541 while (Lex.getKind() != lltok::rparen) {
1542 // If this isn't the first argument, we need a comma.
1543 if (!ArgList.empty() &&
1544 ParseToken(lltok::comma, "expected ',' in argument list"))
1547 // Parse the argument.
1550 AttrBuilder ArgAttrs;
1552 if (ParseType(ArgTy, ArgLoc))
1555 // Otherwise, handle normal operands.
1556 if (ParseOptionalParamAttrs(ArgAttrs) || ParseValue(ArgTy, V, PFS))
1558 ArgList.push_back(ParamInfo(ArgLoc, V, AttributeSet::get(V->getContext(),
1563 Lex.Lex(); // Lex the ')'.
1569 /// ParseArgumentList - Parse the argument list for a function type or function
1571 /// ::= '(' ArgTypeListI ')'
1575 /// ::= ArgTypeList ',' '...'
1576 /// ::= ArgType (',' ArgType)*
1578 bool LLParser::ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
1581 assert(Lex.getKind() == lltok::lparen);
1582 Lex.Lex(); // eat the (.
1584 if (Lex.getKind() == lltok::rparen) {
1586 } else if (Lex.getKind() == lltok::dotdotdot) {
1590 LocTy TypeLoc = Lex.getLoc();
1595 if (ParseType(ArgTy) ||
1596 ParseOptionalParamAttrs(Attrs)) return true;
1598 if (ArgTy->isVoidTy())
1599 return Error(TypeLoc, "argument can not have void type");
1601 if (Lex.getKind() == lltok::LocalVar) {
1602 Name = Lex.getStrVal();
1606 if (!FunctionType::isValidArgumentType(ArgTy))
1607 return Error(TypeLoc, "invalid type for function argument");
1609 unsigned AttrIndex = 1;
1610 ArgList.push_back(ArgInfo(TypeLoc, ArgTy,
1611 AttributeSet::get(ArgTy->getContext(),
1612 AttrIndex++, Attrs), Name));
1614 while (EatIfPresent(lltok::comma)) {
1615 // Handle ... at end of arg list.
1616 if (EatIfPresent(lltok::dotdotdot)) {
1621 // Otherwise must be an argument type.
1622 TypeLoc = Lex.getLoc();
1623 if (ParseType(ArgTy) || ParseOptionalParamAttrs(Attrs)) return true;
1625 if (ArgTy->isVoidTy())
1626 return Error(TypeLoc, "argument can not have void type");
1628 if (Lex.getKind() == lltok::LocalVar) {
1629 Name = Lex.getStrVal();
1635 if (!ArgTy->isFirstClassType())
1636 return Error(TypeLoc, "invalid type for function argument");
1638 ArgList.push_back(ArgInfo(TypeLoc, ArgTy,
1639 AttributeSet::get(ArgTy->getContext(),
1640 AttrIndex++, Attrs),
1645 return ParseToken(lltok::rparen, "expected ')' at end of argument list");
1648 /// ParseFunctionType
1649 /// ::= Type ArgumentList OptionalAttrs
1650 bool LLParser::ParseFunctionType(Type *&Result) {
1651 assert(Lex.getKind() == lltok::lparen);
1653 if (!FunctionType::isValidReturnType(Result))
1654 return TokError("invalid function return type");
1656 SmallVector<ArgInfo, 8> ArgList;
1658 if (ParseArgumentList(ArgList, isVarArg))
1661 // Reject names on the arguments lists.
1662 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
1663 if (!ArgList[i].Name.empty())
1664 return Error(ArgList[i].Loc, "argument name invalid in function type");
1665 if (ArgList[i].Attrs.hasAttributes(i + 1))
1666 return Error(ArgList[i].Loc,
1667 "argument attributes invalid in function type");
1670 SmallVector<Type*, 16> ArgListTy;
1671 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
1672 ArgListTy.push_back(ArgList[i].Ty);
1674 Result = FunctionType::get(Result, ArgListTy, isVarArg);
1678 /// ParseAnonStructType - Parse an anonymous struct type, which is inlined into
1680 bool LLParser::ParseAnonStructType(Type *&Result, bool Packed) {
1681 SmallVector<Type*, 8> Elts;
1682 if (ParseStructBody(Elts)) return true;
1684 Result = StructType::get(Context, Elts, Packed);
1688 /// ParseStructDefinition - Parse a struct in a 'type' definition.
1689 bool LLParser::ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
1690 std::pair<Type*, LocTy> &Entry,
1692 // If the type was already defined, diagnose the redefinition.
1693 if (Entry.first && !Entry.second.isValid())
1694 return Error(TypeLoc, "redefinition of type");
1696 // If we have opaque, just return without filling in the definition for the
1697 // struct. This counts as a definition as far as the .ll file goes.
1698 if (EatIfPresent(lltok::kw_opaque)) {
1699 // This type is being defined, so clear the location to indicate this.
1700 Entry.second = SMLoc();
1702 // If this type number has never been uttered, create it.
1703 if (Entry.first == 0)
1704 Entry.first = StructType::create(Context, Name);
1705 ResultTy = Entry.first;
1709 // If the type starts with '<', then it is either a packed struct or a vector.
1710 bool isPacked = EatIfPresent(lltok::less);
1712 // If we don't have a struct, then we have a random type alias, which we
1713 // accept for compatibility with old files. These types are not allowed to be
1714 // forward referenced and not allowed to be recursive.
1715 if (Lex.getKind() != lltok::lbrace) {
1717 return Error(TypeLoc, "forward references to non-struct type");
1721 return ParseArrayVectorType(ResultTy, true);
1722 return ParseType(ResultTy);
1725 // This type is being defined, so clear the location to indicate this.
1726 Entry.second = SMLoc();
1728 // If this type number has never been uttered, create it.
1729 if (Entry.first == 0)
1730 Entry.first = StructType::create(Context, Name);
1732 StructType *STy = cast<StructType>(Entry.first);
1734 SmallVector<Type*, 8> Body;
1735 if (ParseStructBody(Body) ||
1736 (isPacked && ParseToken(lltok::greater, "expected '>' in packed struct")))
1739 STy->setBody(Body, isPacked);
1745 /// ParseStructType: Handles packed and unpacked types. </> parsed elsewhere.
1748 /// ::= '{' Type (',' Type)* '}'
1749 /// ::= '<' '{' '}' '>'
1750 /// ::= '<' '{' Type (',' Type)* '}' '>'
1751 bool LLParser::ParseStructBody(SmallVectorImpl<Type*> &Body) {
1752 assert(Lex.getKind() == lltok::lbrace);
1753 Lex.Lex(); // Consume the '{'
1755 // Handle the empty struct.
1756 if (EatIfPresent(lltok::rbrace))
1759 LocTy EltTyLoc = Lex.getLoc();
1761 if (ParseType(Ty)) return true;
1764 if (!StructType::isValidElementType(Ty))
1765 return Error(EltTyLoc, "invalid element type for struct");
1767 while (EatIfPresent(lltok::comma)) {
1768 EltTyLoc = Lex.getLoc();
1769 if (ParseType(Ty)) return true;
1771 if (!StructType::isValidElementType(Ty))
1772 return Error(EltTyLoc, "invalid element type for struct");
1777 return ParseToken(lltok::rbrace, "expected '}' at end of struct");
1780 /// ParseArrayVectorType - Parse an array or vector type, assuming the first
1781 /// token has already been consumed.
1783 /// ::= '[' APSINTVAL 'x' Types ']'
1784 /// ::= '<' APSINTVAL 'x' Types '>'
1785 bool LLParser::ParseArrayVectorType(Type *&Result, bool isVector) {
1786 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
1787 Lex.getAPSIntVal().getBitWidth() > 64)
1788 return TokError("expected number in address space");
1790 LocTy SizeLoc = Lex.getLoc();
1791 uint64_t Size = Lex.getAPSIntVal().getZExtValue();
1794 if (ParseToken(lltok::kw_x, "expected 'x' after element count"))
1797 LocTy TypeLoc = Lex.getLoc();
1799 if (ParseType(EltTy)) return true;
1801 if (ParseToken(isVector ? lltok::greater : lltok::rsquare,
1802 "expected end of sequential type"))
1807 return Error(SizeLoc, "zero element vector is illegal");
1808 if ((unsigned)Size != Size)
1809 return Error(SizeLoc, "size too large for vector");
1810 if (!VectorType::isValidElementType(EltTy))
1811 return Error(TypeLoc, "invalid vector element type");
1812 Result = VectorType::get(EltTy, unsigned(Size));
1814 if (!ArrayType::isValidElementType(EltTy))
1815 return Error(TypeLoc, "invalid array element type");
1816 Result = ArrayType::get(EltTy, Size);
1821 //===----------------------------------------------------------------------===//
1822 // Function Semantic Analysis.
1823 //===----------------------------------------------------------------------===//
1825 LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f,
1827 : P(p), F(f), FunctionNumber(functionNumber) {
1829 // Insert unnamed arguments into the NumberedVals list.
1830 for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end();
1833 NumberedVals.push_back(AI);
1836 LLParser::PerFunctionState::~PerFunctionState() {
1837 // If there were any forward referenced non-basicblock values, delete them.
1838 for (std::map<std::string, std::pair<Value*, LocTy> >::iterator
1839 I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
1840 if (!isa<BasicBlock>(I->second.first)) {
1841 I->second.first->replaceAllUsesWith(
1842 UndefValue::get(I->second.first->getType()));
1843 delete I->second.first;
1844 I->second.first = 0;
1847 for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator
1848 I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
1849 if (!isa<BasicBlock>(I->second.first)) {
1850 I->second.first->replaceAllUsesWith(
1851 UndefValue::get(I->second.first->getType()));
1852 delete I->second.first;
1853 I->second.first = 0;
1857 bool LLParser::PerFunctionState::FinishFunction() {
1858 // Check to see if someone took the address of labels in this block.
1859 if (!P.ForwardRefBlockAddresses.empty()) {
1861 if (!F.getName().empty()) {
1862 FunctionID.Kind = ValID::t_GlobalName;
1863 FunctionID.StrVal = F.getName();
1865 FunctionID.Kind = ValID::t_GlobalID;
1866 FunctionID.UIntVal = FunctionNumber;
1869 std::map<ValID, std::vector<std::pair<ValID, GlobalValue*> > >::iterator
1870 FRBAI = P.ForwardRefBlockAddresses.find(FunctionID);
1871 if (FRBAI != P.ForwardRefBlockAddresses.end()) {
1872 // Resolve all these references.
1873 if (P.ResolveForwardRefBlockAddresses(&F, FRBAI->second, this))
1876 P.ForwardRefBlockAddresses.erase(FRBAI);
1880 if (!ForwardRefVals.empty())
1881 return P.Error(ForwardRefVals.begin()->second.second,
1882 "use of undefined value '%" + ForwardRefVals.begin()->first +
1884 if (!ForwardRefValIDs.empty())
1885 return P.Error(ForwardRefValIDs.begin()->second.second,
1886 "use of undefined value '%" +
1887 Twine(ForwardRefValIDs.begin()->first) + "'");
1892 /// GetVal - Get a value with the specified name or ID, creating a
1893 /// forward reference record if needed. This can return null if the value
1894 /// exists but does not have the right type.
1895 Value *LLParser::PerFunctionState::GetVal(const std::string &Name,
1896 Type *Ty, LocTy Loc) {
1897 // Look this name up in the normal function symbol table.
1898 Value *Val = F.getValueSymbolTable().lookup(Name);
1900 // If this is a forward reference for the value, see if we already created a
1901 // forward ref record.
1903 std::map<std::string, std::pair<Value*, LocTy> >::iterator
1904 I = ForwardRefVals.find(Name);
1905 if (I != ForwardRefVals.end())
1906 Val = I->second.first;
1909 // If we have the value in the symbol table or fwd-ref table, return it.
1911 if (Val->getType() == Ty) return Val;
1912 if (Ty->isLabelTy())
1913 P.Error(Loc, "'%" + Name + "' is not a basic block");
1915 P.Error(Loc, "'%" + Name + "' defined with type '" +
1916 getTypeString(Val->getType()) + "'");
1920 // Don't make placeholders with invalid type.
1921 if (!Ty->isFirstClassType() && !Ty->isLabelTy()) {
1922 P.Error(Loc, "invalid use of a non-first-class type");
1926 // Otherwise, create a new forward reference for this value and remember it.
1928 if (Ty->isLabelTy())
1929 FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
1931 FwdVal = new Argument(Ty, Name);
1933 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
1937 Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty,
1939 // Look this name up in the normal function symbol table.
1940 Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0;
1942 // If this is a forward reference for the value, see if we already created a
1943 // forward ref record.
1945 std::map<unsigned, std::pair<Value*, LocTy> >::iterator
1946 I = ForwardRefValIDs.find(ID);
1947 if (I != ForwardRefValIDs.end())
1948 Val = I->second.first;
1951 // If we have the value in the symbol table or fwd-ref table, return it.
1953 if (Val->getType() == Ty) return Val;
1954 if (Ty->isLabelTy())
1955 P.Error(Loc, "'%" + Twine(ID) + "' is not a basic block");
1957 P.Error(Loc, "'%" + Twine(ID) + "' defined with type '" +
1958 getTypeString(Val->getType()) + "'");
1962 if (!Ty->isFirstClassType() && !Ty->isLabelTy()) {
1963 P.Error(Loc, "invalid use of a non-first-class type");
1967 // Otherwise, create a new forward reference for this value and remember it.
1969 if (Ty->isLabelTy())
1970 FwdVal = BasicBlock::Create(F.getContext(), "", &F);
1972 FwdVal = new Argument(Ty);
1974 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
1978 /// SetInstName - After an instruction is parsed and inserted into its
1979 /// basic block, this installs its name.
1980 bool LLParser::PerFunctionState::SetInstName(int NameID,
1981 const std::string &NameStr,
1982 LocTy NameLoc, Instruction *Inst) {
1983 // If this instruction has void type, it cannot have a name or ID specified.
1984 if (Inst->getType()->isVoidTy()) {
1985 if (NameID != -1 || !NameStr.empty())
1986 return P.Error(NameLoc, "instructions returning void cannot have a name");
1990 // If this was a numbered instruction, verify that the instruction is the
1991 // expected value and resolve any forward references.
1992 if (NameStr.empty()) {
1993 // If neither a name nor an ID was specified, just use the next ID.
1995 NameID = NumberedVals.size();
1997 if (unsigned(NameID) != NumberedVals.size())
1998 return P.Error(NameLoc, "instruction expected to be numbered '%" +
1999 Twine(NumberedVals.size()) + "'");
2001 std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI =
2002 ForwardRefValIDs.find(NameID);
2003 if (FI != ForwardRefValIDs.end()) {
2004 if (FI->second.first->getType() != Inst->getType())
2005 return P.Error(NameLoc, "instruction forward referenced with type '" +
2006 getTypeString(FI->second.first->getType()) + "'");
2007 FI->second.first->replaceAllUsesWith(Inst);
2008 delete FI->second.first;
2009 ForwardRefValIDs.erase(FI);
2012 NumberedVals.push_back(Inst);
2016 // Otherwise, the instruction had a name. Resolve forward refs and set it.
2017 std::map<std::string, std::pair<Value*, LocTy> >::iterator
2018 FI = ForwardRefVals.find(NameStr);
2019 if (FI != ForwardRefVals.end()) {
2020 if (FI->second.first->getType() != Inst->getType())
2021 return P.Error(NameLoc, "instruction forward referenced with type '" +
2022 getTypeString(FI->second.first->getType()) + "'");
2023 FI->second.first->replaceAllUsesWith(Inst);
2024 delete FI->second.first;
2025 ForwardRefVals.erase(FI);
2028 // Set the name on the instruction.
2029 Inst->setName(NameStr);
2031 if (Inst->getName() != NameStr)
2032 return P.Error(NameLoc, "multiple definition of local value named '" +
2037 /// GetBB - Get a basic block with the specified name or ID, creating a
2038 /// forward reference record if needed.
2039 BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name,
2041 return cast_or_null<BasicBlock>(GetVal(Name,
2042 Type::getLabelTy(F.getContext()), Loc));
2045 BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) {
2046 return cast_or_null<BasicBlock>(GetVal(ID,
2047 Type::getLabelTy(F.getContext()), Loc));
2050 /// DefineBB - Define the specified basic block, which is either named or
2051 /// unnamed. If there is an error, this returns null otherwise it returns
2052 /// the block being defined.
2053 BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name,
2057 BB = GetBB(NumberedVals.size(), Loc);
2059 BB = GetBB(Name, Loc);
2060 if (BB == 0) return 0; // Already diagnosed error.
2062 // Move the block to the end of the function. Forward ref'd blocks are
2063 // inserted wherever they happen to be referenced.
2064 F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
2066 // Remove the block from forward ref sets.
2068 ForwardRefValIDs.erase(NumberedVals.size());
2069 NumberedVals.push_back(BB);
2071 // BB forward references are already in the function symbol table.
2072 ForwardRefVals.erase(Name);
2078 //===----------------------------------------------------------------------===//
2080 //===----------------------------------------------------------------------===//
2082 /// ParseValID - Parse an abstract value that doesn't necessarily have a
2083 /// type implied. For example, if we parse "4" we don't know what integer type
2084 /// it has. The value will later be combined with its type and checked for
2085 /// sanity. PFS is used to convert function-local operands of metadata (since
2086 /// metadata operands are not just parsed here but also converted to values).
2087 /// PFS can be null when we are not parsing metadata values inside a function.
2088 bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) {
2089 ID.Loc = Lex.getLoc();
2090 switch (Lex.getKind()) {
2091 default: return TokError("expected value token");
2092 case lltok::GlobalID: // @42
2093 ID.UIntVal = Lex.getUIntVal();
2094 ID.Kind = ValID::t_GlobalID;
2096 case lltok::GlobalVar: // @foo
2097 ID.StrVal = Lex.getStrVal();
2098 ID.Kind = ValID::t_GlobalName;
2100 case lltok::LocalVarID: // %42
2101 ID.UIntVal = Lex.getUIntVal();
2102 ID.Kind = ValID::t_LocalID;
2104 case lltok::LocalVar: // %foo
2105 ID.StrVal = Lex.getStrVal();
2106 ID.Kind = ValID::t_LocalName;
2108 case lltok::exclaim: // !42, !{...}, or !"foo"
2109 return ParseMetadataValue(ID, PFS);
2111 ID.APSIntVal = Lex.getAPSIntVal();
2112 ID.Kind = ValID::t_APSInt;
2114 case lltok::APFloat:
2115 ID.APFloatVal = Lex.getAPFloatVal();
2116 ID.Kind = ValID::t_APFloat;
2118 case lltok::kw_true:
2119 ID.ConstantVal = ConstantInt::getTrue(Context);
2120 ID.Kind = ValID::t_Constant;
2122 case lltok::kw_false:
2123 ID.ConstantVal = ConstantInt::getFalse(Context);
2124 ID.Kind = ValID::t_Constant;
2126 case lltok::kw_null: ID.Kind = ValID::t_Null; break;
2127 case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
2128 case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
2130 case lltok::lbrace: {
2131 // ValID ::= '{' ConstVector '}'
2133 SmallVector<Constant*, 16> Elts;
2134 if (ParseGlobalValueVector(Elts) ||
2135 ParseToken(lltok::rbrace, "expected end of struct constant"))
2138 ID.ConstantStructElts = new Constant*[Elts.size()];
2139 ID.UIntVal = Elts.size();
2140 memcpy(ID.ConstantStructElts, Elts.data(), Elts.size()*sizeof(Elts[0]));
2141 ID.Kind = ValID::t_ConstantStruct;
2145 // ValID ::= '<' ConstVector '>' --> Vector.
2146 // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct.
2148 bool isPackedStruct = EatIfPresent(lltok::lbrace);
2150 SmallVector<Constant*, 16> Elts;
2151 LocTy FirstEltLoc = Lex.getLoc();
2152 if (ParseGlobalValueVector(Elts) ||
2154 ParseToken(lltok::rbrace, "expected end of packed struct")) ||
2155 ParseToken(lltok::greater, "expected end of constant"))
2158 if (isPackedStruct) {
2159 ID.ConstantStructElts = new Constant*[Elts.size()];
2160 memcpy(ID.ConstantStructElts, Elts.data(), Elts.size()*sizeof(Elts[0]));
2161 ID.UIntVal = Elts.size();
2162 ID.Kind = ValID::t_PackedConstantStruct;
2167 return Error(ID.Loc, "constant vector must not be empty");
2169 if (!Elts[0]->getType()->isIntegerTy() &&
2170 !Elts[0]->getType()->isFloatingPointTy() &&
2171 !Elts[0]->getType()->isPointerTy())
2172 return Error(FirstEltLoc,
2173 "vector elements must have integer, pointer or floating point type");
2175 // Verify that all the vector elements have the same type.
2176 for (unsigned i = 1, e = Elts.size(); i != e; ++i)
2177 if (Elts[i]->getType() != Elts[0]->getType())
2178 return Error(FirstEltLoc,
2179 "vector element #" + Twine(i) +
2180 " is not of type '" + getTypeString(Elts[0]->getType()));
2182 ID.ConstantVal = ConstantVector::get(Elts);
2183 ID.Kind = ValID::t_Constant;
2186 case lltok::lsquare: { // Array Constant
2188 SmallVector<Constant*, 16> Elts;
2189 LocTy FirstEltLoc = Lex.getLoc();
2190 if (ParseGlobalValueVector(Elts) ||
2191 ParseToken(lltok::rsquare, "expected end of array constant"))
2194 // Handle empty element.
2196 // Use undef instead of an array because it's inconvenient to determine
2197 // the element type at this point, there being no elements to examine.
2198 ID.Kind = ValID::t_EmptyArray;
2202 if (!Elts[0]->getType()->isFirstClassType())
2203 return Error(FirstEltLoc, "invalid array element type: " +
2204 getTypeString(Elts[0]->getType()));
2206 ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
2208 // Verify all elements are correct type!
2209 for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
2210 if (Elts[i]->getType() != Elts[0]->getType())
2211 return Error(FirstEltLoc,
2212 "array element #" + Twine(i) +
2213 " is not of type '" + getTypeString(Elts[0]->getType()));
2216 ID.ConstantVal = ConstantArray::get(ATy, Elts);
2217 ID.Kind = ValID::t_Constant;
2220 case lltok::kw_c: // c "foo"
2222 ID.ConstantVal = ConstantDataArray::getString(Context, Lex.getStrVal(),
2224 if (ParseToken(lltok::StringConstant, "expected string")) return true;
2225 ID.Kind = ValID::t_Constant;
2228 case lltok::kw_asm: {
2229 // ValID ::= 'asm' SideEffect? AlignStack? STRINGCONSTANT ',' STRINGCONSTANT
2230 bool HasSideEffect, AlignStack, AsmDialect;
2232 if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
2233 ParseOptionalToken(lltok::kw_alignstack, AlignStack) ||
2234 ParseOptionalToken(lltok::kw_inteldialect, AsmDialect) ||
2235 ParseStringConstant(ID.StrVal) ||
2236 ParseToken(lltok::comma, "expected comma in inline asm expression") ||
2237 ParseToken(lltok::StringConstant, "expected constraint string"))
2239 ID.StrVal2 = Lex.getStrVal();
2240 ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1) |
2241 (unsigned(AsmDialect)<<2);
2242 ID.Kind = ValID::t_InlineAsm;
2246 case lltok::kw_blockaddress: {
2247 // ValID ::= 'blockaddress' '(' @foo ',' %bar ')'
2251 LocTy FnLoc, LabelLoc;
2253 if (ParseToken(lltok::lparen, "expected '(' in block address expression") ||
2255 ParseToken(lltok::comma, "expected comma in block address expression")||
2256 ParseValID(Label) ||
2257 ParseToken(lltok::rparen, "expected ')' in block address expression"))
2260 if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
2261 return Error(Fn.Loc, "expected function name in blockaddress");
2262 if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
2263 return Error(Label.Loc, "expected basic block name in blockaddress");
2265 // Make a global variable as a placeholder for this reference.
2266 GlobalVariable *FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context),
2267 false, GlobalValue::InternalLinkage,
2269 ForwardRefBlockAddresses[Fn].push_back(std::make_pair(Label, FwdRef));
2270 ID.ConstantVal = FwdRef;
2271 ID.Kind = ValID::t_Constant;
2275 case lltok::kw_trunc:
2276 case lltok::kw_zext:
2277 case lltok::kw_sext:
2278 case lltok::kw_fptrunc:
2279 case lltok::kw_fpext:
2280 case lltok::kw_bitcast:
2281 case lltok::kw_uitofp:
2282 case lltok::kw_sitofp:
2283 case lltok::kw_fptoui:
2284 case lltok::kw_fptosi:
2285 case lltok::kw_inttoptr:
2286 case lltok::kw_ptrtoint: {
2287 unsigned Opc = Lex.getUIntVal();
2291 if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
2292 ParseGlobalTypeAndValue(SrcVal) ||
2293 ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
2294 ParseType(DestTy) ||
2295 ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
2297 if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
2298 return Error(ID.Loc, "invalid cast opcode for cast from '" +
2299 getTypeString(SrcVal->getType()) + "' to '" +
2300 getTypeString(DestTy) + "'");
2301 ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
2303 ID.Kind = ValID::t_Constant;
2306 case lltok::kw_extractvalue: {
2309 SmallVector<unsigned, 4> Indices;
2310 if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")||
2311 ParseGlobalTypeAndValue(Val) ||
2312 ParseIndexList(Indices) ||
2313 ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
2316 if (!Val->getType()->isAggregateType())
2317 return Error(ID.Loc, "extractvalue operand must be aggregate type");
2318 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
2319 return Error(ID.Loc, "invalid indices for extractvalue");
2320 ID.ConstantVal = ConstantExpr::getExtractValue(Val, Indices);
2321 ID.Kind = ValID::t_Constant;
2324 case lltok::kw_insertvalue: {
2326 Constant *Val0, *Val1;
2327 SmallVector<unsigned, 4> Indices;
2328 if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")||
2329 ParseGlobalTypeAndValue(Val0) ||
2330 ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")||
2331 ParseGlobalTypeAndValue(Val1) ||
2332 ParseIndexList(Indices) ||
2333 ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
2335 if (!Val0->getType()->isAggregateType())
2336 return Error(ID.Loc, "insertvalue operand must be aggregate type");
2337 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices))
2338 return Error(ID.Loc, "invalid indices for insertvalue");
2339 ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, Indices);
2340 ID.Kind = ValID::t_Constant;
2343 case lltok::kw_icmp:
2344 case lltok::kw_fcmp: {
2345 unsigned PredVal, Opc = Lex.getUIntVal();
2346 Constant *Val0, *Val1;
2348 if (ParseCmpPredicate(PredVal, Opc) ||
2349 ParseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
2350 ParseGlobalTypeAndValue(Val0) ||
2351 ParseToken(lltok::comma, "expected comma in compare constantexpr") ||
2352 ParseGlobalTypeAndValue(Val1) ||
2353 ParseToken(lltok::rparen, "expected ')' in compare constantexpr"))
2356 if (Val0->getType() != Val1->getType())
2357 return Error(ID.Loc, "compare operands must have the same type");
2359 CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
2361 if (Opc == Instruction::FCmp) {
2362 if (!Val0->getType()->isFPOrFPVectorTy())
2363 return Error(ID.Loc, "fcmp requires floating point operands");
2364 ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
2366 assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
2367 if (!Val0->getType()->isIntOrIntVectorTy() &&
2368 !Val0->getType()->getScalarType()->isPointerTy())
2369 return Error(ID.Loc, "icmp requires pointer or integer operands");
2370 ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
2372 ID.Kind = ValID::t_Constant;
2376 // Binary Operators.
2378 case lltok::kw_fadd:
2380 case lltok::kw_fsub:
2382 case lltok::kw_fmul:
2383 case lltok::kw_udiv:
2384 case lltok::kw_sdiv:
2385 case lltok::kw_fdiv:
2386 case lltok::kw_urem:
2387 case lltok::kw_srem:
2388 case lltok::kw_frem:
2390 case lltok::kw_lshr:
2391 case lltok::kw_ashr: {
2395 unsigned Opc = Lex.getUIntVal();
2396 Constant *Val0, *Val1;
2398 LocTy ModifierLoc = Lex.getLoc();
2399 if (Opc == Instruction::Add || Opc == Instruction::Sub ||
2400 Opc == Instruction::Mul || Opc == Instruction::Shl) {
2401 if (EatIfPresent(lltok::kw_nuw))
2403 if (EatIfPresent(lltok::kw_nsw)) {
2405 if (EatIfPresent(lltok::kw_nuw))
2408 } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
2409 Opc == Instruction::LShr || Opc == Instruction::AShr) {
2410 if (EatIfPresent(lltok::kw_exact))
2413 if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
2414 ParseGlobalTypeAndValue(Val0) ||
2415 ParseToken(lltok::comma, "expected comma in binary constantexpr") ||
2416 ParseGlobalTypeAndValue(Val1) ||
2417 ParseToken(lltok::rparen, "expected ')' in binary constantexpr"))
2419 if (Val0->getType() != Val1->getType())
2420 return Error(ID.Loc, "operands of constexpr must have same type");
2421 if (!Val0->getType()->isIntOrIntVectorTy()) {
2423 return Error(ModifierLoc, "nuw only applies to integer operations");
2425 return Error(ModifierLoc, "nsw only applies to integer operations");
2427 // Check that the type is valid for the operator.
2429 case Instruction::Add:
2430 case Instruction::Sub:
2431 case Instruction::Mul:
2432 case Instruction::UDiv:
2433 case Instruction::SDiv:
2434 case Instruction::URem:
2435 case Instruction::SRem:
2436 case Instruction::Shl:
2437 case Instruction::AShr:
2438 case Instruction::LShr:
2439 if (!Val0->getType()->isIntOrIntVectorTy())
2440 return Error(ID.Loc, "constexpr requires integer operands");
2442 case Instruction::FAdd:
2443 case Instruction::FSub:
2444 case Instruction::FMul:
2445 case Instruction::FDiv:
2446 case Instruction::FRem:
2447 if (!Val0->getType()->isFPOrFPVectorTy())
2448 return Error(ID.Loc, "constexpr requires fp operands");
2450 default: llvm_unreachable("Unknown binary operator!");
2453 if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
2454 if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap;
2455 if (Exact) Flags |= PossiblyExactOperator::IsExact;
2456 Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
2458 ID.Kind = ValID::t_Constant;
2462 // Logical Operations
2465 case lltok::kw_xor: {
2466 unsigned Opc = Lex.getUIntVal();
2467 Constant *Val0, *Val1;
2469 if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
2470 ParseGlobalTypeAndValue(Val0) ||
2471 ParseToken(lltok::comma, "expected comma in logical constantexpr") ||
2472 ParseGlobalTypeAndValue(Val1) ||
2473 ParseToken(lltok::rparen, "expected ')' in logical constantexpr"))
2475 if (Val0->getType() != Val1->getType())
2476 return Error(ID.Loc, "operands of constexpr must have same type");
2477 if (!Val0->getType()->isIntOrIntVectorTy())
2478 return Error(ID.Loc,
2479 "constexpr requires integer or integer vector operands");
2480 ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
2481 ID.Kind = ValID::t_Constant;
2485 case lltok::kw_getelementptr:
2486 case lltok::kw_shufflevector:
2487 case lltok::kw_insertelement:
2488 case lltok::kw_extractelement:
2489 case lltok::kw_select: {
2490 unsigned Opc = Lex.getUIntVal();
2491 SmallVector<Constant*, 16> Elts;
2492 bool InBounds = false;
2494 if (Opc == Instruction::GetElementPtr)
2495 InBounds = EatIfPresent(lltok::kw_inbounds);
2496 if (ParseToken(lltok::lparen, "expected '(' in constantexpr") ||
2497 ParseGlobalValueVector(Elts) ||
2498 ParseToken(lltok::rparen, "expected ')' in constantexpr"))
2501 if (Opc == Instruction::GetElementPtr) {
2502 if (Elts.size() == 0 ||
2503 !Elts[0]->getType()->getScalarType()->isPointerTy())
2504 return Error(ID.Loc, "getelementptr requires pointer operand");
2506 ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
2507 if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(), Indices))
2508 return Error(ID.Loc, "invalid indices for getelementptr");
2509 ID.ConstantVal = ConstantExpr::getGetElementPtr(Elts[0], Indices,
2511 } else if (Opc == Instruction::Select) {
2512 if (Elts.size() != 3)
2513 return Error(ID.Loc, "expected three operands to select");
2514 if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
2516 return Error(ID.Loc, Reason);
2517 ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
2518 } else if (Opc == Instruction::ShuffleVector) {
2519 if (Elts.size() != 3)
2520 return Error(ID.Loc, "expected three operands to shufflevector");
2521 if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2522 return Error(ID.Loc, "invalid operands to shufflevector");
2524 ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]);
2525 } else if (Opc == Instruction::ExtractElement) {
2526 if (Elts.size() != 2)
2527 return Error(ID.Loc, "expected two operands to extractelement");
2528 if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
2529 return Error(ID.Loc, "invalid extractelement operands");
2530 ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
2532 assert(Opc == Instruction::InsertElement && "Unknown opcode");
2533 if (Elts.size() != 3)
2534 return Error(ID.Loc, "expected three operands to insertelement");
2535 if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2536 return Error(ID.Loc, "invalid insertelement operands");
2538 ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
2541 ID.Kind = ValID::t_Constant;
2550 /// ParseGlobalValue - Parse a global value with the specified type.
2551 bool LLParser::ParseGlobalValue(Type *Ty, Constant *&C) {
2555 bool Parsed = ParseValID(ID) ||
2556 ConvertValIDToValue(Ty, ID, V, NULL);
2557 if (V && !(C = dyn_cast<Constant>(V)))
2558 return Error(ID.Loc, "global values must be constants");
2562 bool LLParser::ParseGlobalTypeAndValue(Constant *&V) {
2564 return ParseType(Ty) ||
2565 ParseGlobalValue(Ty, V);
2568 /// ParseGlobalValueVector
2570 /// ::= TypeAndValue (',' TypeAndValue)*
2571 bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts) {
2573 if (Lex.getKind() == lltok::rbrace ||
2574 Lex.getKind() == lltok::rsquare ||
2575 Lex.getKind() == lltok::greater ||
2576 Lex.getKind() == lltok::rparen)
2580 if (ParseGlobalTypeAndValue(C)) return true;
2583 while (EatIfPresent(lltok::comma)) {
2584 if (ParseGlobalTypeAndValue(C)) return true;
2591 bool LLParser::ParseMetadataListValue(ValID &ID, PerFunctionState *PFS) {
2592 assert(Lex.getKind() == lltok::lbrace);
2595 SmallVector<Value*, 16> Elts;
2596 if (ParseMDNodeVector(Elts, PFS) ||
2597 ParseToken(lltok::rbrace, "expected end of metadata node"))
2600 ID.MDNodeVal = MDNode::get(Context, Elts);
2601 ID.Kind = ValID::t_MDNode;
2605 /// ParseMetadataValue
2609 bool LLParser::ParseMetadataValue(ValID &ID, PerFunctionState *PFS) {
2610 assert(Lex.getKind() == lltok::exclaim);
2615 if (Lex.getKind() == lltok::lbrace)
2616 return ParseMetadataListValue(ID, PFS);
2618 // Standalone metadata reference
2620 if (Lex.getKind() == lltok::APSInt) {
2621 if (ParseMDNodeID(ID.MDNodeVal)) return true;
2622 ID.Kind = ValID::t_MDNode;
2627 // ::= '!' STRINGCONSTANT
2628 if (ParseMDString(ID.MDStringVal)) return true;
2629 ID.Kind = ValID::t_MDString;
2634 //===----------------------------------------------------------------------===//
2635 // Function Parsing.
2636 //===----------------------------------------------------------------------===//
2638 bool LLParser::ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
2639 PerFunctionState *PFS) {
2640 if (Ty->isFunctionTy())
2641 return Error(ID.Loc, "functions are not values, refer to them as pointers");
2644 case ValID::t_LocalID:
2645 if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
2646 V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc);
2648 case ValID::t_LocalName:
2649 if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
2650 V = PFS->GetVal(ID.StrVal, Ty, ID.Loc);
2652 case ValID::t_InlineAsm: {
2653 PointerType *PTy = dyn_cast<PointerType>(Ty);
2655 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
2656 if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2))
2657 return Error(ID.Loc, "invalid type for inline asm constraint string");
2658 V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1,
2659 (ID.UIntVal>>1)&1, (InlineAsm::AsmDialect(ID.UIntVal>>2)));
2662 case ValID::t_MDNode:
2663 if (!Ty->isMetadataTy())
2664 return Error(ID.Loc, "metadata value must have metadata type");
2667 case ValID::t_MDString:
2668 if (!Ty->isMetadataTy())
2669 return Error(ID.Loc, "metadata value must have metadata type");
2672 case ValID::t_GlobalName:
2673 V = GetGlobalVal(ID.StrVal, Ty, ID.Loc);
2675 case ValID::t_GlobalID:
2676 V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc);
2678 case ValID::t_APSInt:
2679 if (!Ty->isIntegerTy())
2680 return Error(ID.Loc, "integer constant must have integer type");
2681 ID.APSIntVal = ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
2682 V = ConstantInt::get(Context, ID.APSIntVal);
2684 case ValID::t_APFloat:
2685 if (!Ty->isFloatingPointTy() ||
2686 !ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
2687 return Error(ID.Loc, "floating point constant invalid for type");
2689 // The lexer has no type info, so builds all half, float, and double FP
2690 // constants as double. Fix this here. Long double does not need this.
2691 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble) {
2694 ID.APFloatVal.convert(APFloat::IEEEhalf, APFloat::rmNearestTiesToEven,
2696 else if (Ty->isFloatTy())
2697 ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
2700 V = ConstantFP::get(Context, ID.APFloatVal);
2702 if (V->getType() != Ty)
2703 return Error(ID.Loc, "floating point constant does not have type '" +
2704 getTypeString(Ty) + "'");
2708 if (!Ty->isPointerTy())
2709 return Error(ID.Loc, "null must be a pointer type");
2710 V = ConstantPointerNull::get(cast<PointerType>(Ty));
2712 case ValID::t_Undef:
2713 // FIXME: LabelTy should not be a first-class type.
2714 if (!Ty->isFirstClassType() || Ty->isLabelTy())
2715 return Error(ID.Loc, "invalid type for undef constant");
2716 V = UndefValue::get(Ty);
2718 case ValID::t_EmptyArray:
2719 if (!Ty->isArrayTy() || cast<ArrayType>(Ty)->getNumElements() != 0)
2720 return Error(ID.Loc, "invalid empty array initializer");
2721 V = UndefValue::get(Ty);
2724 // FIXME: LabelTy should not be a first-class type.
2725 if (!Ty->isFirstClassType() || Ty->isLabelTy())
2726 return Error(ID.Loc, "invalid type for null constant");
2727 V = Constant::getNullValue(Ty);
2729 case ValID::t_Constant:
2730 if (ID.ConstantVal->getType() != Ty)
2731 return Error(ID.Loc, "constant expression type mismatch");
2735 case ValID::t_ConstantStruct:
2736 case ValID::t_PackedConstantStruct:
2737 if (StructType *ST = dyn_cast<StructType>(Ty)) {
2738 if (ST->getNumElements() != ID.UIntVal)
2739 return Error(ID.Loc,
2740 "initializer with struct type has wrong # elements");
2741 if (ST->isPacked() != (ID.Kind == ValID::t_PackedConstantStruct))
2742 return Error(ID.Loc, "packed'ness of initializer and type don't match");
2744 // Verify that the elements are compatible with the structtype.
2745 for (unsigned i = 0, e = ID.UIntVal; i != e; ++i)
2746 if (ID.ConstantStructElts[i]->getType() != ST->getElementType(i))
2747 return Error(ID.Loc, "element " + Twine(i) +
2748 " of struct initializer doesn't match struct element type");
2750 V = ConstantStruct::get(ST, makeArrayRef(ID.ConstantStructElts,
2753 return Error(ID.Loc, "constant expression type mismatch");
2756 llvm_unreachable("Invalid ValID");
2759 bool LLParser::ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
2762 return ParseValID(ID, PFS) ||
2763 ConvertValIDToValue(Ty, ID, V, PFS);
2766 bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState *PFS) {
2768 return ParseType(Ty) ||
2769 ParseValue(Ty, V, PFS);
2772 bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
2773 PerFunctionState &PFS) {
2776 if (ParseTypeAndValue(V, PFS)) return true;
2777 if (!isa<BasicBlock>(V))
2778 return Error(Loc, "expected a basic block");
2779 BB = cast<BasicBlock>(V);
2785 /// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs
2786 /// OptUnnamedAddr Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection
2787 /// OptionalAlign OptGC
2788 bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
2789 // Parse the linkage.
2790 LocTy LinkageLoc = Lex.getLoc();
2793 unsigned Visibility;
2794 AttrBuilder RetAttrs;
2797 LocTy RetTypeLoc = Lex.getLoc();
2798 if (ParseOptionalLinkage(Linkage) ||
2799 ParseOptionalVisibility(Visibility) ||
2800 ParseOptionalCallingConv(CC) ||
2801 ParseOptionalReturnAttrs(RetAttrs) ||
2802 ParseType(RetType, RetTypeLoc, true /*void allowed*/))
2805 // Verify that the linkage is ok.
2806 switch ((GlobalValue::LinkageTypes)Linkage) {
2807 case GlobalValue::ExternalLinkage:
2808 break; // always ok.
2809 case GlobalValue::DLLImportLinkage:
2810 case GlobalValue::ExternalWeakLinkage:
2812 return Error(LinkageLoc, "invalid linkage for function definition");
2814 case GlobalValue::PrivateLinkage:
2815 case GlobalValue::LinkerPrivateLinkage:
2816 case GlobalValue::LinkerPrivateWeakLinkage:
2817 case GlobalValue::InternalLinkage:
2818 case GlobalValue::AvailableExternallyLinkage:
2819 case GlobalValue::LinkOnceAnyLinkage:
2820 case GlobalValue::LinkOnceODRLinkage:
2821 case GlobalValue::LinkOnceODRAutoHideLinkage:
2822 case GlobalValue::WeakAnyLinkage:
2823 case GlobalValue::WeakODRLinkage:
2824 case GlobalValue::DLLExportLinkage:
2826 return Error(LinkageLoc, "invalid linkage for function declaration");
2828 case GlobalValue::AppendingLinkage:
2829 case GlobalValue::CommonLinkage:
2830 return Error(LinkageLoc, "invalid function linkage type");
2833 if (!FunctionType::isValidReturnType(RetType))
2834 return Error(RetTypeLoc, "invalid function return type");
2836 LocTy NameLoc = Lex.getLoc();
2838 std::string FunctionName;
2839 if (Lex.getKind() == lltok::GlobalVar) {
2840 FunctionName = Lex.getStrVal();
2841 } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok.
2842 unsigned NameID = Lex.getUIntVal();
2844 if (NameID != NumberedVals.size())
2845 return TokError("function expected to be numbered '%" +
2846 Twine(NumberedVals.size()) + "'");
2848 return TokError("expected function name");
2853 if (Lex.getKind() != lltok::lparen)
2854 return TokError("expected '(' in function argument list");
2856 SmallVector<ArgInfo, 8> ArgList;
2858 AttrBuilder FuncAttrs;
2859 std::string Section;
2863 LocTy UnnamedAddrLoc;
2865 if (ParseArgumentList(ArgList, isVarArg) ||
2866 ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr,
2868 ParseFnAttributeValuePairs(FuncAttrs, false) ||
2869 (EatIfPresent(lltok::kw_section) &&
2870 ParseStringConstant(Section)) ||
2871 ParseOptionalAlignment(Alignment) ||
2872 (EatIfPresent(lltok::kw_gc) &&
2873 ParseStringConstant(GC)))
2876 // If the alignment was parsed as an attribute, move to the alignment field.
2877 if (FuncAttrs.hasAlignmentAttr()) {
2878 Alignment = FuncAttrs.getAlignment();
2879 FuncAttrs.removeAttribute(Attribute::Alignment);
2882 // Okay, if we got here, the function is syntactically valid. Convert types
2883 // and do semantic checks.
2884 std::vector<Type*> ParamTypeList;
2885 SmallVector<AttributeSet, 8> Attrs;
2887 if (RetAttrs.hasAttributes())
2888 Attrs.push_back(AttributeSet::get(RetType->getContext(),
2889 AttributeSet::ReturnIndex,
2892 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
2893 ParamTypeList.push_back(ArgList[i].Ty);
2894 if (ArgList[i].Attrs.hasAttributes(i + 1)) {
2895 AttrBuilder B(ArgList[i].Attrs, i + 1);
2896 Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B));
2900 if (FuncAttrs.hasAttributes())
2901 Attrs.push_back(AttributeSet::get(RetType->getContext(),
2902 AttributeSet::FunctionIndex,
2905 AttributeSet PAL = AttributeSet::get(Context, Attrs);
2907 if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy())
2908 return Error(RetTypeLoc, "functions with 'sret' argument must return void");
2911 FunctionType::get(RetType, ParamTypeList, isVarArg);
2912 PointerType *PFT = PointerType::getUnqual(FT);
2915 if (!FunctionName.empty()) {
2916 // If this was a definition of a forward reference, remove the definition
2917 // from the forward reference table and fill in the forward ref.
2918 std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator FRVI =
2919 ForwardRefVals.find(FunctionName);
2920 if (FRVI != ForwardRefVals.end()) {
2921 Fn = M->getFunction(FunctionName);
2923 return Error(FRVI->second.second, "invalid forward reference to "
2924 "function as global value!");
2925 if (Fn->getType() != PFT)
2926 return Error(FRVI->second.second, "invalid forward reference to "
2927 "function '" + FunctionName + "' with wrong type!");
2929 ForwardRefVals.erase(FRVI);
2930 } else if ((Fn = M->getFunction(FunctionName))) {
2931 // Reject redefinitions.
2932 return Error(NameLoc, "invalid redefinition of function '" +
2933 FunctionName + "'");
2934 } else if (M->getNamedValue(FunctionName)) {
2935 return Error(NameLoc, "redefinition of function '@" + FunctionName + "'");
2939 // If this is a definition of a forward referenced function, make sure the
2941 std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator I
2942 = ForwardRefValIDs.find(NumberedVals.size());
2943 if (I != ForwardRefValIDs.end()) {
2944 Fn = cast<Function>(I->second.first);
2945 if (Fn->getType() != PFT)
2946 return Error(NameLoc, "type of definition and forward reference of '@" +
2947 Twine(NumberedVals.size()) + "' disagree");
2948 ForwardRefValIDs.erase(I);
2953 Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
2954 else // Move the forward-reference to the correct spot in the module.
2955 M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
2957 if (FunctionName.empty())
2958 NumberedVals.push_back(Fn);
2960 Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
2961 Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
2962 Fn->setCallingConv(CC);
2963 Fn->setAttributes(PAL);
2964 Fn->setUnnamedAddr(UnnamedAddr);
2965 Fn->setAlignment(Alignment);
2966 Fn->setSection(Section);
2967 if (!GC.empty()) Fn->setGC(GC.c_str());
2969 // Add all of the arguments we parsed to the function.
2970 Function::arg_iterator ArgIt = Fn->arg_begin();
2971 for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
2972 // If the argument has a name, insert it into the argument symbol table.
2973 if (ArgList[i].Name.empty()) continue;
2975 // Set the name, if it conflicted, it will be auto-renamed.
2976 ArgIt->setName(ArgList[i].Name);
2978 if (ArgIt->getName() != ArgList[i].Name)
2979 return Error(ArgList[i].Loc, "redefinition of argument '%" +
2980 ArgList[i].Name + "'");
2987 /// ParseFunctionBody
2988 /// ::= '{' BasicBlock+ '}'
2990 bool LLParser::ParseFunctionBody(Function &Fn) {
2991 if (Lex.getKind() != lltok::lbrace)
2992 return TokError("expected '{' in function body");
2993 Lex.Lex(); // eat the {.
2995 int FunctionNumber = -1;
2996 if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1;
2998 PerFunctionState PFS(*this, Fn, FunctionNumber);
3000 // We need at least one basic block.
3001 if (Lex.getKind() == lltok::rbrace)
3002 return TokError("function body requires at least one basic block");
3004 while (Lex.getKind() != lltok::rbrace)
3005 if (ParseBasicBlock(PFS)) return true;
3010 // Verify function is ok.
3011 return PFS.FinishFunction();
3015 /// ::= LabelStr? Instruction*
3016 bool LLParser::ParseBasicBlock(PerFunctionState &PFS) {
3017 // If this basic block starts out with a name, remember it.
3019 LocTy NameLoc = Lex.getLoc();
3020 if (Lex.getKind() == lltok::LabelStr) {
3021 Name = Lex.getStrVal();
3025 BasicBlock *BB = PFS.DefineBB(Name, NameLoc);
3026 if (BB == 0) return true;
3028 std::string NameStr;
3030 // Parse the instructions in this block until we get a terminator.
3032 SmallVector<std::pair<unsigned, MDNode *>, 4> MetadataOnInst;
3034 // This instruction may have three possibilities for a name: a) none
3035 // specified, b) name specified "%foo =", c) number specified: "%4 =".
3036 LocTy NameLoc = Lex.getLoc();
3040 if (Lex.getKind() == lltok::LocalVarID) {
3041 NameID = Lex.getUIntVal();
3043 if (ParseToken(lltok::equal, "expected '=' after instruction id"))
3045 } else if (Lex.getKind() == lltok::LocalVar) {
3046 NameStr = Lex.getStrVal();
3048 if (ParseToken(lltok::equal, "expected '=' after instruction name"))
3052 switch (ParseInstruction(Inst, BB, PFS)) {
3053 default: llvm_unreachable("Unknown ParseInstruction result!");
3054 case InstError: return true;
3056 BB->getInstList().push_back(Inst);
3058 // With a normal result, we check to see if the instruction is followed by
3059 // a comma and metadata.
3060 if (EatIfPresent(lltok::comma))
3061 if (ParseInstructionMetadata(Inst, &PFS))
3064 case InstExtraComma:
3065 BB->getInstList().push_back(Inst);
3067 // If the instruction parser ate an extra comma at the end of it, it
3068 // *must* be followed by metadata.
3069 if (ParseInstructionMetadata(Inst, &PFS))
3074 // Set the name on the instruction.
3075 if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true;
3076 } while (!isa<TerminatorInst>(Inst));
3081 //===----------------------------------------------------------------------===//
3082 // Instruction Parsing.
3083 //===----------------------------------------------------------------------===//
3085 /// ParseInstruction - Parse one of the many different instructions.
3087 int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB,
3088 PerFunctionState &PFS) {
3089 lltok::Kind Token = Lex.getKind();
3090 if (Token == lltok::Eof)
3091 return TokError("found end of file when expecting more instructions");
3092 LocTy Loc = Lex.getLoc();
3093 unsigned KeywordVal = Lex.getUIntVal();
3094 Lex.Lex(); // Eat the keyword.
3097 default: return Error(Loc, "expected instruction opcode");
3098 // Terminator Instructions.
3099 case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
3100 case lltok::kw_ret: return ParseRet(Inst, BB, PFS);
3101 case lltok::kw_br: return ParseBr(Inst, PFS);
3102 case lltok::kw_switch: return ParseSwitch(Inst, PFS);
3103 case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS);
3104 case lltok::kw_invoke: return ParseInvoke(Inst, PFS);
3105 case lltok::kw_resume: return ParseResume(Inst, PFS);
3106 // Binary Operators.
3110 case lltok::kw_shl: {
3111 bool NUW = EatIfPresent(lltok::kw_nuw);
3112 bool NSW = EatIfPresent(lltok::kw_nsw);
3113 if (!NUW) NUW = EatIfPresent(lltok::kw_nuw);
3115 if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
3117 if (NUW) cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
3118 if (NSW) cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
3121 case lltok::kw_fadd:
3122 case lltok::kw_fsub:
3123 case lltok::kw_fmul:
3124 case lltok::kw_fdiv:
3125 case lltok::kw_frem: {
3126 FastMathFlags FMF = EatFastMathFlagsIfPresent();
3127 int Res = ParseArithmetic(Inst, PFS, KeywordVal, 2);
3131 Inst->setFastMathFlags(FMF);
3135 case lltok::kw_sdiv:
3136 case lltok::kw_udiv:
3137 case lltok::kw_lshr:
3138 case lltok::kw_ashr: {
3139 bool Exact = EatIfPresent(lltok::kw_exact);
3141 if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
3142 if (Exact) cast<BinaryOperator>(Inst)->setIsExact(true);
3146 case lltok::kw_urem:
3147 case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1);
3150 case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal);
3151 case lltok::kw_icmp:
3152 case lltok::kw_fcmp: return ParseCompare(Inst, PFS, KeywordVal);
3154 case lltok::kw_trunc:
3155 case lltok::kw_zext:
3156 case lltok::kw_sext:
3157 case lltok::kw_fptrunc:
3158 case lltok::kw_fpext:
3159 case lltok::kw_bitcast:
3160 case lltok::kw_uitofp:
3161 case lltok::kw_sitofp:
3162 case lltok::kw_fptoui:
3163 case lltok::kw_fptosi:
3164 case lltok::kw_inttoptr:
3165 case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal);
3167 case lltok::kw_select: return ParseSelect(Inst, PFS);
3168 case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS);
3169 case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS);
3170 case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS);
3171 case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS);
3172 case lltok::kw_phi: return ParsePHI(Inst, PFS);
3173 case lltok::kw_landingpad: return ParseLandingPad(Inst, PFS);
3174 case lltok::kw_call: return ParseCall(Inst, PFS, false);
3175 case lltok::kw_tail: return ParseCall(Inst, PFS, true);
3177 case lltok::kw_alloca: return ParseAlloc(Inst, PFS);
3178 case lltok::kw_load: return ParseLoad(Inst, PFS);
3179 case lltok::kw_store: return ParseStore(Inst, PFS);
3180 case lltok::kw_cmpxchg: return ParseCmpXchg(Inst, PFS);
3181 case lltok::kw_atomicrmw: return ParseAtomicRMW(Inst, PFS);
3182 case lltok::kw_fence: return ParseFence(Inst, PFS);
3183 case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS);
3184 case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS);
3185 case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS);
3189 /// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind.
3190 bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) {
3191 if (Opc == Instruction::FCmp) {
3192 switch (Lex.getKind()) {
3193 default: return TokError("expected fcmp predicate (e.g. 'oeq')");
3194 case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
3195 case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
3196 case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
3197 case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break;
3198 case lltok::kw_ole: P = CmpInst::FCMP_OLE; break;
3199 case lltok::kw_oge: P = CmpInst::FCMP_OGE; break;
3200 case lltok::kw_ord: P = CmpInst::FCMP_ORD; break;
3201 case lltok::kw_uno: P = CmpInst::FCMP_UNO; break;
3202 case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break;
3203 case lltok::kw_une: P = CmpInst::FCMP_UNE; break;
3204 case lltok::kw_ult: P = CmpInst::FCMP_ULT; break;
3205 case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break;
3206 case lltok::kw_ule: P = CmpInst::FCMP_ULE; break;
3207 case lltok::kw_uge: P = CmpInst::FCMP_UGE; break;
3208 case lltok::kw_true: P = CmpInst::FCMP_TRUE; break;
3209 case lltok::kw_false: P = CmpInst::FCMP_FALSE; break;
3212 switch (Lex.getKind()) {
3213 default: return TokError("expected icmp predicate (e.g. 'eq')");
3214 case lltok::kw_eq: P = CmpInst::ICMP_EQ; break;
3215 case lltok::kw_ne: P = CmpInst::ICMP_NE; break;
3216 case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
3217 case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break;
3218 case lltok::kw_sle: P = CmpInst::ICMP_SLE; break;
3219 case lltok::kw_sge: P = CmpInst::ICMP_SGE; break;
3220 case lltok::kw_ult: P = CmpInst::ICMP_ULT; break;
3221 case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break;
3222 case lltok::kw_ule: P = CmpInst::ICMP_ULE; break;
3223 case lltok::kw_uge: P = CmpInst::ICMP_UGE; break;
3230 //===----------------------------------------------------------------------===//
3231 // Terminator Instructions.
3232 //===----------------------------------------------------------------------===//
3234 /// ParseRet - Parse a return instruction.
3235 /// ::= 'ret' void (',' !dbg, !1)*
3236 /// ::= 'ret' TypeAndValue (',' !dbg, !1)*
3237 bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB,
3238 PerFunctionState &PFS) {
3239 SMLoc TypeLoc = Lex.getLoc();
3241 if (ParseType(Ty, true /*void allowed*/)) return true;
3243 Type *ResType = PFS.getFunction().getReturnType();
3245 if (Ty->isVoidTy()) {
3246 if (!ResType->isVoidTy())
3247 return Error(TypeLoc, "value doesn't match function result type '" +
3248 getTypeString(ResType) + "'");
3250 Inst = ReturnInst::Create(Context);
3255 if (ParseValue(Ty, RV, PFS)) return true;
3257 if (ResType != RV->getType())
3258 return Error(TypeLoc, "value doesn't match function result type '" +
3259 getTypeString(ResType) + "'");
3261 Inst = ReturnInst::Create(Context, RV);
3267 /// ::= 'br' TypeAndValue
3268 /// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3269 bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) {
3272 BasicBlock *Op1, *Op2;
3273 if (ParseTypeAndValue(Op0, Loc, PFS)) return true;
3275 if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) {
3276 Inst = BranchInst::Create(BB);
3280 if (Op0->getType() != Type::getInt1Ty(Context))
3281 return Error(Loc, "branch condition must have 'i1' type");
3283 if (ParseToken(lltok::comma, "expected ',' after branch condition") ||
3284 ParseTypeAndBasicBlock(Op1, Loc, PFS) ||
3285 ParseToken(lltok::comma, "expected ',' after true destination") ||
3286 ParseTypeAndBasicBlock(Op2, Loc2, PFS))
3289 Inst = BranchInst::Create(Op1, Op2, Op0);
3295 /// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']'
3297 /// ::= (TypeAndValue ',' TypeAndValue)*
3298 bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
3299 LocTy CondLoc, BBLoc;
3301 BasicBlock *DefaultBB;
3302 if (ParseTypeAndValue(Cond, CondLoc, PFS) ||
3303 ParseToken(lltok::comma, "expected ',' after switch condition") ||
3304 ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
3305 ParseToken(lltok::lsquare, "expected '[' with switch table"))
3308 if (!Cond->getType()->isIntegerTy())
3309 return Error(CondLoc, "switch condition must have integer type");
3311 // Parse the jump table pairs.
3312 SmallPtrSet<Value*, 32> SeenCases;
3313 SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
3314 while (Lex.getKind() != lltok::rsquare) {
3318 if (ParseTypeAndValue(Constant, CondLoc, PFS) ||
3319 ParseToken(lltok::comma, "expected ',' after case value") ||
3320 ParseTypeAndBasicBlock(DestBB, PFS))
3323 if (!SeenCases.insert(Constant))
3324 return Error(CondLoc, "duplicate case value in switch");
3325 if (!isa<ConstantInt>(Constant))
3326 return Error(CondLoc, "case value is not a constant integer");
3328 Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
3331 Lex.Lex(); // Eat the ']'.
3333 SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size());
3334 for (unsigned i = 0, e = Table.size(); i != e; ++i)
3335 SI->addCase(Table[i].first, Table[i].second);
3342 /// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']'
3343 bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
3346 if (ParseTypeAndValue(Address, AddrLoc, PFS) ||
3347 ParseToken(lltok::comma, "expected ',' after indirectbr address") ||
3348 ParseToken(lltok::lsquare, "expected '[' with indirectbr"))
3351 if (!Address->getType()->isPointerTy())
3352 return Error(AddrLoc, "indirectbr address must have pointer type");
3354 // Parse the destination list.
3355 SmallVector<BasicBlock*, 16> DestList;
3357 if (Lex.getKind() != lltok::rsquare) {
3359 if (ParseTypeAndBasicBlock(DestBB, PFS))
3361 DestList.push_back(DestBB);
3363 while (EatIfPresent(lltok::comma)) {
3364 if (ParseTypeAndBasicBlock(DestBB, PFS))
3366 DestList.push_back(DestBB);
3370 if (ParseToken(lltok::rsquare, "expected ']' at end of block list"))
3373 IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size());
3374 for (unsigned i = 0, e = DestList.size(); i != e; ++i)
3375 IBI->addDestination(DestList[i]);
3382 /// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList
3383 /// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
3384 bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
3385 LocTy CallLoc = Lex.getLoc();
3386 AttrBuilder RetAttrs, FnAttrs;
3391 SmallVector<ParamInfo, 16> ArgList;
3393 BasicBlock *NormalBB, *UnwindBB;
3394 if (ParseOptionalCallingConv(CC) ||
3395 ParseOptionalReturnAttrs(RetAttrs) ||
3396 ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
3397 ParseValID(CalleeID) ||
3398 ParseParameterList(ArgList, PFS) ||
3399 ParseFnAttributeValuePairs(FnAttrs, false) ||
3400 ParseToken(lltok::kw_to, "expected 'to' in invoke") ||
3401 ParseTypeAndBasicBlock(NormalBB, PFS) ||
3402 ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") ||
3403 ParseTypeAndBasicBlock(UnwindBB, PFS))
3406 // If RetType is a non-function pointer type, then this is the short syntax
3407 // for the call, which means that RetType is just the return type. Infer the
3408 // rest of the function argument types from the arguments that are present.
3409 PointerType *PFTy = 0;
3410 FunctionType *Ty = 0;
3411 if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
3412 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
3413 // Pull out the types of all of the arguments...
3414 std::vector<Type*> ParamTypes;
3415 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
3416 ParamTypes.push_back(ArgList[i].V->getType());
3418 if (!FunctionType::isValidReturnType(RetType))
3419 return Error(RetTypeLoc, "Invalid result type for LLVM function");
3421 Ty = FunctionType::get(RetType, ParamTypes, false);
3422 PFTy = PointerType::getUnqual(Ty);
3425 // Look up the callee.
3427 if (ConvertValIDToValue(PFTy, CalleeID, Callee, &PFS)) return true;
3429 // Set up the Attribute for the function.
3430 SmallVector<AttributeSet, 8> Attrs;
3431 if (RetAttrs.hasAttributes())
3432 Attrs.push_back(AttributeSet::get(RetType->getContext(),
3433 AttributeSet::ReturnIndex,
3436 SmallVector<Value*, 8> Args;
3438 // Loop through FunctionType's arguments and ensure they are specified
3439 // correctly. Also, gather any parameter attributes.
3440 FunctionType::param_iterator I = Ty->param_begin();
3441 FunctionType::param_iterator E = Ty->param_end();
3442 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
3443 Type *ExpectedTy = 0;
3446 } else if (!Ty->isVarArg()) {
3447 return Error(ArgList[i].Loc, "too many arguments specified");
3450 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
3451 return Error(ArgList[i].Loc, "argument is not of expected type '" +
3452 getTypeString(ExpectedTy) + "'");
3453 Args.push_back(ArgList[i].V);
3454 if (ArgList[i].Attrs.hasAttributes(i + 1)) {
3455 AttrBuilder B(ArgList[i].Attrs, i + 1);
3456 Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B));
3461 return Error(CallLoc, "not enough parameters specified for call");
3463 if (FnAttrs.hasAttributes())
3464 Attrs.push_back(AttributeSet::get(RetType->getContext(),
3465 AttributeSet::FunctionIndex,
3468 // Finish off the Attribute and check them
3469 AttributeSet PAL = AttributeSet::get(Context, Attrs);
3471 InvokeInst *II = InvokeInst::Create(Callee, NormalBB, UnwindBB, Args);
3472 II->setCallingConv(CC);
3473 II->setAttributes(PAL);
3479 /// ::= 'resume' TypeAndValue
3480 bool LLParser::ParseResume(Instruction *&Inst, PerFunctionState &PFS) {
3481 Value *Exn; LocTy ExnLoc;
3482 if (ParseTypeAndValue(Exn, ExnLoc, PFS))
3485 ResumeInst *RI = ResumeInst::Create(Exn);
3490 //===----------------------------------------------------------------------===//
3491 // Binary Operators.
3492 //===----------------------------------------------------------------------===//
3495 /// ::= ArithmeticOps TypeAndValue ',' Value
3497 /// If OperandType is 0, then any FP or integer operand is allowed. If it is 1,
3498 /// then any integer operand is allowed, if it is 2, any fp operand is allowed.
3499 bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
3500 unsigned Opc, unsigned OperandType) {
3501 LocTy Loc; Value *LHS, *RHS;
3502 if (ParseTypeAndValue(LHS, Loc, PFS) ||
3503 ParseToken(lltok::comma, "expected ',' in arithmetic operation") ||
3504 ParseValue(LHS->getType(), RHS, PFS))
3508 switch (OperandType) {
3509 default: llvm_unreachable("Unknown operand type!");
3510 case 0: // int or FP.
3511 Valid = LHS->getType()->isIntOrIntVectorTy() ||
3512 LHS->getType()->isFPOrFPVectorTy();
3514 case 1: Valid = LHS->getType()->isIntOrIntVectorTy(); break;
3515 case 2: Valid = LHS->getType()->isFPOrFPVectorTy(); break;
3519 return Error(Loc, "invalid operand type for instruction");
3521 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3526 /// ::= ArithmeticOps TypeAndValue ',' Value {
3527 bool LLParser::ParseLogical(Instruction *&Inst, PerFunctionState &PFS,
3529 LocTy Loc; Value *LHS, *RHS;
3530 if (ParseTypeAndValue(LHS, Loc, PFS) ||
3531 ParseToken(lltok::comma, "expected ',' in logical operation") ||
3532 ParseValue(LHS->getType(), RHS, PFS))
3535 if (!LHS->getType()->isIntOrIntVectorTy())
3536 return Error(Loc,"instruction requires integer or integer vector operands");
3538 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3544 /// ::= 'icmp' IPredicates TypeAndValue ',' Value
3545 /// ::= 'fcmp' FPredicates TypeAndValue ',' Value
3546 bool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS,
3548 // Parse the integer/fp comparison predicate.
3552 if (ParseCmpPredicate(Pred, Opc) ||
3553 ParseTypeAndValue(LHS, Loc, PFS) ||
3554 ParseToken(lltok::comma, "expected ',' after compare value") ||
3555 ParseValue(LHS->getType(), RHS, PFS))
3558 if (Opc == Instruction::FCmp) {
3559 if (!LHS->getType()->isFPOrFPVectorTy())
3560 return Error(Loc, "fcmp requires floating point operands");
3561 Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS);
3563 assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!");
3564 if (!LHS->getType()->isIntOrIntVectorTy() &&
3565 !LHS->getType()->getScalarType()->isPointerTy())
3566 return Error(Loc, "icmp requires integer operands");
3567 Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS);
3572 //===----------------------------------------------------------------------===//
3573 // Other Instructions.
3574 //===----------------------------------------------------------------------===//
3578 /// ::= CastOpc TypeAndValue 'to' Type
3579 bool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS,
3584 if (ParseTypeAndValue(Op, Loc, PFS) ||
3585 ParseToken(lltok::kw_to, "expected 'to' after cast value") ||
3589 if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) {
3590 CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy);
3591 return Error(Loc, "invalid cast opcode for cast from '" +
3592 getTypeString(Op->getType()) + "' to '" +
3593 getTypeString(DestTy) + "'");
3595 Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy);
3600 /// ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3601 bool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) {
3603 Value *Op0, *Op1, *Op2;
3604 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3605 ParseToken(lltok::comma, "expected ',' after select condition") ||
3606 ParseTypeAndValue(Op1, PFS) ||
3607 ParseToken(lltok::comma, "expected ',' after select value") ||
3608 ParseTypeAndValue(Op2, PFS))
3611 if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2))
3612 return Error(Loc, Reason);
3614 Inst = SelectInst::Create(Op0, Op1, Op2);
3619 /// ::= 'va_arg' TypeAndValue ',' Type
3620 bool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) {
3624 if (ParseTypeAndValue(Op, PFS) ||
3625 ParseToken(lltok::comma, "expected ',' after vaarg operand") ||
3626 ParseType(EltTy, TypeLoc))
3629 if (!EltTy->isFirstClassType())
3630 return Error(TypeLoc, "va_arg requires operand with first class type");
3632 Inst = new VAArgInst(Op, EltTy);
3636 /// ParseExtractElement
3637 /// ::= 'extractelement' TypeAndValue ',' TypeAndValue
3638 bool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) {
3641 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3642 ParseToken(lltok::comma, "expected ',' after extract value") ||
3643 ParseTypeAndValue(Op1, PFS))
3646 if (!ExtractElementInst::isValidOperands(Op0, Op1))
3647 return Error(Loc, "invalid extractelement operands");
3649 Inst = ExtractElementInst::Create(Op0, Op1);
3653 /// ParseInsertElement
3654 /// ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3655 bool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) {
3657 Value *Op0, *Op1, *Op2;
3658 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3659 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3660 ParseTypeAndValue(Op1, PFS) ||
3661 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3662 ParseTypeAndValue(Op2, PFS))
3665 if (!InsertElementInst::isValidOperands(Op0, Op1, Op2))
3666 return Error(Loc, "invalid insertelement operands");
3668 Inst = InsertElementInst::Create(Op0, Op1, Op2);
3672 /// ParseShuffleVector
3673 /// ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3674 bool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) {
3676 Value *Op0, *Op1, *Op2;
3677 if (ParseTypeAndValue(Op0, Loc, PFS) ||
3678 ParseToken(lltok::comma, "expected ',' after shuffle mask") ||
3679 ParseTypeAndValue(Op1, PFS) ||
3680 ParseToken(lltok::comma, "expected ',' after shuffle value") ||
3681 ParseTypeAndValue(Op2, PFS))
3684 if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2))
3685 return Error(Loc, "invalid shufflevector operands");
3687 Inst = new ShuffleVectorInst(Op0, Op1, Op2);
3692 /// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')*
3693 int LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) {
3694 Type *Ty = 0; LocTy TypeLoc;
3697 if (ParseType(Ty, TypeLoc) ||
3698 ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
3699 ParseValue(Ty, Op0, PFS) ||
3700 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3701 ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
3702 ParseToken(lltok::rsquare, "expected ']' in phi value list"))
3705 bool AteExtraComma = false;
3706 SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals;
3708 PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1)));
3710 if (!EatIfPresent(lltok::comma))
3713 if (Lex.getKind() == lltok::MetadataVar) {
3714 AteExtraComma = true;
3718 if (ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
3719 ParseValue(Ty, Op0, PFS) ||
3720 ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3721 ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
3722 ParseToken(lltok::rsquare, "expected ']' in phi value list"))
3726 if (!Ty->isFirstClassType())
3727 return Error(TypeLoc, "phi node must have first class type");
3729 PHINode *PN = PHINode::Create(Ty, PHIVals.size());
3730 for (unsigned i = 0, e = PHIVals.size(); i != e; ++i)
3731 PN->addIncoming(PHIVals[i].first, PHIVals[i].second);
3733 return AteExtraComma ? InstExtraComma : InstNormal;
3737 /// ::= 'landingpad' Type 'personality' TypeAndValue 'cleanup'? Clause+
3739 /// ::= 'catch' TypeAndValue
3741 /// ::= 'filter' TypeAndValue ( ',' TypeAndValue )*
3742 bool LLParser::ParseLandingPad(Instruction *&Inst, PerFunctionState &PFS) {
3743 Type *Ty = 0; LocTy TyLoc;
3744 Value *PersFn; LocTy PersFnLoc;
3746 if (ParseType(Ty, TyLoc) ||
3747 ParseToken(lltok::kw_personality, "expected 'personality'") ||
3748 ParseTypeAndValue(PersFn, PersFnLoc, PFS))
3751 LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, 0);
3752 LP->setCleanup(EatIfPresent(lltok::kw_cleanup));
3754 while (Lex.getKind() == lltok::kw_catch || Lex.getKind() == lltok::kw_filter){
3755 LandingPadInst::ClauseType CT;
3756 if (EatIfPresent(lltok::kw_catch))
3757 CT = LandingPadInst::Catch;
3758 else if (EatIfPresent(lltok::kw_filter))
3759 CT = LandingPadInst::Filter;
3761 return TokError("expected 'catch' or 'filter' clause type");
3763 Value *V; LocTy VLoc;
3764 if (ParseTypeAndValue(V, VLoc, PFS)) {
3769 // A 'catch' type expects a non-array constant. A filter clause expects an
3771 if (CT == LandingPadInst::Catch) {
3772 if (isa<ArrayType>(V->getType()))
3773 Error(VLoc, "'catch' clause has an invalid type");
3775 if (!isa<ArrayType>(V->getType()))
3776 Error(VLoc, "'filter' clause has an invalid type");
3787 /// ::= 'tail'? 'call' OptionalCallingConv OptionalAttrs Type Value
3788 /// ParameterList OptionalAttrs
3789 bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
3791 AttrBuilder RetAttrs, FnAttrs;
3796 SmallVector<ParamInfo, 16> ArgList;
3797 LocTy CallLoc = Lex.getLoc();
3799 if ((isTail && ParseToken(lltok::kw_call, "expected 'tail call'")) ||
3800 ParseOptionalCallingConv(CC) ||
3801 ParseOptionalReturnAttrs(RetAttrs) ||
3802 ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
3803 ParseValID(CalleeID) ||
3804 ParseParameterList(ArgList, PFS) ||
3805 ParseFnAttributeValuePairs(FnAttrs, false))
3808 // If RetType is a non-function pointer type, then this is the short syntax
3809 // for the call, which means that RetType is just the return type. Infer the
3810 // rest of the function argument types from the arguments that are present.
3811 PointerType *PFTy = 0;
3812 FunctionType *Ty = 0;
3813 if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
3814 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
3815 // Pull out the types of all of the arguments...
3816 std::vector<Type*> ParamTypes;
3817 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
3818 ParamTypes.push_back(ArgList[i].V->getType());
3820 if (!FunctionType::isValidReturnType(RetType))
3821 return Error(RetTypeLoc, "Invalid result type for LLVM function");
3823 Ty = FunctionType::get(RetType, ParamTypes, false);
3824 PFTy = PointerType::getUnqual(Ty);
3827 // Look up the callee.
3829 if (ConvertValIDToValue(PFTy, CalleeID, Callee, &PFS)) return true;
3831 // Set up the Attribute for the function.
3832 SmallVector<AttributeSet, 8> Attrs;
3833 if (RetAttrs.hasAttributes())
3834 Attrs.push_back(AttributeSet::get(RetType->getContext(),
3835 AttributeSet::ReturnIndex,
3838 SmallVector<Value*, 8> Args;
3840 // Loop through FunctionType's arguments and ensure they are specified
3841 // correctly. Also, gather any parameter attributes.
3842 FunctionType::param_iterator I = Ty->param_begin();
3843 FunctionType::param_iterator E = Ty->param_end();
3844 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
3845 Type *ExpectedTy = 0;
3848 } else if (!Ty->isVarArg()) {
3849 return Error(ArgList[i].Loc, "too many arguments specified");
3852 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
3853 return Error(ArgList[i].Loc, "argument is not of expected type '" +
3854 getTypeString(ExpectedTy) + "'");
3855 Args.push_back(ArgList[i].V);
3856 if (ArgList[i].Attrs.hasAttributes(i + 1)) {
3857 AttrBuilder B(ArgList[i].Attrs, i + 1);
3858 Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B));
3863 return Error(CallLoc, "not enough parameters specified for call");
3865 if (FnAttrs.hasAttributes())
3866 Attrs.push_back(AttributeSet::get(RetType->getContext(),
3867 AttributeSet::FunctionIndex,
3870 // Finish off the Attribute and check them
3871 AttributeSet PAL = AttributeSet::get(Context, Attrs);
3873 CallInst *CI = CallInst::Create(Callee, Args);
3874 CI->setTailCall(isTail);
3875 CI->setCallingConv(CC);
3876 CI->setAttributes(PAL);
3881 //===----------------------------------------------------------------------===//
3882 // Memory Instructions.
3883 //===----------------------------------------------------------------------===//
3886 /// ::= 'alloca' Type (',' TypeAndValue)? (',' OptionalInfo)?
3887 int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
3890 unsigned Alignment = 0;
3892 if (ParseType(Ty)) return true;
3894 bool AteExtraComma = false;
3895 if (EatIfPresent(lltok::comma)) {
3896 if (Lex.getKind() == lltok::kw_align) {
3897 if (ParseOptionalAlignment(Alignment)) return true;
3898 } else if (Lex.getKind() == lltok::MetadataVar) {
3899 AteExtraComma = true;
3901 if (ParseTypeAndValue(Size, SizeLoc, PFS) ||
3902 ParseOptionalCommaAlign(Alignment, AteExtraComma))
3907 if (Size && !Size->getType()->isIntegerTy())
3908 return Error(SizeLoc, "element count must have integer type");
3910 Inst = new AllocaInst(Ty, Size, Alignment);
3911 return AteExtraComma ? InstExtraComma : InstNormal;
3915 /// ::= 'load' 'volatile'? TypeAndValue (',' 'align' i32)?
3916 /// ::= 'load' 'atomic' 'volatile'? TypeAndValue
3917 /// 'singlethread'? AtomicOrdering (',' 'align' i32)?
3918 int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS) {
3919 Value *Val; LocTy Loc;
3920 unsigned Alignment = 0;
3921 bool AteExtraComma = false;
3922 bool isAtomic = false;
3923 AtomicOrdering Ordering = NotAtomic;
3924 SynchronizationScope Scope = CrossThread;
3926 if (Lex.getKind() == lltok::kw_atomic) {
3931 bool isVolatile = false;
3932 if (Lex.getKind() == lltok::kw_volatile) {
3937 if (ParseTypeAndValue(Val, Loc, PFS) ||
3938 ParseScopeAndOrdering(isAtomic, Scope, Ordering) ||
3939 ParseOptionalCommaAlign(Alignment, AteExtraComma))
3942 if (!Val->getType()->isPointerTy() ||
3943 !cast<PointerType>(Val->getType())->getElementType()->isFirstClassType())
3944 return Error(Loc, "load operand must be a pointer to a first class type");
3945 if (isAtomic && !Alignment)
3946 return Error(Loc, "atomic load must have explicit non-zero alignment");
3947 if (Ordering == Release || Ordering == AcquireRelease)
3948 return Error(Loc, "atomic load cannot use Release ordering");
3950 Inst = new LoadInst(Val, "", isVolatile, Alignment, Ordering, Scope);
3951 return AteExtraComma ? InstExtraComma : InstNormal;
3956 /// ::= 'store' 'volatile'? TypeAndValue ',' TypeAndValue (',' 'align' i32)?
3957 /// ::= 'store' 'atomic' 'volatile'? TypeAndValue ',' TypeAndValue
3958 /// 'singlethread'? AtomicOrdering (',' 'align' i32)?
3959 int LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS) {
3960 Value *Val, *Ptr; LocTy Loc, PtrLoc;
3961 unsigned Alignment = 0;
3962 bool AteExtraComma = false;
3963 bool isAtomic = false;
3964 AtomicOrdering Ordering = NotAtomic;
3965 SynchronizationScope Scope = CrossThread;
3967 if (Lex.getKind() == lltok::kw_atomic) {
3972 bool isVolatile = false;
3973 if (Lex.getKind() == lltok::kw_volatile) {
3978 if (ParseTypeAndValue(Val, Loc, PFS) ||
3979 ParseToken(lltok::comma, "expected ',' after store operand") ||
3980 ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
3981 ParseScopeAndOrdering(isAtomic, Scope, Ordering) ||
3982 ParseOptionalCommaAlign(Alignment, AteExtraComma))
3985 if (!Ptr->getType()->isPointerTy())
3986 return Error(PtrLoc, "store operand must be a pointer");
3987 if (!Val->getType()->isFirstClassType())
3988 return Error(Loc, "store operand must be a first class value");
3989 if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
3990 return Error(Loc, "stored value and pointer type do not match");
3991 if (isAtomic && !Alignment)
3992 return Error(Loc, "atomic store must have explicit non-zero alignment");
3993 if (Ordering == Acquire || Ordering == AcquireRelease)
3994 return Error(Loc, "atomic store cannot use Acquire ordering");
3996 Inst = new StoreInst(Val, Ptr, isVolatile, Alignment, Ordering, Scope);
3997 return AteExtraComma ? InstExtraComma : InstNormal;
4001 /// ::= 'cmpxchg' 'volatile'? TypeAndValue ',' TypeAndValue ',' TypeAndValue
4002 /// 'singlethread'? AtomicOrdering
4003 int LLParser::ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
4004 Value *Ptr, *Cmp, *New; LocTy PtrLoc, CmpLoc, NewLoc;
4005 bool AteExtraComma = false;
4006 AtomicOrdering Ordering = NotAtomic;
4007 SynchronizationScope Scope = CrossThread;
4008 bool isVolatile = false;
4010 if (EatIfPresent(lltok::kw_volatile))
4013 if (ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
4014 ParseToken(lltok::comma, "expected ',' after cmpxchg address") ||
4015 ParseTypeAndValue(Cmp, CmpLoc, PFS) ||
4016 ParseToken(lltok::comma, "expected ',' after cmpxchg cmp operand") ||
4017 ParseTypeAndValue(New, NewLoc, PFS) ||
4018 ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
4021 if (Ordering == Unordered)
4022 return TokError("cmpxchg cannot be unordered");
4023 if (!Ptr->getType()->isPointerTy())
4024 return Error(PtrLoc, "cmpxchg operand must be a pointer");
4025 if (cast<PointerType>(Ptr->getType())->getElementType() != Cmp->getType())
4026 return Error(CmpLoc, "compare value and pointer type do not match");
4027 if (cast<PointerType>(Ptr->getType())->getElementType() != New->getType())
4028 return Error(NewLoc, "new value and pointer type do not match");
4029 if (!New->getType()->isIntegerTy())
4030 return Error(NewLoc, "cmpxchg operand must be an integer");
4031 unsigned Size = New->getType()->getPrimitiveSizeInBits();
4032 if (Size < 8 || (Size & (Size - 1)))
4033 return Error(NewLoc, "cmpxchg operand must be power-of-two byte-sized"
4036 AtomicCmpXchgInst *CXI =
4037 new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, Scope);
4038 CXI->setVolatile(isVolatile);
4040 return AteExtraComma ? InstExtraComma : InstNormal;
4044 /// ::= 'atomicrmw' 'volatile'? BinOp TypeAndValue ',' TypeAndValue
4045 /// 'singlethread'? AtomicOrdering
4046 int LLParser::ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
4047 Value *Ptr, *Val; LocTy PtrLoc, ValLoc;
4048 bool AteExtraComma = false;
4049 AtomicOrdering Ordering = NotAtomic;
4050 SynchronizationScope Scope = CrossThread;
4051 bool isVolatile = false;
4052 AtomicRMWInst::BinOp Operation;
4054 if (EatIfPresent(lltok::kw_volatile))
4057 switch (Lex.getKind()) {
4058 default: return TokError("expected binary operation in atomicrmw");
4059 case lltok::kw_xchg: Operation = AtomicRMWInst::Xchg; break;
4060 case lltok::kw_add: Operation = AtomicRMWInst::Add; break;
4061 case lltok::kw_sub: Operation = AtomicRMWInst::Sub; break;
4062 case lltok::kw_and: Operation = AtomicRMWInst::And; break;
4063 case lltok::kw_nand: Operation = AtomicRMWInst::Nand; break;
4064 case lltok::kw_or: Operation = AtomicRMWInst::Or; break;
4065 case lltok::kw_xor: Operation = AtomicRMWInst::Xor; break;
4066 case lltok::kw_max: Operation = AtomicRMWInst::Max; break;
4067 case lltok::kw_min: Operation = AtomicRMWInst::Min; break;
4068 case lltok::kw_umax: Operation = AtomicRMWInst::UMax; break;
4069 case lltok::kw_umin: Operation = AtomicRMWInst::UMin; break;
4071 Lex.Lex(); // Eat the operation.
4073 if (ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
4074 ParseToken(lltok::comma, "expected ',' after atomicrmw address") ||
4075 ParseTypeAndValue(Val, ValLoc, PFS) ||
4076 ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
4079 if (Ordering == Unordered)
4080 return TokError("atomicrmw cannot be unordered");
4081 if (!Ptr->getType()->isPointerTy())
4082 return Error(PtrLoc, "atomicrmw operand must be a pointer");
4083 if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
4084 return Error(ValLoc, "atomicrmw value and pointer type do not match");
4085 if (!Val->getType()->isIntegerTy())
4086 return Error(ValLoc, "atomicrmw operand must be an integer");
4087 unsigned Size = Val->getType()->getPrimitiveSizeInBits();
4088 if (Size < 8 || (Size & (Size - 1)))
4089 return Error(ValLoc, "atomicrmw operand must be power-of-two byte-sized"
4092 AtomicRMWInst *RMWI =
4093 new AtomicRMWInst(Operation, Ptr, Val, Ordering, Scope);
4094 RMWI->setVolatile(isVolatile);
4096 return AteExtraComma ? InstExtraComma : InstNormal;
4100 /// ::= 'fence' 'singlethread'? AtomicOrdering
4101 int LLParser::ParseFence(Instruction *&Inst, PerFunctionState &PFS) {
4102 AtomicOrdering Ordering = NotAtomic;
4103 SynchronizationScope Scope = CrossThread;
4104 if (ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
4107 if (Ordering == Unordered)
4108 return TokError("fence cannot be unordered");
4109 if (Ordering == Monotonic)
4110 return TokError("fence cannot be monotonic");
4112 Inst = new FenceInst(Context, Ordering, Scope);
4116 /// ParseGetElementPtr
4117 /// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)*
4118 int LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
4123 bool InBounds = EatIfPresent(lltok::kw_inbounds);
4125 if (ParseTypeAndValue(Ptr, Loc, PFS)) return true;
4127 if (!Ptr->getType()->getScalarType()->isPointerTy())
4128 return Error(Loc, "base of getelementptr must be a pointer");
4130 SmallVector<Value*, 16> Indices;
4131 bool AteExtraComma = false;
4132 while (EatIfPresent(lltok::comma)) {
4133 if (Lex.getKind() == lltok::MetadataVar) {
4134 AteExtraComma = true;
4137 if (ParseTypeAndValue(Val, EltLoc, PFS)) return true;
4138 if (!Val->getType()->getScalarType()->isIntegerTy())
4139 return Error(EltLoc, "getelementptr index must be an integer");
4140 if (Val->getType()->isVectorTy() != Ptr->getType()->isVectorTy())
4141 return Error(EltLoc, "getelementptr index type missmatch");
4142 if (Val->getType()->isVectorTy()) {
4143 unsigned ValNumEl = cast<VectorType>(Val->getType())->getNumElements();
4144 unsigned PtrNumEl = cast<VectorType>(Ptr->getType())->getNumElements();
4145 if (ValNumEl != PtrNumEl)
4146 return Error(EltLoc,
4147 "getelementptr vector index has a wrong number of elements");
4149 Indices.push_back(Val);
4152 if (!GetElementPtrInst::getIndexedType(Ptr->getType(), Indices))
4153 return Error(Loc, "invalid getelementptr indices");
4154 Inst = GetElementPtrInst::Create(Ptr, Indices);
4156 cast<GetElementPtrInst>(Inst)->setIsInBounds(true);
4157 return AteExtraComma ? InstExtraComma : InstNormal;
4160 /// ParseExtractValue
4161 /// ::= 'extractvalue' TypeAndValue (',' uint32)+
4162 int LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
4163 Value *Val; LocTy Loc;
4164 SmallVector<unsigned, 4> Indices;
4166 if (ParseTypeAndValue(Val, Loc, PFS) ||
4167 ParseIndexList(Indices, AteExtraComma))
4170 if (!Val->getType()->isAggregateType())
4171 return Error(Loc, "extractvalue operand must be aggregate type");
4173 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
4174 return Error(Loc, "invalid indices for extractvalue");
4175 Inst = ExtractValueInst::Create(Val, Indices);
4176 return AteExtraComma ? InstExtraComma : InstNormal;
4179 /// ParseInsertValue
4180 /// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+
4181 int LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
4182 Value *Val0, *Val1; LocTy Loc0, Loc1;
4183 SmallVector<unsigned, 4> Indices;
4185 if (ParseTypeAndValue(Val0, Loc0, PFS) ||
4186 ParseToken(lltok::comma, "expected comma after insertvalue operand") ||
4187 ParseTypeAndValue(Val1, Loc1, PFS) ||
4188 ParseIndexList(Indices, AteExtraComma))
4191 if (!Val0->getType()->isAggregateType())
4192 return Error(Loc0, "insertvalue operand must be aggregate type");
4194 if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices))
4195 return Error(Loc0, "invalid indices for insertvalue");
4196 Inst = InsertValueInst::Create(Val0, Val1, Indices);
4197 return AteExtraComma ? InstExtraComma : InstNormal;
4200 //===----------------------------------------------------------------------===//
4201 // Embedded metadata.
4202 //===----------------------------------------------------------------------===//
4204 /// ParseMDNodeVector
4205 /// ::= Element (',' Element)*
4207 /// ::= 'null' | TypeAndValue
4208 bool LLParser::ParseMDNodeVector(SmallVectorImpl<Value*> &Elts,
4209 PerFunctionState *PFS) {
4210 // Check for an empty list.
4211 if (Lex.getKind() == lltok::rbrace)
4215 // Null is a special case since it is typeless.
4216 if (EatIfPresent(lltok::kw_null)) {
4222 if (ParseTypeAndValue(V, PFS)) return true;
4224 } while (EatIfPresent(lltok::comma));