Try to fix the build for C++ standard libraries missing std::map::emplace
[oota-llvm.git] / lib / AsmParser / LLParser.cpp
1 //===-- LLParser.cpp - Parser Class ---------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file defines the parser class for .ll files.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "LLParser.h"
15 #include "llvm/ADT/SmallPtrSet.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/AsmParser/SlotMapping.h"
18 #include "llvm/IR/AutoUpgrade.h"
19 #include "llvm/IR/CallingConv.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/DebugInfo.h"
22 #include "llvm/IR/DebugInfoMetadata.h"
23 #include "llvm/IR/DerivedTypes.h"
24 #include "llvm/IR/InlineAsm.h"
25 #include "llvm/IR/Instructions.h"
26 #include "llvm/IR/LLVMContext.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/IR/Operator.h"
29 #include "llvm/IR/ValueSymbolTable.h"
30 #include "llvm/Support/Dwarf.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/SaveAndRestore.h"
33 #include "llvm/Support/raw_ostream.h"
34 using namespace llvm;
35
36 static std::string getTypeString(Type *T) {
37   std::string Result;
38   raw_string_ostream Tmp(Result);
39   Tmp << *T;
40   return Tmp.str();
41 }
42
43 /// Run: module ::= toplevelentity*
44 bool LLParser::Run() {
45   // Prime the lexer.
46   Lex.Lex();
47
48   return ParseTopLevelEntities() ||
49          ValidateEndOfModule();
50 }
51
52 bool LLParser::parseStandaloneConstantValue(Constant *&C) {
53   Lex.Lex();
54
55   Type *Ty = nullptr;
56   if (ParseType(Ty) || parseConstantValue(Ty, C))
57     return true;
58   if (Lex.getKind() != lltok::Eof)
59     return Error(Lex.getLoc(), "expected end of string");
60   return false;
61 }
62
63 /// ValidateEndOfModule - Do final validity and sanity checks at the end of the
64 /// module.
65 bool LLParser::ValidateEndOfModule() {
66   for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++)
67     UpgradeInstWithTBAATag(InstsWithTBAATag[I]);
68
69   // Handle any function attribute group forward references.
70   for (std::map<Value*, std::vector<unsigned> >::iterator
71          I = ForwardRefAttrGroups.begin(), E = ForwardRefAttrGroups.end();
72          I != E; ++I) {
73     Value *V = I->first;
74     std::vector<unsigned> &Vec = I->second;
75     AttrBuilder B;
76
77     for (std::vector<unsigned>::iterator VI = Vec.begin(), VE = Vec.end();
78          VI != VE; ++VI)
79       B.merge(NumberedAttrBuilders[*VI]);
80
81     if (Function *Fn = dyn_cast<Function>(V)) {
82       AttributeSet AS = Fn->getAttributes();
83       AttrBuilder FnAttrs(AS.getFnAttributes(), AttributeSet::FunctionIndex);
84       AS = AS.removeAttributes(Context, AttributeSet::FunctionIndex,
85                                AS.getFnAttributes());
86
87       FnAttrs.merge(B);
88
89       // If the alignment was parsed as an attribute, move to the alignment
90       // field.
91       if (FnAttrs.hasAlignmentAttr()) {
92         Fn->setAlignment(FnAttrs.getAlignment());
93         FnAttrs.removeAttribute(Attribute::Alignment);
94       }
95
96       AS = AS.addAttributes(Context, AttributeSet::FunctionIndex,
97                             AttributeSet::get(Context,
98                                               AttributeSet::FunctionIndex,
99                                               FnAttrs));
100       Fn->setAttributes(AS);
101     } else if (CallInst *CI = dyn_cast<CallInst>(V)) {
102       AttributeSet AS = CI->getAttributes();
103       AttrBuilder FnAttrs(AS.getFnAttributes(), AttributeSet::FunctionIndex);
104       AS = AS.removeAttributes(Context, AttributeSet::FunctionIndex,
105                                AS.getFnAttributes());
106       FnAttrs.merge(B);
107       AS = AS.addAttributes(Context, AttributeSet::FunctionIndex,
108                             AttributeSet::get(Context,
109                                               AttributeSet::FunctionIndex,
110                                               FnAttrs));
111       CI->setAttributes(AS);
112     } else if (InvokeInst *II = dyn_cast<InvokeInst>(V)) {
113       AttributeSet AS = II->getAttributes();
114       AttrBuilder FnAttrs(AS.getFnAttributes(), AttributeSet::FunctionIndex);
115       AS = AS.removeAttributes(Context, AttributeSet::FunctionIndex,
116                                AS.getFnAttributes());
117       FnAttrs.merge(B);
118       AS = AS.addAttributes(Context, AttributeSet::FunctionIndex,
119                             AttributeSet::get(Context,
120                                               AttributeSet::FunctionIndex,
121                                               FnAttrs));
122       II->setAttributes(AS);
123     } else {
124       llvm_unreachable("invalid object with forward attribute group reference");
125     }
126   }
127
128   // If there are entries in ForwardRefBlockAddresses at this point, the
129   // function was never defined.
130   if (!ForwardRefBlockAddresses.empty())
131     return Error(ForwardRefBlockAddresses.begin()->first.Loc,
132                  "expected function name in blockaddress");
133
134   for (const auto &NT : NumberedTypes)
135     if (NT.second.second.isValid())
136       return Error(NT.second.second,
137                    "use of undefined type '%" + Twine(NT.first) + "'");
138
139   for (StringMap<std::pair<Type*, LocTy> >::iterator I =
140        NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I)
141     if (I->second.second.isValid())
142       return Error(I->second.second,
143                    "use of undefined type named '" + I->getKey() + "'");
144
145   if (!ForwardRefComdats.empty())
146     return Error(ForwardRefComdats.begin()->second,
147                  "use of undefined comdat '$" +
148                      ForwardRefComdats.begin()->first + "'");
149
150   if (!ForwardRefVals.empty())
151     return Error(ForwardRefVals.begin()->second.second,
152                  "use of undefined value '@" + ForwardRefVals.begin()->first +
153                  "'");
154
155   if (!ForwardRefValIDs.empty())
156     return Error(ForwardRefValIDs.begin()->second.second,
157                  "use of undefined value '@" +
158                  Twine(ForwardRefValIDs.begin()->first) + "'");
159
160   if (!ForwardRefMDNodes.empty())
161     return Error(ForwardRefMDNodes.begin()->second.second,
162                  "use of undefined metadata '!" +
163                  Twine(ForwardRefMDNodes.begin()->first) + "'");
164
165   // Resolve metadata cycles.
166   for (auto &N : NumberedMetadata) {
167     if (N.second && !N.second->isResolved())
168       N.second->resolveCycles();
169   }
170
171   // Look for intrinsic functions and CallInst that need to be upgraded
172   for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
173     UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
174
175   UpgradeDebugInfo(*M);
176
177   if (!Slots)
178     return false;
179   // Initialize the slot mapping.
180   // Because by this point we've parsed and validated everything, we can "steal"
181   // the mapping from LLParser as it doesn't need it anymore.
182   Slots->GlobalValues = std::move(NumberedVals);
183   Slots->MetadataNodes = std::move(NumberedMetadata);
184
185   return false;
186 }
187
188 //===----------------------------------------------------------------------===//
189 // Top-Level Entities
190 //===----------------------------------------------------------------------===//
191
192 bool LLParser::ParseTopLevelEntities() {
193   while (1) {
194     switch (Lex.getKind()) {
195     default:         return TokError("expected top-level entity");
196     case lltok::Eof: return false;
197     case lltok::kw_declare: if (ParseDeclare()) return true; break;
198     case lltok::kw_define:  if (ParseDefine()) return true; break;
199     case lltok::kw_module:  if (ParseModuleAsm()) return true; break;
200     case lltok::kw_target:  if (ParseTargetDefinition()) return true; break;
201     case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
202     case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
203     case lltok::LocalVar:   if (ParseNamedType()) return true; break;
204     case lltok::GlobalID:   if (ParseUnnamedGlobal()) return true; break;
205     case lltok::GlobalVar:  if (ParseNamedGlobal()) return true; break;
206     case lltok::ComdatVar:  if (parseComdat()) return true; break;
207     case lltok::exclaim:    if (ParseStandaloneMetadata()) return true; break;
208     case lltok::MetadataVar:if (ParseNamedMetadata()) return true; break;
209
210     // The Global variable production with no name can have many different
211     // optional leading prefixes, the production is:
212     // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalDLLStorageClass
213     //               OptionalThreadLocal OptionalAddrSpace OptionalUnnamedAddr
214     //               ('constant'|'global') ...
215     case lltok::kw_private:             // OptionalLinkage
216     case lltok::kw_internal:            // OptionalLinkage
217     case lltok::kw_weak:                // OptionalLinkage
218     case lltok::kw_weak_odr:            // OptionalLinkage
219     case lltok::kw_linkonce:            // OptionalLinkage
220     case lltok::kw_linkonce_odr:        // OptionalLinkage
221     case lltok::kw_appending:           // OptionalLinkage
222     case lltok::kw_common:              // OptionalLinkage
223     case lltok::kw_extern_weak:         // OptionalLinkage
224     case lltok::kw_external:            // OptionalLinkage
225     case lltok::kw_default:             // OptionalVisibility
226     case lltok::kw_hidden:              // OptionalVisibility
227     case lltok::kw_protected:           // OptionalVisibility
228     case lltok::kw_dllimport:           // OptionalDLLStorageClass
229     case lltok::kw_dllexport:           // OptionalDLLStorageClass
230     case lltok::kw_thread_local:        // OptionalThreadLocal
231     case lltok::kw_addrspace:           // OptionalAddrSpace
232     case lltok::kw_constant:            // GlobalType
233     case lltok::kw_global: {            // GlobalType
234       unsigned Linkage, Visibility, DLLStorageClass;
235       bool UnnamedAddr;
236       GlobalVariable::ThreadLocalMode TLM;
237       bool HasLinkage;
238       if (ParseOptionalLinkage(Linkage, HasLinkage) ||
239           ParseOptionalVisibility(Visibility) ||
240           ParseOptionalDLLStorageClass(DLLStorageClass) ||
241           ParseOptionalThreadLocal(TLM) ||
242           parseOptionalUnnamedAddr(UnnamedAddr) ||
243           ParseGlobal("", SMLoc(), Linkage, HasLinkage, Visibility,
244                       DLLStorageClass, TLM, UnnamedAddr))
245         return true;
246       break;
247     }
248
249     case lltok::kw_attributes: if (ParseUnnamedAttrGrp()) return true; break;
250     case lltok::kw_uselistorder: if (ParseUseListOrder()) return true; break;
251     case lltok::kw_uselistorder_bb:
252                                  if (ParseUseListOrderBB()) return true; break;
253     }
254   }
255 }
256
257
258 /// toplevelentity
259 ///   ::= 'module' 'asm' STRINGCONSTANT
260 bool LLParser::ParseModuleAsm() {
261   assert(Lex.getKind() == lltok::kw_module);
262   Lex.Lex();
263
264   std::string AsmStr;
265   if (ParseToken(lltok::kw_asm, "expected 'module asm'") ||
266       ParseStringConstant(AsmStr)) return true;
267
268   M->appendModuleInlineAsm(AsmStr);
269   return false;
270 }
271
272 /// toplevelentity
273 ///   ::= 'target' 'triple' '=' STRINGCONSTANT
274 ///   ::= 'target' 'datalayout' '=' STRINGCONSTANT
275 bool LLParser::ParseTargetDefinition() {
276   assert(Lex.getKind() == lltok::kw_target);
277   std::string Str;
278   switch (Lex.Lex()) {
279   default: return TokError("unknown target property");
280   case lltok::kw_triple:
281     Lex.Lex();
282     if (ParseToken(lltok::equal, "expected '=' after target triple") ||
283         ParseStringConstant(Str))
284       return true;
285     M->setTargetTriple(Str);
286     return false;
287   case lltok::kw_datalayout:
288     Lex.Lex();
289     if (ParseToken(lltok::equal, "expected '=' after target datalayout") ||
290         ParseStringConstant(Str))
291       return true;
292     M->setDataLayout(Str);
293     return false;
294   }
295 }
296
297 /// toplevelentity
298 ///   ::= 'deplibs' '=' '[' ']'
299 ///   ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
300 /// FIXME: Remove in 4.0. Currently parse, but ignore.
301 bool LLParser::ParseDepLibs() {
302   assert(Lex.getKind() == lltok::kw_deplibs);
303   Lex.Lex();
304   if (ParseToken(lltok::equal, "expected '=' after deplibs") ||
305       ParseToken(lltok::lsquare, "expected '=' after deplibs"))
306     return true;
307
308   if (EatIfPresent(lltok::rsquare))
309     return false;
310
311   do {
312     std::string Str;
313     if (ParseStringConstant(Str)) return true;
314   } while (EatIfPresent(lltok::comma));
315
316   return ParseToken(lltok::rsquare, "expected ']' at end of list");
317 }
318
319 /// ParseUnnamedType:
320 ///   ::= LocalVarID '=' 'type' type
321 bool LLParser::ParseUnnamedType() {
322   LocTy TypeLoc = Lex.getLoc();
323   unsigned TypeID = Lex.getUIntVal();
324   Lex.Lex(); // eat LocalVarID;
325
326   if (ParseToken(lltok::equal, "expected '=' after name") ||
327       ParseToken(lltok::kw_type, "expected 'type' after '='"))
328     return true;
329
330   Type *Result = nullptr;
331   if (ParseStructDefinition(TypeLoc, "",
332                             NumberedTypes[TypeID], Result)) return true;
333
334   if (!isa<StructType>(Result)) {
335     std::pair<Type*, LocTy> &Entry = NumberedTypes[TypeID];
336     if (Entry.first)
337       return Error(TypeLoc, "non-struct types may not be recursive");
338     Entry.first = Result;
339     Entry.second = SMLoc();
340   }
341
342   return false;
343 }
344
345
346 /// toplevelentity
347 ///   ::= LocalVar '=' 'type' type
348 bool LLParser::ParseNamedType() {
349   std::string Name = Lex.getStrVal();
350   LocTy NameLoc = Lex.getLoc();
351   Lex.Lex();  // eat LocalVar.
352
353   if (ParseToken(lltok::equal, "expected '=' after name") ||
354       ParseToken(lltok::kw_type, "expected 'type' after name"))
355     return true;
356
357   Type *Result = nullptr;
358   if (ParseStructDefinition(NameLoc, Name,
359                             NamedTypes[Name], Result)) return true;
360
361   if (!isa<StructType>(Result)) {
362     std::pair<Type*, LocTy> &Entry = NamedTypes[Name];
363     if (Entry.first)
364       return Error(NameLoc, "non-struct types may not be recursive");
365     Entry.first = Result;
366     Entry.second = SMLoc();
367   }
368
369   return false;
370 }
371
372
373 /// toplevelentity
374 ///   ::= 'declare' FunctionHeader
375 bool LLParser::ParseDeclare() {
376   assert(Lex.getKind() == lltok::kw_declare);
377   Lex.Lex();
378
379   Function *F;
380   return ParseFunctionHeader(F, false);
381 }
382
383 /// toplevelentity
384 ///   ::= 'define' FunctionHeader (!dbg !56)* '{' ...
385 bool LLParser::ParseDefine() {
386   assert(Lex.getKind() == lltok::kw_define);
387   Lex.Lex();
388
389   Function *F;
390   return ParseFunctionHeader(F, true) ||
391          ParseOptionalFunctionMetadata(*F) ||
392          ParseFunctionBody(*F);
393 }
394
395 /// ParseGlobalType
396 ///   ::= 'constant'
397 ///   ::= 'global'
398 bool LLParser::ParseGlobalType(bool &IsConstant) {
399   if (Lex.getKind() == lltok::kw_constant)
400     IsConstant = true;
401   else if (Lex.getKind() == lltok::kw_global)
402     IsConstant = false;
403   else {
404     IsConstant = false;
405     return TokError("expected 'global' or 'constant'");
406   }
407   Lex.Lex();
408   return false;
409 }
410
411 /// ParseUnnamedGlobal:
412 ///   OptionalVisibility ALIAS ...
413 ///   OptionalLinkage OptionalVisibility OptionalDLLStorageClass
414 ///                                                     ...   -> global variable
415 ///   GlobalID '=' OptionalVisibility ALIAS ...
416 ///   GlobalID '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
417 ///                                                     ...   -> global variable
418 bool LLParser::ParseUnnamedGlobal() {
419   unsigned VarID = NumberedVals.size();
420   std::string Name;
421   LocTy NameLoc = Lex.getLoc();
422
423   // Handle the GlobalID form.
424   if (Lex.getKind() == lltok::GlobalID) {
425     if (Lex.getUIntVal() != VarID)
426       return Error(Lex.getLoc(), "variable expected to be numbered '%" +
427                    Twine(VarID) + "'");
428     Lex.Lex(); // eat GlobalID;
429
430     if (ParseToken(lltok::equal, "expected '=' after name"))
431       return true;
432   }
433
434   bool HasLinkage;
435   unsigned Linkage, Visibility, DLLStorageClass;
436   GlobalVariable::ThreadLocalMode TLM;
437   bool UnnamedAddr;
438   if (ParseOptionalLinkage(Linkage, HasLinkage) ||
439       ParseOptionalVisibility(Visibility) ||
440       ParseOptionalDLLStorageClass(DLLStorageClass) ||
441       ParseOptionalThreadLocal(TLM) ||
442       parseOptionalUnnamedAddr(UnnamedAddr))
443     return true;
444
445   if (Lex.getKind() != lltok::kw_alias)
446     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
447                        DLLStorageClass, TLM, UnnamedAddr);
448   return ParseAlias(Name, NameLoc, Linkage, Visibility, DLLStorageClass, TLM,
449                     UnnamedAddr);
450 }
451
452 /// ParseNamedGlobal:
453 ///   GlobalVar '=' OptionalVisibility ALIAS ...
454 ///   GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
455 ///                                                     ...   -> global variable
456 bool LLParser::ParseNamedGlobal() {
457   assert(Lex.getKind() == lltok::GlobalVar);
458   LocTy NameLoc = Lex.getLoc();
459   std::string Name = Lex.getStrVal();
460   Lex.Lex();
461
462   bool HasLinkage;
463   unsigned Linkage, Visibility, DLLStorageClass;
464   GlobalVariable::ThreadLocalMode TLM;
465   bool UnnamedAddr;
466   if (ParseToken(lltok::equal, "expected '=' in global variable") ||
467       ParseOptionalLinkage(Linkage, HasLinkage) ||
468       ParseOptionalVisibility(Visibility) ||
469       ParseOptionalDLLStorageClass(DLLStorageClass) ||
470       ParseOptionalThreadLocal(TLM) ||
471       parseOptionalUnnamedAddr(UnnamedAddr))
472     return true;
473
474   if (Lex.getKind() != lltok::kw_alias)
475     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
476                        DLLStorageClass, TLM, UnnamedAddr);
477
478   return ParseAlias(Name, NameLoc, Linkage, Visibility, DLLStorageClass, TLM,
479                     UnnamedAddr);
480 }
481
482 bool LLParser::parseComdat() {
483   assert(Lex.getKind() == lltok::ComdatVar);
484   std::string Name = Lex.getStrVal();
485   LocTy NameLoc = Lex.getLoc();
486   Lex.Lex();
487
488   if (ParseToken(lltok::equal, "expected '=' here"))
489     return true;
490
491   if (ParseToken(lltok::kw_comdat, "expected comdat keyword"))
492     return TokError("expected comdat type");
493
494   Comdat::SelectionKind SK;
495   switch (Lex.getKind()) {
496   default:
497     return TokError("unknown selection kind");
498   case lltok::kw_any:
499     SK = Comdat::Any;
500     break;
501   case lltok::kw_exactmatch:
502     SK = Comdat::ExactMatch;
503     break;
504   case lltok::kw_largest:
505     SK = Comdat::Largest;
506     break;
507   case lltok::kw_noduplicates:
508     SK = Comdat::NoDuplicates;
509     break;
510   case lltok::kw_samesize:
511     SK = Comdat::SameSize;
512     break;
513   }
514   Lex.Lex();
515
516   // See if the comdat was forward referenced, if so, use the comdat.
517   Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
518   Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
519   if (I != ComdatSymTab.end() && !ForwardRefComdats.erase(Name))
520     return Error(NameLoc, "redefinition of comdat '$" + Name + "'");
521
522   Comdat *C;
523   if (I != ComdatSymTab.end())
524     C = &I->second;
525   else
526     C = M->getOrInsertComdat(Name);
527   C->setSelectionKind(SK);
528
529   return false;
530 }
531
532 // MDString:
533 //   ::= '!' STRINGCONSTANT
534 bool LLParser::ParseMDString(MDString *&Result) {
535   std::string Str;
536   if (ParseStringConstant(Str)) return true;
537   llvm::UpgradeMDStringConstant(Str);
538   Result = MDString::get(Context, Str);
539   return false;
540 }
541
542 // MDNode:
543 //   ::= '!' MDNodeNumber
544 bool LLParser::ParseMDNodeID(MDNode *&Result) {
545   // !{ ..., !42, ... }
546   unsigned MID = 0;
547   if (ParseUInt32(MID))
548     return true;
549
550   // If not a forward reference, just return it now.
551   if (NumberedMetadata.count(MID)) {
552     Result = NumberedMetadata[MID];
553     return false;
554   }
555
556   // Otherwise, create MDNode forward reference.
557   auto &FwdRef = ForwardRefMDNodes[MID];
558   FwdRef = std::make_pair(MDTuple::getTemporary(Context, None), Lex.getLoc());
559
560   Result = FwdRef.first.get();
561   NumberedMetadata[MID].reset(Result);
562   return false;
563 }
564
565 /// ParseNamedMetadata:
566 ///   !foo = !{ !1, !2 }
567 bool LLParser::ParseNamedMetadata() {
568   assert(Lex.getKind() == lltok::MetadataVar);
569   std::string Name = Lex.getStrVal();
570   Lex.Lex();
571
572   if (ParseToken(lltok::equal, "expected '=' here") ||
573       ParseToken(lltok::exclaim, "Expected '!' here") ||
574       ParseToken(lltok::lbrace, "Expected '{' here"))
575     return true;
576
577   NamedMDNode *NMD = M->getOrInsertNamedMetadata(Name);
578   if (Lex.getKind() != lltok::rbrace)
579     do {
580       if (ParseToken(lltok::exclaim, "Expected '!' here"))
581         return true;
582
583       MDNode *N = nullptr;
584       if (ParseMDNodeID(N)) return true;
585       NMD->addOperand(N);
586     } while (EatIfPresent(lltok::comma));
587
588   return ParseToken(lltok::rbrace, "expected end of metadata node");
589 }
590
591 /// ParseStandaloneMetadata:
592 ///   !42 = !{...}
593 bool LLParser::ParseStandaloneMetadata() {
594   assert(Lex.getKind() == lltok::exclaim);
595   Lex.Lex();
596   unsigned MetadataID = 0;
597
598   MDNode *Init;
599   if (ParseUInt32(MetadataID) ||
600       ParseToken(lltok::equal, "expected '=' here"))
601     return true;
602
603   // Detect common error, from old metadata syntax.
604   if (Lex.getKind() == lltok::Type)
605     return TokError("unexpected type in metadata definition");
606
607   bool IsDistinct = EatIfPresent(lltok::kw_distinct);
608   if (Lex.getKind() == lltok::MetadataVar) {
609     if (ParseSpecializedMDNode(Init, IsDistinct))
610       return true;
611   } else if (ParseToken(lltok::exclaim, "Expected '!' here") ||
612              ParseMDTuple(Init, IsDistinct))
613     return true;
614
615   // See if this was forward referenced, if so, handle it.
616   auto FI = ForwardRefMDNodes.find(MetadataID);
617   if (FI != ForwardRefMDNodes.end()) {
618     FI->second.first->replaceAllUsesWith(Init);
619     ForwardRefMDNodes.erase(FI);
620
621     assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work");
622   } else {
623     if (NumberedMetadata.count(MetadataID))
624       return TokError("Metadata id is already used");
625     NumberedMetadata[MetadataID].reset(Init);
626   }
627
628   return false;
629 }
630
631 static bool isValidVisibilityForLinkage(unsigned V, unsigned L) {
632   return !GlobalValue::isLocalLinkage((GlobalValue::LinkageTypes)L) ||
633          (GlobalValue::VisibilityTypes)V == GlobalValue::DefaultVisibility;
634 }
635
636 /// ParseAlias:
637 ///   ::= GlobalVar '=' OptionalLinkage OptionalVisibility
638 ///                     OptionalDLLStorageClass OptionalThreadLocal
639 ///                     OptionalUnnamedAddr 'alias' Aliasee
640 ///
641 /// Aliasee
642 ///   ::= TypeAndValue
643 ///
644 /// Everything through OptionalUnnamedAddr has already been parsed.
645 ///
646 bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, unsigned L,
647                           unsigned Visibility, unsigned DLLStorageClass,
648                           GlobalVariable::ThreadLocalMode TLM,
649                           bool UnnamedAddr) {
650   assert(Lex.getKind() == lltok::kw_alias);
651   Lex.Lex();
652
653   GlobalValue::LinkageTypes Linkage = (GlobalValue::LinkageTypes) L;
654
655   if(!GlobalAlias::isValidLinkage(Linkage))
656     return Error(NameLoc, "invalid linkage type for alias");
657
658   if (!isValidVisibilityForLinkage(Visibility, L))
659     return Error(NameLoc,
660                  "symbol with local linkage must have default visibility");
661
662   Constant *Aliasee;
663   LocTy AliaseeLoc = Lex.getLoc();
664   if (Lex.getKind() != lltok::kw_bitcast &&
665       Lex.getKind() != lltok::kw_getelementptr &&
666       Lex.getKind() != lltok::kw_addrspacecast &&
667       Lex.getKind() != lltok::kw_inttoptr) {
668     if (ParseGlobalTypeAndValue(Aliasee))
669       return true;
670   } else {
671     // The bitcast dest type is not present, it is implied by the dest type.
672     ValID ID;
673     if (ParseValID(ID))
674       return true;
675     if (ID.Kind != ValID::t_Constant)
676       return Error(AliaseeLoc, "invalid aliasee");
677     Aliasee = ID.ConstantVal;
678   }
679
680   Type *AliaseeType = Aliasee->getType();
681   auto *PTy = dyn_cast<PointerType>(AliaseeType);
682   if (!PTy)
683     return Error(AliaseeLoc, "An alias must have pointer type");
684
685   // Okay, create the alias but do not insert it into the module yet.
686   std::unique_ptr<GlobalAlias> GA(
687       GlobalAlias::create(PTy, (GlobalValue::LinkageTypes)Linkage, Name,
688                           Aliasee, /*Parent*/ nullptr));
689   GA->setThreadLocalMode(TLM);
690   GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
691   GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
692   GA->setUnnamedAddr(UnnamedAddr);
693
694   if (Name.empty())
695     NumberedVals.push_back(GA.get());
696
697   // See if this value already exists in the symbol table.  If so, it is either
698   // a redefinition or a definition of a forward reference.
699   if (GlobalValue *Val = M->getNamedValue(Name)) {
700     // See if this was a redefinition.  If so, there is no entry in
701     // ForwardRefVals.
702     std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
703       I = ForwardRefVals.find(Name);
704     if (I == ForwardRefVals.end())
705       return Error(NameLoc, "redefinition of global named '@" + Name + "'");
706
707     // Otherwise, this was a definition of forward ref.  Verify that types
708     // agree.
709     if (Val->getType() != GA->getType())
710       return Error(NameLoc,
711               "forward reference and definition of alias have different types");
712
713     // If they agree, just RAUW the old value with the alias and remove the
714     // forward ref info.
715     Val->replaceAllUsesWith(GA.get());
716     Val->eraseFromParent();
717     ForwardRefVals.erase(I);
718   }
719
720   // Insert into the module, we know its name won't collide now.
721   M->getAliasList().push_back(GA.get());
722   assert(GA->getName() == Name && "Should not be a name conflict!");
723
724   // The module owns this now
725   GA.release();
726
727   return false;
728 }
729
730 /// ParseGlobal
731 ///   ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
732 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
733 ///       OptionalExternallyInitialized GlobalType Type Const
734 ///   ::= OptionalLinkage OptionalVisibility OptionalDLLStorageClass
735 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
736 ///       OptionalExternallyInitialized GlobalType Type Const
737 ///
738 /// Everything up to and including OptionalUnnamedAddr has been parsed
739 /// already.
740 ///
741 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
742                            unsigned Linkage, bool HasLinkage,
743                            unsigned Visibility, unsigned DLLStorageClass,
744                            GlobalVariable::ThreadLocalMode TLM,
745                            bool UnnamedAddr) {
746   if (!isValidVisibilityForLinkage(Visibility, Linkage))
747     return Error(NameLoc,
748                  "symbol with local linkage must have default visibility");
749
750   unsigned AddrSpace;
751   bool IsConstant, IsExternallyInitialized;
752   LocTy IsExternallyInitializedLoc;
753   LocTy TyLoc;
754
755   Type *Ty = nullptr;
756   if (ParseOptionalAddrSpace(AddrSpace) ||
757       ParseOptionalToken(lltok::kw_externally_initialized,
758                          IsExternallyInitialized,
759                          &IsExternallyInitializedLoc) ||
760       ParseGlobalType(IsConstant) ||
761       ParseType(Ty, TyLoc))
762     return true;
763
764   // If the linkage is specified and is external, then no initializer is
765   // present.
766   Constant *Init = nullptr;
767   if (!HasLinkage || (Linkage != GlobalValue::ExternalWeakLinkage &&
768                       Linkage != GlobalValue::ExternalLinkage)) {
769     if (ParseGlobalValue(Ty, Init))
770       return true;
771   }
772
773   if (Ty->isFunctionTy() || !PointerType::isValidElementType(Ty))
774     return Error(TyLoc, "invalid type for global variable");
775
776   GlobalValue *GVal = nullptr;
777
778   // See if the global was forward referenced, if so, use the global.
779   if (!Name.empty()) {
780     GVal = M->getNamedValue(Name);
781     if (GVal) {
782       if (!ForwardRefVals.erase(Name) || !isa<GlobalValue>(GVal))
783         return Error(NameLoc, "redefinition of global '@" + Name + "'");
784     }
785   } else {
786     std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
787       I = ForwardRefValIDs.find(NumberedVals.size());
788     if (I != ForwardRefValIDs.end()) {
789       GVal = I->second.first;
790       ForwardRefValIDs.erase(I);
791     }
792   }
793
794   GlobalVariable *GV;
795   if (!GVal) {
796     GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, nullptr,
797                             Name, nullptr, GlobalVariable::NotThreadLocal,
798                             AddrSpace);
799   } else {
800     if (GVal->getValueType() != Ty)
801       return Error(TyLoc,
802             "forward reference and definition of global have different types");
803
804     GV = cast<GlobalVariable>(GVal);
805
806     // Move the forward-reference to the correct spot in the module.
807     M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV);
808   }
809
810   if (Name.empty())
811     NumberedVals.push_back(GV);
812
813   // Set the parsed properties on the global.
814   if (Init)
815     GV->setInitializer(Init);
816   GV->setConstant(IsConstant);
817   GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
818   GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
819   GV->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
820   GV->setExternallyInitialized(IsExternallyInitialized);
821   GV->setThreadLocalMode(TLM);
822   GV->setUnnamedAddr(UnnamedAddr);
823
824   // Parse attributes on the global.
825   while (Lex.getKind() == lltok::comma) {
826     Lex.Lex();
827
828     if (Lex.getKind() == lltok::kw_section) {
829       Lex.Lex();
830       GV->setSection(Lex.getStrVal());
831       if (ParseToken(lltok::StringConstant, "expected global section string"))
832         return true;
833     } else if (Lex.getKind() == lltok::kw_align) {
834       unsigned Alignment;
835       if (ParseOptionalAlignment(Alignment)) return true;
836       GV->setAlignment(Alignment);
837     } else {
838       Comdat *C;
839       if (parseOptionalComdat(Name, C))
840         return true;
841       if (C)
842         GV->setComdat(C);
843       else
844         return TokError("unknown global variable property!");
845     }
846   }
847
848   return false;
849 }
850
851 /// ParseUnnamedAttrGrp
852 ///   ::= 'attributes' AttrGrpID '=' '{' AttrValPair+ '}'
853 bool LLParser::ParseUnnamedAttrGrp() {
854   assert(Lex.getKind() == lltok::kw_attributes);
855   LocTy AttrGrpLoc = Lex.getLoc();
856   Lex.Lex();
857
858   if (Lex.getKind() != lltok::AttrGrpID)
859     return TokError("expected attribute group id");
860
861   unsigned VarID = Lex.getUIntVal();
862   std::vector<unsigned> unused;
863   LocTy BuiltinLoc;
864   Lex.Lex();
865
866   if (ParseToken(lltok::equal, "expected '=' here") ||
867       ParseToken(lltok::lbrace, "expected '{' here") ||
868       ParseFnAttributeValuePairs(NumberedAttrBuilders[VarID], unused, true,
869                                  BuiltinLoc) ||
870       ParseToken(lltok::rbrace, "expected end of attribute group"))
871     return true;
872
873   if (!NumberedAttrBuilders[VarID].hasAttributes())
874     return Error(AttrGrpLoc, "attribute group has no attributes");
875
876   return false;
877 }
878
879 /// ParseFnAttributeValuePairs
880 ///   ::= <attr> | <attr> '=' <value>
881 bool LLParser::ParseFnAttributeValuePairs(AttrBuilder &B,
882                                           std::vector<unsigned> &FwdRefAttrGrps,
883                                           bool inAttrGrp, LocTy &BuiltinLoc) {
884   bool HaveError = false;
885
886   B.clear();
887
888   while (true) {
889     lltok::Kind Token = Lex.getKind();
890     if (Token == lltok::kw_builtin)
891       BuiltinLoc = Lex.getLoc();
892     switch (Token) {
893     default:
894       if (!inAttrGrp) return HaveError;
895       return Error(Lex.getLoc(), "unterminated attribute group");
896     case lltok::rbrace:
897       // Finished.
898       return false;
899
900     case lltok::AttrGrpID: {
901       // Allow a function to reference an attribute group:
902       //
903       //   define void @foo() #1 { ... }
904       if (inAttrGrp)
905         HaveError |=
906           Error(Lex.getLoc(),
907               "cannot have an attribute group reference in an attribute group");
908
909       unsigned AttrGrpNum = Lex.getUIntVal();
910       if (inAttrGrp) break;
911
912       // Save the reference to the attribute group. We'll fill it in later.
913       FwdRefAttrGrps.push_back(AttrGrpNum);
914       break;
915     }
916     // Target-dependent attributes:
917     case lltok::StringConstant: {
918       if (ParseStringAttribute(B))
919         return true;
920       continue;
921     }
922
923     // Target-independent attributes:
924     case lltok::kw_align: {
925       // As a hack, we allow function alignment to be initially parsed as an
926       // attribute on a function declaration/definition or added to an attribute
927       // group and later moved to the alignment field.
928       unsigned Alignment;
929       if (inAttrGrp) {
930         Lex.Lex();
931         if (ParseToken(lltok::equal, "expected '=' here") ||
932             ParseUInt32(Alignment))
933           return true;
934       } else {
935         if (ParseOptionalAlignment(Alignment))
936           return true;
937       }
938       B.addAlignmentAttr(Alignment);
939       continue;
940     }
941     case lltok::kw_alignstack: {
942       unsigned Alignment;
943       if (inAttrGrp) {
944         Lex.Lex();
945         if (ParseToken(lltok::equal, "expected '=' here") ||
946             ParseUInt32(Alignment))
947           return true;
948       } else {
949         if (ParseOptionalStackAlignment(Alignment))
950           return true;
951       }
952       B.addStackAlignmentAttr(Alignment);
953       continue;
954     }
955     case lltok::kw_alwaysinline: B.addAttribute(Attribute::AlwaysInline); break;
956     case lltok::kw_argmemonly: B.addAttribute(Attribute::ArgMemOnly); break;
957     case lltok::kw_builtin: B.addAttribute(Attribute::Builtin); break;
958     case lltok::kw_cold: B.addAttribute(Attribute::Cold); break;
959     case lltok::kw_convergent: B.addAttribute(Attribute::Convergent); break;
960     case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;
961     case lltok::kw_jumptable: B.addAttribute(Attribute::JumpTable); break;
962     case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;
963     case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;
964     case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;
965     case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
966     case lltok::kw_noimplicitfloat:
967       B.addAttribute(Attribute::NoImplicitFloat); break;
968     case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;
969     case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
970     case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
971     case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
972     case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break;
973     case lltok::kw_optnone: B.addAttribute(Attribute::OptimizeNone); break;
974     case lltok::kw_optsize: B.addAttribute(Attribute::OptimizeForSize); break;
975     case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
976     case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
977     case lltok::kw_returns_twice:
978       B.addAttribute(Attribute::ReturnsTwice); break;
979     case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break;
980     case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break;
981     case lltok::kw_sspstrong:
982       B.addAttribute(Attribute::StackProtectStrong); break;
983     case lltok::kw_safestack: B.addAttribute(Attribute::SafeStack); break;
984     case lltok::kw_sanitize_address:
985       B.addAttribute(Attribute::SanitizeAddress); break;
986     case lltok::kw_sanitize_thread:
987       B.addAttribute(Attribute::SanitizeThread); break;
988     case lltok::kw_sanitize_memory:
989       B.addAttribute(Attribute::SanitizeMemory); break;
990     case lltok::kw_uwtable: B.addAttribute(Attribute::UWTable); break;
991
992     // Error handling.
993     case lltok::kw_inreg:
994     case lltok::kw_signext:
995     case lltok::kw_zeroext:
996       HaveError |=
997         Error(Lex.getLoc(),
998               "invalid use of attribute on a function");
999       break;
1000     case lltok::kw_byval:
1001     case lltok::kw_dereferenceable:
1002     case lltok::kw_dereferenceable_or_null:
1003     case lltok::kw_inalloca:
1004     case lltok::kw_nest:
1005     case lltok::kw_noalias:
1006     case lltok::kw_nocapture:
1007     case lltok::kw_nonnull:
1008     case lltok::kw_returned:
1009     case lltok::kw_sret:
1010       HaveError |=
1011         Error(Lex.getLoc(),
1012               "invalid use of parameter-only attribute on a function");
1013       break;
1014     }
1015
1016     Lex.Lex();
1017   }
1018 }
1019
1020 //===----------------------------------------------------------------------===//
1021 // GlobalValue Reference/Resolution Routines.
1022 //===----------------------------------------------------------------------===//
1023
1024 /// GetGlobalVal - Get a value with the specified name or ID, creating a
1025 /// forward reference record if needed.  This can return null if the value
1026 /// exists but does not have the right type.
1027 GlobalValue *LLParser::GetGlobalVal(const std::string &Name, Type *Ty,
1028                                     LocTy Loc) {
1029   PointerType *PTy = dyn_cast<PointerType>(Ty);
1030   if (!PTy) {
1031     Error(Loc, "global variable reference must have pointer type");
1032     return nullptr;
1033   }
1034
1035   // Look this name up in the normal function symbol table.
1036   GlobalValue *Val =
1037     cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name));
1038
1039   // If this is a forward reference for the value, see if we already created a
1040   // forward ref record.
1041   if (!Val) {
1042     std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
1043       I = ForwardRefVals.find(Name);
1044     if (I != ForwardRefVals.end())
1045       Val = I->second.first;
1046   }
1047
1048   // If we have the value in the symbol table or fwd-ref table, return it.
1049   if (Val) {
1050     if (Val->getType() == Ty) return Val;
1051     Error(Loc, "'@" + Name + "' defined with type '" +
1052           getTypeString(Val->getType()) + "'");
1053     return nullptr;
1054   }
1055
1056   // Otherwise, create a new forward reference for this value and remember it.
1057   GlobalValue *FwdVal;
1058   if (FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType()))
1059     FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M);
1060   else
1061     FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
1062                                 GlobalValue::ExternalWeakLinkage, nullptr, Name,
1063                                 nullptr, GlobalVariable::NotThreadLocal,
1064                                 PTy->getAddressSpace());
1065
1066   ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
1067   return FwdVal;
1068 }
1069
1070 GlobalValue *LLParser::GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc) {
1071   PointerType *PTy = dyn_cast<PointerType>(Ty);
1072   if (!PTy) {
1073     Error(Loc, "global variable reference must have pointer type");
1074     return nullptr;
1075   }
1076
1077   GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
1078
1079   // If this is a forward reference for the value, see if we already created a
1080   // forward ref record.
1081   if (!Val) {
1082     std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
1083       I = ForwardRefValIDs.find(ID);
1084     if (I != ForwardRefValIDs.end())
1085       Val = I->second.first;
1086   }
1087
1088   // If we have the value in the symbol table or fwd-ref table, return it.
1089   if (Val) {
1090     if (Val->getType() == Ty) return Val;
1091     Error(Loc, "'@" + Twine(ID) + "' defined with type '" +
1092           getTypeString(Val->getType()) + "'");
1093     return nullptr;
1094   }
1095
1096   // Otherwise, create a new forward reference for this value and remember it.
1097   GlobalValue *FwdVal;
1098   if (FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType()))
1099     FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, "", M);
1100   else
1101     FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
1102                                 GlobalValue::ExternalWeakLinkage, nullptr, "");
1103
1104   ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
1105   return FwdVal;
1106 }
1107
1108
1109 //===----------------------------------------------------------------------===//
1110 // Comdat Reference/Resolution Routines.
1111 //===----------------------------------------------------------------------===//
1112
1113 Comdat *LLParser::getComdat(const std::string &Name, LocTy Loc) {
1114   // Look this name up in the comdat symbol table.
1115   Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
1116   Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
1117   if (I != ComdatSymTab.end())
1118     return &I->second;
1119
1120   // Otherwise, create a new forward reference for this value and remember it.
1121   Comdat *C = M->getOrInsertComdat(Name);
1122   ForwardRefComdats[Name] = Loc;
1123   return C;
1124 }
1125
1126
1127 //===----------------------------------------------------------------------===//
1128 // Helper Routines.
1129 //===----------------------------------------------------------------------===//
1130
1131 /// ParseToken - If the current token has the specified kind, eat it and return
1132 /// success.  Otherwise, emit the specified error and return failure.
1133 bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) {
1134   if (Lex.getKind() != T)
1135     return TokError(ErrMsg);
1136   Lex.Lex();
1137   return false;
1138 }
1139
1140 /// ParseStringConstant
1141 ///   ::= StringConstant
1142 bool LLParser::ParseStringConstant(std::string &Result) {
1143   if (Lex.getKind() != lltok::StringConstant)
1144     return TokError("expected string constant");
1145   Result = Lex.getStrVal();
1146   Lex.Lex();
1147   return false;
1148 }
1149
1150 /// ParseUInt32
1151 ///   ::= uint32
1152 bool LLParser::ParseUInt32(unsigned &Val) {
1153   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
1154     return TokError("expected integer");
1155   uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1);
1156   if (Val64 != unsigned(Val64))
1157     return TokError("expected 32-bit integer (too large)");
1158   Val = Val64;
1159   Lex.Lex();
1160   return false;
1161 }
1162
1163 /// ParseUInt64
1164 ///   ::= uint64
1165 bool LLParser::ParseUInt64(uint64_t &Val) {
1166   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
1167     return TokError("expected integer");
1168   Val = Lex.getAPSIntVal().getLimitedValue();
1169   Lex.Lex();
1170   return false;
1171 }
1172
1173 /// ParseTLSModel
1174 ///   := 'localdynamic'
1175 ///   := 'initialexec'
1176 ///   := 'localexec'
1177 bool LLParser::ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM) {
1178   switch (Lex.getKind()) {
1179     default:
1180       return TokError("expected localdynamic, initialexec or localexec");
1181     case lltok::kw_localdynamic:
1182       TLM = GlobalVariable::LocalDynamicTLSModel;
1183       break;
1184     case lltok::kw_initialexec:
1185       TLM = GlobalVariable::InitialExecTLSModel;
1186       break;
1187     case lltok::kw_localexec:
1188       TLM = GlobalVariable::LocalExecTLSModel;
1189       break;
1190   }
1191
1192   Lex.Lex();
1193   return false;
1194 }
1195
1196 /// ParseOptionalThreadLocal
1197 ///   := /*empty*/
1198 ///   := 'thread_local'
1199 ///   := 'thread_local' '(' tlsmodel ')'
1200 bool LLParser::ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM) {
1201   TLM = GlobalVariable::NotThreadLocal;
1202   if (!EatIfPresent(lltok::kw_thread_local))
1203     return false;
1204
1205   TLM = GlobalVariable::GeneralDynamicTLSModel;
1206   if (Lex.getKind() == lltok::lparen) {
1207     Lex.Lex();
1208     return ParseTLSModel(TLM) ||
1209       ParseToken(lltok::rparen, "expected ')' after thread local model");
1210   }
1211   return false;
1212 }
1213
1214 /// ParseOptionalAddrSpace
1215 ///   := /*empty*/
1216 ///   := 'addrspace' '(' uint32 ')'
1217 bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) {
1218   AddrSpace = 0;
1219   if (!EatIfPresent(lltok::kw_addrspace))
1220     return false;
1221   return ParseToken(lltok::lparen, "expected '(' in address space") ||
1222          ParseUInt32(AddrSpace) ||
1223          ParseToken(lltok::rparen, "expected ')' in address space");
1224 }
1225
1226 /// ParseStringAttribute
1227 ///   := StringConstant
1228 ///   := StringConstant '=' StringConstant
1229 bool LLParser::ParseStringAttribute(AttrBuilder &B) {
1230   std::string Attr = Lex.getStrVal();
1231   Lex.Lex();
1232   std::string Val;
1233   if (EatIfPresent(lltok::equal) && ParseStringConstant(Val))
1234     return true;
1235   B.addAttribute(Attr, Val);
1236   return false;
1237 }
1238
1239 /// ParseOptionalParamAttrs - Parse a potentially empty list of parameter attributes.
1240 bool LLParser::ParseOptionalParamAttrs(AttrBuilder &B) {
1241   bool HaveError = false;
1242
1243   B.clear();
1244
1245   while (1) {
1246     lltok::Kind Token = Lex.getKind();
1247     switch (Token) {
1248     default:  // End of attributes.
1249       return HaveError;
1250     case lltok::StringConstant: {
1251       if (ParseStringAttribute(B))
1252         return true;
1253       continue;
1254     }
1255     case lltok::kw_align: {
1256       unsigned Alignment;
1257       if (ParseOptionalAlignment(Alignment))
1258         return true;
1259       B.addAlignmentAttr(Alignment);
1260       continue;
1261     }
1262     case lltok::kw_byval:           B.addAttribute(Attribute::ByVal); break;
1263     case lltok::kw_dereferenceable: {
1264       uint64_t Bytes;
1265       if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1266         return true;
1267       B.addDereferenceableAttr(Bytes);
1268       continue;
1269     }
1270     case lltok::kw_dereferenceable_or_null: {
1271       uint64_t Bytes;
1272       if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1273         return true;
1274       B.addDereferenceableOrNullAttr(Bytes);
1275       continue;
1276     }
1277     case lltok::kw_inalloca:        B.addAttribute(Attribute::InAlloca); break;
1278     case lltok::kw_inreg:           B.addAttribute(Attribute::InReg); break;
1279     case lltok::kw_nest:            B.addAttribute(Attribute::Nest); break;
1280     case lltok::kw_noalias:         B.addAttribute(Attribute::NoAlias); break;
1281     case lltok::kw_nocapture:       B.addAttribute(Attribute::NoCapture); break;
1282     case lltok::kw_nonnull:         B.addAttribute(Attribute::NonNull); break;
1283     case lltok::kw_readnone:        B.addAttribute(Attribute::ReadNone); break;
1284     case lltok::kw_readonly:        B.addAttribute(Attribute::ReadOnly); break;
1285     case lltok::kw_returned:        B.addAttribute(Attribute::Returned); break;
1286     case lltok::kw_signext:         B.addAttribute(Attribute::SExt); break;
1287     case lltok::kw_sret:            B.addAttribute(Attribute::StructRet); break;
1288     case lltok::kw_zeroext:         B.addAttribute(Attribute::ZExt); break;
1289
1290     case lltok::kw_alignstack:
1291     case lltok::kw_alwaysinline:
1292     case lltok::kw_argmemonly:
1293     case lltok::kw_builtin:
1294     case lltok::kw_inlinehint:
1295     case lltok::kw_jumptable:
1296     case lltok::kw_minsize:
1297     case lltok::kw_naked:
1298     case lltok::kw_nobuiltin:
1299     case lltok::kw_noduplicate:
1300     case lltok::kw_noimplicitfloat:
1301     case lltok::kw_noinline:
1302     case lltok::kw_nonlazybind:
1303     case lltok::kw_noredzone:
1304     case lltok::kw_noreturn:
1305     case lltok::kw_nounwind:
1306     case lltok::kw_optnone:
1307     case lltok::kw_optsize:
1308     case lltok::kw_returns_twice:
1309     case lltok::kw_sanitize_address:
1310     case lltok::kw_sanitize_memory:
1311     case lltok::kw_sanitize_thread:
1312     case lltok::kw_ssp:
1313     case lltok::kw_sspreq:
1314     case lltok::kw_sspstrong:
1315     case lltok::kw_safestack:
1316     case lltok::kw_uwtable:
1317       HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
1318       break;
1319     }
1320
1321     Lex.Lex();
1322   }
1323 }
1324
1325 /// ParseOptionalReturnAttrs - Parse a potentially empty list of return attributes.
1326 bool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
1327   bool HaveError = false;
1328
1329   B.clear();
1330
1331   while (1) {
1332     lltok::Kind Token = Lex.getKind();
1333     switch (Token) {
1334     default:  // End of attributes.
1335       return HaveError;
1336     case lltok::StringConstant: {
1337       if (ParseStringAttribute(B))
1338         return true;
1339       continue;
1340     }
1341     case lltok::kw_dereferenceable: {
1342       uint64_t Bytes;
1343       if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1344         return true;
1345       B.addDereferenceableAttr(Bytes);
1346       continue;
1347     }
1348     case lltok::kw_dereferenceable_or_null: {
1349       uint64_t Bytes;
1350       if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1351         return true;
1352       B.addDereferenceableOrNullAttr(Bytes);
1353       continue;
1354     }
1355     case lltok::kw_inreg:           B.addAttribute(Attribute::InReg); break;
1356     case lltok::kw_noalias:         B.addAttribute(Attribute::NoAlias); break;
1357     case lltok::kw_nonnull:         B.addAttribute(Attribute::NonNull); break;
1358     case lltok::kw_signext:         B.addAttribute(Attribute::SExt); break;
1359     case lltok::kw_zeroext:         B.addAttribute(Attribute::ZExt); break;
1360
1361     // Error handling.
1362     case lltok::kw_align:
1363     case lltok::kw_byval:
1364     case lltok::kw_inalloca:
1365     case lltok::kw_nest:
1366     case lltok::kw_nocapture:
1367     case lltok::kw_returned:
1368     case lltok::kw_sret:
1369       HaveError |= Error(Lex.getLoc(), "invalid use of parameter-only attribute");
1370       break;
1371
1372     case lltok::kw_alignstack:
1373     case lltok::kw_alwaysinline:
1374     case lltok::kw_argmemonly:
1375     case lltok::kw_builtin:
1376     case lltok::kw_cold:
1377     case lltok::kw_inlinehint:
1378     case lltok::kw_jumptable:
1379     case lltok::kw_minsize:
1380     case lltok::kw_naked:
1381     case lltok::kw_nobuiltin:
1382     case lltok::kw_noduplicate:
1383     case lltok::kw_noimplicitfloat:
1384     case lltok::kw_noinline:
1385     case lltok::kw_nonlazybind:
1386     case lltok::kw_noredzone:
1387     case lltok::kw_noreturn:
1388     case lltok::kw_nounwind:
1389     case lltok::kw_optnone:
1390     case lltok::kw_optsize:
1391     case lltok::kw_returns_twice:
1392     case lltok::kw_sanitize_address:
1393     case lltok::kw_sanitize_memory:
1394     case lltok::kw_sanitize_thread:
1395     case lltok::kw_ssp:
1396     case lltok::kw_sspreq:
1397     case lltok::kw_sspstrong:
1398     case lltok::kw_safestack:
1399     case lltok::kw_uwtable:
1400       HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
1401       break;
1402
1403     case lltok::kw_readnone:
1404     case lltok::kw_readonly:
1405       HaveError |= Error(Lex.getLoc(), "invalid use of attribute on return type");
1406     }
1407
1408     Lex.Lex();
1409   }
1410 }
1411
1412 /// ParseOptionalLinkage
1413 ///   ::= /*empty*/
1414 ///   ::= 'private'
1415 ///   ::= 'internal'
1416 ///   ::= 'weak'
1417 ///   ::= 'weak_odr'
1418 ///   ::= 'linkonce'
1419 ///   ::= 'linkonce_odr'
1420 ///   ::= 'available_externally'
1421 ///   ::= 'appending'
1422 ///   ::= 'common'
1423 ///   ::= 'extern_weak'
1424 ///   ::= 'external'
1425 bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {
1426   HasLinkage = false;
1427   switch (Lex.getKind()) {
1428   default:                       Res=GlobalValue::ExternalLinkage; return false;
1429   case lltok::kw_private:        Res = GlobalValue::PrivateLinkage;       break;
1430   case lltok::kw_internal:       Res = GlobalValue::InternalLinkage;      break;
1431   case lltok::kw_weak:           Res = GlobalValue::WeakAnyLinkage;       break;
1432   case lltok::kw_weak_odr:       Res = GlobalValue::WeakODRLinkage;       break;
1433   case lltok::kw_linkonce:       Res = GlobalValue::LinkOnceAnyLinkage;   break;
1434   case lltok::kw_linkonce_odr:   Res = GlobalValue::LinkOnceODRLinkage;   break;
1435   case lltok::kw_available_externally:
1436     Res = GlobalValue::AvailableExternallyLinkage;
1437     break;
1438   case lltok::kw_appending:      Res = GlobalValue::AppendingLinkage;     break;
1439   case lltok::kw_common:         Res = GlobalValue::CommonLinkage;        break;
1440   case lltok::kw_extern_weak:    Res = GlobalValue::ExternalWeakLinkage;  break;
1441   case lltok::kw_external:       Res = GlobalValue::ExternalLinkage;      break;
1442   }
1443   Lex.Lex();
1444   HasLinkage = true;
1445   return false;
1446 }
1447
1448 /// ParseOptionalVisibility
1449 ///   ::= /*empty*/
1450 ///   ::= 'default'
1451 ///   ::= 'hidden'
1452 ///   ::= 'protected'
1453 ///
1454 bool LLParser::ParseOptionalVisibility(unsigned &Res) {
1455   switch (Lex.getKind()) {
1456   default:                  Res = GlobalValue::DefaultVisibility; return false;
1457   case lltok::kw_default:   Res = GlobalValue::DefaultVisibility; break;
1458   case lltok::kw_hidden:    Res = GlobalValue::HiddenVisibility; break;
1459   case lltok::kw_protected: Res = GlobalValue::ProtectedVisibility; break;
1460   }
1461   Lex.Lex();
1462   return false;
1463 }
1464
1465 /// ParseOptionalDLLStorageClass
1466 ///   ::= /*empty*/
1467 ///   ::= 'dllimport'
1468 ///   ::= 'dllexport'
1469 ///
1470 bool LLParser::ParseOptionalDLLStorageClass(unsigned &Res) {
1471   switch (Lex.getKind()) {
1472   default:                  Res = GlobalValue::DefaultStorageClass; return false;
1473   case lltok::kw_dllimport: Res = GlobalValue::DLLImportStorageClass; break;
1474   case lltok::kw_dllexport: Res = GlobalValue::DLLExportStorageClass; break;
1475   }
1476   Lex.Lex();
1477   return false;
1478 }
1479
1480 /// ParseOptionalCallingConv
1481 ///   ::= /*empty*/
1482 ///   ::= 'ccc'
1483 ///   ::= 'fastcc'
1484 ///   ::= 'intel_ocl_bicc'
1485 ///   ::= 'coldcc'
1486 ///   ::= 'x86_stdcallcc'
1487 ///   ::= 'x86_fastcallcc'
1488 ///   ::= 'x86_thiscallcc'
1489 ///   ::= 'x86_vectorcallcc'
1490 ///   ::= 'arm_apcscc'
1491 ///   ::= 'arm_aapcscc'
1492 ///   ::= 'arm_aapcs_vfpcc'
1493 ///   ::= 'msp430_intrcc'
1494 ///   ::= 'ptx_kernel'
1495 ///   ::= 'ptx_device'
1496 ///   ::= 'spir_func'
1497 ///   ::= 'spir_kernel'
1498 ///   ::= 'x86_64_sysvcc'
1499 ///   ::= 'x86_64_win64cc'
1500 ///   ::= 'webkit_jscc'
1501 ///   ::= 'anyregcc'
1502 ///   ::= 'preserve_mostcc'
1503 ///   ::= 'preserve_allcc'
1504 ///   ::= 'ghccc'
1505 ///   ::= 'cc' UINT
1506 ///
1507 bool LLParser::ParseOptionalCallingConv(unsigned &CC) {
1508   switch (Lex.getKind()) {
1509   default:                       CC = CallingConv::C; return false;
1510   case lltok::kw_ccc:            CC = CallingConv::C; break;
1511   case lltok::kw_fastcc:         CC = CallingConv::Fast; break;
1512   case lltok::kw_coldcc:         CC = CallingConv::Cold; break;
1513   case lltok::kw_x86_stdcallcc:  CC = CallingConv::X86_StdCall; break;
1514   case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break;
1515   case lltok::kw_x86_thiscallcc: CC = CallingConv::X86_ThisCall; break;
1516   case lltok::kw_x86_vectorcallcc:CC = CallingConv::X86_VectorCall; break;
1517   case lltok::kw_arm_apcscc:     CC = CallingConv::ARM_APCS; break;
1518   case lltok::kw_arm_aapcscc:    CC = CallingConv::ARM_AAPCS; break;
1519   case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break;
1520   case lltok::kw_msp430_intrcc:  CC = CallingConv::MSP430_INTR; break;
1521   case lltok::kw_ptx_kernel:     CC = CallingConv::PTX_Kernel; break;
1522   case lltok::kw_ptx_device:     CC = CallingConv::PTX_Device; break;
1523   case lltok::kw_spir_kernel:    CC = CallingConv::SPIR_KERNEL; break;
1524   case lltok::kw_spir_func:      CC = CallingConv::SPIR_FUNC; break;
1525   case lltok::kw_intel_ocl_bicc: CC = CallingConv::Intel_OCL_BI; break;
1526   case lltok::kw_x86_64_sysvcc:  CC = CallingConv::X86_64_SysV; break;
1527   case lltok::kw_x86_64_win64cc: CC = CallingConv::X86_64_Win64; break;
1528   case lltok::kw_webkit_jscc:    CC = CallingConv::WebKit_JS; break;
1529   case lltok::kw_anyregcc:       CC = CallingConv::AnyReg; break;
1530   case lltok::kw_preserve_mostcc:CC = CallingConv::PreserveMost; break;
1531   case lltok::kw_preserve_allcc: CC = CallingConv::PreserveAll; break;
1532   case lltok::kw_ghccc:          CC = CallingConv::GHC; break;
1533   case lltok::kw_cc: {
1534       Lex.Lex();
1535       return ParseUInt32(CC);
1536     }
1537   }
1538
1539   Lex.Lex();
1540   return false;
1541 }
1542
1543 /// ParseMetadataAttachment
1544 ///   ::= !dbg !42
1545 bool LLParser::ParseMetadataAttachment(unsigned &Kind, MDNode *&MD) {
1546   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata attachment");
1547
1548   std::string Name = Lex.getStrVal();
1549   Kind = M->getMDKindID(Name);
1550   Lex.Lex();
1551
1552   return ParseMDNode(MD);
1553 }
1554
1555 /// ParseInstructionMetadata
1556 ///   ::= !dbg !42 (',' !dbg !57)*
1557 bool LLParser::ParseInstructionMetadata(Instruction &Inst) {
1558   do {
1559     if (Lex.getKind() != lltok::MetadataVar)
1560       return TokError("expected metadata after comma");
1561
1562     unsigned MDK;
1563     MDNode *N;
1564     if (ParseMetadataAttachment(MDK, N))
1565       return true;
1566
1567     Inst.setMetadata(MDK, N);
1568     if (MDK == LLVMContext::MD_tbaa)
1569       InstsWithTBAATag.push_back(&Inst);
1570
1571     // If this is the end of the list, we're done.
1572   } while (EatIfPresent(lltok::comma));
1573   return false;
1574 }
1575
1576 /// ParseOptionalFunctionMetadata
1577 ///   ::= (!dbg !57)*
1578 bool LLParser::ParseOptionalFunctionMetadata(Function &F) {
1579   while (Lex.getKind() == lltok::MetadataVar) {
1580     unsigned MDK;
1581     MDNode *N;
1582     if (ParseMetadataAttachment(MDK, N))
1583       return true;
1584
1585     F.setMetadata(MDK, N);
1586   }
1587   return false;
1588 }
1589
1590 /// ParseOptionalAlignment
1591 ///   ::= /* empty */
1592 ///   ::= 'align' 4
1593 bool LLParser::ParseOptionalAlignment(unsigned &Alignment) {
1594   Alignment = 0;
1595   if (!EatIfPresent(lltok::kw_align))
1596     return false;
1597   LocTy AlignLoc = Lex.getLoc();
1598   if (ParseUInt32(Alignment)) return true;
1599   if (!isPowerOf2_32(Alignment))
1600     return Error(AlignLoc, "alignment is not a power of two");
1601   if (Alignment > Value::MaximumAlignment)
1602     return Error(AlignLoc, "huge alignments are not supported yet");
1603   return false;
1604 }
1605
1606 /// ParseOptionalDerefAttrBytes
1607 ///   ::= /* empty */
1608 ///   ::= AttrKind '(' 4 ')'
1609 ///
1610 /// where AttrKind is either 'dereferenceable' or 'dereferenceable_or_null'.
1611 bool LLParser::ParseOptionalDerefAttrBytes(lltok::Kind AttrKind,
1612                                            uint64_t &Bytes) {
1613   assert((AttrKind == lltok::kw_dereferenceable ||
1614           AttrKind == lltok::kw_dereferenceable_or_null) &&
1615          "contract!");
1616
1617   Bytes = 0;
1618   if (!EatIfPresent(AttrKind))
1619     return false;
1620   LocTy ParenLoc = Lex.getLoc();
1621   if (!EatIfPresent(lltok::lparen))
1622     return Error(ParenLoc, "expected '('");
1623   LocTy DerefLoc = Lex.getLoc();
1624   if (ParseUInt64(Bytes)) return true;
1625   ParenLoc = Lex.getLoc();
1626   if (!EatIfPresent(lltok::rparen))
1627     return Error(ParenLoc, "expected ')'");
1628   if (!Bytes)
1629     return Error(DerefLoc, "dereferenceable bytes must be non-zero");
1630   return false;
1631 }
1632
1633 /// ParseOptionalCommaAlign
1634 ///   ::=
1635 ///   ::= ',' align 4
1636 ///
1637 /// This returns with AteExtraComma set to true if it ate an excess comma at the
1638 /// end.
1639 bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment,
1640                                        bool &AteExtraComma) {
1641   AteExtraComma = false;
1642   while (EatIfPresent(lltok::comma)) {
1643     // Metadata at the end is an early exit.
1644     if (Lex.getKind() == lltok::MetadataVar) {
1645       AteExtraComma = true;
1646       return false;
1647     }
1648
1649     if (Lex.getKind() != lltok::kw_align)
1650       return Error(Lex.getLoc(), "expected metadata or 'align'");
1651
1652     if (ParseOptionalAlignment(Alignment)) return true;
1653   }
1654
1655   return false;
1656 }
1657
1658 /// ParseScopeAndOrdering
1659 ///   if isAtomic: ::= 'singlethread'? AtomicOrdering
1660 ///   else: ::=
1661 ///
1662 /// This sets Scope and Ordering to the parsed values.
1663 bool LLParser::ParseScopeAndOrdering(bool isAtomic, SynchronizationScope &Scope,
1664                                      AtomicOrdering &Ordering) {
1665   if (!isAtomic)
1666     return false;
1667
1668   Scope = CrossThread;
1669   if (EatIfPresent(lltok::kw_singlethread))
1670     Scope = SingleThread;
1671
1672   return ParseOrdering(Ordering);
1673 }
1674
1675 /// ParseOrdering
1676 ///   ::= AtomicOrdering
1677 ///
1678 /// This sets Ordering to the parsed value.
1679 bool LLParser::ParseOrdering(AtomicOrdering &Ordering) {
1680   switch (Lex.getKind()) {
1681   default: return TokError("Expected ordering on atomic instruction");
1682   case lltok::kw_unordered: Ordering = Unordered; break;
1683   case lltok::kw_monotonic: Ordering = Monotonic; break;
1684   case lltok::kw_acquire: Ordering = Acquire; break;
1685   case lltok::kw_release: Ordering = Release; break;
1686   case lltok::kw_acq_rel: Ordering = AcquireRelease; break;
1687   case lltok::kw_seq_cst: Ordering = SequentiallyConsistent; break;
1688   }
1689   Lex.Lex();
1690   return false;
1691 }
1692
1693 /// ParseOptionalStackAlignment
1694 ///   ::= /* empty */
1695 ///   ::= 'alignstack' '(' 4 ')'
1696 bool LLParser::ParseOptionalStackAlignment(unsigned &Alignment) {
1697   Alignment = 0;
1698   if (!EatIfPresent(lltok::kw_alignstack))
1699     return false;
1700   LocTy ParenLoc = Lex.getLoc();
1701   if (!EatIfPresent(lltok::lparen))
1702     return Error(ParenLoc, "expected '('");
1703   LocTy AlignLoc = Lex.getLoc();
1704   if (ParseUInt32(Alignment)) return true;
1705   ParenLoc = Lex.getLoc();
1706   if (!EatIfPresent(lltok::rparen))
1707     return Error(ParenLoc, "expected ')'");
1708   if (!isPowerOf2_32(Alignment))
1709     return Error(AlignLoc, "stack alignment is not a power of two");
1710   return false;
1711 }
1712
1713 /// ParseIndexList - This parses the index list for an insert/extractvalue
1714 /// instruction.  This sets AteExtraComma in the case where we eat an extra
1715 /// comma at the end of the line and find that it is followed by metadata.
1716 /// Clients that don't allow metadata can call the version of this function that
1717 /// only takes one argument.
1718 ///
1719 /// ParseIndexList
1720 ///    ::=  (',' uint32)+
1721 ///
1722 bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices,
1723                               bool &AteExtraComma) {
1724   AteExtraComma = false;
1725
1726   if (Lex.getKind() != lltok::comma)
1727     return TokError("expected ',' as start of index list");
1728
1729   while (EatIfPresent(lltok::comma)) {
1730     if (Lex.getKind() == lltok::MetadataVar) {
1731       if (Indices.empty()) return TokError("expected index");
1732       AteExtraComma = true;
1733       return false;
1734     }
1735     unsigned Idx = 0;
1736     if (ParseUInt32(Idx)) return true;
1737     Indices.push_back(Idx);
1738   }
1739
1740   return false;
1741 }
1742
1743 //===----------------------------------------------------------------------===//
1744 // Type Parsing.
1745 //===----------------------------------------------------------------------===//
1746
1747 /// ParseType - Parse a type.
1748 bool LLParser::ParseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
1749   SMLoc TypeLoc = Lex.getLoc();
1750   switch (Lex.getKind()) {
1751   default:
1752     return TokError(Msg);
1753   case lltok::Type:
1754     // Type ::= 'float' | 'void' (etc)
1755     Result = Lex.getTyVal();
1756     Lex.Lex();
1757     break;
1758   case lltok::lbrace:
1759     // Type ::= StructType
1760     if (ParseAnonStructType(Result, false))
1761       return true;
1762     break;
1763   case lltok::lsquare:
1764     // Type ::= '[' ... ']'
1765     Lex.Lex(); // eat the lsquare.
1766     if (ParseArrayVectorType(Result, false))
1767       return true;
1768     break;
1769   case lltok::less: // Either vector or packed struct.
1770     // Type ::= '<' ... '>'
1771     Lex.Lex();
1772     if (Lex.getKind() == lltok::lbrace) {
1773       if (ParseAnonStructType(Result, true) ||
1774           ParseToken(lltok::greater, "expected '>' at end of packed struct"))
1775         return true;
1776     } else if (ParseArrayVectorType(Result, true))
1777       return true;
1778     break;
1779   case lltok::LocalVar: {
1780     // Type ::= %foo
1781     std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.getStrVal()];
1782
1783     // If the type hasn't been defined yet, create a forward definition and
1784     // remember where that forward def'n was seen (in case it never is defined).
1785     if (!Entry.first) {
1786       Entry.first = StructType::create(Context, Lex.getStrVal());
1787       Entry.second = Lex.getLoc();
1788     }
1789     Result = Entry.first;
1790     Lex.Lex();
1791     break;
1792   }
1793
1794   case lltok::LocalVarID: {
1795     // Type ::= %4
1796     std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.getUIntVal()];
1797
1798     // If the type hasn't been defined yet, create a forward definition and
1799     // remember where that forward def'n was seen (in case it never is defined).
1800     if (!Entry.first) {
1801       Entry.first = StructType::create(Context);
1802       Entry.second = Lex.getLoc();
1803     }
1804     Result = Entry.first;
1805     Lex.Lex();
1806     break;
1807   }
1808   }
1809
1810   // Parse the type suffixes.
1811   while (1) {
1812     switch (Lex.getKind()) {
1813     // End of type.
1814     default:
1815       if (!AllowVoid && Result->isVoidTy())
1816         return Error(TypeLoc, "void type only allowed for function results");
1817       return false;
1818
1819     // Type ::= Type '*'
1820     case lltok::star:
1821       if (Result->isLabelTy())
1822         return TokError("basic block pointers are invalid");
1823       if (Result->isVoidTy())
1824         return TokError("pointers to void are invalid - use i8* instead");
1825       if (!PointerType::isValidElementType(Result))
1826         return TokError("pointer to this type is invalid");
1827       Result = PointerType::getUnqual(Result);
1828       Lex.Lex();
1829       break;
1830
1831     // Type ::= Type 'addrspace' '(' uint32 ')' '*'
1832     case lltok::kw_addrspace: {
1833       if (Result->isLabelTy())
1834         return TokError("basic block pointers are invalid");
1835       if (Result->isVoidTy())
1836         return TokError("pointers to void are invalid; use i8* instead");
1837       if (!PointerType::isValidElementType(Result))
1838         return TokError("pointer to this type is invalid");
1839       unsigned AddrSpace;
1840       if (ParseOptionalAddrSpace(AddrSpace) ||
1841           ParseToken(lltok::star, "expected '*' in address space"))
1842         return true;
1843
1844       Result = PointerType::get(Result, AddrSpace);
1845       break;
1846     }
1847
1848     /// Types '(' ArgTypeListI ')' OptFuncAttrs
1849     case lltok::lparen:
1850       if (ParseFunctionType(Result))
1851         return true;
1852       break;
1853     }
1854   }
1855 }
1856
1857 /// ParseParameterList
1858 ///    ::= '(' ')'
1859 ///    ::= '(' Arg (',' Arg)* ')'
1860 ///  Arg
1861 ///    ::= Type OptionalAttributes Value OptionalAttributes
1862 bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
1863                                   PerFunctionState &PFS, bool IsMustTailCall,
1864                                   bool InVarArgsFunc) {
1865   if (ParseToken(lltok::lparen, "expected '(' in call"))
1866     return true;
1867
1868   unsigned AttrIndex = 1;
1869   while (Lex.getKind() != lltok::rparen) {
1870     // If this isn't the first argument, we need a comma.
1871     if (!ArgList.empty() &&
1872         ParseToken(lltok::comma, "expected ',' in argument list"))
1873       return true;
1874
1875     // Parse an ellipsis if this is a musttail call in a variadic function.
1876     if (Lex.getKind() == lltok::dotdotdot) {
1877       const char *Msg = "unexpected ellipsis in argument list for ";
1878       if (!IsMustTailCall)
1879         return TokError(Twine(Msg) + "non-musttail call");
1880       if (!InVarArgsFunc)
1881         return TokError(Twine(Msg) + "musttail call in non-varargs function");
1882       Lex.Lex();  // Lex the '...', it is purely for readability.
1883       return ParseToken(lltok::rparen, "expected ')' at end of argument list");
1884     }
1885
1886     // Parse the argument.
1887     LocTy ArgLoc;
1888     Type *ArgTy = nullptr;
1889     AttrBuilder ArgAttrs;
1890     Value *V;
1891     if (ParseType(ArgTy, ArgLoc))
1892       return true;
1893
1894     if (ArgTy->isMetadataTy()) {
1895       if (ParseMetadataAsValue(V, PFS))
1896         return true;
1897     } else {
1898       // Otherwise, handle normal operands.
1899       if (ParseOptionalParamAttrs(ArgAttrs) || ParseValue(ArgTy, V, PFS))
1900         return true;
1901     }
1902     ArgList.push_back(ParamInfo(ArgLoc, V, AttributeSet::get(V->getContext(),
1903                                                              AttrIndex++,
1904                                                              ArgAttrs)));
1905   }
1906
1907   if (IsMustTailCall && InVarArgsFunc)
1908     return TokError("expected '...' at end of argument list for musttail call "
1909                     "in varargs function");
1910
1911   Lex.Lex();  // Lex the ')'.
1912   return false;
1913 }
1914
1915
1916
1917 /// ParseArgumentList - Parse the argument list for a function type or function
1918 /// prototype.
1919 ///   ::= '(' ArgTypeListI ')'
1920 /// ArgTypeListI
1921 ///   ::= /*empty*/
1922 ///   ::= '...'
1923 ///   ::= ArgTypeList ',' '...'
1924 ///   ::= ArgType (',' ArgType)*
1925 ///
1926 bool LLParser::ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
1927                                  bool &isVarArg){
1928   isVarArg = false;
1929   assert(Lex.getKind() == lltok::lparen);
1930   Lex.Lex(); // eat the (.
1931
1932   if (Lex.getKind() == lltok::rparen) {
1933     // empty
1934   } else if (Lex.getKind() == lltok::dotdotdot) {
1935     isVarArg = true;
1936     Lex.Lex();
1937   } else {
1938     LocTy TypeLoc = Lex.getLoc();
1939     Type *ArgTy = nullptr;
1940     AttrBuilder Attrs;
1941     std::string Name;
1942
1943     if (ParseType(ArgTy) ||
1944         ParseOptionalParamAttrs(Attrs)) return true;
1945
1946     if (ArgTy->isVoidTy())
1947       return Error(TypeLoc, "argument can not have void type");
1948
1949     if (Lex.getKind() == lltok::LocalVar) {
1950       Name = Lex.getStrVal();
1951       Lex.Lex();
1952     }
1953
1954     if (!FunctionType::isValidArgumentType(ArgTy))
1955       return Error(TypeLoc, "invalid type for function argument");
1956
1957     unsigned AttrIndex = 1;
1958     ArgList.emplace_back(TypeLoc, ArgTy, AttributeSet::get(ArgTy->getContext(),
1959                                                            AttrIndex++, Attrs),
1960                          std::move(Name));
1961
1962     while (EatIfPresent(lltok::comma)) {
1963       // Handle ... at end of arg list.
1964       if (EatIfPresent(lltok::dotdotdot)) {
1965         isVarArg = true;
1966         break;
1967       }
1968
1969       // Otherwise must be an argument type.
1970       TypeLoc = Lex.getLoc();
1971       if (ParseType(ArgTy) || ParseOptionalParamAttrs(Attrs)) return true;
1972
1973       if (ArgTy->isVoidTy())
1974         return Error(TypeLoc, "argument can not have void type");
1975
1976       if (Lex.getKind() == lltok::LocalVar) {
1977         Name = Lex.getStrVal();
1978         Lex.Lex();
1979       } else {
1980         Name = "";
1981       }
1982
1983       if (!ArgTy->isFirstClassType())
1984         return Error(TypeLoc, "invalid type for function argument");
1985
1986       ArgList.emplace_back(
1987           TypeLoc, ArgTy,
1988           AttributeSet::get(ArgTy->getContext(), AttrIndex++, Attrs),
1989           std::move(Name));
1990     }
1991   }
1992
1993   return ParseToken(lltok::rparen, "expected ')' at end of argument list");
1994 }
1995
1996 /// ParseFunctionType
1997 ///  ::= Type ArgumentList OptionalAttrs
1998 bool LLParser::ParseFunctionType(Type *&Result) {
1999   assert(Lex.getKind() == lltok::lparen);
2000
2001   if (!FunctionType::isValidReturnType(Result))
2002     return TokError("invalid function return type");
2003
2004   SmallVector<ArgInfo, 8> ArgList;
2005   bool isVarArg;
2006   if (ParseArgumentList(ArgList, isVarArg))
2007     return true;
2008
2009   // Reject names on the arguments lists.
2010   for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
2011     if (!ArgList[i].Name.empty())
2012       return Error(ArgList[i].Loc, "argument name invalid in function type");
2013     if (ArgList[i].Attrs.hasAttributes(i + 1))
2014       return Error(ArgList[i].Loc,
2015                    "argument attributes invalid in function type");
2016   }
2017
2018   SmallVector<Type*, 16> ArgListTy;
2019   for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
2020     ArgListTy.push_back(ArgList[i].Ty);
2021
2022   Result = FunctionType::get(Result, ArgListTy, isVarArg);
2023   return false;
2024 }
2025
2026 /// ParseAnonStructType - Parse an anonymous struct type, which is inlined into
2027 /// other structs.
2028 bool LLParser::ParseAnonStructType(Type *&Result, bool Packed) {
2029   SmallVector<Type*, 8> Elts;
2030   if (ParseStructBody(Elts)) return true;
2031
2032   Result = StructType::get(Context, Elts, Packed);
2033   return false;
2034 }
2035
2036 /// ParseStructDefinition - Parse a struct in a 'type' definition.
2037 bool LLParser::ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
2038                                      std::pair<Type*, LocTy> &Entry,
2039                                      Type *&ResultTy) {
2040   // If the type was already defined, diagnose the redefinition.
2041   if (Entry.first && !Entry.second.isValid())
2042     return Error(TypeLoc, "redefinition of type");
2043
2044   // If we have opaque, just return without filling in the definition for the
2045   // struct.  This counts as a definition as far as the .ll file goes.
2046   if (EatIfPresent(lltok::kw_opaque)) {
2047     // This type is being defined, so clear the location to indicate this.
2048     Entry.second = SMLoc();
2049
2050     // If this type number has never been uttered, create it.
2051     if (!Entry.first)
2052       Entry.first = StructType::create(Context, Name);
2053     ResultTy = Entry.first;
2054     return false;
2055   }
2056
2057   // If the type starts with '<', then it is either a packed struct or a vector.
2058   bool isPacked = EatIfPresent(lltok::less);
2059
2060   // If we don't have a struct, then we have a random type alias, which we
2061   // accept for compatibility with old files.  These types are not allowed to be
2062   // forward referenced and not allowed to be recursive.
2063   if (Lex.getKind() != lltok::lbrace) {
2064     if (Entry.first)
2065       return Error(TypeLoc, "forward references to non-struct type");
2066
2067     ResultTy = nullptr;
2068     if (isPacked)
2069       return ParseArrayVectorType(ResultTy, true);
2070     return ParseType(ResultTy);
2071   }
2072
2073   // This type is being defined, so clear the location to indicate this.
2074   Entry.second = SMLoc();
2075
2076   // If this type number has never been uttered, create it.
2077   if (!Entry.first)
2078     Entry.first = StructType::create(Context, Name);
2079
2080   StructType *STy = cast<StructType>(Entry.first);
2081
2082   SmallVector<Type*, 8> Body;
2083   if (ParseStructBody(Body) ||
2084       (isPacked && ParseToken(lltok::greater, "expected '>' in packed struct")))
2085     return true;
2086
2087   STy->setBody(Body, isPacked);
2088   ResultTy = STy;
2089   return false;
2090 }
2091
2092
2093 /// ParseStructType: Handles packed and unpacked types.  </> parsed elsewhere.
2094 ///   StructType
2095 ///     ::= '{' '}'
2096 ///     ::= '{' Type (',' Type)* '}'
2097 ///     ::= '<' '{' '}' '>'
2098 ///     ::= '<' '{' Type (',' Type)* '}' '>'
2099 bool LLParser::ParseStructBody(SmallVectorImpl<Type*> &Body) {
2100   assert(Lex.getKind() == lltok::lbrace);
2101   Lex.Lex(); // Consume the '{'
2102
2103   // Handle the empty struct.
2104   if (EatIfPresent(lltok::rbrace))
2105     return false;
2106
2107   LocTy EltTyLoc = Lex.getLoc();
2108   Type *Ty = nullptr;
2109   if (ParseType(Ty)) return true;
2110   Body.push_back(Ty);
2111
2112   if (!StructType::isValidElementType(Ty))
2113     return Error(EltTyLoc, "invalid element type for struct");
2114
2115   while (EatIfPresent(lltok::comma)) {
2116     EltTyLoc = Lex.getLoc();
2117     if (ParseType(Ty)) return true;
2118
2119     if (!StructType::isValidElementType(Ty))
2120       return Error(EltTyLoc, "invalid element type for struct");
2121
2122     Body.push_back(Ty);
2123   }
2124
2125   return ParseToken(lltok::rbrace, "expected '}' at end of struct");
2126 }
2127
2128 /// ParseArrayVectorType - Parse an array or vector type, assuming the first
2129 /// token has already been consumed.
2130 ///   Type
2131 ///     ::= '[' APSINTVAL 'x' Types ']'
2132 ///     ::= '<' APSINTVAL 'x' Types '>'
2133 bool LLParser::ParseArrayVectorType(Type *&Result, bool isVector) {
2134   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
2135       Lex.getAPSIntVal().getBitWidth() > 64)
2136     return TokError("expected number in address space");
2137
2138   LocTy SizeLoc = Lex.getLoc();
2139   uint64_t Size = Lex.getAPSIntVal().getZExtValue();
2140   Lex.Lex();
2141
2142   if (ParseToken(lltok::kw_x, "expected 'x' after element count"))
2143       return true;
2144
2145   LocTy TypeLoc = Lex.getLoc();
2146   Type *EltTy = nullptr;
2147   if (ParseType(EltTy)) return true;
2148
2149   if (ParseToken(isVector ? lltok::greater : lltok::rsquare,
2150                  "expected end of sequential type"))
2151     return true;
2152
2153   if (isVector) {
2154     if (Size == 0)
2155       return Error(SizeLoc, "zero element vector is illegal");
2156     if ((unsigned)Size != Size)
2157       return Error(SizeLoc, "size too large for vector");
2158     if (!VectorType::isValidElementType(EltTy))
2159       return Error(TypeLoc, "invalid vector element type");
2160     Result = VectorType::get(EltTy, unsigned(Size));
2161   } else {
2162     if (!ArrayType::isValidElementType(EltTy))
2163       return Error(TypeLoc, "invalid array element type");
2164     Result = ArrayType::get(EltTy, Size);
2165   }
2166   return false;
2167 }
2168
2169 //===----------------------------------------------------------------------===//
2170 // Function Semantic Analysis.
2171 //===----------------------------------------------------------------------===//
2172
2173 LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f,
2174                                              int functionNumber)
2175   : P(p), F(f), FunctionNumber(functionNumber) {
2176
2177   // Insert unnamed arguments into the NumberedVals list.
2178   for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end();
2179        AI != E; ++AI)
2180     if (!AI->hasName())
2181       NumberedVals.push_back(AI);
2182 }
2183
2184 LLParser::PerFunctionState::~PerFunctionState() {
2185   // If there were any forward referenced non-basicblock values, delete them.
2186   for (std::map<std::string, std::pair<Value*, LocTy> >::iterator
2187        I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
2188     if (!isa<BasicBlock>(I->second.first)) {
2189       I->second.first->replaceAllUsesWith(
2190                            UndefValue::get(I->second.first->getType()));
2191       delete I->second.first;
2192       I->second.first = nullptr;
2193     }
2194
2195   for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator
2196        I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
2197     if (!isa<BasicBlock>(I->second.first)) {
2198       I->second.first->replaceAllUsesWith(
2199                            UndefValue::get(I->second.first->getType()));
2200       delete I->second.first;
2201       I->second.first = nullptr;
2202     }
2203 }
2204
2205 bool LLParser::PerFunctionState::FinishFunction() {
2206   if (!ForwardRefVals.empty())
2207     return P.Error(ForwardRefVals.begin()->second.second,
2208                    "use of undefined value '%" + ForwardRefVals.begin()->first +
2209                    "'");
2210   if (!ForwardRefValIDs.empty())
2211     return P.Error(ForwardRefValIDs.begin()->second.second,
2212                    "use of undefined value '%" +
2213                    Twine(ForwardRefValIDs.begin()->first) + "'");
2214   return false;
2215 }
2216
2217
2218 /// GetVal - Get a value with the specified name or ID, creating a
2219 /// forward reference record if needed.  This can return null if the value
2220 /// exists but does not have the right type.
2221 Value *LLParser::PerFunctionState::GetVal(const std::string &Name,
2222                                           Type *Ty, LocTy Loc) {
2223   // Look this name up in the normal function symbol table.
2224   Value *Val = F.getValueSymbolTable().lookup(Name);
2225
2226   // If this is a forward reference for the value, see if we already created a
2227   // forward ref record.
2228   if (!Val) {
2229     std::map<std::string, std::pair<Value*, LocTy> >::iterator
2230       I = ForwardRefVals.find(Name);
2231     if (I != ForwardRefVals.end())
2232       Val = I->second.first;
2233   }
2234
2235   // If we have the value in the symbol table or fwd-ref table, return it.
2236   if (Val) {
2237     if (Val->getType() == Ty) return Val;
2238     if (Ty->isLabelTy())
2239       P.Error(Loc, "'%" + Name + "' is not a basic block");
2240     else
2241       P.Error(Loc, "'%" + Name + "' defined with type '" +
2242               getTypeString(Val->getType()) + "'");
2243     return nullptr;
2244   }
2245
2246   // Don't make placeholders with invalid type.
2247   if (!Ty->isFirstClassType()) {
2248     P.Error(Loc, "invalid use of a non-first-class type");
2249     return nullptr;
2250   }
2251
2252   // Otherwise, create a new forward reference for this value and remember it.
2253   Value *FwdVal;
2254   if (Ty->isLabelTy())
2255     FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
2256   else
2257     FwdVal = new Argument(Ty, Name);
2258
2259   ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
2260   return FwdVal;
2261 }
2262
2263 Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty,
2264                                           LocTy Loc) {
2265   // Look this name up in the normal function symbol table.
2266   Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
2267
2268   // If this is a forward reference for the value, see if we already created a
2269   // forward ref record.
2270   if (!Val) {
2271     std::map<unsigned, std::pair<Value*, LocTy> >::iterator
2272       I = ForwardRefValIDs.find(ID);
2273     if (I != ForwardRefValIDs.end())
2274       Val = I->second.first;
2275   }
2276
2277   // If we have the value in the symbol table or fwd-ref table, return it.
2278   if (Val) {
2279     if (Val->getType() == Ty) return Val;
2280     if (Ty->isLabelTy())
2281       P.Error(Loc, "'%" + Twine(ID) + "' is not a basic block");
2282     else
2283       P.Error(Loc, "'%" + Twine(ID) + "' defined with type '" +
2284               getTypeString(Val->getType()) + "'");
2285     return nullptr;
2286   }
2287
2288   if (!Ty->isFirstClassType()) {
2289     P.Error(Loc, "invalid use of a non-first-class type");
2290     return nullptr;
2291   }
2292
2293   // Otherwise, create a new forward reference for this value and remember it.
2294   Value *FwdVal;
2295   if (Ty->isLabelTy())
2296     FwdVal = BasicBlock::Create(F.getContext(), "", &F);
2297   else
2298     FwdVal = new Argument(Ty);
2299
2300   ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
2301   return FwdVal;
2302 }
2303
2304 /// SetInstName - After an instruction is parsed and inserted into its
2305 /// basic block, this installs its name.
2306 bool LLParser::PerFunctionState::SetInstName(int NameID,
2307                                              const std::string &NameStr,
2308                                              LocTy NameLoc, Instruction *Inst) {
2309   // If this instruction has void type, it cannot have a name or ID specified.
2310   if (Inst->getType()->isVoidTy()) {
2311     if (NameID != -1 || !NameStr.empty())
2312       return P.Error(NameLoc, "instructions returning void cannot have a name");
2313     return false;
2314   }
2315
2316   // If this was a numbered instruction, verify that the instruction is the
2317   // expected value and resolve any forward references.
2318   if (NameStr.empty()) {
2319     // If neither a name nor an ID was specified, just use the next ID.
2320     if (NameID == -1)
2321       NameID = NumberedVals.size();
2322
2323     if (unsigned(NameID) != NumberedVals.size())
2324       return P.Error(NameLoc, "instruction expected to be numbered '%" +
2325                      Twine(NumberedVals.size()) + "'");
2326
2327     std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI =
2328       ForwardRefValIDs.find(NameID);
2329     if (FI != ForwardRefValIDs.end()) {
2330       if (FI->second.first->getType() != Inst->getType())
2331         return P.Error(NameLoc, "instruction forward referenced with type '" +
2332                        getTypeString(FI->second.first->getType()) + "'");
2333       FI->second.first->replaceAllUsesWith(Inst);
2334       delete FI->second.first;
2335       ForwardRefValIDs.erase(FI);
2336     }
2337
2338     NumberedVals.push_back(Inst);
2339     return false;
2340   }
2341
2342   // Otherwise, the instruction had a name.  Resolve forward refs and set it.
2343   std::map<std::string, std::pair<Value*, LocTy> >::iterator
2344     FI = ForwardRefVals.find(NameStr);
2345   if (FI != ForwardRefVals.end()) {
2346     if (FI->second.first->getType() != Inst->getType())
2347       return P.Error(NameLoc, "instruction forward referenced with type '" +
2348                      getTypeString(FI->second.first->getType()) + "'");
2349     FI->second.first->replaceAllUsesWith(Inst);
2350     delete FI->second.first;
2351     ForwardRefVals.erase(FI);
2352   }
2353
2354   // Set the name on the instruction.
2355   Inst->setName(NameStr);
2356
2357   if (Inst->getName() != NameStr)
2358     return P.Error(NameLoc, "multiple definition of local value named '" +
2359                    NameStr + "'");
2360   return false;
2361 }
2362
2363 /// GetBB - Get a basic block with the specified name or ID, creating a
2364 /// forward reference record if needed.
2365 BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name,
2366                                               LocTy Loc) {
2367   return dyn_cast_or_null<BasicBlock>(GetVal(Name,
2368                                       Type::getLabelTy(F.getContext()), Loc));
2369 }
2370
2371 BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) {
2372   return dyn_cast_or_null<BasicBlock>(GetVal(ID,
2373                                       Type::getLabelTy(F.getContext()), Loc));
2374 }
2375
2376 /// DefineBB - Define the specified basic block, which is either named or
2377 /// unnamed.  If there is an error, this returns null otherwise it returns
2378 /// the block being defined.
2379 BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name,
2380                                                  LocTy Loc) {
2381   BasicBlock *BB;
2382   if (Name.empty())
2383     BB = GetBB(NumberedVals.size(), Loc);
2384   else
2385     BB = GetBB(Name, Loc);
2386   if (!BB) return nullptr; // Already diagnosed error.
2387
2388   // Move the block to the end of the function.  Forward ref'd blocks are
2389   // inserted wherever they happen to be referenced.
2390   F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
2391
2392   // Remove the block from forward ref sets.
2393   if (Name.empty()) {
2394     ForwardRefValIDs.erase(NumberedVals.size());
2395     NumberedVals.push_back(BB);
2396   } else {
2397     // BB forward references are already in the function symbol table.
2398     ForwardRefVals.erase(Name);
2399   }
2400
2401   return BB;
2402 }
2403
2404 //===----------------------------------------------------------------------===//
2405 // Constants.
2406 //===----------------------------------------------------------------------===//
2407
2408 /// ParseValID - Parse an abstract value that doesn't necessarily have a
2409 /// type implied.  For example, if we parse "4" we don't know what integer type
2410 /// it has.  The value will later be combined with its type and checked for
2411 /// sanity.  PFS is used to convert function-local operands of metadata (since
2412 /// metadata operands are not just parsed here but also converted to values).
2413 /// PFS can be null when we are not parsing metadata values inside a function.
2414 bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) {
2415   ID.Loc = Lex.getLoc();
2416   switch (Lex.getKind()) {
2417   default: return TokError("expected value token");
2418   case lltok::GlobalID:  // @42
2419     ID.UIntVal = Lex.getUIntVal();
2420     ID.Kind = ValID::t_GlobalID;
2421     break;
2422   case lltok::GlobalVar:  // @foo
2423     ID.StrVal = Lex.getStrVal();
2424     ID.Kind = ValID::t_GlobalName;
2425     break;
2426   case lltok::LocalVarID:  // %42
2427     ID.UIntVal = Lex.getUIntVal();
2428     ID.Kind = ValID::t_LocalID;
2429     break;
2430   case lltok::LocalVar:  // %foo
2431     ID.StrVal = Lex.getStrVal();
2432     ID.Kind = ValID::t_LocalName;
2433     break;
2434   case lltok::APSInt:
2435     ID.APSIntVal = Lex.getAPSIntVal();
2436     ID.Kind = ValID::t_APSInt;
2437     break;
2438   case lltok::APFloat:
2439     ID.APFloatVal = Lex.getAPFloatVal();
2440     ID.Kind = ValID::t_APFloat;
2441     break;
2442   case lltok::kw_true:
2443     ID.ConstantVal = ConstantInt::getTrue(Context);
2444     ID.Kind = ValID::t_Constant;
2445     break;
2446   case lltok::kw_false:
2447     ID.ConstantVal = ConstantInt::getFalse(Context);
2448     ID.Kind = ValID::t_Constant;
2449     break;
2450   case lltok::kw_null: ID.Kind = ValID::t_Null; break;
2451   case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
2452   case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
2453
2454   case lltok::lbrace: {
2455     // ValID ::= '{' ConstVector '}'
2456     Lex.Lex();
2457     SmallVector<Constant*, 16> Elts;
2458     if (ParseGlobalValueVector(Elts) ||
2459         ParseToken(lltok::rbrace, "expected end of struct constant"))
2460       return true;
2461
2462     ID.ConstantStructElts = make_unique<Constant *[]>(Elts.size());
2463     ID.UIntVal = Elts.size();
2464     memcpy(ID.ConstantStructElts.get(), Elts.data(),
2465            Elts.size() * sizeof(Elts[0]));
2466     ID.Kind = ValID::t_ConstantStruct;
2467     return false;
2468   }
2469   case lltok::less: {
2470     // ValID ::= '<' ConstVector '>'         --> Vector.
2471     // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct.
2472     Lex.Lex();
2473     bool isPackedStruct = EatIfPresent(lltok::lbrace);
2474
2475     SmallVector<Constant*, 16> Elts;
2476     LocTy FirstEltLoc = Lex.getLoc();
2477     if (ParseGlobalValueVector(Elts) ||
2478         (isPackedStruct &&
2479          ParseToken(lltok::rbrace, "expected end of packed struct")) ||
2480         ParseToken(lltok::greater, "expected end of constant"))
2481       return true;
2482
2483     if (isPackedStruct) {
2484       ID.ConstantStructElts = make_unique<Constant *[]>(Elts.size());
2485       memcpy(ID.ConstantStructElts.get(), Elts.data(),
2486              Elts.size() * sizeof(Elts[0]));
2487       ID.UIntVal = Elts.size();
2488       ID.Kind = ValID::t_PackedConstantStruct;
2489       return false;
2490     }
2491
2492     if (Elts.empty())
2493       return Error(ID.Loc, "constant vector must not be empty");
2494
2495     if (!Elts[0]->getType()->isIntegerTy() &&
2496         !Elts[0]->getType()->isFloatingPointTy() &&
2497         !Elts[0]->getType()->isPointerTy())
2498       return Error(FirstEltLoc,
2499             "vector elements must have integer, pointer or floating point type");
2500
2501     // Verify that all the vector elements have the same type.
2502     for (unsigned i = 1, e = Elts.size(); i != e; ++i)
2503       if (Elts[i]->getType() != Elts[0]->getType())
2504         return Error(FirstEltLoc,
2505                      "vector element #" + Twine(i) +
2506                     " is not of type '" + getTypeString(Elts[0]->getType()));
2507
2508     ID.ConstantVal = ConstantVector::get(Elts);
2509     ID.Kind = ValID::t_Constant;
2510     return false;
2511   }
2512   case lltok::lsquare: {   // Array Constant
2513     Lex.Lex();
2514     SmallVector<Constant*, 16> Elts;
2515     LocTy FirstEltLoc = Lex.getLoc();
2516     if (ParseGlobalValueVector(Elts) ||
2517         ParseToken(lltok::rsquare, "expected end of array constant"))
2518       return true;
2519
2520     // Handle empty element.
2521     if (Elts.empty()) {
2522       // Use undef instead of an array because it's inconvenient to determine
2523       // the element type at this point, there being no elements to examine.
2524       ID.Kind = ValID::t_EmptyArray;
2525       return false;
2526     }
2527
2528     if (!Elts[0]->getType()->isFirstClassType())
2529       return Error(FirstEltLoc, "invalid array element type: " +
2530                    getTypeString(Elts[0]->getType()));
2531
2532     ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
2533
2534     // Verify all elements are correct type!
2535     for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
2536       if (Elts[i]->getType() != Elts[0]->getType())
2537         return Error(FirstEltLoc,
2538                      "array element #" + Twine(i) +
2539                      " is not of type '" + getTypeString(Elts[0]->getType()));
2540     }
2541
2542     ID.ConstantVal = ConstantArray::get(ATy, Elts);
2543     ID.Kind = ValID::t_Constant;
2544     return false;
2545   }
2546   case lltok::kw_c:  // c "foo"
2547     Lex.Lex();
2548     ID.ConstantVal = ConstantDataArray::getString(Context, Lex.getStrVal(),
2549                                                   false);
2550     if (ParseToken(lltok::StringConstant, "expected string")) return true;
2551     ID.Kind = ValID::t_Constant;
2552     return false;
2553
2554   case lltok::kw_asm: {
2555     // ValID ::= 'asm' SideEffect? AlignStack? IntelDialect? STRINGCONSTANT ','
2556     //             STRINGCONSTANT
2557     bool HasSideEffect, AlignStack, AsmDialect;
2558     Lex.Lex();
2559     if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
2560         ParseOptionalToken(lltok::kw_alignstack, AlignStack) ||
2561         ParseOptionalToken(lltok::kw_inteldialect, AsmDialect) ||
2562         ParseStringConstant(ID.StrVal) ||
2563         ParseToken(lltok::comma, "expected comma in inline asm expression") ||
2564         ParseToken(lltok::StringConstant, "expected constraint string"))
2565       return true;
2566     ID.StrVal2 = Lex.getStrVal();
2567     ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1) |
2568       (unsigned(AsmDialect)<<2);
2569     ID.Kind = ValID::t_InlineAsm;
2570     return false;
2571   }
2572
2573   case lltok::kw_blockaddress: {
2574     // ValID ::= 'blockaddress' '(' @foo ',' %bar ')'
2575     Lex.Lex();
2576
2577     ValID Fn, Label;
2578
2579     if (ParseToken(lltok::lparen, "expected '(' in block address expression") ||
2580         ParseValID(Fn) ||
2581         ParseToken(lltok::comma, "expected comma in block address expression")||
2582         ParseValID(Label) ||
2583         ParseToken(lltok::rparen, "expected ')' in block address expression"))
2584       return true;
2585
2586     if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
2587       return Error(Fn.Loc, "expected function name in blockaddress");
2588     if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
2589       return Error(Label.Loc, "expected basic block name in blockaddress");
2590
2591     // Try to find the function (but skip it if it's forward-referenced).
2592     GlobalValue *GV = nullptr;
2593     if (Fn.Kind == ValID::t_GlobalID) {
2594       if (Fn.UIntVal < NumberedVals.size())
2595         GV = NumberedVals[Fn.UIntVal];
2596     } else if (!ForwardRefVals.count(Fn.StrVal)) {
2597       GV = M->getNamedValue(Fn.StrVal);
2598     }
2599     Function *F = nullptr;
2600     if (GV) {
2601       // Confirm that it's actually a function with a definition.
2602       if (!isa<Function>(GV))
2603         return Error(Fn.Loc, "expected function name in blockaddress");
2604       F = cast<Function>(GV);
2605       if (F->isDeclaration())
2606         return Error(Fn.Loc, "cannot take blockaddress inside a declaration");
2607     }
2608
2609     if (!F) {
2610       // Make a global variable as a placeholder for this reference.
2611       GlobalValue *&FwdRef =
2612           ForwardRefBlockAddresses.insert(std::make_pair, std::move(Fn),
2613                                           std::map<ValID, GlobalValue *>())
2614               .first->second.insert(std::make_pair(std::move(Label), nullptr))
2615               .first->second;
2616       if (!FwdRef)
2617         FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), false,
2618                                     GlobalValue::InternalLinkage, nullptr, "");
2619       ID.ConstantVal = FwdRef;
2620       ID.Kind = ValID::t_Constant;
2621       return false;
2622     }
2623
2624     // We found the function; now find the basic block.  Don't use PFS, since we
2625     // might be inside a constant expression.
2626     BasicBlock *BB;
2627     if (BlockAddressPFS && F == &BlockAddressPFS->getFunction()) {
2628       if (Label.Kind == ValID::t_LocalID)
2629         BB = BlockAddressPFS->GetBB(Label.UIntVal, Label.Loc);
2630       else
2631         BB = BlockAddressPFS->GetBB(Label.StrVal, Label.Loc);
2632       if (!BB)
2633         return Error(Label.Loc, "referenced value is not a basic block");
2634     } else {
2635       if (Label.Kind == ValID::t_LocalID)
2636         return Error(Label.Loc, "cannot take address of numeric label after "
2637                                 "the function is defined");
2638       BB = dyn_cast_or_null<BasicBlock>(
2639           F->getValueSymbolTable().lookup(Label.StrVal));
2640       if (!BB)
2641         return Error(Label.Loc, "referenced value is not a basic block");
2642     }
2643
2644     ID.ConstantVal = BlockAddress::get(F, BB);
2645     ID.Kind = ValID::t_Constant;
2646     return false;
2647   }
2648
2649   case lltok::kw_trunc:
2650   case lltok::kw_zext:
2651   case lltok::kw_sext:
2652   case lltok::kw_fptrunc:
2653   case lltok::kw_fpext:
2654   case lltok::kw_bitcast:
2655   case lltok::kw_addrspacecast:
2656   case lltok::kw_uitofp:
2657   case lltok::kw_sitofp:
2658   case lltok::kw_fptoui:
2659   case lltok::kw_fptosi:
2660   case lltok::kw_inttoptr:
2661   case lltok::kw_ptrtoint: {
2662     unsigned Opc = Lex.getUIntVal();
2663     Type *DestTy = nullptr;
2664     Constant *SrcVal;
2665     Lex.Lex();
2666     if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
2667         ParseGlobalTypeAndValue(SrcVal) ||
2668         ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
2669         ParseType(DestTy) ||
2670         ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
2671       return true;
2672     if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
2673       return Error(ID.Loc, "invalid cast opcode for cast from '" +
2674                    getTypeString(SrcVal->getType()) + "' to '" +
2675                    getTypeString(DestTy) + "'");
2676     ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
2677                                                  SrcVal, DestTy);
2678     ID.Kind = ValID::t_Constant;
2679     return false;
2680   }
2681   case lltok::kw_extractvalue: {
2682     Lex.Lex();
2683     Constant *Val;
2684     SmallVector<unsigned, 4> Indices;
2685     if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")||
2686         ParseGlobalTypeAndValue(Val) ||
2687         ParseIndexList(Indices) ||
2688         ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
2689       return true;
2690
2691     if (!Val->getType()->isAggregateType())
2692       return Error(ID.Loc, "extractvalue operand must be aggregate type");
2693     if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
2694       return Error(ID.Loc, "invalid indices for extractvalue");
2695     ID.ConstantVal = ConstantExpr::getExtractValue(Val, Indices);
2696     ID.Kind = ValID::t_Constant;
2697     return false;
2698   }
2699   case lltok::kw_insertvalue: {
2700     Lex.Lex();
2701     Constant *Val0, *Val1;
2702     SmallVector<unsigned, 4> Indices;
2703     if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")||
2704         ParseGlobalTypeAndValue(Val0) ||
2705         ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")||
2706         ParseGlobalTypeAndValue(Val1) ||
2707         ParseIndexList(Indices) ||
2708         ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
2709       return true;
2710     if (!Val0->getType()->isAggregateType())
2711       return Error(ID.Loc, "insertvalue operand must be aggregate type");
2712     Type *IndexedType =
2713         ExtractValueInst::getIndexedType(Val0->getType(), Indices);
2714     if (!IndexedType)
2715       return Error(ID.Loc, "invalid indices for insertvalue");
2716     if (IndexedType != Val1->getType())
2717       return Error(ID.Loc, "insertvalue operand and field disagree in type: '" +
2718                                getTypeString(Val1->getType()) +
2719                                "' instead of '" + getTypeString(IndexedType) +
2720                                "'");
2721     ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, Indices);
2722     ID.Kind = ValID::t_Constant;
2723     return false;
2724   }
2725   case lltok::kw_icmp:
2726   case lltok::kw_fcmp: {
2727     unsigned PredVal, Opc = Lex.getUIntVal();
2728     Constant *Val0, *Val1;
2729     Lex.Lex();
2730     if (ParseCmpPredicate(PredVal, Opc) ||
2731         ParseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
2732         ParseGlobalTypeAndValue(Val0) ||
2733         ParseToken(lltok::comma, "expected comma in compare constantexpr") ||
2734         ParseGlobalTypeAndValue(Val1) ||
2735         ParseToken(lltok::rparen, "expected ')' in compare constantexpr"))
2736       return true;
2737
2738     if (Val0->getType() != Val1->getType())
2739       return Error(ID.Loc, "compare operands must have the same type");
2740
2741     CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
2742
2743     if (Opc == Instruction::FCmp) {
2744       if (!Val0->getType()->isFPOrFPVectorTy())
2745         return Error(ID.Loc, "fcmp requires floating point operands");
2746       ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
2747     } else {
2748       assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
2749       if (!Val0->getType()->isIntOrIntVectorTy() &&
2750           !Val0->getType()->getScalarType()->isPointerTy())
2751         return Error(ID.Loc, "icmp requires pointer or integer operands");
2752       ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
2753     }
2754     ID.Kind = ValID::t_Constant;
2755     return false;
2756   }
2757
2758   // Binary Operators.
2759   case lltok::kw_add:
2760   case lltok::kw_fadd:
2761   case lltok::kw_sub:
2762   case lltok::kw_fsub:
2763   case lltok::kw_mul:
2764   case lltok::kw_fmul:
2765   case lltok::kw_udiv:
2766   case lltok::kw_sdiv:
2767   case lltok::kw_fdiv:
2768   case lltok::kw_urem:
2769   case lltok::kw_srem:
2770   case lltok::kw_frem:
2771   case lltok::kw_shl:
2772   case lltok::kw_lshr:
2773   case lltok::kw_ashr: {
2774     bool NUW = false;
2775     bool NSW = false;
2776     bool Exact = false;
2777     unsigned Opc = Lex.getUIntVal();
2778     Constant *Val0, *Val1;
2779     Lex.Lex();
2780     LocTy ModifierLoc = Lex.getLoc();
2781     if (Opc == Instruction::Add || Opc == Instruction::Sub ||
2782         Opc == Instruction::Mul || Opc == Instruction::Shl) {
2783       if (EatIfPresent(lltok::kw_nuw))
2784         NUW = true;
2785       if (EatIfPresent(lltok::kw_nsw)) {
2786         NSW = true;
2787         if (EatIfPresent(lltok::kw_nuw))
2788           NUW = true;
2789       }
2790     } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
2791                Opc == Instruction::LShr || Opc == Instruction::AShr) {
2792       if (EatIfPresent(lltok::kw_exact))
2793         Exact = true;
2794     }
2795     if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
2796         ParseGlobalTypeAndValue(Val0) ||
2797         ParseToken(lltok::comma, "expected comma in binary constantexpr") ||
2798         ParseGlobalTypeAndValue(Val1) ||
2799         ParseToken(lltok::rparen, "expected ')' in binary constantexpr"))
2800       return true;
2801     if (Val0->getType() != Val1->getType())
2802       return Error(ID.Loc, "operands of constexpr must have same type");
2803     if (!Val0->getType()->isIntOrIntVectorTy()) {
2804       if (NUW)
2805         return Error(ModifierLoc, "nuw only applies to integer operations");
2806       if (NSW)
2807         return Error(ModifierLoc, "nsw only applies to integer operations");
2808     }
2809     // Check that the type is valid for the operator.
2810     switch (Opc) {
2811     case Instruction::Add:
2812     case Instruction::Sub:
2813     case Instruction::Mul:
2814     case Instruction::UDiv:
2815     case Instruction::SDiv:
2816     case Instruction::URem:
2817     case Instruction::SRem:
2818     case Instruction::Shl:
2819     case Instruction::AShr:
2820     case Instruction::LShr:
2821       if (!Val0->getType()->isIntOrIntVectorTy())
2822         return Error(ID.Loc, "constexpr requires integer operands");
2823       break;
2824     case Instruction::FAdd:
2825     case Instruction::FSub:
2826     case Instruction::FMul:
2827     case Instruction::FDiv:
2828     case Instruction::FRem:
2829       if (!Val0->getType()->isFPOrFPVectorTy())
2830         return Error(ID.Loc, "constexpr requires fp operands");
2831       break;
2832     default: llvm_unreachable("Unknown binary operator!");
2833     }
2834     unsigned Flags = 0;
2835     if (NUW)   Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
2836     if (NSW)   Flags |= OverflowingBinaryOperator::NoSignedWrap;
2837     if (Exact) Flags |= PossiblyExactOperator::IsExact;
2838     Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
2839     ID.ConstantVal = C;
2840     ID.Kind = ValID::t_Constant;
2841     return false;
2842   }
2843
2844   // Logical Operations
2845   case lltok::kw_and:
2846   case lltok::kw_or:
2847   case lltok::kw_xor: {
2848     unsigned Opc = Lex.getUIntVal();
2849     Constant *Val0, *Val1;
2850     Lex.Lex();
2851     if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
2852         ParseGlobalTypeAndValue(Val0) ||
2853         ParseToken(lltok::comma, "expected comma in logical constantexpr") ||
2854         ParseGlobalTypeAndValue(Val1) ||
2855         ParseToken(lltok::rparen, "expected ')' in logical constantexpr"))
2856       return true;
2857     if (Val0->getType() != Val1->getType())
2858       return Error(ID.Loc, "operands of constexpr must have same type");
2859     if (!Val0->getType()->isIntOrIntVectorTy())
2860       return Error(ID.Loc,
2861                    "constexpr requires integer or integer vector operands");
2862     ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
2863     ID.Kind = ValID::t_Constant;
2864     return false;
2865   }
2866
2867   case lltok::kw_getelementptr:
2868   case lltok::kw_shufflevector:
2869   case lltok::kw_insertelement:
2870   case lltok::kw_extractelement:
2871   case lltok::kw_select: {
2872     unsigned Opc = Lex.getUIntVal();
2873     SmallVector<Constant*, 16> Elts;
2874     bool InBounds = false;
2875     Type *Ty;
2876     Lex.Lex();
2877
2878     if (Opc == Instruction::GetElementPtr)
2879       InBounds = EatIfPresent(lltok::kw_inbounds);
2880
2881     if (ParseToken(lltok::lparen, "expected '(' in constantexpr"))
2882       return true;
2883
2884     LocTy ExplicitTypeLoc = Lex.getLoc();
2885     if (Opc == Instruction::GetElementPtr) {
2886       if (ParseType(Ty) ||
2887           ParseToken(lltok::comma, "expected comma after getelementptr's type"))
2888         return true;
2889     }
2890
2891     if (ParseGlobalValueVector(Elts) ||
2892         ParseToken(lltok::rparen, "expected ')' in constantexpr"))
2893       return true;
2894
2895     if (Opc == Instruction::GetElementPtr) {
2896       if (Elts.size() == 0 ||
2897           !Elts[0]->getType()->getScalarType()->isPointerTy())
2898         return Error(ID.Loc, "base of getelementptr must be a pointer");
2899
2900       Type *BaseType = Elts[0]->getType();
2901       auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
2902       if (Ty != BasePointerType->getElementType())
2903         return Error(
2904             ExplicitTypeLoc,
2905             "explicit pointee type doesn't match operand's pointee type");
2906
2907       ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
2908       for (Constant *Val : Indices) {
2909         Type *ValTy = Val->getType();
2910         if (!ValTy->getScalarType()->isIntegerTy())
2911           return Error(ID.Loc, "getelementptr index must be an integer");
2912         if (ValTy->isVectorTy() != BaseType->isVectorTy())
2913           return Error(ID.Loc, "getelementptr index type missmatch");
2914         if (ValTy->isVectorTy()) {
2915           unsigned ValNumEl = ValTy->getVectorNumElements();
2916           unsigned PtrNumEl = BaseType->getVectorNumElements();
2917           if (ValNumEl != PtrNumEl)
2918             return Error(
2919                 ID.Loc,
2920                 "getelementptr vector index has a wrong number of elements");
2921         }
2922       }
2923
2924       SmallPtrSet<Type*, 4> Visited;
2925       if (!Indices.empty() && !Ty->isSized(&Visited))
2926         return Error(ID.Loc, "base element of getelementptr must be sized");
2927
2928       if (!GetElementPtrInst::getIndexedType(Ty, Indices))
2929         return Error(ID.Loc, "invalid getelementptr indices");
2930       ID.ConstantVal =
2931           ConstantExpr::getGetElementPtr(Ty, Elts[0], Indices, InBounds);
2932     } else if (Opc == Instruction::Select) {
2933       if (Elts.size() != 3)
2934         return Error(ID.Loc, "expected three operands to select");
2935       if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
2936                                                               Elts[2]))
2937         return Error(ID.Loc, Reason);
2938       ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
2939     } else if (Opc == Instruction::ShuffleVector) {
2940       if (Elts.size() != 3)
2941         return Error(ID.Loc, "expected three operands to shufflevector");
2942       if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2943         return Error(ID.Loc, "invalid operands to shufflevector");
2944       ID.ConstantVal =
2945                  ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]);
2946     } else if (Opc == Instruction::ExtractElement) {
2947       if (Elts.size() != 2)
2948         return Error(ID.Loc, "expected two operands to extractelement");
2949       if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
2950         return Error(ID.Loc, "invalid extractelement operands");
2951       ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
2952     } else {
2953       assert(Opc == Instruction::InsertElement && "Unknown opcode");
2954       if (Elts.size() != 3)
2955       return Error(ID.Loc, "expected three operands to insertelement");
2956       if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2957         return Error(ID.Loc, "invalid insertelement operands");
2958       ID.ConstantVal =
2959                  ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
2960     }
2961
2962     ID.Kind = ValID::t_Constant;
2963     return false;
2964   }
2965   }
2966
2967   Lex.Lex();
2968   return false;
2969 }
2970
2971 /// ParseGlobalValue - Parse a global value with the specified type.
2972 bool LLParser::ParseGlobalValue(Type *Ty, Constant *&C) {
2973   C = nullptr;
2974   ValID ID;
2975   Value *V = nullptr;
2976   bool Parsed = ParseValID(ID) ||
2977                 ConvertValIDToValue(Ty, ID, V, nullptr);
2978   if (V && !(C = dyn_cast<Constant>(V)))
2979     return Error(ID.Loc, "global values must be constants");
2980   return Parsed;
2981 }
2982
2983 bool LLParser::ParseGlobalTypeAndValue(Constant *&V) {
2984   Type *Ty = nullptr;
2985   return ParseType(Ty) ||
2986          ParseGlobalValue(Ty, V);
2987 }
2988
2989 bool LLParser::parseOptionalComdat(StringRef GlobalName, Comdat *&C) {
2990   C = nullptr;
2991
2992   LocTy KwLoc = Lex.getLoc();
2993   if (!EatIfPresent(lltok::kw_comdat))
2994     return false;
2995
2996   if (EatIfPresent(lltok::lparen)) {
2997     if (Lex.getKind() != lltok::ComdatVar)
2998       return TokError("expected comdat variable");
2999     C = getComdat(Lex.getStrVal(), Lex.getLoc());
3000     Lex.Lex();
3001     if (ParseToken(lltok::rparen, "expected ')' after comdat var"))
3002       return true;
3003   } else {
3004     if (GlobalName.empty())
3005       return TokError("comdat cannot be unnamed");
3006     C = getComdat(GlobalName, KwLoc);
3007   }
3008
3009   return false;
3010 }
3011
3012 /// ParseGlobalValueVector
3013 ///   ::= /*empty*/
3014 ///   ::= TypeAndValue (',' TypeAndValue)*
3015 bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant *> &Elts) {
3016   // Empty list.
3017   if (Lex.getKind() == lltok::rbrace ||
3018       Lex.getKind() == lltok::rsquare ||
3019       Lex.getKind() == lltok::greater ||
3020       Lex.getKind() == lltok::rparen)
3021     return false;
3022
3023   Constant *C;
3024   if (ParseGlobalTypeAndValue(C)) return true;
3025   Elts.push_back(C);
3026
3027   while (EatIfPresent(lltok::comma)) {
3028     if (ParseGlobalTypeAndValue(C)) return true;
3029     Elts.push_back(C);
3030   }
3031
3032   return false;
3033 }
3034
3035 bool LLParser::ParseMDTuple(MDNode *&MD, bool IsDistinct) {
3036   SmallVector<Metadata *, 16> Elts;
3037   if (ParseMDNodeVector(Elts))
3038     return true;
3039
3040   MD = (IsDistinct ? MDTuple::getDistinct : MDTuple::get)(Context, Elts);
3041   return false;
3042 }
3043
3044 /// MDNode:
3045 ///  ::= !{ ... }
3046 ///  ::= !7
3047 ///  ::= !DILocation(...)
3048 bool LLParser::ParseMDNode(MDNode *&N) {
3049   if (Lex.getKind() == lltok::MetadataVar)
3050     return ParseSpecializedMDNode(N);
3051
3052   return ParseToken(lltok::exclaim, "expected '!' here") ||
3053          ParseMDNodeTail(N);
3054 }
3055
3056 bool LLParser::ParseMDNodeTail(MDNode *&N) {
3057   // !{ ... }
3058   if (Lex.getKind() == lltok::lbrace)
3059     return ParseMDTuple(N);
3060
3061   // !42
3062   return ParseMDNodeID(N);
3063 }
3064
3065 namespace {
3066
3067 /// Structure to represent an optional metadata field.
3068 template <class FieldTy> struct MDFieldImpl {
3069   typedef MDFieldImpl ImplTy;
3070   FieldTy Val;
3071   bool Seen;
3072
3073   void assign(FieldTy Val) {
3074     Seen = true;
3075     this->Val = std::move(Val);
3076   }
3077
3078   explicit MDFieldImpl(FieldTy Default)
3079       : Val(std::move(Default)), Seen(false) {}
3080 };
3081
3082 struct MDUnsignedField : public MDFieldImpl<uint64_t> {
3083   uint64_t Max;
3084
3085   MDUnsignedField(uint64_t Default = 0, uint64_t Max = UINT64_MAX)
3086       : ImplTy(Default), Max(Max) {}
3087 };
3088 struct LineField : public MDUnsignedField {
3089   LineField() : MDUnsignedField(0, UINT32_MAX) {}
3090 };
3091 struct ColumnField : public MDUnsignedField {
3092   ColumnField() : MDUnsignedField(0, UINT16_MAX) {}
3093 };
3094 struct DwarfTagField : public MDUnsignedField {
3095   DwarfTagField() : MDUnsignedField(0, dwarf::DW_TAG_hi_user) {}
3096   DwarfTagField(dwarf::Tag DefaultTag)
3097       : MDUnsignedField(DefaultTag, dwarf::DW_TAG_hi_user) {}
3098 };
3099 struct DwarfAttEncodingField : public MDUnsignedField {
3100   DwarfAttEncodingField() : MDUnsignedField(0, dwarf::DW_ATE_hi_user) {}
3101 };
3102 struct DwarfVirtualityField : public MDUnsignedField {
3103   DwarfVirtualityField() : MDUnsignedField(0, dwarf::DW_VIRTUALITY_max) {}
3104 };
3105 struct DwarfLangField : public MDUnsignedField {
3106   DwarfLangField() : MDUnsignedField(0, dwarf::DW_LANG_hi_user) {}
3107 };
3108
3109 struct DIFlagField : public MDUnsignedField {
3110   DIFlagField() : MDUnsignedField(0, UINT32_MAX) {}
3111 };
3112
3113 struct MDSignedField : public MDFieldImpl<int64_t> {
3114   int64_t Min;
3115   int64_t Max;
3116
3117   MDSignedField(int64_t Default = 0)
3118       : ImplTy(Default), Min(INT64_MIN), Max(INT64_MAX) {}
3119   MDSignedField(int64_t Default, int64_t Min, int64_t Max)
3120       : ImplTy(Default), Min(Min), Max(Max) {}
3121 };
3122
3123 struct MDBoolField : public MDFieldImpl<bool> {
3124   MDBoolField(bool Default = false) : ImplTy(Default) {}
3125 };
3126 struct MDField : public MDFieldImpl<Metadata *> {
3127   bool AllowNull;
3128
3129   MDField(bool AllowNull = true) : ImplTy(nullptr), AllowNull(AllowNull) {}
3130 };
3131 struct MDConstant : public MDFieldImpl<ConstantAsMetadata *> {
3132   MDConstant() : ImplTy(nullptr) {}
3133 };
3134 struct MDStringField : public MDFieldImpl<MDString *> {
3135   bool AllowEmpty;
3136   MDStringField(bool AllowEmpty = true)
3137       : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
3138 };
3139 struct MDFieldList : public MDFieldImpl<SmallVector<Metadata *, 4>> {
3140   MDFieldList() : ImplTy(SmallVector<Metadata *, 4>()) {}
3141 };
3142
3143 } // end namespace
3144
3145 namespace llvm {
3146
3147 template <>
3148 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3149                             MDUnsignedField &Result) {
3150   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
3151     return TokError("expected unsigned integer");
3152
3153   auto &U = Lex.getAPSIntVal();
3154   if (U.ugt(Result.Max))
3155     return TokError("value for '" + Name + "' too large, limit is " +
3156                     Twine(Result.Max));
3157   Result.assign(U.getZExtValue());
3158   assert(Result.Val <= Result.Max && "Expected value in range");
3159   Lex.Lex();
3160   return false;
3161 }
3162
3163 template <>
3164 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, LineField &Result) {
3165   return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3166 }
3167 template <>
3168 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, ColumnField &Result) {
3169   return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3170 }
3171
3172 template <>
3173 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfTagField &Result) {
3174   if (Lex.getKind() == lltok::APSInt)
3175     return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3176
3177   if (Lex.getKind() != lltok::DwarfTag)
3178     return TokError("expected DWARF tag");
3179
3180   unsigned Tag = dwarf::getTag(Lex.getStrVal());
3181   if (Tag == dwarf::DW_TAG_invalid)
3182     return TokError("invalid DWARF tag" + Twine(" '") + Lex.getStrVal() + "'");
3183   assert(Tag <= Result.Max && "Expected valid DWARF tag");
3184
3185   Result.assign(Tag);
3186   Lex.Lex();
3187   return false;
3188 }
3189
3190 template <>
3191 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3192                             DwarfVirtualityField &Result) {
3193   if (Lex.getKind() == lltok::APSInt)
3194     return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3195
3196   if (Lex.getKind() != lltok::DwarfVirtuality)
3197     return TokError("expected DWARF virtuality code");
3198
3199   unsigned Virtuality = dwarf::getVirtuality(Lex.getStrVal());
3200   if (!Virtuality)
3201     return TokError("invalid DWARF virtuality code" + Twine(" '") +
3202                     Lex.getStrVal() + "'");
3203   assert(Virtuality <= Result.Max && "Expected valid DWARF virtuality code");
3204   Result.assign(Virtuality);
3205   Lex.Lex();
3206   return false;
3207 }
3208
3209 template <>
3210 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) {
3211   if (Lex.getKind() == lltok::APSInt)
3212     return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3213
3214   if (Lex.getKind() != lltok::DwarfLang)
3215     return TokError("expected DWARF language");
3216
3217   unsigned Lang = dwarf::getLanguage(Lex.getStrVal());
3218   if (!Lang)
3219     return TokError("invalid DWARF language" + Twine(" '") + Lex.getStrVal() +
3220                     "'");
3221   assert(Lang <= Result.Max && "Expected valid DWARF language");
3222   Result.assign(Lang);
3223   Lex.Lex();
3224   return false;
3225 }
3226
3227 template <>
3228 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3229                             DwarfAttEncodingField &Result) {
3230   if (Lex.getKind() == lltok::APSInt)
3231     return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3232
3233   if (Lex.getKind() != lltok::DwarfAttEncoding)
3234     return TokError("expected DWARF type attribute encoding");
3235
3236   unsigned Encoding = dwarf::getAttributeEncoding(Lex.getStrVal());
3237   if (!Encoding)
3238     return TokError("invalid DWARF type attribute encoding" + Twine(" '") +
3239                     Lex.getStrVal() + "'");
3240   assert(Encoding <= Result.Max && "Expected valid DWARF language");
3241   Result.assign(Encoding);
3242   Lex.Lex();
3243   return false;
3244 }
3245
3246 /// DIFlagField
3247 ///  ::= uint32
3248 ///  ::= DIFlagVector
3249 ///  ::= DIFlagVector '|' DIFlagFwdDecl '|' uint32 '|' DIFlagPublic
3250 template <>
3251 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DIFlagField &Result) {
3252   assert(Result.Max == UINT32_MAX && "Expected only 32-bits");
3253
3254   // Parser for a single flag.
3255   auto parseFlag = [&](unsigned &Val) {
3256     if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned())
3257       return ParseUInt32(Val);
3258
3259     if (Lex.getKind() != lltok::DIFlag)
3260       return TokError("expected debug info flag");
3261
3262     Val = DINode::getFlag(Lex.getStrVal());
3263     if (!Val)
3264       return TokError(Twine("invalid debug info flag flag '") +
3265                       Lex.getStrVal() + "'");
3266     Lex.Lex();
3267     return false;
3268   };
3269
3270   // Parse the flags and combine them together.
3271   unsigned Combined = 0;
3272   do {
3273     unsigned Val;
3274     if (parseFlag(Val))
3275       return true;
3276     Combined |= Val;
3277   } while (EatIfPresent(lltok::bar));
3278
3279   Result.assign(Combined);
3280   return false;
3281 }
3282
3283 template <>
3284 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3285                             MDSignedField &Result) {
3286   if (Lex.getKind() != lltok::APSInt)
3287     return TokError("expected signed integer");
3288
3289   auto &S = Lex.getAPSIntVal();
3290   if (S < Result.Min)
3291     return TokError("value for '" + Name + "' too small, limit is " +
3292                     Twine(Result.Min));
3293   if (S > Result.Max)
3294     return TokError("value for '" + Name + "' too large, limit is " +
3295                     Twine(Result.Max));
3296   Result.assign(S.getExtValue());
3297   assert(Result.Val >= Result.Min && "Expected value in range");
3298   assert(Result.Val <= Result.Max && "Expected value in range");
3299   Lex.Lex();
3300   return false;
3301 }
3302
3303 template <>
3304 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDBoolField &Result) {
3305   switch (Lex.getKind()) {
3306   default:
3307     return TokError("expected 'true' or 'false'");
3308   case lltok::kw_true:
3309     Result.assign(true);
3310     break;
3311   case lltok::kw_false:
3312     Result.assign(false);
3313     break;
3314   }
3315   Lex.Lex();
3316   return false;
3317 }
3318
3319 template <>
3320 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDField &Result) {
3321   if (Lex.getKind() == lltok::kw_null) {
3322     if (!Result.AllowNull)
3323       return TokError("'" + Name + "' cannot be null");
3324     Lex.Lex();
3325     Result.assign(nullptr);
3326     return false;
3327   }
3328
3329   Metadata *MD;
3330   if (ParseMetadata(MD, nullptr))
3331     return true;
3332
3333   Result.assign(MD);
3334   return false;
3335 }
3336
3337 template <>
3338 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDConstant &Result) {
3339   Metadata *MD;
3340   if (ParseValueAsMetadata(MD, "expected constant", nullptr))
3341     return true;
3342
3343   Result.assign(cast<ConstantAsMetadata>(MD));
3344   return false;
3345 }
3346
3347 template <>
3348 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDStringField &Result) {
3349   LocTy ValueLoc = Lex.getLoc();
3350   std::string S;
3351   if (ParseStringConstant(S))
3352     return true;
3353
3354   if (!Result.AllowEmpty && S.empty())
3355     return Error(ValueLoc, "'" + Name + "' cannot be empty");
3356
3357   Result.assign(S.empty() ? nullptr : MDString::get(Context, S));
3358   return false;
3359 }
3360
3361 template <>
3362 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDFieldList &Result) {
3363   SmallVector<Metadata *, 4> MDs;
3364   if (ParseMDNodeVector(MDs))
3365     return true;
3366
3367   Result.assign(std::move(MDs));
3368   return false;
3369 }
3370
3371 } // end namespace llvm
3372
3373 template <class ParserTy>
3374 bool LLParser::ParseMDFieldsImplBody(ParserTy parseField) {
3375   do {
3376     if (Lex.getKind() != lltok::LabelStr)
3377       return TokError("expected field label here");
3378
3379     if (parseField())
3380       return true;
3381   } while (EatIfPresent(lltok::comma));
3382
3383   return false;
3384 }
3385
3386 template <class ParserTy>
3387 bool LLParser::ParseMDFieldsImpl(ParserTy parseField, LocTy &ClosingLoc) {
3388   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
3389   Lex.Lex();
3390
3391   if (ParseToken(lltok::lparen, "expected '(' here"))
3392     return true;
3393   if (Lex.getKind() != lltok::rparen)
3394     if (ParseMDFieldsImplBody(parseField))
3395       return true;
3396
3397   ClosingLoc = Lex.getLoc();
3398   return ParseToken(lltok::rparen, "expected ')' here");
3399 }
3400
3401 template <class FieldTy>
3402 bool LLParser::ParseMDField(StringRef Name, FieldTy &Result) {
3403   if (Result.Seen)
3404     return TokError("field '" + Name + "' cannot be specified more than once");
3405
3406   LocTy Loc = Lex.getLoc();
3407   Lex.Lex();
3408   return ParseMDField(Loc, Name, Result);
3409 }
3410
3411 bool LLParser::ParseSpecializedMDNode(MDNode *&N, bool IsDistinct) {
3412   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
3413
3414 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)                                  \
3415   if (Lex.getStrVal() == #CLASS)                                               \
3416     return Parse##CLASS(N, IsDistinct);
3417 #include "llvm/IR/Metadata.def"
3418
3419   return TokError("expected metadata type");
3420 }
3421
3422 #define DECLARE_FIELD(NAME, TYPE, INIT) TYPE NAME INIT
3423 #define NOP_FIELD(NAME, TYPE, INIT)
3424 #define REQUIRE_FIELD(NAME, TYPE, INIT)                                        \
3425   if (!NAME.Seen)                                                              \
3426     return Error(ClosingLoc, "missing required field '" #NAME "'");
3427 #define PARSE_MD_FIELD(NAME, TYPE, DEFAULT)                                    \
3428   if (Lex.getStrVal() == #NAME)                                                \
3429     return ParseMDField(#NAME, NAME);
3430 #define PARSE_MD_FIELDS()                                                      \
3431   VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD)                                \
3432   do {                                                                         \
3433     LocTy ClosingLoc;                                                          \
3434     if (ParseMDFieldsImpl([&]() -> bool {                                      \
3435       VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD)                          \
3436       return TokError(Twine("invalid field '") + Lex.getStrVal() + "'");       \
3437     }, ClosingLoc))                                                            \
3438       return true;                                                             \
3439     VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD)                                  \
3440   } while (false)
3441 #define GET_OR_DISTINCT(CLASS, ARGS)                                           \
3442   (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
3443
3444 /// ParseDILocationFields:
3445 ///   ::= !DILocation(line: 43, column: 8, scope: !5, inlinedAt: !6)
3446 bool LLParser::ParseDILocation(MDNode *&Result, bool IsDistinct) {
3447 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
3448   OPTIONAL(line, LineField, );                                                 \
3449   OPTIONAL(column, ColumnField, );                                             \
3450   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
3451   OPTIONAL(inlinedAt, MDField, );
3452   PARSE_MD_FIELDS();
3453 #undef VISIT_MD_FIELDS
3454
3455   Result = GET_OR_DISTINCT(
3456       DILocation, (Context, line.Val, column.Val, scope.Val, inlinedAt.Val));
3457   return false;
3458 }
3459
3460 /// ParseGenericDINode:
3461 ///   ::= !GenericDINode(tag: 15, header: "...", operands: {...})
3462 bool LLParser::ParseGenericDINode(MDNode *&Result, bool IsDistinct) {
3463 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
3464   REQUIRED(tag, DwarfTagField, );                                              \
3465   OPTIONAL(header, MDStringField, );                                           \
3466   OPTIONAL(operands, MDFieldList, );
3467   PARSE_MD_FIELDS();
3468 #undef VISIT_MD_FIELDS
3469
3470   Result = GET_OR_DISTINCT(GenericDINode,
3471                            (Context, tag.Val, header.Val, operands.Val));
3472   return false;
3473 }
3474
3475 /// ParseDISubrange:
3476 ///   ::= !DISubrange(count: 30, lowerBound: 2)
3477 bool LLParser::ParseDISubrange(MDNode *&Result, bool IsDistinct) {
3478 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
3479   REQUIRED(count, MDSignedField, (-1, -1, INT64_MAX));                         \
3480   OPTIONAL(lowerBound, MDSignedField, );
3481   PARSE_MD_FIELDS();
3482 #undef VISIT_MD_FIELDS
3483
3484   Result = GET_OR_DISTINCT(DISubrange, (Context, count.Val, lowerBound.Val));
3485   return false;
3486 }
3487
3488 /// ParseDIEnumerator:
3489 ///   ::= !DIEnumerator(value: 30, name: "SomeKind")
3490 bool LLParser::ParseDIEnumerator(MDNode *&Result, bool IsDistinct) {
3491 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
3492   REQUIRED(name, MDStringField, );                                             \
3493   REQUIRED(value, MDSignedField, );
3494   PARSE_MD_FIELDS();
3495 #undef VISIT_MD_FIELDS
3496
3497   Result = GET_OR_DISTINCT(DIEnumerator, (Context, value.Val, name.Val));
3498   return false;
3499 }
3500
3501 /// ParseDIBasicType:
3502 ///   ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32)
3503 bool LLParser::ParseDIBasicType(MDNode *&Result, bool IsDistinct) {
3504 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
3505   OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type));                     \
3506   OPTIONAL(name, MDStringField, );                                             \
3507   OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX));                            \
3508   OPTIONAL(align, MDUnsignedField, (0, UINT64_MAX));                           \
3509   OPTIONAL(encoding, DwarfAttEncodingField, );
3510   PARSE_MD_FIELDS();
3511 #undef VISIT_MD_FIELDS
3512
3513   Result = GET_OR_DISTINCT(DIBasicType, (Context, tag.Val, name.Val, size.Val,
3514                                          align.Val, encoding.Val));
3515   return false;
3516 }
3517
3518 /// ParseDIDerivedType:
3519 ///   ::= !DIDerivedType(tag: DW_TAG_pointer_type, name: "int", file: !0,
3520 ///                      line: 7, scope: !1, baseType: !2, size: 32,
3521 ///                      align: 32, offset: 0, flags: 0, extraData: !3)
3522 bool LLParser::ParseDIDerivedType(MDNode *&Result, bool IsDistinct) {
3523 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
3524   REQUIRED(tag, DwarfTagField, );                                              \
3525   OPTIONAL(name, MDStringField, );                                             \
3526   OPTIONAL(file, MDField, );                                                   \
3527   OPTIONAL(line, LineField, );                                                 \
3528   OPTIONAL(scope, MDField, );                                                  \
3529   REQUIRED(baseType, MDField, );                                               \
3530   OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX));                            \
3531   OPTIONAL(align, MDUnsignedField, (0, UINT64_MAX));                           \
3532   OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX));                          \
3533   OPTIONAL(flags, DIFlagField, );                                              \
3534   OPTIONAL(extraData, MDField, );
3535   PARSE_MD_FIELDS();
3536 #undef VISIT_MD_FIELDS
3537
3538   Result = GET_OR_DISTINCT(DIDerivedType,
3539                            (Context, tag.Val, name.Val, file.Val, line.Val,
3540                             scope.Val, baseType.Val, size.Val, align.Val,
3541                             offset.Val, flags.Val, extraData.Val));
3542   return false;
3543 }
3544
3545 bool LLParser::ParseDICompositeType(MDNode *&Result, bool IsDistinct) {
3546 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
3547   REQUIRED(tag, DwarfTagField, );                                              \
3548   OPTIONAL(name, MDStringField, );                                             \
3549   OPTIONAL(file, MDField, );                                                   \
3550   OPTIONAL(line, LineField, );                                                 \
3551   OPTIONAL(scope, MDField, );                                                  \
3552   OPTIONAL(baseType, MDField, );                                               \
3553   OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX));                            \
3554   OPTIONAL(align, MDUnsignedField, (0, UINT64_MAX));                           \
3555   OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX));                          \
3556   OPTIONAL(flags, DIFlagField, );                                              \
3557   OPTIONAL(elements, MDField, );                                               \
3558   OPTIONAL(runtimeLang, DwarfLangField, );                                     \
3559   OPTIONAL(vtableHolder, MDField, );                                           \
3560   OPTIONAL(templateParams, MDField, );                                         \
3561   OPTIONAL(identifier, MDStringField, );
3562   PARSE_MD_FIELDS();
3563 #undef VISIT_MD_FIELDS
3564
3565   Result = GET_OR_DISTINCT(
3566       DICompositeType,
3567       (Context, tag.Val, name.Val, file.Val, line.Val, scope.Val, baseType.Val,
3568        size.Val, align.Val, offset.Val, flags.Val, elements.Val,
3569        runtimeLang.Val, vtableHolder.Val, templateParams.Val, identifier.Val));
3570   return false;
3571 }
3572
3573 bool LLParser::ParseDISubroutineType(MDNode *&Result, bool IsDistinct) {
3574 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
3575   OPTIONAL(flags, DIFlagField, );                                              \
3576   REQUIRED(types, MDField, );
3577   PARSE_MD_FIELDS();
3578 #undef VISIT_MD_FIELDS
3579
3580   Result = GET_OR_DISTINCT(DISubroutineType, (Context, flags.Val, types.Val));
3581   return false;
3582 }
3583
3584 /// ParseDIFileType:
3585 ///   ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir")
3586 bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
3587 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
3588   REQUIRED(filename, MDStringField, );                                         \
3589   REQUIRED(directory, MDStringField, );
3590   PARSE_M