LLVM  3.7.0
LLParser.cpp
Go to the documentation of this file.
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"
17 #include "llvm/IR/AutoUpgrade.h"
18 #include "llvm/IR/CallingConv.h"
19 #include "llvm/IR/Constants.h"
20 #include "llvm/IR/DebugInfo.h"
22 #include "llvm/IR/DerivedTypes.h"
23 #include "llvm/IR/InlineAsm.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/IR/LLVMContext.h"
26 #include "llvm/IR/Module.h"
27 #include "llvm/IR/Operator.h"
29 #include "llvm/Support/Dwarf.h"
33 using namespace llvm;
34 
35 static std::string getTypeString(Type *T) {
36  std::string Result;
37  raw_string_ostream Tmp(Result);
38  Tmp << *T;
39  return Tmp.str();
40 }
41 
42 /// Run: module ::= toplevelentity*
43 bool LLParser::Run() {
44  // Prime the lexer.
45  Lex.Lex();
46 
47  return ParseTopLevelEntities() ||
48  ValidateEndOfModule();
49 }
50 
51 /// ValidateEndOfModule - Do final validity and sanity checks at the end of the
52 /// module.
53 bool LLParser::ValidateEndOfModule() {
54  for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++)
55  UpgradeInstWithTBAATag(InstsWithTBAATag[I]);
56 
57  // Handle any function attribute group forward references.
58  for (std::map<Value*, std::vector<unsigned> >::iterator
59  I = ForwardRefAttrGroups.begin(), E = ForwardRefAttrGroups.end();
60  I != E; ++I) {
61  Value *V = I->first;
62  std::vector<unsigned> &Vec = I->second;
63  AttrBuilder B;
64 
65  for (std::vector<unsigned>::iterator VI = Vec.begin(), VE = Vec.end();
66  VI != VE; ++VI)
67  B.merge(NumberedAttrBuilders[*VI]);
68 
69  if (Function *Fn = dyn_cast<Function>(V)) {
70  AttributeSet AS = Fn->getAttributes();
73  AS.getFnAttributes());
74 
75  FnAttrs.merge(B);
76 
77  // If the alignment was parsed as an attribute, move to the alignment
78  // field.
79  if (FnAttrs.hasAlignmentAttr()) {
80  Fn->setAlignment(FnAttrs.getAlignment());
82  }
83 
85  AttributeSet::get(Context,
87  FnAttrs));
88  Fn->setAttributes(AS);
89  } else if (CallInst *CI = dyn_cast<CallInst>(V)) {
90  AttributeSet AS = CI->getAttributes();
93  AS.getFnAttributes());
94  FnAttrs.merge(B);
96  AttributeSet::get(Context,
98  FnAttrs));
99  CI->setAttributes(AS);
100  } else if (InvokeInst *II = dyn_cast<InvokeInst>(V)) {
101  AttributeSet AS = II->getAttributes();
104  AS.getFnAttributes());
105  FnAttrs.merge(B);
107  AttributeSet::get(Context,
109  FnAttrs));
110  II->setAttributes(AS);
111  } else {
112  llvm_unreachable("invalid object with forward attribute group reference");
113  }
114  }
115 
116  // If there are entries in ForwardRefBlockAddresses at this point, the
117  // function was never defined.
118  if (!ForwardRefBlockAddresses.empty())
119  return Error(ForwardRefBlockAddresses.begin()->first.Loc,
120  "expected function name in blockaddress");
121 
122  for (const auto &NT : NumberedTypes)
123  if (NT.second.second.isValid())
124  return Error(NT.second.second,
125  "use of undefined type '%" + Twine(NT.first) + "'");
126 
127  for (StringMap<std::pair<Type*, LocTy> >::iterator I =
128  NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I)
129  if (I->second.second.isValid())
130  return Error(I->second.second,
131  "use of undefined type named '" + I->getKey() + "'");
132 
133  if (!ForwardRefComdats.empty())
134  return Error(ForwardRefComdats.begin()->second,
135  "use of undefined comdat '$" +
136  ForwardRefComdats.begin()->first + "'");
137 
138  if (!ForwardRefVals.empty())
139  return Error(ForwardRefVals.begin()->second.second,
140  "use of undefined value '@" + ForwardRefVals.begin()->first +
141  "'");
142 
143  if (!ForwardRefValIDs.empty())
144  return Error(ForwardRefValIDs.begin()->second.second,
145  "use of undefined value '@" +
146  Twine(ForwardRefValIDs.begin()->first) + "'");
147 
148  if (!ForwardRefMDNodes.empty())
149  return Error(ForwardRefMDNodes.begin()->second.second,
150  "use of undefined metadata '!" +
151  Twine(ForwardRefMDNodes.begin()->first) + "'");
152 
153  // Resolve metadata cycles.
154  for (auto &N : NumberedMetadata) {
155  if (N.second && !N.second->isResolved())
156  N.second->resolveCycles();
157  }
158 
159  // Look for intrinsic functions and CallInst that need to be upgraded
160  for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
161  UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
162 
163  UpgradeDebugInfo(*M);
164 
165  if (!Slots)
166  return false;
167  // Initialize the slot mapping.
168  // Because by this point we've parsed and validated everything, we can "steal"
169  // the mapping from LLParser as it doesn't need it anymore.
170  Slots->GlobalValues = std::move(NumberedVals);
171  Slots->MetadataNodes = std::move(NumberedMetadata);
172 
173  return false;
174 }
175 
176 //===----------------------------------------------------------------------===//
177 // Top-Level Entities
178 //===----------------------------------------------------------------------===//
179 
180 bool LLParser::ParseTopLevelEntities() {
181  while (1) {
182  switch (Lex.getKind()) {
183  default: return TokError("expected top-level entity");
184  case lltok::Eof: return false;
185  case lltok::kw_declare: if (ParseDeclare()) return true; break;
186  case lltok::kw_define: if (ParseDefine()) return true; break;
187  case lltok::kw_module: if (ParseModuleAsm()) return true; break;
188  case lltok::kw_target: if (ParseTargetDefinition()) return true; break;
189  case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
190  case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
191  case lltok::LocalVar: if (ParseNamedType()) return true; break;
192  case lltok::GlobalID: if (ParseUnnamedGlobal()) return true; break;
193  case lltok::GlobalVar: if (ParseNamedGlobal()) return true; break;
194  case lltok::ComdatVar: if (parseComdat()) return true; break;
195  case lltok::exclaim: if (ParseStandaloneMetadata()) return true; break;
196  case lltok::MetadataVar:if (ParseNamedMetadata()) return true; break;
197 
198  // The Global variable production with no name can have many different
199  // optional leading prefixes, the production is:
200  // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalDLLStorageClass
201  // OptionalThreadLocal OptionalAddrSpace OptionalUnnamedAddr
202  // ('constant'|'global') ...
203  case lltok::kw_private: // OptionalLinkage
204  case lltok::kw_internal: // OptionalLinkage
205  case lltok::kw_weak: // OptionalLinkage
206  case lltok::kw_weak_odr: // OptionalLinkage
207  case lltok::kw_linkonce: // OptionalLinkage
208  case lltok::kw_linkonce_odr: // OptionalLinkage
209  case lltok::kw_appending: // OptionalLinkage
210  case lltok::kw_common: // OptionalLinkage
211  case lltok::kw_extern_weak: // OptionalLinkage
212  case lltok::kw_external: // OptionalLinkage
213  case lltok::kw_default: // OptionalVisibility
214  case lltok::kw_hidden: // OptionalVisibility
215  case lltok::kw_protected: // OptionalVisibility
216  case lltok::kw_dllimport: // OptionalDLLStorageClass
217  case lltok::kw_dllexport: // OptionalDLLStorageClass
218  case lltok::kw_thread_local: // OptionalThreadLocal
219  case lltok::kw_addrspace: // OptionalAddrSpace
220  case lltok::kw_constant: // GlobalType
221  case lltok::kw_global: { // GlobalType
222  unsigned Linkage, Visibility, DLLStorageClass;
223  bool UnnamedAddr;
225  bool HasLinkage;
226  if (ParseOptionalLinkage(Linkage, HasLinkage) ||
227  ParseOptionalVisibility(Visibility) ||
228  ParseOptionalDLLStorageClass(DLLStorageClass) ||
229  ParseOptionalThreadLocal(TLM) ||
230  parseOptionalUnnamedAddr(UnnamedAddr) ||
231  ParseGlobal("", SMLoc(), Linkage, HasLinkage, Visibility,
232  DLLStorageClass, TLM, UnnamedAddr))
233  return true;
234  break;
235  }
236 
237  case lltok::kw_attributes: if (ParseUnnamedAttrGrp()) return true; break;
238  case lltok::kw_uselistorder: if (ParseUseListOrder()) return true; break;
240  if (ParseUseListOrderBB()) return true; break;
241  }
242  }
243 }
244 
245 
246 /// toplevelentity
247 /// ::= 'module' 'asm' STRINGCONSTANT
248 bool LLParser::ParseModuleAsm() {
249  assert(Lex.getKind() == lltok::kw_module);
250  Lex.Lex();
251 
252  std::string AsmStr;
253  if (ParseToken(lltok::kw_asm, "expected 'module asm'") ||
254  ParseStringConstant(AsmStr)) return true;
255 
256  M->appendModuleInlineAsm(AsmStr);
257  return false;
258 }
259 
260 /// toplevelentity
261 /// ::= 'target' 'triple' '=' STRINGCONSTANT
262 /// ::= 'target' 'datalayout' '=' STRINGCONSTANT
263 bool LLParser::ParseTargetDefinition() {
264  assert(Lex.getKind() == lltok::kw_target);
265  std::string Str;
266  switch (Lex.Lex()) {
267  default: return TokError("unknown target property");
268  case lltok::kw_triple:
269  Lex.Lex();
270  if (ParseToken(lltok::equal, "expected '=' after target triple") ||
271  ParseStringConstant(Str))
272  return true;
273  M->setTargetTriple(Str);
274  return false;
276  Lex.Lex();
277  if (ParseToken(lltok::equal, "expected '=' after target datalayout") ||
278  ParseStringConstant(Str))
279  return true;
280  M->setDataLayout(Str);
281  return false;
282  }
283 }
284 
285 /// toplevelentity
286 /// ::= 'deplibs' '=' '[' ']'
287 /// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
288 /// FIXME: Remove in 4.0. Currently parse, but ignore.
289 bool LLParser::ParseDepLibs() {
290  assert(Lex.getKind() == lltok::kw_deplibs);
291  Lex.Lex();
292  if (ParseToken(lltok::equal, "expected '=' after deplibs") ||
293  ParseToken(lltok::lsquare, "expected '=' after deplibs"))
294  return true;
295 
296  if (EatIfPresent(lltok::rsquare))
297  return false;
298 
299  do {
300  std::string Str;
301  if (ParseStringConstant(Str)) return true;
302  } while (EatIfPresent(lltok::comma));
303 
304  return ParseToken(lltok::rsquare, "expected ']' at end of list");
305 }
306 
307 /// ParseUnnamedType:
308 /// ::= LocalVarID '=' 'type' type
309 bool LLParser::ParseUnnamedType() {
310  LocTy TypeLoc = Lex.getLoc();
311  unsigned TypeID = Lex.getUIntVal();
312  Lex.Lex(); // eat LocalVarID;
313 
314  if (ParseToken(lltok::equal, "expected '=' after name") ||
315  ParseToken(lltok::kw_type, "expected 'type' after '='"))
316  return true;
317 
318  Type *Result = nullptr;
319  if (ParseStructDefinition(TypeLoc, "",
320  NumberedTypes[TypeID], Result)) return true;
321 
322  if (!isa<StructType>(Result)) {
323  std::pair<Type*, LocTy> &Entry = NumberedTypes[TypeID];
324  if (Entry.first)
325  return Error(TypeLoc, "non-struct types may not be recursive");
326  Entry.first = Result;
327  Entry.second = SMLoc();
328  }
329 
330  return false;
331 }
332 
333 
334 /// toplevelentity
335 /// ::= LocalVar '=' 'type' type
336 bool LLParser::ParseNamedType() {
337  std::string Name = Lex.getStrVal();
338  LocTy NameLoc = Lex.getLoc();
339  Lex.Lex(); // eat LocalVar.
340 
341  if (ParseToken(lltok::equal, "expected '=' after name") ||
342  ParseToken(lltok::kw_type, "expected 'type' after name"))
343  return true;
344 
345  Type *Result = nullptr;
346  if (ParseStructDefinition(NameLoc, Name,
347  NamedTypes[Name], Result)) return true;
348 
349  if (!isa<StructType>(Result)) {
350  std::pair<Type*, LocTy> &Entry = NamedTypes[Name];
351  if (Entry.first)
352  return Error(NameLoc, "non-struct types may not be recursive");
353  Entry.first = Result;
354  Entry.second = SMLoc();
355  }
356 
357  return false;
358 }
359 
360 
361 /// toplevelentity
362 /// ::= 'declare' FunctionHeader
363 bool LLParser::ParseDeclare() {
364  assert(Lex.getKind() == lltok::kw_declare);
365  Lex.Lex();
366 
367  Function *F;
368  return ParseFunctionHeader(F, false);
369 }
370 
371 /// toplevelentity
372 /// ::= 'define' FunctionHeader (!dbg !56)* '{' ...
373 bool LLParser::ParseDefine() {
374  assert(Lex.getKind() == lltok::kw_define);
375  Lex.Lex();
376 
377  Function *F;
378  return ParseFunctionHeader(F, true) ||
379  ParseOptionalFunctionMetadata(*F) ||
380  ParseFunctionBody(*F);
381 }
382 
383 /// ParseGlobalType
384 /// ::= 'constant'
385 /// ::= 'global'
386 bool LLParser::ParseGlobalType(bool &IsConstant) {
387  if (Lex.getKind() == lltok::kw_constant)
388  IsConstant = true;
389  else if (Lex.getKind() == lltok::kw_global)
390  IsConstant = false;
391  else {
392  IsConstant = false;
393  return TokError("expected 'global' or 'constant'");
394  }
395  Lex.Lex();
396  return false;
397 }
398 
399 /// ParseUnnamedGlobal:
400 /// OptionalVisibility ALIAS ...
401 /// OptionalLinkage OptionalVisibility OptionalDLLStorageClass
402 /// ... -> global variable
403 /// GlobalID '=' OptionalVisibility ALIAS ...
404 /// GlobalID '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
405 /// ... -> global variable
406 bool LLParser::ParseUnnamedGlobal() {
407  unsigned VarID = NumberedVals.size();
408  std::string Name;
409  LocTy NameLoc = Lex.getLoc();
410 
411  // Handle the GlobalID form.
412  if (Lex.getKind() == lltok::GlobalID) {
413  if (Lex.getUIntVal() != VarID)
414  return Error(Lex.getLoc(), "variable expected to be numbered '%" +
415  Twine(VarID) + "'");
416  Lex.Lex(); // eat GlobalID;
417 
418  if (ParseToken(lltok::equal, "expected '=' after name"))
419  return true;
420  }
421 
422  bool HasLinkage;
423  unsigned Linkage, Visibility, DLLStorageClass;
425  bool UnnamedAddr;
426  if (ParseOptionalLinkage(Linkage, HasLinkage) ||
427  ParseOptionalVisibility(Visibility) ||
428  ParseOptionalDLLStorageClass(DLLStorageClass) ||
429  ParseOptionalThreadLocal(TLM) ||
430  parseOptionalUnnamedAddr(UnnamedAddr))
431  return true;
432 
433  if (Lex.getKind() != lltok::kw_alias)
434  return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
435  DLLStorageClass, TLM, UnnamedAddr);
436  return ParseAlias(Name, NameLoc, Linkage, Visibility, DLLStorageClass, TLM,
437  UnnamedAddr);
438 }
439 
440 /// ParseNamedGlobal:
441 /// GlobalVar '=' OptionalVisibility ALIAS ...
442 /// GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
443 /// ... -> global variable
444 bool LLParser::ParseNamedGlobal() {
445  assert(Lex.getKind() == lltok::GlobalVar);
446  LocTy NameLoc = Lex.getLoc();
447  std::string Name = Lex.getStrVal();
448  Lex.Lex();
449 
450  bool HasLinkage;
451  unsigned Linkage, Visibility, DLLStorageClass;
453  bool UnnamedAddr;
454  if (ParseToken(lltok::equal, "expected '=' in global variable") ||
455  ParseOptionalLinkage(Linkage, HasLinkage) ||
456  ParseOptionalVisibility(Visibility) ||
457  ParseOptionalDLLStorageClass(DLLStorageClass) ||
458  ParseOptionalThreadLocal(TLM) ||
459  parseOptionalUnnamedAddr(UnnamedAddr))
460  return true;
461 
462  if (Lex.getKind() != lltok::kw_alias)
463  return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
464  DLLStorageClass, TLM, UnnamedAddr);
465 
466  return ParseAlias(Name, NameLoc, Linkage, Visibility, DLLStorageClass, TLM,
467  UnnamedAddr);
468 }
469 
470 bool LLParser::parseComdat() {
471  assert(Lex.getKind() == lltok::ComdatVar);
472  std::string Name = Lex.getStrVal();
473  LocTy NameLoc = Lex.getLoc();
474  Lex.Lex();
475 
476  if (ParseToken(lltok::equal, "expected '=' here"))
477  return true;
478 
479  if (ParseToken(lltok::kw_comdat, "expected comdat keyword"))
480  return TokError("expected comdat type");
481 
483  switch (Lex.getKind()) {
484  default:
485  return TokError("unknown selection kind");
486  case lltok::kw_any:
487  SK = Comdat::Any;
488  break;
490  SK = Comdat::ExactMatch;
491  break;
492  case lltok::kw_largest:
493  SK = Comdat::Largest;
494  break;
497  break;
498  case lltok::kw_samesize:
499  SK = Comdat::SameSize;
500  break;
501  }
502  Lex.Lex();
503 
504  // See if the comdat was forward referenced, if so, use the comdat.
505  Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
506  Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
507  if (I != ComdatSymTab.end() && !ForwardRefComdats.erase(Name))
508  return Error(NameLoc, "redefinition of comdat '$" + Name + "'");
509 
510  Comdat *C;
511  if (I != ComdatSymTab.end())
512  C = &I->second;
513  else
514  C = M->getOrInsertComdat(Name);
515  C->setSelectionKind(SK);
516 
517  return false;
518 }
519 
520 // MDString:
521 // ::= '!' STRINGCONSTANT
522 bool LLParser::ParseMDString(MDString *&Result) {
523  std::string Str;
524  if (ParseStringConstant(Str)) return true;
526  Result = MDString::get(Context, Str);
527  return false;
528 }
529 
530 // MDNode:
531 // ::= '!' MDNodeNumber
532 bool LLParser::ParseMDNodeID(MDNode *&Result) {
533  // !{ ..., !42, ... }
534  unsigned MID = 0;
535  if (ParseUInt32(MID))
536  return true;
537 
538  // If not a forward reference, just return it now.
539  if (NumberedMetadata.count(MID)) {
540  Result = NumberedMetadata[MID];
541  return false;
542  }
543 
544  // Otherwise, create MDNode forward reference.
545  auto &FwdRef = ForwardRefMDNodes[MID];
546  FwdRef = std::make_pair(MDTuple::getTemporary(Context, None), Lex.getLoc());
547 
548  Result = FwdRef.first.get();
549  NumberedMetadata[MID].reset(Result);
550  return false;
551 }
552 
553 /// ParseNamedMetadata:
554 /// !foo = !{ !1, !2 }
555 bool LLParser::ParseNamedMetadata() {
556  assert(Lex.getKind() == lltok::MetadataVar);
557  std::string Name = Lex.getStrVal();
558  Lex.Lex();
559 
560  if (ParseToken(lltok::equal, "expected '=' here") ||
561  ParseToken(lltok::exclaim, "Expected '!' here") ||
562  ParseToken(lltok::lbrace, "Expected '{' here"))
563  return true;
564 
565  NamedMDNode *NMD = M->getOrInsertNamedMetadata(Name);
566  if (Lex.getKind() != lltok::rbrace)
567  do {
568  if (ParseToken(lltok::exclaim, "Expected '!' here"))
569  return true;
570 
571  MDNode *N = nullptr;
572  if (ParseMDNodeID(N)) return true;
573  NMD->addOperand(N);
574  } while (EatIfPresent(lltok::comma));
575 
576  return ParseToken(lltok::rbrace, "expected end of metadata node");
577 }
578 
579 /// ParseStandaloneMetadata:
580 /// !42 = !{...}
581 bool LLParser::ParseStandaloneMetadata() {
582  assert(Lex.getKind() == lltok::exclaim);
583  Lex.Lex();
584  unsigned MetadataID = 0;
585 
586  MDNode *Init;
587  if (ParseUInt32(MetadataID) ||
588  ParseToken(lltok::equal, "expected '=' here"))
589  return true;
590 
591  // Detect common error, from old metadata syntax.
592  if (Lex.getKind() == lltok::Type)
593  return TokError("unexpected type in metadata definition");
594 
595  bool IsDistinct = EatIfPresent(lltok::kw_distinct);
596  if (Lex.getKind() == lltok::MetadataVar) {
597  if (ParseSpecializedMDNode(Init, IsDistinct))
598  return true;
599  } else if (ParseToken(lltok::exclaim, "Expected '!' here") ||
600  ParseMDTuple(Init, IsDistinct))
601  return true;
602 
603  // See if this was forward referenced, if so, handle it.
604  auto FI = ForwardRefMDNodes.find(MetadataID);
605  if (FI != ForwardRefMDNodes.end()) {
606  FI->second.first->replaceAllUsesWith(Init);
607  ForwardRefMDNodes.erase(FI);
608 
609  assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work");
610  } else {
611  if (NumberedMetadata.count(MetadataID))
612  return TokError("Metadata id is already used");
613  NumberedMetadata[MetadataID].reset(Init);
614  }
615 
616  return false;
617 }
618 
619 static bool isValidVisibilityForLinkage(unsigned V, unsigned L) {
622 }
623 
624 /// ParseAlias:
625 /// ::= GlobalVar '=' OptionalLinkage OptionalVisibility
626 /// OptionalDLLStorageClass OptionalThreadLocal
627 /// OptionalUnnamedAddr 'alias' Aliasee
628 ///
629 /// Aliasee
630 /// ::= TypeAndValue
631 ///
632 /// Everything through OptionalUnnamedAddr has already been parsed.
633 ///
634 bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, unsigned L,
635  unsigned Visibility, unsigned DLLStorageClass,
637  bool UnnamedAddr) {
638  assert(Lex.getKind() == lltok::kw_alias);
639  Lex.Lex();
640 
642 
643  if(!GlobalAlias::isValidLinkage(Linkage))
644  return Error(NameLoc, "invalid linkage type for alias");
645 
646  if (!isValidVisibilityForLinkage(Visibility, L))
647  return Error(NameLoc,
648  "symbol with local linkage must have default visibility");
649 
650  Constant *Aliasee;
651  LocTy AliaseeLoc = Lex.getLoc();
652  if (Lex.getKind() != lltok::kw_bitcast &&
653  Lex.getKind() != lltok::kw_getelementptr &&
654  Lex.getKind() != lltok::kw_addrspacecast &&
655  Lex.getKind() != lltok::kw_inttoptr) {
656  if (ParseGlobalTypeAndValue(Aliasee))
657  return true;
658  } else {
659  // The bitcast dest type is not present, it is implied by the dest type.
660  ValID ID;
661  if (ParseValID(ID))
662  return true;
663  if (ID.Kind != ValID::t_Constant)
664  return Error(AliaseeLoc, "invalid aliasee");
665  Aliasee = ID.ConstantVal;
666  }
667 
668  Type *AliaseeType = Aliasee->getType();
669  auto *PTy = dyn_cast<PointerType>(AliaseeType);
670  if (!PTy)
671  return Error(AliaseeLoc, "An alias must have pointer type");
672 
673  // Okay, create the alias but do not insert it into the module yet.
674  std::unique_ptr<GlobalAlias> GA(
676  Aliasee, /*Parent*/ nullptr));
677  GA->setThreadLocalMode(TLM);
678  GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
679  GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
680  GA->setUnnamedAddr(UnnamedAddr);
681 
682  if (Name.empty())
683  NumberedVals.push_back(GA.get());
684 
685  // See if this value already exists in the symbol table. If so, it is either
686  // a redefinition or a definition of a forward reference.
687  if (GlobalValue *Val = M->getNamedValue(Name)) {
688  // See if this was a redefinition. If so, there is no entry in
689  // ForwardRefVals.
690  std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
691  I = ForwardRefVals.find(Name);
692  if (I == ForwardRefVals.end())
693  return Error(NameLoc, "redefinition of global named '@" + Name + "'");
694 
695  // Otherwise, this was a definition of forward ref. Verify that types
696  // agree.
697  if (Val->getType() != GA->getType())
698  return Error(NameLoc,
699  "forward reference and definition of alias have different types");
700 
701  // If they agree, just RAUW the old value with the alias and remove the
702  // forward ref info.
703  Val->replaceAllUsesWith(GA.get());
704  Val->eraseFromParent();
705  ForwardRefVals.erase(I);
706  }
707 
708  // Insert into the module, we know its name won't collide now.
709  M->getAliasList().push_back(GA.get());
710  assert(GA->getName() == Name && "Should not be a name conflict!");
711 
712  // The module owns this now
713  GA.release();
714 
715  return false;
716 }
717 
718 /// ParseGlobal
719 /// ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
720 /// OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
721 /// OptionalExternallyInitialized GlobalType Type Const
722 /// ::= OptionalLinkage OptionalVisibility OptionalDLLStorageClass
723 /// OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
724 /// OptionalExternallyInitialized GlobalType Type Const
725 ///
726 /// Everything up to and including OptionalUnnamedAddr has been parsed
727 /// already.
728 ///
729 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
730  unsigned Linkage, bool HasLinkage,
731  unsigned Visibility, unsigned DLLStorageClass,
733  bool UnnamedAddr) {
734  if (!isValidVisibilityForLinkage(Visibility, Linkage))
735  return Error(NameLoc,
736  "symbol with local linkage must have default visibility");
737 
738  unsigned AddrSpace;
739  bool IsConstant, IsExternallyInitialized;
740  LocTy IsExternallyInitializedLoc;
741  LocTy TyLoc;
742 
743  Type *Ty = nullptr;
744  if (ParseOptionalAddrSpace(AddrSpace) ||
745  ParseOptionalToken(lltok::kw_externally_initialized,
746  IsExternallyInitialized,
747  &IsExternallyInitializedLoc) ||
748  ParseGlobalType(IsConstant) ||
749  ParseType(Ty, TyLoc))
750  return true;
751 
752  // If the linkage is specified and is external, then no initializer is
753  // present.
754  Constant *Init = nullptr;
755  if (!HasLinkage || (Linkage != GlobalValue::ExternalWeakLinkage &&
756  Linkage != GlobalValue::ExternalLinkage)) {
757  if (ParseGlobalValue(Ty, Init))
758  return true;
759  }
760 
762  return Error(TyLoc, "invalid type for global variable");
763 
764  GlobalValue *GVal = nullptr;
765 
766  // See if the global was forward referenced, if so, use the global.
767  if (!Name.empty()) {
768  GVal = M->getNamedValue(Name);
769  if (GVal) {
770  if (!ForwardRefVals.erase(Name) || !isa<GlobalValue>(GVal))
771  return Error(NameLoc, "redefinition of global '@" + Name + "'");
772  }
773  } else {
774  std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
775  I = ForwardRefValIDs.find(NumberedVals.size());
776  if (I != ForwardRefValIDs.end()) {
777  GVal = I->second.first;
778  ForwardRefValIDs.erase(I);
779  }
780  }
781 
782  GlobalVariable *GV;
783  if (!GVal) {
784  GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, nullptr,
785  Name, nullptr, GlobalVariable::NotThreadLocal,
786  AddrSpace);
787  } else {
788  if (GVal->getValueType() != Ty)
789  return Error(TyLoc,
790  "forward reference and definition of global have different types");
791 
792  GV = cast<GlobalVariable>(GVal);
793 
794  // Move the forward-reference to the correct spot in the module.
795  M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV);
796  }
797 
798  if (Name.empty())
799  NumberedVals.push_back(GV);
800 
801  // Set the parsed properties on the global.
802  if (Init)
803  GV->setInitializer(Init);
804  GV->setConstant(IsConstant);
808  GV->setExternallyInitialized(IsExternallyInitialized);
809  GV->setThreadLocalMode(TLM);
810  GV->setUnnamedAddr(UnnamedAddr);
811 
812  // Parse attributes on the global.
813  while (Lex.getKind() == lltok::comma) {
814  Lex.Lex();
815 
816  if (Lex.getKind() == lltok::kw_section) {
817  Lex.Lex();
818  GV->setSection(Lex.getStrVal());
819  if (ParseToken(lltok::StringConstant, "expected global section string"))
820  return true;
821  } else if (Lex.getKind() == lltok::kw_align) {
822  unsigned Alignment;
823  if (ParseOptionalAlignment(Alignment)) return true;
824  GV->setAlignment(Alignment);
825  } else {
826  Comdat *C;
827  if (parseOptionalComdat(Name, C))
828  return true;
829  if (C)
830  GV->setComdat(C);
831  else
832  return TokError("unknown global variable property!");
833  }
834  }
835 
836  return false;
837 }
838 
839 /// ParseUnnamedAttrGrp
840 /// ::= 'attributes' AttrGrpID '=' '{' AttrValPair+ '}'
841 bool LLParser::ParseUnnamedAttrGrp() {
842  assert(Lex.getKind() == lltok::kw_attributes);
843  LocTy AttrGrpLoc = Lex.getLoc();
844  Lex.Lex();
845 
846  if (Lex.getKind() != lltok::AttrGrpID)
847  return TokError("expected attribute group id");
848 
849  unsigned VarID = Lex.getUIntVal();
850  std::vector<unsigned> unused;
851  LocTy BuiltinLoc;
852  Lex.Lex();
853 
854  if (ParseToken(lltok::equal, "expected '=' here") ||
855  ParseToken(lltok::lbrace, "expected '{' here") ||
856  ParseFnAttributeValuePairs(NumberedAttrBuilders[VarID], unused, true,
857  BuiltinLoc) ||
858  ParseToken(lltok::rbrace, "expected end of attribute group"))
859  return true;
860 
861  if (!NumberedAttrBuilders[VarID].hasAttributes())
862  return Error(AttrGrpLoc, "attribute group has no attributes");
863 
864  return false;
865 }
866 
867 /// ParseFnAttributeValuePairs
868 /// ::= <attr> | <attr> '=' <value>
869 bool LLParser::ParseFnAttributeValuePairs(AttrBuilder &B,
870  std::vector<unsigned> &FwdRefAttrGrps,
871  bool inAttrGrp, LocTy &BuiltinLoc) {
872  bool HaveError = false;
873 
874  B.clear();
875 
876  while (true) {
877  lltok::Kind Token = Lex.getKind();
878  if (Token == lltok::kw_builtin)
879  BuiltinLoc = Lex.getLoc();
880  switch (Token) {
881  default:
882  if (!inAttrGrp) return HaveError;
883  return Error(Lex.getLoc(), "unterminated attribute group");
884  case lltok::rbrace:
885  // Finished.
886  return false;
887 
888  case lltok::AttrGrpID: {
889  // Allow a function to reference an attribute group:
890  //
891  // define void @foo() #1 { ... }
892  if (inAttrGrp)
893  HaveError |=
894  Error(Lex.getLoc(),
895  "cannot have an attribute group reference in an attribute group");
896 
897  unsigned AttrGrpNum = Lex.getUIntVal();
898  if (inAttrGrp) break;
899 
900  // Save the reference to the attribute group. We'll fill it in later.
901  FwdRefAttrGrps.push_back(AttrGrpNum);
902  break;
903  }
904  // Target-dependent attributes:
905  case lltok::StringConstant: {
906  std::string Attr = Lex.getStrVal();
907  Lex.Lex();
908  std::string Val;
909  if (EatIfPresent(lltok::equal) &&
910  ParseStringConstant(Val))
911  return true;
912 
913  B.addAttribute(Attr, Val);
914  continue;
915  }
916 
917  // Target-independent attributes:
918  case lltok::kw_align: {
919  // As a hack, we allow function alignment to be initially parsed as an
920  // attribute on a function declaration/definition or added to an attribute
921  // group and later moved to the alignment field.
922  unsigned Alignment;
923  if (inAttrGrp) {
924  Lex.Lex();
925  if (ParseToken(lltok::equal, "expected '=' here") ||
926  ParseUInt32(Alignment))
927  return true;
928  } else {
929  if (ParseOptionalAlignment(Alignment))
930  return true;
931  }
932  B.addAlignmentAttr(Alignment);
933  continue;
934  }
935  case lltok::kw_alignstack: {
936  unsigned Alignment;
937  if (inAttrGrp) {
938  Lex.Lex();
939  if (ParseToken(lltok::equal, "expected '=' here") ||
940  ParseUInt32(Alignment))
941  return true;
942  } else {
943  if (ParseOptionalStackAlignment(Alignment))
944  return true;
945  }
946  B.addStackAlignmentAttr(Alignment);
947  continue;
948  }
975  case lltok::kw_sspstrong:
985 
986  // Error handling.
987  case lltok::kw_inreg:
988  case lltok::kw_signext:
989  case lltok::kw_zeroext:
990  HaveError |=
991  Error(Lex.getLoc(),
992  "invalid use of attribute on a function");
993  break;
994  case lltok::kw_byval:
997  case lltok::kw_inalloca:
998  case lltok::kw_nest:
999  case lltok::kw_noalias:
1000  case lltok::kw_nocapture:
1001  case lltok::kw_nonnull:
1002  case lltok::kw_returned:
1003  case lltok::kw_sret:
1004  HaveError |=
1005  Error(Lex.getLoc(),
1006  "invalid use of parameter-only attribute on a function");
1007  break;
1008  }
1009 
1010  Lex.Lex();
1011  }
1012 }
1013 
1014 //===----------------------------------------------------------------------===//
1015 // GlobalValue Reference/Resolution Routines.
1016 //===----------------------------------------------------------------------===//
1017 
1018 /// GetGlobalVal - Get a value with the specified name or ID, creating a
1019 /// forward reference record if needed. This can return null if the value
1020 /// exists but does not have the right type.
1021 GlobalValue *LLParser::GetGlobalVal(const std::string &Name, Type *Ty,
1022  LocTy Loc) {
1023  PointerType *PTy = dyn_cast<PointerType>(Ty);
1024  if (!PTy) {
1025  Error(Loc, "global variable reference must have pointer type");
1026  return nullptr;
1027  }
1028 
1029  // Look this name up in the normal function symbol table.
1030  GlobalValue *Val =
1031  cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name));
1032 
1033  // If this is a forward reference for the value, see if we already created a
1034  // forward ref record.
1035  if (!Val) {
1036  std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
1037  I = ForwardRefVals.find(Name);
1038  if (I != ForwardRefVals.end())
1039  Val = I->second.first;
1040  }
1041 
1042  // If we have the value in the symbol table or fwd-ref table, return it.
1043  if (Val) {
1044  if (Val->getType() == Ty) return Val;
1045  Error(Loc, "'@" + Name + "' defined with type '" +
1046  getTypeString(Val->getType()) + "'");
1047  return nullptr;
1048  }
1049 
1050  // Otherwise, create a new forward reference for this value and remember it.
1051  GlobalValue *FwdVal;
1052  if (FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType()))
1053  FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M);
1054  else
1055  FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
1058  PTy->getAddressSpace());
1059 
1060  ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
1061  return FwdVal;
1062 }
1063 
1064 GlobalValue *LLParser::GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc) {
1065  PointerType *PTy = dyn_cast<PointerType>(Ty);
1066  if (!PTy) {
1067  Error(Loc, "global variable reference must have pointer type");
1068  return nullptr;
1069  }
1070 
1071  GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
1072 
1073  // If this is a forward reference for the value, see if we already created a
1074  // forward ref record.
1075  if (!Val) {
1076  std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
1077  I = ForwardRefValIDs.find(ID);
1078  if (I != ForwardRefValIDs.end())
1079  Val = I->second.first;
1080  }
1081 
1082  // If we have the value in the symbol table or fwd-ref table, return it.
1083  if (Val) {
1084  if (Val->getType() == Ty) return Val;
1085  Error(Loc, "'@" + Twine(ID) + "' defined with type '" +
1086  getTypeString(Val->getType()) + "'");
1087  return nullptr;
1088  }
1089 
1090  // Otherwise, create a new forward reference for this value and remember it.
1091  GlobalValue *FwdVal;
1092  if (FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType()))
1094  else
1095  FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
1096  GlobalValue::ExternalWeakLinkage, nullptr, "");
1097 
1098  ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
1099  return FwdVal;
1100 }
1101 
1102 
1103 //===----------------------------------------------------------------------===//
1104 // Comdat Reference/Resolution Routines.
1105 //===----------------------------------------------------------------------===//
1106 
1107 Comdat *LLParser::getComdat(const std::string &Name, LocTy Loc) {
1108  // Look this name up in the comdat symbol table.
1109  Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
1110  Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
1111  if (I != ComdatSymTab.end())
1112  return &I->second;
1113 
1114  // Otherwise, create a new forward reference for this value and remember it.
1115  Comdat *C = M->getOrInsertComdat(Name);
1116  ForwardRefComdats[Name] = Loc;
1117  return C;
1118 }
1119 
1120 
1121 //===----------------------------------------------------------------------===//
1122 // Helper Routines.
1123 //===----------------------------------------------------------------------===//
1124 
1125 /// ParseToken - If the current token has the specified kind, eat it and return
1126 /// success. Otherwise, emit the specified error and return failure.
1127 bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) {
1128  if (Lex.getKind() != T)
1129  return TokError(ErrMsg);
1130  Lex.Lex();
1131  return false;
1132 }
1133 
1134 /// ParseStringConstant
1135 /// ::= StringConstant
1136 bool LLParser::ParseStringConstant(std::string &Result) {
1137  if (Lex.getKind() != lltok::StringConstant)
1138  return TokError("expected string constant");
1139  Result = Lex.getStrVal();
1140  Lex.Lex();
1141  return false;
1142 }
1143 
1144 /// ParseUInt32
1145 /// ::= uint32
1146 bool LLParser::ParseUInt32(unsigned &Val) {
1147  if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
1148  return TokError("expected integer");
1149  uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1);
1150  if (Val64 != unsigned(Val64))
1151  return TokError("expected 32-bit integer (too large)");
1152  Val = Val64;
1153  Lex.Lex();
1154  return false;
1155 }
1156 
1157 /// ParseUInt64
1158 /// ::= uint64
1159 bool LLParser::ParseUInt64(uint64_t &Val) {
1160  if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
1161  return TokError("expected integer");
1162  Val = Lex.getAPSIntVal().getLimitedValue();
1163  Lex.Lex();
1164  return false;
1165 }
1166 
1167 /// ParseTLSModel
1168 /// := 'localdynamic'
1169 /// := 'initialexec'
1170 /// := 'localexec'
1171 bool LLParser::ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM) {
1172  switch (Lex.getKind()) {
1173  default:
1174  return TokError("expected localdynamic, initialexec or localexec");
1177  break;
1178  case lltok::kw_initialexec:
1180  break;
1181  case lltok::kw_localexec:
1183  break;
1184  }
1185 
1186  Lex.Lex();
1187  return false;
1188 }
1189 
1190 /// ParseOptionalThreadLocal
1191 /// := /*empty*/
1192 /// := 'thread_local'
1193 /// := 'thread_local' '(' tlsmodel ')'
1194 bool LLParser::ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM) {
1196  if (!EatIfPresent(lltok::kw_thread_local))
1197  return false;
1198 
1200  if (Lex.getKind() == lltok::lparen) {
1201  Lex.Lex();
1202  return ParseTLSModel(TLM) ||
1203  ParseToken(lltok::rparen, "expected ')' after thread local model");
1204  }
1205  return false;
1206 }
1207 
1208 /// ParseOptionalAddrSpace
1209 /// := /*empty*/
1210 /// := 'addrspace' '(' uint32 ')'
1211 bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) {
1212  AddrSpace = 0;
1213  if (!EatIfPresent(lltok::kw_addrspace))
1214  return false;
1215  return ParseToken(lltok::lparen, "expected '(' in address space") ||
1216  ParseUInt32(AddrSpace) ||
1217  ParseToken(lltok::rparen, "expected ')' in address space");
1218 }
1219 
1220 /// ParseOptionalParamAttrs - Parse a potentially empty list of parameter attributes.
1221 bool LLParser::ParseOptionalParamAttrs(AttrBuilder &B) {
1222  bool HaveError = false;
1223 
1224  B.clear();
1225 
1226  while (1) {
1227  lltok::Kind Token = Lex.getKind();
1228  switch (Token) {
1229  default: // End of attributes.
1230  return HaveError;
1231  case lltok::kw_align: {
1232  unsigned Alignment;
1233  if (ParseOptionalAlignment(Alignment))
1234  return true;
1235  B.addAlignmentAttr(Alignment);
1236  continue;
1237  }
1240  uint64_t Bytes;
1241  if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1242  return true;
1243  B.addDereferenceableAttr(Bytes);
1244  continue;
1245  }
1247  uint64_t Bytes;
1248  if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1249  return true;
1251  continue;
1252  }
1265 
1266  case lltok::kw_alignstack:
1268  case lltok::kw_argmemonly:
1269  case lltok::kw_builtin:
1270  case lltok::kw_inlinehint:
1271  case lltok::kw_jumptable:
1272  case lltok::kw_minsize:
1273  case lltok::kw_naked:
1274  case lltok::kw_nobuiltin:
1275  case lltok::kw_noduplicate:
1277  case lltok::kw_noinline:
1278  case lltok::kw_nonlazybind:
1279  case lltok::kw_noredzone:
1280  case lltok::kw_noreturn:
1281  case lltok::kw_nounwind:
1282  case lltok::kw_optnone:
1283  case lltok::kw_optsize:
1288  case lltok::kw_ssp:
1289  case lltok::kw_sspreq:
1290  case lltok::kw_sspstrong:
1291  case lltok::kw_safestack:
1292  case lltok::kw_uwtable:
1293  HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
1294  break;
1295  }
1296 
1297  Lex.Lex();
1298  }
1299 }
1300 
1301 /// ParseOptionalReturnAttrs - Parse a potentially empty list of return attributes.
1302 bool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
1303  bool HaveError = false;
1304 
1305  B.clear();
1306 
1307  while (1) {
1308  lltok::Kind Token = Lex.getKind();
1309  switch (Token) {
1310  default: // End of attributes.
1311  return HaveError;
1313  uint64_t Bytes;
1314  if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1315  return true;
1316  B.addDereferenceableAttr(Bytes);
1317  continue;
1318  }
1320  uint64_t Bytes;
1321  if (ParseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1322  return true;
1324  continue;
1325  }
1331 
1332  // Error handling.
1333  case lltok::kw_align:
1334  case lltok::kw_byval:
1335  case lltok::kw_inalloca:
1336  case lltok::kw_nest:
1337  case lltok::kw_nocapture:
1338  case lltok::kw_returned:
1339  case lltok::kw_sret:
1340  HaveError |= Error(Lex.getLoc(), "invalid use of parameter-only attribute");
1341  break;
1342 
1343  case lltok::kw_alignstack:
1345  case lltok::kw_argmemonly:
1346  case lltok::kw_builtin:
1347  case lltok::kw_cold:
1348  case lltok::kw_inlinehint:
1349  case lltok::kw_jumptable:
1350  case lltok::kw_minsize:
1351  case lltok::kw_naked:
1352  case lltok::kw_nobuiltin:
1353  case lltok::kw_noduplicate:
1355  case lltok::kw_noinline:
1356  case lltok::kw_nonlazybind:
1357  case lltok::kw_noredzone:
1358  case lltok::kw_noreturn:
1359  case lltok::kw_nounwind:
1360  case lltok::kw_optnone:
1361  case lltok::kw_optsize:
1366  case lltok::kw_ssp:
1367  case lltok::kw_sspreq:
1368  case lltok::kw_sspstrong:
1369  case lltok::kw_safestack:
1370  case lltok::kw_uwtable:
1371  HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
1372  break;
1373 
1374  case lltok::kw_readnone:
1375  case lltok::kw_readonly:
1376  HaveError |= Error(Lex.getLoc(), "invalid use of attribute on return type");
1377  }
1378 
1379  Lex.Lex();
1380  }
1381 }
1382 
1383 /// ParseOptionalLinkage
1384 /// ::= /*empty*/
1385 /// ::= 'private'
1386 /// ::= 'internal'
1387 /// ::= 'weak'
1388 /// ::= 'weak_odr'
1389 /// ::= 'linkonce'
1390 /// ::= 'linkonce_odr'
1391 /// ::= 'available_externally'
1392 /// ::= 'appending'
1393 /// ::= 'common'
1394 /// ::= 'extern_weak'
1395 /// ::= 'external'
1396 bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {
1397  HasLinkage = false;
1398  switch (Lex.getKind()) {
1399  default: Res=GlobalValue::ExternalLinkage; return false;
1402  case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break;
1408  break;
1410  case lltok::kw_common: Res = GlobalValue::CommonLinkage; break;
1413  }
1414  Lex.Lex();
1415  HasLinkage = true;
1416  return false;
1417 }
1418 
1419 /// ParseOptionalVisibility
1420 /// ::= /*empty*/
1421 /// ::= 'default'
1422 /// ::= 'hidden'
1423 /// ::= 'protected'
1424 ///
1425 bool LLParser::ParseOptionalVisibility(unsigned &Res) {
1426  switch (Lex.getKind()) {
1427  default: Res = GlobalValue::DefaultVisibility; return false;
1431  }
1432  Lex.Lex();
1433  return false;
1434 }
1435 
1436 /// ParseOptionalDLLStorageClass
1437 /// ::= /*empty*/
1438 /// ::= 'dllimport'
1439 /// ::= 'dllexport'
1440 ///
1441 bool LLParser::ParseOptionalDLLStorageClass(unsigned &Res) {
1442  switch (Lex.getKind()) {
1443  default: Res = GlobalValue::DefaultStorageClass; return false;
1446  }
1447  Lex.Lex();
1448  return false;
1449 }
1450 
1451 /// ParseOptionalCallingConv
1452 /// ::= /*empty*/
1453 /// ::= 'ccc'
1454 /// ::= 'fastcc'
1455 /// ::= 'intel_ocl_bicc'
1456 /// ::= 'coldcc'
1457 /// ::= 'x86_stdcallcc'
1458 /// ::= 'x86_fastcallcc'
1459 /// ::= 'x86_thiscallcc'
1460 /// ::= 'x86_vectorcallcc'
1461 /// ::= 'arm_apcscc'
1462 /// ::= 'arm_aapcscc'
1463 /// ::= 'arm_aapcs_vfpcc'
1464 /// ::= 'msp430_intrcc'
1465 /// ::= 'ptx_kernel'
1466 /// ::= 'ptx_device'
1467 /// ::= 'spir_func'
1468 /// ::= 'spir_kernel'
1469 /// ::= 'x86_64_sysvcc'
1470 /// ::= 'x86_64_win64cc'
1471 /// ::= 'webkit_jscc'
1472 /// ::= 'anyregcc'
1473 /// ::= 'preserve_mostcc'
1474 /// ::= 'preserve_allcc'
1475 /// ::= 'ghccc'
1476 /// ::= 'cc' UINT
1477 ///
1478 bool LLParser::ParseOptionalCallingConv(unsigned &CC) {
1479  switch (Lex.getKind()) {
1480  default: CC = CallingConv::C; return false;
1481  case lltok::kw_ccc: CC = CallingConv::C; break;
1482  case lltok::kw_fastcc: CC = CallingConv::Fast; break;
1483  case lltok::kw_coldcc: CC = CallingConv::Cold; break;
1488  case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break;
1495  case lltok::kw_spir_func: CC = CallingConv::SPIR_FUNC; break;
1500  case lltok::kw_anyregcc: CC = CallingConv::AnyReg; break;
1503  case lltok::kw_ghccc: CC = CallingConv::GHC; break;
1504  case lltok::kw_cc: {
1505  Lex.Lex();
1506  return ParseUInt32(CC);
1507  }
1508  }
1509 
1510  Lex.Lex();
1511  return false;
1512 }
1513 
1514 /// ParseMetadataAttachment
1515 /// ::= !dbg !42
1516 bool LLParser::ParseMetadataAttachment(unsigned &Kind, MDNode *&MD) {
1517  assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata attachment");
1518 
1519  std::string Name = Lex.getStrVal();
1520  Kind = M->getMDKindID(Name);
1521  Lex.Lex();
1522 
1523  return ParseMDNode(MD);
1524 }
1525 
1526 /// ParseInstructionMetadata
1527 /// ::= !dbg !42 (',' !dbg !57)*
1528 bool LLParser::ParseInstructionMetadata(Instruction &Inst) {
1529  do {
1530  if (Lex.getKind() != lltok::MetadataVar)
1531  return TokError("expected metadata after comma");
1532 
1533  unsigned MDK;
1534  MDNode *N;
1535  if (ParseMetadataAttachment(MDK, N))
1536  return true;
1537 
1538  Inst.setMetadata(MDK, N);
1539  if (MDK == LLVMContext::MD_tbaa)
1540  InstsWithTBAATag.push_back(&Inst);
1541 
1542  // If this is the end of the list, we're done.
1543  } while (EatIfPresent(lltok::comma));
1544  return false;
1545 }
1546 
1547 /// ParseOptionalFunctionMetadata
1548 /// ::= (!dbg !57)*
1549 bool LLParser::ParseOptionalFunctionMetadata(Function &F) {
1550  while (Lex.getKind() == lltok::MetadataVar) {
1551  unsigned MDK;
1552  MDNode *N;
1553  if (ParseMetadataAttachment(MDK, N))
1554  return true;
1555 
1556  F.setMetadata(MDK, N);
1557  }
1558  return false;
1559 }
1560 
1561 /// ParseOptionalAlignment
1562 /// ::= /* empty */
1563 /// ::= 'align' 4
1564 bool LLParser::ParseOptionalAlignment(unsigned &Alignment) {
1565  Alignment = 0;
1566  if (!EatIfPresent(lltok::kw_align))
1567  return false;
1568  LocTy AlignLoc = Lex.getLoc();
1569  if (ParseUInt32(Alignment)) return true;
1570  if (!isPowerOf2_32(Alignment))
1571  return Error(AlignLoc, "alignment is not a power of two");
1572  if (Alignment > Value::MaximumAlignment)
1573  return Error(AlignLoc, "huge alignments are not supported yet");
1574  return false;
1575 }
1576 
1577 /// ParseOptionalDerefAttrBytes
1578 /// ::= /* empty */
1579 /// ::= AttrKind '(' 4 ')'
1580 ///
1581 /// where AttrKind is either 'dereferenceable' or 'dereferenceable_or_null'.
1582 bool LLParser::ParseOptionalDerefAttrBytes(lltok::Kind AttrKind,
1583  uint64_t &Bytes) {
1584  assert((AttrKind == lltok::kw_dereferenceable ||
1585  AttrKind == lltok::kw_dereferenceable_or_null) &&
1586  "contract!");
1587 
1588  Bytes = 0;
1589  if (!EatIfPresent(AttrKind))
1590  return false;
1591  LocTy ParenLoc = Lex.getLoc();
1592  if (!EatIfPresent(lltok::lparen))
1593  return Error(ParenLoc, "expected '('");
1594  LocTy DerefLoc = Lex.getLoc();
1595  if (ParseUInt64(Bytes)) return true;
1596  ParenLoc = Lex.getLoc();
1597  if (!EatIfPresent(lltok::rparen))
1598  return Error(ParenLoc, "expected ')'");
1599  if (!Bytes)
1600  return Error(DerefLoc, "dereferenceable bytes must be non-zero");
1601  return false;
1602 }
1603 
1604 /// ParseOptionalCommaAlign
1605 /// ::=
1606 /// ::= ',' align 4
1607 ///
1608 /// This returns with AteExtraComma set to true if it ate an excess comma at the
1609 /// end.
1610 bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment,
1611  bool &AteExtraComma) {
1612  AteExtraComma = false;
1613  while (EatIfPresent(lltok::comma)) {
1614  // Metadata at the end is an early exit.
1615  if (Lex.getKind() == lltok::MetadataVar) {
1616  AteExtraComma = true;
1617  return false;
1618  }
1619 
1620  if (Lex.getKind() != lltok::kw_align)
1621  return Error(Lex.getLoc(), "expected metadata or 'align'");
1622 
1623  if (ParseOptionalAlignment(Alignment)) return true;
1624  }
1625 
1626  return false;
1627 }
1628 
1629 /// ParseScopeAndOrdering
1630 /// if isAtomic: ::= 'singlethread'? AtomicOrdering
1631 /// else: ::=
1632 ///
1633 /// This sets Scope and Ordering to the parsed values.
1634 bool LLParser::ParseScopeAndOrdering(bool isAtomic, SynchronizationScope &Scope,
1635  AtomicOrdering &Ordering) {
1636  if (!isAtomic)
1637  return false;
1638 
1639  Scope = CrossThread;
1640  if (EatIfPresent(lltok::kw_singlethread))
1641  Scope = SingleThread;
1642 
1643  return ParseOrdering(Ordering);
1644 }
1645 
1646 /// ParseOrdering
1647 /// ::= AtomicOrdering
1648 ///
1649 /// This sets Ordering to the parsed value.
1650 bool LLParser::ParseOrdering(AtomicOrdering &Ordering) {
1651  switch (Lex.getKind()) {
1652  default: return TokError("Expected ordering on atomic instruction");
1653  case lltok::kw_unordered: Ordering = Unordered; break;
1654  case lltok::kw_monotonic: Ordering = Monotonic; break;
1655  case lltok::kw_acquire: Ordering = Acquire; break;
1656  case lltok::kw_release: Ordering = Release; break;
1657  case lltok::kw_acq_rel: Ordering = AcquireRelease; break;
1658  case lltok::kw_seq_cst: Ordering = SequentiallyConsistent; break;
1659  }
1660  Lex.Lex();
1661  return false;
1662 }
1663 
1664 /// ParseOptionalStackAlignment
1665 /// ::= /* empty */
1666 /// ::= 'alignstack' '(' 4 ')'
1667 bool LLParser::ParseOptionalStackAlignment(unsigned &Alignment) {
1668  Alignment = 0;
1669  if (!EatIfPresent(lltok::kw_alignstack))
1670  return false;
1671  LocTy ParenLoc = Lex.getLoc();
1672  if (!EatIfPresent(lltok::lparen))
1673  return Error(ParenLoc, "expected '('");
1674  LocTy AlignLoc = Lex.getLoc();
1675  if (ParseUInt32(Alignment)) return true;
1676  ParenLoc = Lex.getLoc();
1677  if (!EatIfPresent(lltok::rparen))
1678  return Error(ParenLoc, "expected ')'");
1679  if (!isPowerOf2_32(Alignment))
1680  return Error(AlignLoc, "stack alignment is not a power of two");
1681  return false;
1682 }
1683 
1684 /// ParseIndexList - This parses the index list for an insert/extractvalue
1685 /// instruction. This sets AteExtraComma in the case where we eat an extra
1686 /// comma at the end of the line and find that it is followed by metadata.
1687 /// Clients that don't allow metadata can call the version of this function that
1688 /// only takes one argument.
1689 ///
1690 /// ParseIndexList
1691 /// ::= (',' uint32)+
1692 ///
1693 bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices,
1694  bool &AteExtraComma) {
1695  AteExtraComma = false;
1696 
1697  if (Lex.getKind() != lltok::comma)
1698  return TokError("expected ',' as start of index list");
1699 
1700  while (EatIfPresent(lltok::comma)) {
1701  if (Lex.getKind() == lltok::MetadataVar) {
1702  if (Indices.empty()) return TokError("expected index");
1703  AteExtraComma = true;
1704  return false;
1705  }
1706  unsigned Idx = 0;
1707  if (ParseUInt32(Idx)) return true;
1708  Indices.push_back(Idx);
1709  }
1710 
1711  return false;
1712 }
1713 
1714 //===----------------------------------------------------------------------===//
1715 // Type Parsing.
1716 //===----------------------------------------------------------------------===//
1717 
1718 /// ParseType - Parse a type.
1719 bool LLParser::ParseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
1720  SMLoc TypeLoc = Lex.getLoc();
1721  switch (Lex.getKind()) {
1722  default:
1723  return TokError(Msg);
1724  case lltok::Type:
1725  // Type ::= 'float' | 'void' (etc)
1726  Result = Lex.getTyVal();
1727  Lex.Lex();
1728  break;
1729  case lltok::lbrace:
1730  // Type ::= StructType
1731  if (ParseAnonStructType(Result, false))
1732  return true;
1733  break;
1734  case lltok::lsquare:
1735  // Type ::= '[' ... ']'
1736  Lex.Lex(); // eat the lsquare.
1737  if (ParseArrayVectorType(Result, false))
1738  return true;
1739  break;
1740  case lltok::less: // Either vector or packed struct.
1741  // Type ::= '<' ... '>'
1742  Lex.Lex();
1743  if (Lex.getKind() == lltok::lbrace) {
1744  if (ParseAnonStructType(Result, true) ||
1745  ParseToken(lltok::greater, "expected '>' at end of packed struct"))
1746  return true;
1747  } else if (ParseArrayVectorType(Result, true))
1748  return true;
1749  break;
1750  case lltok::LocalVar: {
1751  // Type ::= %foo
1752  std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.getStrVal()];
1753 
1754  // If the type hasn't been defined yet, create a forward definition and
1755  // remember where that forward def'n was seen (in case it never is defined).
1756  if (!Entry.first) {
1757  Entry.first = StructType::create(Context, Lex.getStrVal());
1758  Entry.second = Lex.getLoc();
1759  }
1760  Result = Entry.first;
1761  Lex.Lex();
1762  break;
1763  }
1764 
1765  case lltok::LocalVarID: {
1766  // Type ::= %4
1767  std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.getUIntVal()];
1768 
1769  // If the type hasn't been defined yet, create a forward definition and
1770  // remember where that forward def'n was seen (in case it never is defined).
1771  if (!Entry.first) {
1772  Entry.first = StructType::create(Context);
1773  Entry.second = Lex.getLoc();
1774  }
1775  Result = Entry.first;
1776  Lex.Lex();
1777  break;
1778  }
1779  }
1780 
1781  // Parse the type suffixes.
1782  while (1) {
1783  switch (Lex.getKind()) {
1784  // End of type.
1785  default:
1786  if (!AllowVoid && Result->isVoidTy())
1787  return Error(TypeLoc, "void type only allowed for function results");
1788  return false;
1789 
1790  // Type ::= Type '*'
1791  case lltok::star:
1792  if (Result->isLabelTy())
1793  return TokError("basic block pointers are invalid");
1794  if (Result->isVoidTy())
1795  return TokError("pointers to void are invalid - use i8* instead");
1796  if (!PointerType::isValidElementType(Result))
1797  return TokError("pointer to this type is invalid");
1798  Result = PointerType::getUnqual(Result);
1799  Lex.Lex();
1800  break;
1801 
1802  // Type ::= Type 'addrspace' '(' uint32 ')' '*'
1803  case lltok::kw_addrspace: {
1804  if (Result->isLabelTy())
1805  return TokError("basic block pointers are invalid");
1806  if (Result->isVoidTy())
1807  return TokError("pointers to void are invalid; use i8* instead");
1808  if (!PointerType::isValidElementType(Result))
1809  return TokError("pointer to this type is invalid");
1810  unsigned AddrSpace;
1811  if (ParseOptionalAddrSpace(AddrSpace) ||
1812  ParseToken(lltok::star, "expected '*' in address space"))
1813  return true;
1814 
1815  Result = PointerType::get(Result, AddrSpace);
1816  break;
1817  }
1818 
1819  /// Types '(' ArgTypeListI ')' OptFuncAttrs
1820  case lltok::lparen:
1821  if (ParseFunctionType(Result))
1822  return true;
1823  break;
1824  }
1825  }
1826 }
1827 
1828 /// ParseParameterList
1829 /// ::= '(' ')'
1830 /// ::= '(' Arg (',' Arg)* ')'
1831 /// Arg
1832 /// ::= Type OptionalAttributes Value OptionalAttributes
1833 bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
1834  PerFunctionState &PFS, bool IsMustTailCall,
1835  bool InVarArgsFunc) {
1836  if (ParseToken(lltok::lparen, "expected '(' in call"))
1837  return true;
1838 
1839  unsigned AttrIndex = 1;
1840  while (Lex.getKind() != lltok::rparen) {
1841  // If this isn't the first argument, we need a comma.
1842  if (!ArgList.empty() &&
1843  ParseToken(lltok::comma, "expected ',' in argument list"))
1844  return true;
1845 
1846  // Parse an ellipsis if this is a musttail call in a variadic function.
1847  if (Lex.getKind() == lltok::dotdotdot) {
1848  const char *Msg = "unexpected ellipsis in argument list for ";
1849  if (!IsMustTailCall)
1850  return TokError(Twine(Msg) + "non-musttail call");
1851  if (!InVarArgsFunc)
1852  return TokError(Twine(Msg) + "musttail call in non-varargs function");
1853  Lex.Lex(); // Lex the '...', it is purely for readability.
1854  return ParseToken(lltok::rparen, "expected ')' at end of argument list");
1855  }
1856 
1857  // Parse the argument.
1858  LocTy ArgLoc;
1859  Type *ArgTy = nullptr;
1860  AttrBuilder ArgAttrs;
1861  Value *V;
1862  if (ParseType(ArgTy, ArgLoc))
1863  return true;
1864 
1865  if (ArgTy->isMetadataTy()) {
1866  if (ParseMetadataAsValue(V, PFS))
1867  return true;
1868  } else {
1869  // Otherwise, handle normal operands.
1870  if (ParseOptionalParamAttrs(ArgAttrs) || ParseValue(ArgTy, V, PFS))
1871  return true;
1872  }
1873  ArgList.push_back(ParamInfo(ArgLoc, V, AttributeSet::get(V->getContext(),
1874  AttrIndex++,
1875  ArgAttrs)));
1876  }
1877 
1878  if (IsMustTailCall && InVarArgsFunc)
1879  return TokError("expected '...' at end of argument list for musttail call "
1880  "in varargs function");
1881 
1882  Lex.Lex(); // Lex the ')'.
1883  return false;
1884 }
1885 
1886 
1887 
1888 /// ParseArgumentList - Parse the argument list for a function type or function
1889 /// prototype.
1890 /// ::= '(' ArgTypeListI ')'
1891 /// ArgTypeListI
1892 /// ::= /*empty*/
1893 /// ::= '...'
1894 /// ::= ArgTypeList ',' '...'
1895 /// ::= ArgType (',' ArgType)*
1896 ///
1897 bool LLParser::ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
1898  bool &isVarArg){
1899  isVarArg = false;
1900  assert(Lex.getKind() == lltok::lparen);
1901  Lex.Lex(); // eat the (.
1902 
1903  if (Lex.getKind() == lltok::rparen) {
1904  // empty
1905  } else if (Lex.getKind() == lltok::dotdotdot) {
1906  isVarArg = true;
1907  Lex.Lex();
1908  } else {
1909  LocTy TypeLoc = Lex.getLoc();
1910  Type *ArgTy = nullptr;
1911  AttrBuilder Attrs;
1912  std::string Name;
1913 
1914  if (ParseType(ArgTy) ||
1915  ParseOptionalParamAttrs(Attrs)) return true;
1916 
1917  if (ArgTy->isVoidTy())
1918  return Error(TypeLoc, "argument can not have void type");
1919 
1920  if (Lex.getKind() == lltok::LocalVar) {
1921  Name = Lex.getStrVal();
1922  Lex.Lex();
1923  }
1924 
1926  return Error(TypeLoc, "invalid type for function argument");
1927 
1928  unsigned AttrIndex = 1;
1929  ArgList.emplace_back(TypeLoc, ArgTy, AttributeSet::get(ArgTy->getContext(),
1930  AttrIndex++, Attrs),
1931  std::move(Name));
1932 
1933  while (EatIfPresent(lltok::comma)) {
1934  // Handle ... at end of arg list.
1935  if (EatIfPresent(lltok::dotdotdot)) {
1936  isVarArg = true;
1937  break;
1938  }
1939 
1940  // Otherwise must be an argument type.
1941  TypeLoc = Lex.getLoc();
1942  if (ParseType(ArgTy) || ParseOptionalParamAttrs(Attrs)) return true;
1943 
1944  if (ArgTy->isVoidTy())
1945  return Error(TypeLoc, "argument can not have void type");
1946 
1947  if (Lex.getKind() == lltok::LocalVar) {
1948  Name = Lex.getStrVal();
1949  Lex.Lex();
1950  } else {
1951  Name = "";
1952  }
1953 
1954  if (!ArgTy->isFirstClassType())
1955  return Error(TypeLoc, "invalid type for function argument");
1956 
1957  ArgList.emplace_back(
1958  TypeLoc, ArgTy,
1959  AttributeSet::get(ArgTy->getContext(), AttrIndex++, Attrs),
1960  std::move(Name));
1961  }
1962  }
1963 
1964  return ParseToken(lltok::rparen, "expected ')' at end of argument list");
1965 }
1966 
1967 /// ParseFunctionType
1968 /// ::= Type ArgumentList OptionalAttrs
1969 bool LLParser::ParseFunctionType(Type *&Result) {
1970  assert(Lex.getKind() == lltok::lparen);
1971 
1972  if (!FunctionType::isValidReturnType(Result))
1973  return TokError("invalid function return type");
1974 
1975  SmallVector<ArgInfo, 8> ArgList;
1976  bool isVarArg;
1977  if (ParseArgumentList(ArgList, isVarArg))
1978  return true;
1979 
1980  // Reject names on the arguments lists.
1981  for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
1982  if (!ArgList[i].Name.empty())
1983  return Error(ArgList[i].Loc, "argument name invalid in function type");
1984  if (ArgList[i].Attrs.hasAttributes(i + 1))
1985  return Error(ArgList[i].Loc,
1986  "argument attributes invalid in function type");
1987  }
1988 
1989  SmallVector<Type*, 16> ArgListTy;
1990  for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
1991  ArgListTy.push_back(ArgList[i].Ty);
1992 
1993  Result = FunctionType::get(Result, ArgListTy, isVarArg);
1994  return false;
1995 }
1996 
1997 /// ParseAnonStructType - Parse an anonymous struct type, which is inlined into
1998 /// other structs.
1999 bool LLParser::ParseAnonStructType(Type *&Result, bool Packed) {
2000  SmallVector<Type*, 8> Elts;
2001  if (ParseStructBody(Elts)) return true;
2002 
2003  Result = StructType::get(Context, Elts, Packed);
2004  return false;
2005 }
2006 
2007 /// ParseStructDefinition - Parse a struct in a 'type' definition.
2008 bool LLParser::ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
2009  std::pair<Type*, LocTy> &Entry,
2010  Type *&ResultTy) {
2011  // If the type was already defined, diagnose the redefinition.
2012  if (Entry.first && !Entry.second.isValid())
2013  return Error(TypeLoc, "redefinition of type");
2014 
2015  // If we have opaque, just return without filling in the definition for the
2016  // struct. This counts as a definition as far as the .ll file goes.
2017  if (EatIfPresent(lltok::kw_opaque)) {
2018  // This type is being defined, so clear the location to indicate this.
2019  Entry.second = SMLoc();
2020 
2021  // If this type number has never been uttered, create it.
2022  if (!Entry.first)
2023  Entry.first = StructType::create(Context, Name);
2024  ResultTy = Entry.first;
2025  return false;
2026  }
2027 
2028  // If the type starts with '<', then it is either a packed struct or a vector.
2029  bool isPacked = EatIfPresent(lltok::less);
2030 
2031  // If we don't have a struct, then we have a random type alias, which we
2032  // accept for compatibility with old files. These types are not allowed to be
2033  // forward referenced and not allowed to be recursive.
2034  if (Lex.getKind() != lltok::lbrace) {
2035  if (Entry.first)
2036  return Error(TypeLoc, "forward references to non-struct type");
2037 
2038  ResultTy = nullptr;
2039  if (isPacked)
2040  return ParseArrayVectorType(ResultTy, true);
2041  return ParseType(ResultTy);
2042  }
2043 
2044  // This type is being defined, so clear the location to indicate this.
2045  Entry.second = SMLoc();
2046 
2047  // If this type number has never been uttered, create it.
2048  if (!Entry.first)
2049  Entry.first = StructType::create(Context, Name);
2050 
2051  StructType *STy = cast<StructType>(Entry.first);
2052 
2053  SmallVector<Type*, 8> Body;
2054  if (ParseStructBody(Body) ||
2055  (isPacked && ParseToken(lltok::greater, "expected '>' in packed struct")))
2056  return true;
2057 
2058  STy->setBody(Body, isPacked);
2059  ResultTy = STy;
2060  return false;
2061 }
2062 
2063 
2064 /// ParseStructType: Handles packed and unpacked types. </> parsed elsewhere.
2065 /// StructType
2066 /// ::= '{' '}'
2067 /// ::= '{' Type (',' Type)* '}'
2068 /// ::= '<' '{' '}' '>'
2069 /// ::= '<' '{' Type (',' Type)* '}' '>'
2070 bool LLParser::ParseStructBody(SmallVectorImpl<Type*> &Body) {
2071  assert(Lex.getKind() == lltok::lbrace);
2072  Lex.Lex(); // Consume the '{'
2073 
2074  // Handle the empty struct.
2075  if (EatIfPresent(lltok::rbrace))
2076  return false;
2077 
2078  LocTy EltTyLoc = Lex.getLoc();
2079  Type *Ty = nullptr;
2080  if (ParseType(Ty)) return true;
2081  Body.push_back(Ty);
2082 
2084  return Error(EltTyLoc, "invalid element type for struct");
2085 
2086  while (EatIfPresent(lltok::comma)) {
2087  EltTyLoc = Lex.getLoc();
2088  if (ParseType(Ty)) return true;
2089 
2091  return Error(EltTyLoc, "invalid element type for struct");
2092 
2093  Body.push_back(Ty);
2094  }
2095 
2096  return ParseToken(lltok::rbrace, "expected '}' at end of struct");
2097 }
2098 
2099 /// ParseArrayVectorType - Parse an array or vector type, assuming the first
2100 /// token has already been consumed.
2101 /// Type
2102 /// ::= '[' APSINTVAL 'x' Types ']'
2103 /// ::= '<' APSINTVAL 'x' Types '>'
2104 bool LLParser::ParseArrayVectorType(Type *&Result, bool isVector) {
2105  if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
2106  Lex.getAPSIntVal().getBitWidth() > 64)
2107  return TokError("expected number in address space");
2108 
2109  LocTy SizeLoc = Lex.getLoc();
2110  uint64_t Size = Lex.getAPSIntVal().getZExtValue();
2111  Lex.Lex();
2112 
2113  if (ParseToken(lltok::kw_x, "expected 'x' after element count"))
2114  return true;
2115 
2116  LocTy TypeLoc = Lex.getLoc();
2117  Type *EltTy = nullptr;
2118  if (ParseType(EltTy)) return true;
2119 
2120  if (ParseToken(isVector ? lltok::greater : lltok::rsquare,
2121  "expected end of sequential type"))
2122  return true;
2123 
2124  if (isVector) {
2125  if (Size == 0)
2126  return Error(SizeLoc, "zero element vector is illegal");
2127  if ((unsigned)Size != Size)
2128  return Error(SizeLoc, "size too large for vector");
2129  if (!VectorType::isValidElementType(EltTy))
2130  return Error(TypeLoc, "invalid vector element type");
2131  Result = VectorType::get(EltTy, unsigned(Size));
2132  } else {
2133  if (!ArrayType::isValidElementType(EltTy))
2134  return Error(TypeLoc, "invalid array element type");
2135  Result = ArrayType::get(EltTy, Size);
2136  }
2137  return false;
2138 }
2139 
2140 //===----------------------------------------------------------------------===//
2141 // Function Semantic Analysis.
2142 //===----------------------------------------------------------------------===//
2143 
2144 LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f,
2145  int functionNumber)
2146  : P(p), F(f), FunctionNumber(functionNumber) {
2147 
2148  // Insert unnamed arguments into the NumberedVals list.
2149  for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end();
2150  AI != E; ++AI)
2151  if (!AI->hasName())
2152  NumberedVals.push_back(AI);
2153 }
2154 
2155 LLParser::PerFunctionState::~PerFunctionState() {
2156  // If there were any forward referenced non-basicblock values, delete them.
2157  for (std::map<std::string, std::pair<Value*, LocTy> >::iterator
2158  I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
2159  if (!isa<BasicBlock>(I->second.first)) {
2160  I->second.first->replaceAllUsesWith(
2161  UndefValue::get(I->second.first->getType()));
2162  delete I->second.first;
2163  I->second.first = nullptr;
2164  }
2165 
2166  for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator
2167  I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
2168  if (!isa<BasicBlock>(I->second.first)) {
2169  I->second.first->replaceAllUsesWith(
2170  UndefValue::get(I->second.first->getType()));
2171  delete I->second.first;
2172  I->second.first = nullptr;
2173  }
2174 }
2175 
2176 bool LLParser::PerFunctionState::FinishFunction() {
2177  if (!ForwardRefVals.empty())
2178  return P.Error(ForwardRefVals.begin()->second.second,
2179  "use of undefined value '%" + ForwardRefVals.begin()->first +
2180  "'");
2181  if (!ForwardRefValIDs.empty())
2182  return P.Error(ForwardRefValIDs.begin()->second.second,
2183  "use of undefined value '%" +
2184  Twine(ForwardRefValIDs.begin()->first) + "'");
2185  return false;
2186 }
2187 
2188 
2189 /// GetVal - Get a value with the specified name or ID, creating a
2190 /// forward reference record if needed. This can return null if the value
2191 /// exists but does not have the right type.
2192 Value *LLParser::PerFunctionState::GetVal(const std::string &Name,
2193  Type *Ty, LocTy Loc) {
2194  // Look this name up in the normal function symbol table.
2195  Value *Val = F.getValueSymbolTable().lookup(Name);
2196 
2197  // If this is a forward reference for the value, see if we already created a
2198  // forward ref record.
2199  if (!Val) {
2200  std::map<std::string, std::pair<Value*, LocTy> >::iterator
2201  I = ForwardRefVals.find(Name);
2202  if (I != ForwardRefVals.end())
2203  Val = I->second.first;
2204  }
2205 
2206  // If we have the value in the symbol table or fwd-ref table, return it.
2207  if (Val) {
2208  if (Val->getType() == Ty) return Val;
2209  if (Ty->isLabelTy())
2210  P.Error(Loc, "'%" + Name + "' is not a basic block");
2211  else
2212  P.Error(Loc, "'%" + Name + "' defined with type '" +
2213  getTypeString(Val->getType()) + "'");
2214  return nullptr;
2215  }
2216 
2217  // Don't make placeholders with invalid type.
2218  if (!Ty->isFirstClassType()) {
2219  P.Error(Loc, "invalid use of a non-first-class type");
2220  return nullptr;
2221  }
2222 
2223  // Otherwise, create a new forward reference for this value and remember it.
2224  Value *FwdVal;
2225  if (Ty->isLabelTy())
2226  FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
2227  else
2228  FwdVal = new Argument(Ty, Name);
2229 
2230  ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
2231  return FwdVal;
2232 }
2233 
2234 Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty,
2235  LocTy Loc) {
2236  // Look this name up in the normal function symbol table.
2237  Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
2238 
2239  // If this is a forward reference for the value, see if we already created a
2240  // forward ref record.
2241  if (!Val) {
2242  std::map<unsigned, std::pair<Value*, LocTy> >::iterator
2243  I = ForwardRefValIDs.find(ID);
2244  if (I != ForwardRefValIDs.end())
2245  Val = I->second.first;
2246  }
2247 
2248  // If we have the value in the symbol table or fwd-ref table, return it.
2249  if (Val) {
2250  if (Val->getType() == Ty) return Val;
2251  if (Ty->isLabelTy())
2252  P.Error(Loc, "'%" + Twine(ID) + "' is not a basic block");
2253  else
2254  P.Error(Loc, "'%" + Twine(ID) + "' defined with type '" +
2255  getTypeString(Val->getType()) + "'");
2256  return nullptr;
2257  }
2258 
2259  if (!Ty->isFirstClassType()) {
2260  P.Error(Loc, "invalid use of a non-first-class type");
2261  return nullptr;
2262  }
2263 
2264  // Otherwise, create a new forward reference for this value and remember it.
2265  Value *FwdVal;
2266  if (Ty->isLabelTy())
2267  FwdVal = BasicBlock::Create(F.getContext(), "", &F);
2268  else
2269  FwdVal = new Argument(Ty);
2270 
2271  ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
2272  return FwdVal;
2273 }
2274 
2275 /// SetInstName - After an instruction is parsed and inserted into its
2276 /// basic block, this installs its name.
2277 bool LLParser::PerFunctionState::SetInstName(int NameID,
2278  const std::string &NameStr,
2279  LocTy NameLoc, Instruction *Inst) {
2280  // If this instruction has void type, it cannot have a name or ID specified.
2281  if (Inst->getType()->isVoidTy()) {
2282  if (NameID != -1 || !NameStr.empty())
2283  return P.Error(NameLoc, "instructions returning void cannot have a name");
2284  return false;
2285  }
2286 
2287  // If this was a numbered instruction, verify that the instruction is the
2288  // expected value and resolve any forward references.
2289  if (NameStr.empty()) {
2290  // If neither a name nor an ID was specified, just use the next ID.
2291  if (NameID == -1)
2292  NameID = NumberedVals.size();
2293 
2294  if (unsigned(NameID) != NumberedVals.size())
2295  return P.Error(NameLoc, "instruction expected to be numbered '%" +
2296  Twine(NumberedVals.size()) + "'");
2297 
2298  std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI =
2299  ForwardRefValIDs.find(NameID);
2300  if (FI != ForwardRefValIDs.end()) {
2301  if (FI->second.first->getType() != Inst->getType())
2302  return P.Error(NameLoc, "instruction forward referenced with type '" +
2303  getTypeString(FI->second.first->getType()) + "'");
2304  FI->second.first->replaceAllUsesWith(Inst);
2305  delete FI->second.first;
2306  ForwardRefValIDs.erase(FI);
2307  }
2308 
2309  NumberedVals.push_back(Inst);
2310  return false;
2311  }
2312 
2313  // Otherwise, the instruction had a name. Resolve forward refs and set it.
2314  std::map<std::string, std::pair<Value*, LocTy> >::iterator
2315  FI = ForwardRefVals.find(NameStr);
2316  if (FI != ForwardRefVals.end()) {
2317  if (FI->second.first->getType() != Inst->getType())
2318  return P.Error(NameLoc, "instruction forward referenced with type '" +
2319  getTypeString(FI->second.first->getType()) + "'");
2320  FI->second.first->replaceAllUsesWith(Inst);
2321  delete FI->second.first;
2322  ForwardRefVals.erase(FI);
2323  }
2324 
2325  // Set the name on the instruction.
2326  Inst->setName(NameStr);
2327 
2328  if (Inst->getName() != NameStr)
2329  return P.Error(NameLoc, "multiple definition of local value named '" +
2330  NameStr + "'");
2331  return false;
2332 }
2333 
2334 /// GetBB - Get a basic block with the specified name or ID, creating a
2335 /// forward reference record if needed.
2336 BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name,
2337  LocTy Loc) {
2338  return dyn_cast_or_null<BasicBlock>(GetVal(Name,
2339  Type::getLabelTy(F.getContext()), Loc));
2340 }
2341 
2342 BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) {
2343  return dyn_cast_or_null<BasicBlock>(GetVal(ID,
2344  Type::getLabelTy(F.getContext()), Loc));
2345 }
2346 
2347 /// DefineBB - Define the specified basic block, which is either named or
2348 /// unnamed. If there is an error, this returns null otherwise it returns
2349 /// the block being defined.
2350 BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name,
2351  LocTy Loc) {
2352  BasicBlock *BB;
2353  if (Name.empty())
2354  BB = GetBB(NumberedVals.size(), Loc);
2355  else
2356  BB = GetBB(Name, Loc);
2357  if (!BB) return nullptr; // Already diagnosed error.
2358 
2359  // Move the block to the end of the function. Forward ref'd blocks are
2360  // inserted wherever they happen to be referenced.
2361  F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
2362 
2363  // Remove the block from forward ref sets.
2364  if (Name.empty()) {
2365  ForwardRefValIDs.erase(NumberedVals.size());
2366  NumberedVals.push_back(BB);
2367  } else {
2368  // BB forward references are already in the function symbol table.
2369  ForwardRefVals.erase(Name);
2370  }
2371 
2372  return BB;
2373 }
2374 
2375 //===----------------------------------------------------------------------===//
2376 // Constants.
2377 //===----------------------------------------------------------------------===//
2378 
2379 /// ParseValID - Parse an abstract value that doesn't necessarily have a
2380 /// type implied. For example, if we parse "4" we don't know what integer type
2381 /// it has. The value will later be combined with its type and checked for
2382 /// sanity. PFS is used to convert function-local operands of metadata (since
2383 /// metadata operands are not just parsed here but also converted to values).
2384 /// PFS can be null when we are not parsing metadata values inside a function.
2385 bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) {
2386  ID.Loc = Lex.getLoc();
2387  switch (Lex.getKind()) {
2388  default: return TokError("expected value token");
2389  case lltok::GlobalID: // @42
2390  ID.UIntVal = Lex.getUIntVal();
2391  ID.Kind = ValID::t_GlobalID;
2392  break;
2393  case lltok::GlobalVar: // @foo
2394  ID.StrVal = Lex.getStrVal();
2396  break;
2397  case lltok::LocalVarID: // %42
2398  ID.UIntVal = Lex.getUIntVal();
2399  ID.Kind = ValID::t_LocalID;
2400  break;
2401  case lltok::LocalVar: // %foo
2402  ID.StrVal = Lex.getStrVal();
2403  ID.Kind = ValID::t_LocalName;
2404  break;
2405  case lltok::APSInt:
2406  ID.APSIntVal = Lex.getAPSIntVal();
2407  ID.Kind = ValID::t_APSInt;
2408  break;
2409  case lltok::APFloat:
2410  ID.APFloatVal = Lex.getAPFloatVal();
2411  ID.Kind = ValID::t_APFloat;
2412  break;
2413  case lltok::kw_true:
2414  ID.ConstantVal = ConstantInt::getTrue(Context);
2415  ID.Kind = ValID::t_Constant;
2416  break;
2417  case lltok::kw_false:
2418  ID.ConstantVal = ConstantInt::getFalse(Context);
2419  ID.Kind = ValID::t_Constant;
2420  break;
2421  case lltok::kw_null: ID.Kind = ValID::t_Null; break;
2422  case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
2423  case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
2424 
2425  case lltok::lbrace: {
2426  // ValID ::= '{' ConstVector '}'
2427  Lex.Lex();
2429  if (ParseGlobalValueVector(Elts) ||
2430  ParseToken(lltok::rbrace, "expected end of struct constant"))
2431  return true;
2432 
2433  ID.ConstantStructElts = new Constant*[Elts.size()];
2434  ID.UIntVal = Elts.size();
2435  memcpy(ID.ConstantStructElts, Elts.data(), Elts.size()*sizeof(Elts[0]));
2437  return false;
2438  }
2439  case lltok::less: {
2440  // ValID ::= '<' ConstVector '>' --> Vector.
2441  // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct.
2442  Lex.Lex();
2443  bool isPackedStruct = EatIfPresent(lltok::lbrace);
2444 
2446  LocTy FirstEltLoc = Lex.getLoc();
2447  if (ParseGlobalValueVector(Elts) ||
2448  (isPackedStruct &&
2449  ParseToken(lltok::rbrace, "expected end of packed struct")) ||
2450  ParseToken(lltok::greater, "expected end of constant"))
2451  return true;
2452 
2453  if (isPackedStruct) {
2454  ID.ConstantStructElts = new Constant*[Elts.size()];
2455  memcpy(ID.ConstantStructElts, Elts.data(), Elts.size()*sizeof(Elts[0]));
2456  ID.UIntVal = Elts.size();
2458  return false;
2459  }
2460 
2461  if (Elts.empty())
2462  return Error(ID.Loc, "constant vector must not be empty");
2463 
2464  if (!Elts[0]->getType()->isIntegerTy() &&
2465  !Elts[0]->getType()->isFloatingPointTy() &&
2466  !Elts[0]->getType()->isPointerTy())
2467  return Error(FirstEltLoc,
2468  "vector elements must have integer, pointer or floating point type");
2469 
2470  // Verify that all the vector elements have the same type.
2471  for (unsigned i = 1, e = Elts.size(); i != e; ++i)
2472  if (Elts[i]->getType() != Elts[0]->getType())
2473  return Error(FirstEltLoc,
2474  "vector element #" + Twine(i) +
2475  " is not of type '" + getTypeString(Elts[0]->getType()));
2476 
2477  ID.ConstantVal = ConstantVector::get(Elts);
2478  ID.Kind = ValID::t_Constant;
2479  return false;
2480  }
2481  case lltok::lsquare: { // Array Constant
2482  Lex.Lex();
2484  LocTy FirstEltLoc = Lex.getLoc();
2485  if (ParseGlobalValueVector(Elts) ||
2486  ParseToken(lltok::rsquare, "expected end of array constant"))
2487  return true;
2488 
2489  // Handle empty element.
2490  if (Elts.empty()) {
2491  // Use undef instead of an array because it's inconvenient to determine
2492  // the element type at this point, there being no elements to examine.
2494  return false;
2495  }
2496 
2497  if (!Elts[0]->getType()->isFirstClassType())
2498  return Error(FirstEltLoc, "invalid array element type: " +
2499  getTypeString(Elts[0]->getType()));
2500 
2501  ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
2502 
2503  // Verify all elements are correct type!
2504  for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
2505  if (Elts[i]->getType() != Elts[0]->getType())
2506  return Error(FirstEltLoc,
2507  "array element #" + Twine(i) +
2508  " is not of type '" + getTypeString(Elts[0]->getType()));
2509  }
2510 
2511  ID.ConstantVal = ConstantArray::get(ATy, Elts);
2512  ID.Kind = ValID::t_Constant;
2513  return false;
2514  }
2515  case lltok::kw_c: // c "foo"
2516  Lex.Lex();
2518  false);
2519  if (ParseToken(lltok::StringConstant, "expected string")) return true;
2520  ID.Kind = ValID::t_Constant;
2521  return false;
2522 
2523  case lltok::kw_asm: {
2524  // ValID ::= 'asm' SideEffect? AlignStack? IntelDialect? STRINGCONSTANT ','
2525  // STRINGCONSTANT
2526  bool HasSideEffect, AlignStack, AsmDialect;
2527  Lex.Lex();
2528  if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
2529  ParseOptionalToken(lltok::kw_alignstack, AlignStack) ||
2530  ParseOptionalToken(lltok::kw_inteldialect, AsmDialect) ||
2531  ParseStringConstant(ID.StrVal) ||
2532  ParseToken(lltok::comma, "expected comma in inline asm expression") ||
2533  ParseToken(lltok::StringConstant, "expected constraint string"))
2534  return true;
2535  ID.StrVal2 = Lex.getStrVal();
2536  ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1) |
2537  (unsigned(AsmDialect)<<2);
2538  ID.Kind = ValID::t_InlineAsm;
2539  return false;
2540  }
2541 
2542  case lltok::kw_blockaddress: {
2543  // ValID ::= 'blockaddress' '(' @foo ',' %bar ')'
2544  Lex.Lex();
2545 
2546  ValID Fn, Label;
2547 
2548  if (ParseToken(lltok::lparen, "expected '(' in block address expression") ||
2549  ParseValID(Fn) ||
2550  ParseToken(lltok::comma, "expected comma in block address expression")||
2551  ParseValID(Label) ||
2552  ParseToken(lltok::rparen, "expected ')' in block address expression"))
2553  return true;
2554 
2555  if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
2556  return Error(Fn.Loc, "expected function name in blockaddress");
2557  if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
2558  return Error(Label.Loc, "expected basic block name in blockaddress");
2559 
2560  // Try to find the function (but skip it if it's forward-referenced).
2561  GlobalValue *GV = nullptr;
2562  if (Fn.Kind == ValID::t_GlobalID) {
2563  if (Fn.UIntVal < NumberedVals.size())
2564  GV = NumberedVals[Fn.UIntVal];
2565  } else if (!ForwardRefVals.count(Fn.StrVal)) {
2566  GV = M->getNamedValue(Fn.StrVal);
2567  }
2568  Function *F = nullptr;
2569  if (GV) {
2570  // Confirm that it's actually a function with a definition.
2571  if (!isa<Function>(GV))
2572  return Error(Fn.Loc, "expected function name in blockaddress");
2573  F = cast<Function>(GV);
2574  if (F->isDeclaration())
2575  return Error(Fn.Loc, "cannot take blockaddress inside a declaration");
2576  }
2577 
2578  if (!F) {
2579  // Make a global variable as a placeholder for this reference.
2580  GlobalValue *&FwdRef =
2581  ForwardRefBlockAddresses.insert(std::make_pair(
2582  std::move(Fn),
2583  std::map<ValID, GlobalValue *>()))
2584  .first->second.insert(std::make_pair(std::move(Label), nullptr))
2585  .first->second;
2586  if (!FwdRef)
2587  FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), false,
2588  GlobalValue::InternalLinkage, nullptr, "");
2589  ID.ConstantVal = FwdRef;
2590  ID.Kind = ValID::t_Constant;
2591  return false;
2592  }
2593 
2594  // We found the function; now find the basic block. Don't use PFS, since we
2595  // might be inside a constant expression.
2596  BasicBlock *BB;
2597  if (BlockAddressPFS && F == &BlockAddressPFS->getFunction()) {
2598  if (Label.Kind == ValID::t_LocalID)
2599  BB = BlockAddressPFS->GetBB(Label.UIntVal, Label.Loc);
2600  else
2601  BB = BlockAddressPFS->GetBB(Label.StrVal, Label.Loc);
2602  if (!BB)
2603  return Error(Label.Loc, "referenced value is not a basic block");
2604  } else {
2605  if (Label.Kind == ValID::t_LocalID)
2606  return Error(Label.Loc, "cannot take address of numeric label after "
2607  "the function is defined");
2608  BB = dyn_cast_or_null<BasicBlock>(
2609  F->getValueSymbolTable().lookup(Label.StrVal));
2610  if (!BB)
2611  return Error(Label.Loc, "referenced value is not a basic block");
2612  }
2613 
2614  ID.ConstantVal = BlockAddress::get(F, BB);
2615  ID.Kind = ValID::t_Constant;
2616  return false;
2617  }
2618 
2619  case lltok::kw_trunc:
2620  case lltok::kw_zext:
2621  case lltok::kw_sext:
2622  case lltok::kw_fptrunc:
2623  case lltok::kw_fpext:
2624  case lltok::kw_bitcast:
2626  case lltok::kw_uitofp:
2627  case lltok::kw_sitofp:
2628  case lltok::kw_fptoui:
2629  case lltok::kw_fptosi:
2630  case lltok::kw_inttoptr:
2631  case lltok::kw_ptrtoint: {
2632  unsigned Opc = Lex.getUIntVal();
2633  Type *DestTy = nullptr;
2634  Constant *SrcVal;
2635  Lex.Lex();
2636  if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
2637  ParseGlobalTypeAndValue(SrcVal) ||
2638  ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
2639  ParseType(DestTy) ||
2640  ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
2641  return true;
2642  if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
2643  return Error(ID.Loc, "invalid cast opcode for cast from '" +
2644  getTypeString(SrcVal->getType()) + "' to '" +
2645  getTypeString(DestTy) + "'");
2647  SrcVal, DestTy);
2648  ID.Kind = ValID::t_Constant;
2649  return false;
2650  }
2651  case lltok::kw_extractvalue: {
2652  Lex.Lex();
2653  Constant *Val;
2654  SmallVector<unsigned, 4> Indices;
2655  if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")||
2656  ParseGlobalTypeAndValue(Val) ||
2657  ParseIndexList(Indices) ||
2658  ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
2659  return true;
2660 
2661  if (!Val->getType()->isAggregateType())
2662  return Error(ID.Loc, "extractvalue operand must be aggregate type");
2663  if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
2664  return Error(ID.Loc, "invalid indices for extractvalue");
2665  ID.ConstantVal = ConstantExpr::getExtractValue(Val, Indices);
2666  ID.Kind = ValID::t_Constant;
2667  return false;
2668  }
2669  case lltok::kw_insertvalue: {
2670  Lex.Lex();
2671  Constant *Val0, *Val1;
2672  SmallVector<unsigned, 4> Indices;
2673  if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")||
2674  ParseGlobalTypeAndValue(Val0) ||
2675  ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")||
2676  ParseGlobalTypeAndValue(Val1) ||
2677  ParseIndexList(Indices) ||
2678  ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
2679  return true;
2680  if (!Val0->getType()->isAggregateType())
2681  return Error(ID.Loc, "insertvalue operand must be aggregate type");
2682  Type *IndexedType =
2683  ExtractValueInst::getIndexedType(Val0->getType(), Indices);
2684  if (!IndexedType)
2685  return Error(ID.Loc, "invalid indices for insertvalue");
2686  if (IndexedType != Val1->getType())
2687  return Error(ID.Loc, "insertvalue operand and field disagree in type: '" +
2688  getTypeString(Val1->getType()) +
2689  "' instead of '" + getTypeString(IndexedType) +
2690  "'");
2691  ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, Indices);
2692  ID.Kind = ValID::t_Constant;
2693  return false;
2694  }
2695  case lltok::kw_icmp:
2696  case lltok::kw_fcmp: {
2697  unsigned PredVal, Opc = Lex.getUIntVal();
2698  Constant *Val0, *Val1;
2699  Lex.Lex();
2700  if (ParseCmpPredicate(PredVal, Opc) ||
2701  ParseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
2702  ParseGlobalTypeAndValue(Val0) ||
2703  ParseToken(lltok::comma, "expected comma in compare constantexpr") ||
2704  ParseGlobalTypeAndValue(Val1) ||
2705  ParseToken(lltok::rparen, "expected ')' in compare constantexpr"))
2706  return true;
2707 
2708  if (Val0->getType() != Val1->getType())
2709  return Error(ID.Loc, "compare operands must have the same type");
2710 
2711  CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
2712 
2713  if (Opc == Instruction::FCmp) {
2714  if (!Val0->getType()->isFPOrFPVectorTy())
2715  return Error(ID.Loc, "fcmp requires floating point operands");
2716  ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
2717  } else {
2718  assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
2719  if (!Val0->getType()->isIntOrIntVectorTy() &&
2720  !Val0->getType()->getScalarType()->isPointerTy())
2721  return Error(ID.Loc, "icmp requires pointer or integer operands");
2722  ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
2723  }
2724  ID.Kind = ValID::t_Constant;
2725  return false;
2726  }
2727 
2728  // Binary Operators.
2729  case lltok::kw_add:
2730  case lltok::kw_fadd:
2731  case lltok::kw_sub:
2732  case lltok::kw_fsub:
2733  case lltok::kw_mul:
2734  case lltok::kw_fmul:
2735  case lltok::kw_udiv:
2736  case lltok::kw_sdiv:
2737  case lltok::kw_fdiv:
2738  case lltok::kw_urem:
2739  case lltok::kw_srem:
2740  case lltok::kw_frem:
2741  case lltok::kw_shl:
2742  case lltok::kw_lshr:
2743  case lltok::kw_ashr: {
2744  bool NUW = false;
2745  bool NSW = false;
2746  bool Exact = false;
2747  unsigned Opc = Lex.getUIntVal();
2748  Constant *Val0, *Val1;
2749  Lex.Lex();
2750  LocTy ModifierLoc = Lex.getLoc();
2751  if (Opc == Instruction::Add || Opc == Instruction::Sub ||
2752  Opc == Instruction::Mul || Opc == Instruction::Shl) {
2753  if (EatIfPresent(lltok::kw_nuw))
2754  NUW = true;
2755  if (EatIfPresent(lltok::kw_nsw)) {
2756  NSW = true;
2757  if (EatIfPresent(lltok::kw_nuw))
2758  NUW = true;
2759  }
2760  } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
2761  Opc == Instruction::LShr || Opc == Instruction::AShr) {
2762  if (EatIfPresent(lltok::kw_exact))
2763  Exact = true;
2764  }
2765  if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
2766  ParseGlobalTypeAndValue(Val0) ||
2767  ParseToken(lltok::comma, "expected comma in binary constantexpr") ||
2768  ParseGlobalTypeAndValue(Val1) ||
2769  ParseToken(lltok::rparen, "expected ')' in binary constantexpr"))
2770  return true;
2771  if (Val0->getType() != Val1->getType())
2772  return Error(ID.Loc, "operands of constexpr must have same type");
2773  if (!Val0->getType()->isIntOrIntVectorTy()) {
2774  if (NUW)
2775  return Error(ModifierLoc, "nuw only applies to integer operations");
2776  if (NSW)
2777  return Error(ModifierLoc, "nsw only applies to integer operations");
2778  }
2779  // Check that the type is valid for the operator.
2780  switch (Opc) {
2781  case Instruction::Add:
2782  case Instruction::Sub:
2783  case Instruction::Mul:
2784  case Instruction::UDiv:
2785  case Instruction::SDiv:
2786  case Instruction::URem:
2787  case Instruction::SRem:
2788  case Instruction::Shl:
2789  case Instruction::AShr:
2790  case Instruction::LShr:
2791  if (!Val0->getType()->isIntOrIntVectorTy())
2792  return Error(ID.Loc, "constexpr requires integer operands");
2793  break;
2794  case Instruction::FAdd:
2795  case Instruction::FSub:
2796  case Instruction::FMul:
2797  case Instruction::FDiv:
2798  case Instruction::FRem:
2799  if (!Val0->getType()->isFPOrFPVectorTy())
2800  return Error(ID.Loc, "constexpr requires fp operands");
2801  break;
2802  default: llvm_unreachable("Unknown binary operator!");
2803  }
2804  unsigned Flags = 0;
2806  if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap;
2807  if (Exact) Flags |= PossiblyExactOperator::IsExact;
2808  Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
2809  ID.ConstantVal = C;
2810  ID.Kind = ValID::t_Constant;
2811  return false;
2812  }
2813 
2814  // Logical Operations
2815  case lltok::kw_and:
2816  case lltok::kw_or:
2817  case lltok::kw_xor: {
2818  unsigned Opc = Lex.getUIntVal();
2819  Constant *Val0, *Val1;
2820  Lex.Lex();
2821  if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
2822  ParseGlobalTypeAndValue(Val0) ||
2823  ParseToken(lltok::comma, "expected comma in logical constantexpr") ||
2824  ParseGlobalTypeAndValue(Val1) ||
2825  ParseToken(lltok::rparen, "expected ')' in logical constantexpr"))
2826  return true;
2827  if (Val0->getType() != Val1->getType())
2828  return Error(ID.Loc, "operands of constexpr must have same type");
2829  if (!Val0->getType()->isIntOrIntVectorTy())
2830  return Error(ID.Loc,
2831  "constexpr requires integer or integer vector operands");
2832  ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
2833  ID.Kind = ValID::t_Constant;
2834  return false;
2835  }
2836 
2841  case lltok::kw_select: {
2842  unsigned Opc = Lex.getUIntVal();
2844  bool InBounds = false;
2845  Type *Ty;
2846  Lex.Lex();
2847 
2848  if (Opc == Instruction::GetElementPtr)
2849  InBounds = EatIfPresent(lltok::kw_inbounds);
2850 
2851  if (ParseToken(lltok::lparen, "expected '(' in constantexpr"))
2852  return true;
2853 
2854  LocTy ExplicitTypeLoc = Lex.getLoc();
2855  if (Opc == Instruction::GetElementPtr) {
2856  if (ParseType(Ty) ||
2857  ParseToken(lltok::comma, "expected comma after getelementptr's type"))
2858  return true;
2859  }
2860 
2861  if (ParseGlobalValueVector(Elts) ||
2862  ParseToken(lltok::rparen, "expected ')' in constantexpr"))
2863  return true;
2864 
2865  if (Opc == Instruction::GetElementPtr) {
2866  if (Elts.size() == 0 ||
2867  !Elts[0]->getType()->getScalarType()->isPointerTy())
2868  return Error(ID.Loc, "base of getelementptr must be a pointer");
2869 
2870  Type *BaseType = Elts[0]->getType();
2871  auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
2872  if (Ty != BasePointerType->getElementType())
2873  return Error(
2874  ExplicitTypeLoc,
2875  "explicit pointee type doesn't match operand's pointee type");
2876 
2877  ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
2878  for (Constant *Val : Indices) {
2879  Type *ValTy = Val->getType();
2880  if (!ValTy->getScalarType()->isIntegerTy())
2881  return Error(ID.Loc, "getelementptr index must be an integer");
2882  if (ValTy->isVectorTy() != BaseType->isVectorTy())
2883  return Error(ID.Loc, "getelementptr index type missmatch");
2884  if (ValTy->isVectorTy()) {
2885  unsigned ValNumEl = ValTy->getVectorNumElements();
2886  unsigned PtrNumEl = BaseType->getVectorNumElements();
2887  if (ValNumEl != PtrNumEl)
2888  return Error(
2889  ID.Loc,
2890  "getelementptr vector index has a wrong number of elements");
2891  }
2892  }
2893 
2895  if (!Indices.empty() && !Ty->isSized(&Visited))
2896  return Error(ID.Loc, "base element of getelementptr must be sized");
2897 
2898  if (!GetElementPtrInst::getIndexedType(Ty, Indices))
2899  return Error(ID.Loc, "invalid getelementptr indices");
2900  ID.ConstantVal =
2901  ConstantExpr::getGetElementPtr(Ty, Elts[0], Indices, InBounds);
2902  } else if (Opc == Instruction::Select) {
2903  if (Elts.size() != 3)
2904  return Error(ID.Loc, "expected three operands to select");
2905  if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
2906  Elts[2]))
2907  return Error(ID.Loc, Reason);
2908  ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
2909  } else if (Opc == Instruction::ShuffleVector) {
2910  if (Elts.size() != 3)
2911  return Error(ID.Loc, "expected three operands to shufflevector");
2912  if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2913  return Error(ID.Loc, "invalid operands to shufflevector");
2914  ID.ConstantVal =
2915  ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]);
2916  } else if (Opc == Instruction::ExtractElement) {
2917  if (Elts.size() != 2)
2918  return Error(ID.Loc, "expected two operands to extractelement");
2919  if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
2920  return Error(ID.Loc, "invalid extractelement operands");
2921  ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
2922  } else {
2923  assert(Opc == Instruction::InsertElement && "Unknown opcode");
2924  if (Elts.size() != 3)
2925  return Error(ID.Loc, "expected three operands to insertelement");
2926  if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2927  return Error(ID.Loc, "invalid insertelement operands");
2928  ID.ConstantVal =
2929  ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
2930  }
2931 
2932  ID.Kind = ValID::t_Constant;
2933  return false;
2934  }
2935  }
2936 
2937  Lex.Lex();
2938  return false;
2939 }
2940 
2941 /// ParseGlobalValue - Parse a global value with the specified type.
2942 bool LLParser::ParseGlobalValue(Type *Ty, Constant *&C) {
2943  C = nullptr;
2944  ValID ID;
2945  Value *V = nullptr;
2946  bool Parsed = ParseValID(ID) ||
2947  ConvertValIDToValue(Ty, ID, V, nullptr);
2948  if (V && !(C = dyn_cast<Constant>(V)))
2949  return Error(ID.Loc, "global values must be constants");
2950  return Parsed;
2951 }
2952 
2953 bool LLParser::ParseGlobalTypeAndValue(Constant *&V) {
2954  Type *Ty = nullptr;
2955  return ParseType(Ty) ||
2956  ParseGlobalValue(Ty, V);
2957 }
2958 
2959 bool LLParser::parseOptionalComdat(StringRef GlobalName, Comdat *&C) {
2960  C = nullptr;
2961 
2962  LocTy KwLoc = Lex.getLoc();
2963  if (!EatIfPresent(lltok::kw_comdat))
2964  return false;
2965 
2966  if (EatIfPresent(lltok::lparen)) {
2967  if (Lex.getKind() != lltok::ComdatVar)
2968  return TokError("expected comdat variable");
2969  C = getComdat(Lex.getStrVal(), Lex.getLoc());
2970  Lex.Lex();
2971  if (ParseToken(lltok::rparen, "expected ')' after comdat var"))
2972  return true;
2973  } else {
2974  if (GlobalName.empty())
2975  return TokError("comdat cannot be unnamed");
2976  C = getComdat(GlobalName, KwLoc);
2977  }
2978 
2979  return false;
2980 }
2981 
2982 /// ParseGlobalValueVector
2983 /// ::= /*empty*/
2984 /// ::= TypeAndValue (',' TypeAndValue)*
2985 bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant *> &Elts) {
2986  // Empty list.
2987  if (Lex.getKind() == lltok::rbrace ||
2988  Lex.getKind() == lltok::rsquare ||
2989  Lex.getKind() == lltok::greater ||
2990  Lex.getKind() == lltok::rparen)
2991  return false;
2992 
2993  Constant *C;
2994  if (ParseGlobalTypeAndValue(C)) return true;
2995  Elts.push_back(C);
2996 
2997  while (EatIfPresent(lltok::comma)) {
2998  if (ParseGlobalTypeAndValue(C)) return true;
2999  Elts.push_back(C);
3000  }
3001 
3002  return false;
3003 }
3004 
3005 bool LLParser::ParseMDTuple(MDNode *&MD, bool IsDistinct) {
3007  if (ParseMDNodeVector(Elts))
3008  return true;
3009 
3010  MD = (IsDistinct ? MDTuple::getDistinct : MDTuple::get)(Context, Elts);
3011  return false;
3012 }
3013 
3014 /// MDNode:
3015 /// ::= !{ ... }
3016 /// ::= !7
3017 /// ::= !DILocation(...)
3018 bool LLParser::ParseMDNode(MDNode *&N) {
3019  if (Lex.getKind() == lltok::MetadataVar)
3020  return ParseSpecializedMDNode(N);
3021 
3022  return ParseToken(lltok::exclaim, "expected '!' here") ||
3023  ParseMDNodeTail(N);
3024 }
3025 
3026 bool LLParser::ParseMDNodeTail(MDNode *&N) {
3027  // !{ ... }
3028  if (Lex.getKind() == lltok::lbrace)
3029  return ParseMDTuple(N);
3030 
3031  // !42
3032  return ParseMDNodeID(N);
3033 }
3034 
3035 namespace {
3036 
3037 /// Structure to represent an optional metadata field.
3038 template <class FieldTy> struct MDFieldImpl {
3039  typedef MDFieldImpl ImplTy;
3040  FieldTy Val;
3041  bool Seen;
3042 
3043  void assign(FieldTy Val) {
3044  Seen = true;
3045  this->Val = std::move(Val);
3046  }
3047 
3048  explicit MDFieldImpl(FieldTy Default)
3049  : Val(std::move(Default)), Seen(false) {}
3050 };
3051 
3052 struct MDUnsignedField : public MDFieldImpl<uint64_t> {
3053  uint64_t Max;
3054 
3055  MDUnsignedField(uint64_t Default = 0, uint64_t Max = UINT64_MAX)
3056  : ImplTy(Default), Max(Max) {}
3057 };
3058 struct LineField : public MDUnsignedField {
3059  LineField() : MDUnsignedField(0, UINT32_MAX) {}
3060 };
3061 struct ColumnField : public MDUnsignedField {
3062  ColumnField() : MDUnsignedField(0, UINT16_MAX) {}
3063 };
3064 struct DwarfTagField : public MDUnsignedField {
3065  DwarfTagField() : MDUnsignedField(0, dwarf::DW_TAG_hi_user) {}
3066  DwarfTagField(dwarf::Tag DefaultTag)
3067  : MDUnsignedField(DefaultTag, dwarf::DW_TAG_hi_user) {}
3068 };
3069 struct DwarfAttEncodingField : public MDUnsignedField {
3070  DwarfAttEncodingField() : MDUnsignedField(0, dwarf::DW_ATE_hi_user) {}
3071 };
3072 struct DwarfVirtualityField : public MDUnsignedField {
3073  DwarfVirtualityField() : MDUnsignedField(0, dwarf::DW_VIRTUALITY_max) {}
3074 };
3075 struct DwarfLangField : public MDUnsignedField {
3076  DwarfLangField() : MDUnsignedField(0, dwarf::DW_LANG_hi_user) {}
3077 };
3078 
3079 struct DIFlagField : public MDUnsignedField {
3080  DIFlagField() : MDUnsignedField(0, UINT32_MAX) {}
3081 };
3082 
3083 struct MDSignedField : public MDFieldImpl<int64_t> {
3084  int64_t Min;
3085  int64_t Max;
3086 
3087  MDSignedField(int64_t Default = 0)
3088  : ImplTy(Default), Min(INT64_MIN), Max(INT64_MAX) {}
3089  MDSignedField(int64_t Default, int64_t Min, int64_t Max)
3090  : ImplTy(Default), Min(Min), Max(Max) {}
3091 };
3092 
3093 struct MDBoolField : public MDFieldImpl<bool> {
3094  MDBoolField(bool Default = false) : ImplTy(Default) {}
3095 };
3096 struct MDField : public MDFieldImpl<Metadata *> {
3097  bool AllowNull;
3098 
3099  MDField(bool AllowNull = true) : ImplTy(nullptr), AllowNull(AllowNull) {}
3100 };
3101 struct MDConstant : public MDFieldImpl<ConstantAsMetadata *> {
3102  MDConstant() : ImplTy(nullptr) {}
3103 };
3104 struct MDStringField : public MDFieldImpl<MDString *> {
3105  bool AllowEmpty;
3106  MDStringField(bool AllowEmpty = true)
3107  : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
3108 };
3109 struct MDFieldList : public MDFieldImpl<SmallVector<Metadata *, 4>> {
3110  MDFieldList() : ImplTy(SmallVector<Metadata *, 4>()) {}
3111 };
3112 
3113 } // end namespace
3114 
3115 namespace llvm {
3116 
3117 template <>
3118 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3119  MDUnsignedField &Result) {
3120  if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
3121  return TokError("expected unsigned integer");
3122 
3123  auto &U = Lex.getAPSIntVal();
3124  if (U.ugt(Result.Max))
3125  return TokError("value for '" + Name + "' too large, limit is " +
3126  Twine(Result.Max));
3127  Result.assign(U.getZExtValue());
3128  assert(Result.Val <= Result.Max && "Expected value in range");
3129  Lex.Lex();
3130  return false;
3131 }
3132 
3133 template <>
3134 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, LineField &Result) {
3135  return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3136 }
3137 template <>
3138 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, ColumnField &Result) {
3139  return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3140 }
3141 
3142 template <>
3143 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfTagField &Result) {
3144  if (Lex.getKind() == lltok::APSInt)
3145  return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3146 
3147  if (Lex.getKind() != lltok::DwarfTag)
3148  return TokError("expected DWARF tag");
3149 
3150  unsigned Tag = dwarf::getTag(Lex.getStrVal());
3151  if (Tag == dwarf::DW_TAG_invalid)
3152  return TokError("invalid DWARF tag" + Twine(" '") + Lex.getStrVal() + "'");
3153  assert(Tag <= Result.Max && "Expected valid DWARF tag");
3154 
3155  Result.assign(Tag);
3156  Lex.Lex();
3157  return false;
3158 }
3159 
3160 template <>
3161 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3162  DwarfVirtualityField &Result) {
3163  if (Lex.getKind() == lltok::APSInt)
3164  return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3165 
3166  if (Lex.getKind() != lltok::DwarfVirtuality)
3167  return TokError("expected DWARF virtuality code");
3168 
3169  unsigned Virtuality = dwarf::getVirtuality(Lex.getStrVal());
3170  if (!Virtuality)
3171  return TokError("invalid DWARF virtuality code" + Twine(" '") +
3172  Lex.getStrVal() + "'");
3173  assert(Virtuality <= Result.Max && "Expected valid DWARF virtuality code");
3174  Result.assign(Virtuality);
3175  Lex.Lex();
3176  return false;
3177 }
3178 
3179 template <>
3180 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) {
3181  if (Lex.getKind() == lltok::APSInt)
3182  return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3183 
3184  if (Lex.getKind() != lltok::DwarfLang)
3185  return TokError("expected DWARF language");
3186 
3187  unsigned Lang = dwarf::getLanguage(Lex.getStrVal());
3188  if (!Lang)
3189  return TokError("invalid DWARF language" + Twine(" '") + Lex.getStrVal() +
3190  "'");
3191  assert(Lang <= Result.Max && "Expected valid DWARF language");
3192  Result.assign(Lang);
3193  Lex.Lex();
3194  return false;
3195 }
3196 
3197 template <>
3198 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3199  DwarfAttEncodingField &Result) {
3200  if (Lex.getKind() == lltok::APSInt)
3201  return ParseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
3202 
3203  if (Lex.getKind() != lltok::DwarfAttEncoding)
3204  return TokError("expected DWARF type attribute encoding");
3205 
3206  unsigned Encoding = dwarf::getAttributeEncoding(Lex.getStrVal());
3207  if (!Encoding)
3208  return TokError("invalid DWARF type attribute encoding" + Twine(" '") +
3209  Lex.getStrVal() + "'");
3210  assert(Encoding <= Result.Max && "Expected valid DWARF language");
3211  Result.assign(Encoding);
3212  Lex.Lex();
3213  return false;
3214 }
3215 
3216 /// DIFlagField
3217 /// ::= uint32
3218 /// ::= DIFlagVector
3219 /// ::= DIFlagVector '|' DIFlagFwdDecl '|' uint32 '|' DIFlagPublic
3220 template <>
3221 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, DIFlagField &Result) {
3222  assert(Result.Max == UINT32_MAX && "Expected only 32-bits");
3223 
3224  // Parser for a single flag.
3225  auto parseFlag = [&](unsigned &Val) {
3226  if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned())
3227  return ParseUInt32(Val);
3228 
3229  if (Lex.getKind() != lltok::DIFlag)
3230  return TokError("expected debug info flag");
3231 
3232  Val = DINode::getFlag(Lex.getStrVal());
3233  if (!Val)
3234  return TokError(Twine("invalid debug info flag flag '") +
3235  Lex.getStrVal() + "'");
3236  Lex.Lex();
3237  return false;
3238  };
3239 
3240  // Parse the flags and combine them together.
3241  unsigned Combined = 0;
3242  do {
3243  unsigned Val;
3244  if (parseFlag(Val))
3245  return true;
3246  Combined |= Val;
3247  } while (EatIfPresent(lltok::bar));
3248 
3249  Result.assign(Combined);
3250  return false;
3251 }
3252 
3253 template <>
3254 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
3255  MDSignedField &Result) {
3256  if (Lex.getKind() != lltok::APSInt)
3257  return TokError("expected signed integer");
3258 
3259  auto &S = Lex.getAPSIntVal();
3260  if (S < Result.Min)
3261  return TokError("value for '" + Name + "' too small, limit is " +
3262  Twine(Result.Min));
3263  if (S > Result.Max)
3264  return TokError("value for '" + Name + "' too large, limit is " +
3265  Twine(Result.Max));
3266  Result.assign(S.getExtValue());
3267  assert(Result.Val >= Result.Min && "Expected value in range");
3268  assert(Result.Val <= Result.Max && "Expected value in range");
3269  Lex.Lex();
3270  return false;
3271 }
3272 
3273 template <>
3274 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDBoolField &Result) {
3275  switch (Lex.getKind()) {
3276  default:
3277  return TokError("expected 'true' or 'false'");
3278  case lltok::kw_true:
3279  Result.assign(true);
3280  break;
3281  case lltok::kw_false:
3282  Result.assign(false);
3283  break;
3284  }
3285  Lex.Lex();
3286  return false;
3287 }
3288 
3289 template <>
3290 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDField &Result) {
3291  if (Lex.getKind() == lltok::kw_null) {
3292  if (!Result.AllowNull)
3293  return TokError("'" + Name + "' cannot be null");
3294  Lex.Lex();
3295  Result.assign(nullptr);
3296  return false;
3297  }
3298 
3299  Metadata *MD;
3300  if (ParseMetadata(MD, nullptr))
3301  return true;
3302 
3303  Result.assign(MD);
3304  return false;
3305 }
3306 
3307 template <>
3308 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDConstant &Result) {
3309  Metadata *MD;
3310  if (ParseValueAsMetadata(MD, "expected constant", nullptr))
3311  return true;
3312 
3313  Result.assign(cast<ConstantAsMetadata>(MD));
3314  return false;
3315 }
3316 
3317 template <>
3318 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDStringField &Result) {
3319  LocTy ValueLoc = Lex.getLoc();
3320  std::string S;
3321  if (ParseStringConstant(S))
3322  return true;
3323 
3324  if (!Result.AllowEmpty && S.empty())
3325  return Error(ValueLoc, "'" + Name + "' cannot be empty");
3326 
3327  Result.assign(S.empty() ? nullptr : MDString::get(Context, S));
3328  return false;
3329 }
3330 
3331 template <>
3332 bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDFieldList &Result) {
3334  if (ParseMDNodeVector(MDs))
3335  return true;
3336 
3337  Result.assign(std::move(MDs));
3338  return false;
3339 }
3340 
3341 } // end namespace llvm
3342 
3343 template <class ParserTy>
3344 bool LLParser::ParseMDFieldsImplBody(ParserTy parseField) {
3345  do {
3346  if (Lex.getKind() != lltok::LabelStr)
3347  return TokError("expected field label here");
3348 
3349  if (parseField())
3350  return true;
3351  } while (EatIfPresent(lltok::comma));
3352 
3353  return false;
3354 }
3355 
3356 template <class ParserTy>
3357 bool LLParser::ParseMDFieldsImpl(ParserTy parseField, LocTy &ClosingLoc) {
3358  assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
3359  Lex.Lex();
3360 
3361  if (ParseToken(lltok::lparen, "expected '(' here"))
3362  return true;
3363  if (Lex.getKind() != lltok::rparen)
3364  if (ParseMDFieldsImplBody(parseField))
3365  return true;
3366 
3367  ClosingLoc = Lex.getLoc();
3368  return ParseToken(lltok::rparen, "expected ')' here");
3369 }
3370 
3371 template <class FieldTy>
3372 bool LLParser::ParseMDField(StringRef Name, FieldTy &Result) {
3373  if (Result.Seen)
3374  return TokError("field '" + Name + "' cannot be specified more than once");
3375 
3376  LocTy Loc = Lex.getLoc();
3377  Lex.Lex();
3378  return ParseMDField(Loc, Name, Result);
3379 }
3380 
3381 bool LLParser::ParseSpecializedMDNode(MDNode *&N, bool IsDistinct) {
3382  assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
3383 
3384 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
3385  if (Lex.getStrVal() == #CLASS) \
3386  return Parse##CLASS(N, IsDistinct);
3387 #include "llvm/IR/Metadata.def"
3388 
3389  return TokError("expected metadata type");
3390 }
3391 
3392 #define DECLARE_FIELD(NAME, TYPE, INIT) TYPE NAME INIT
3393 #define NOP_FIELD(NAME, TYPE, INIT)
3394 #define REQUIRE_FIELD(NAME, TYPE, INIT) \
3395  if (!NAME.Seen) \
3396  return Error(ClosingLoc, "missing required field '" #NAME "'");
3397 #define PARSE_MD_FIELD(NAME, TYPE, DEFAULT) \
3398  if (Lex.getStrVal() == #NAME) \
3399  return ParseMDField(#NAME, NAME);
3400 #define PARSE_MD_FIELDS() \
3401  VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) \
3402  do { \
3403  LocTy ClosingLoc; \
3404  if (ParseMDFieldsImpl([&]() -> bool { \
3405  VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD) \
3406  return TokError(Twine("invalid field '") + Lex.getStrVal() + "'"); \
3407  }, ClosingLoc)) \
3408  return true; \
3409  VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD) \
3410  } while (false)
3411 #define GET_OR_DISTINCT(CLASS, ARGS) \
3412  (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
3413 
3414 /// ParseDILocationFields:
3415 /// ::= !DILocation(line: 43, column: 8, scope: !5, inlinedAt: !6)
3416 bool LLParser::ParseDILocation(MDNode *&Result, bool IsDistinct) {
3417 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3418  OPTIONAL(line, LineField, ); \
3419  OPTIONAL(column, ColumnField, ); \
3420  REQUIRED(scope, MDField, (/* AllowNull */ false)); \
3421  OPTIONAL(inlinedAt, MDField, );
3422  PARSE_MD_FIELDS();
3423 #undef VISIT_MD_FIELDS
3424 
3425  Result = GET_OR_DISTINCT(
3426  DILocation, (Context, line.Val, column.Val, scope.Val, inlinedAt.Val));
3427  return false;
3428 }
3429 
3430 /// ParseGenericDINode:
3431 /// ::= !GenericDINode(tag: 15, header: "...", operands: {...})
3432 bool LLParser::ParseGenericDINode(MDNode *&Result, bool IsDistinct) {
3433 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3434  REQUIRED(tag, DwarfTagField, ); \
3435  OPTIONAL(header, MDStringField, ); \
3436  OPTIONAL(operands, MDFieldList, );
3437  PARSE_MD_FIELDS();
3438 #undef VISIT_MD_FIELDS
3439 
3440  Result = GET_OR_DISTINCT(GenericDINode,
3441  (Context, tag.Val, header.Val, operands.Val));
3442  return false;
3443 }
3444 
3445 /// ParseDISubrange:
3446 /// ::= !DISubrange(count: 30, lowerBound: 2)
3447 bool LLParser::ParseDISubrange(MDNode *&Result, bool IsDistinct) {
3448 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3449  REQUIRED(count, MDSignedField, (-1, -1, INT64_MAX)); \
3450  OPTIONAL(lowerBound, MDSignedField, );
3451  PARSE_MD_FIELDS();
3452 #undef VISIT_MD_FIELDS
3453 
3454  Result = GET_OR_DISTINCT(DISubrange, (Context, count.Val, lowerBound.Val));
3455  return false;
3456 }
3457 
3458 /// ParseDIEnumerator:
3459 /// ::= !DIEnumerator(value: 30, name: "SomeKind")
3460 bool LLParser::ParseDIEnumerator(MDNode *&Result, bool IsDistinct) {
3461 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3462  REQUIRED(name, MDStringField, ); \
3463  REQUIRED(value, MDSignedField, );
3464  PARSE_MD_FIELDS();
3465 #undef VISIT_MD_FIELDS
3466 
3467  Result = GET_OR_DISTINCT(DIEnumerator, (Context, value.Val, name.Val));
3468  return false;
3469 }
3470 
3471 /// ParseDIBasicType:
3472 /// ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32)
3473 bool LLParser::ParseDIBasicType(MDNode *&Result, bool IsDistinct) {
3474 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3475  OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type)); \
3476  OPTIONAL(name, MDStringField, ); \
3477  OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
3478  OPTIONAL(align, MDUnsignedField, (0, UINT64_MAX)); \
3479  OPTIONAL(encoding, DwarfAttEncodingField, );
3480  PARSE_MD_FIELDS();
3481 #undef VISIT_MD_FIELDS
3482 
3483  Result = GET_OR_DISTINCT(DIBasicType, (Context, tag.Val, name.Val, size.Val,
3484  align.Val, encoding.Val));
3485  return false;
3486 }
3487 
3488 /// ParseDIDerivedType:
3489 /// ::= !DIDerivedType(tag: DW_TAG_pointer_type, name: "int", file: !0,
3490 /// line: 7, scope: !1, baseType: !2, size: 32,
3491 /// align: 32, offset: 0, flags: 0, extraData: !3)
3492 bool LLParser::ParseDIDerivedType(MDNode *&Result, bool IsDistinct) {
3493 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3494  REQUIRED(tag, DwarfTagField, ); \
3495  OPTIONAL(name, MDStringField, ); \
3496  OPTIONAL(file, MDField, ); \
3497  OPTIONAL(line, LineField, ); \
3498  OPTIONAL(scope, MDField, ); \
3499  REQUIRED(baseType, MDField, ); \
3500  OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
3501  OPTIONAL(align, MDUnsignedField, (0, UINT64_MAX)); \
3502  OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX)); \
3503  OPTIONAL(flags, DIFlagField, ); \
3504  OPTIONAL(extraData, MDField, );
3505  PARSE_MD_FIELDS();
3506 #undef VISIT_MD_FIELDS
3507 
3508  Result = GET_OR_DISTINCT(DIDerivedType,
3509  (Context, tag.Val, name.Val, file.Val, line.Val,
3510  scope.Val, baseType.Val, size.Val, align.Val,
3511  offset.Val, flags.Val, extraData.Val));
3512  return false;
3513 }
3514 
3515 bool LLParser::ParseDICompositeType(MDNode *&Result, bool IsDistinct) {
3516 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3517  REQUIRED(tag, DwarfTagField, ); \
3518  OPTIONAL(name, MDStringField, ); \
3519  OPTIONAL(file, MDField, ); \
3520  OPTIONAL(line, LineField, ); \
3521  OPTIONAL(scope, MDField, ); \
3522  OPTIONAL(baseType, MDField, ); \
3523  OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
3524  OPTIONAL(align, MDUnsignedField, (0, UINT64_MAX)); \
3525  OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX)); \
3526  OPTIONAL(flags, DIFlagField, ); \
3527  OPTIONAL(elements, MDField, ); \
3528  OPTIONAL(runtimeLang, DwarfLangField, ); \
3529  OPTIONAL(vtableHolder, MDField, ); \
3530  OPTIONAL(templateParams, MDField, ); \
3531  OPTIONAL(identifier, MDStringField, );
3532  PARSE_MD_FIELDS();
3533 #undef VISIT_MD_FIELDS
3534 
3535  Result = GET_OR_DISTINCT(
3537  (Context, tag.Val, name.Val, file.Val, line.Val, scope.Val, baseType.Val,
3538  size.Val, align.Val, offset.Val, flags.Val, elements.Val,
3539  runtimeLang.Val, vtableHolder.Val, templateParams.Val, identifier.Val));
3540  return false;
3541 }
3542 
3543 bool LLParser::ParseDISubroutineType(MDNode *&Result, bool IsDistinct) {
3544 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3545  OPTIONAL(flags, DIFlagField, ); \
3546  REQUIRED(types, MDField, );
3547  PARSE_MD_FIELDS();
3548 #undef VISIT_MD_FIELDS
3549 
3550  Result = GET_OR_DISTINCT(DISubroutineType, (Context, flags.Val, types.Val));
3551  return false;
3552 }
3553 
3554 /// ParseDIFileType:
3555 /// ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir")
3556 bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
3557 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3558  REQUIRED(filename, MDStringField, ); \
3559  REQUIRED(directory, MDStringField, );
3560  PARSE_MD_FIELDS();
3561 #undef VISIT_MD_FIELDS
3562 
3563  Result = GET_OR_DISTINCT(DIFile, (Context, filename.Val, directory.Val));
3564  return false;
3565 }
3566 
3567 /// ParseDICompileUnit:
3568 /// ::= !DICompileUnit(language: DW_LANG_C99, file: !0, producer: "clang",
3569 /// isOptimized: true, flags: "-O2", runtimeVersion: 1,
3570 /// splitDebugFilename: "abc.debug", emissionKind: 1,
3571 /// enums: !1, retainedTypes: !2, subprograms: !3,
3572 /// globals: !4, imports: !5, dwoId: 0x0abcd)
3573 bool LLParser::ParseDICompileUnit(MDNode *&Result, bool IsDistinct) {
3574 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3575  REQUIRED(language, DwarfLangField, ); \
3576  REQUIRED(file, MDField, (/* AllowNull */ false)); \
3577  OPTIONAL(producer, MDStringField, ); \
3578  OPTIONAL(isOptimized, MDBoolField, ); \
3579  OPTIONAL(flags, MDStringField, ); \
3580  OPTIONAL(runtimeVersion, MDUnsignedField, (0, UINT32_MAX)); \
3581  OPTIONAL(splitDebugFilename, MDStringField, ); \
3582  OPTIONAL(emissionKind, MDUnsignedField, (0, UINT32_MAX)); \
3583  OPTIONAL(enums, MDField, ); \
3584  OPTIONAL(retainedTypes, MDField, ); \
3585  OPTIONAL(subprograms, MDField, ); \
3586  OPTIONAL(globals, MDField, ); \
3587  OPTIONAL(imports, MDField, ); \
3588  OPTIONAL(dwoId, MDUnsignedField, );
3589  PARSE_MD_FIELDS();
3590 #undef VISIT_MD_FIELDS
3591 
3592  Result = GET_OR_DISTINCT(DICompileUnit,
3593  (Context, language.Val, file.Val, producer.Val,
3594  isOptimized.Val, flags.Val, runtimeVersion.Val,
3595  splitDebugFilename.Val, emissionKind.Val, enums.Val,
3596  retainedTypes.Val, subprograms.Val, globals.Val,
3597  imports.Val, dwoId.Val));
3598  return false;
3599 }
3600 
3601 /// ParseDISubprogram:
3602 /// ::= !DISubprogram(scope: !0, name: "foo", linkageName: "_Zfoo",
3603 /// file: !1, line: 7, type: !2, isLocal: false,
3604 /// isDefinition: true, scopeLine: 8, containingType: !3,
3605 /// virtuality: DW_VIRTUALTIY_pure_virtual,
3606 /// virtualIndex: 10, flags: 11,
3607 /// isOptimized: false, function: void ()* @_Z3foov,
3608 /// templateParams: !4, declaration: !5, variables: !6)
3609 bool LLParser::ParseDISubprogram(MDNode *&Result, bool IsDistinct) {
3610 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3611  OPTIONAL(scope, MDField, ); \
3612  OPTIONAL(name, MDStringField, ); \
3613  OPTIONAL(linkageName, MDStringField, ); \
3614  OPTIONAL(file, MDField, ); \
3615  OPTIONAL(line, LineField, ); \
3616  OPTIONAL(type, MDField, ); \
3617  OPTIONAL(isLocal, MDBoolField, ); \
3618  OPTIONAL(isDefinition, MDBoolField, (true)); \
3619  OPTIONAL(scopeLine, LineField, ); \
3620  OPTIONAL(containingType, MDField, ); \
3621  OPTIONAL(virtuality, DwarfVirtualityField, ); \
3622  OPTIONAL(virtualIndex, MDUnsignedField, (0, UINT32_MAX)); \
3623  OPTIONAL(flags, DIFlagField, ); \
3624  OPTIONAL(isOptimized, MDBoolField, ); \
3625  OPTIONAL(function, MDConstant, ); \
3626  OPTIONAL(templateParams, MDField, ); \
3627  OPTIONAL(declaration, MDField, ); \
3628  OPTIONAL(variables, MDField, );
3629  PARSE_MD_FIELDS();
3630 #undef VISIT_MD_FIELDS
3631 
3632  Result = GET_OR_DISTINCT(
3633  DISubprogram, (Context, scope.Val, name.Val, linkageName.Val, file.Val,
3634  line.Val, type.Val, isLocal.Val, isDefinition.Val,
3635  scopeLine.Val, containingType.Val, virtuality.Val,
3636  virtualIndex.Val, flags.Val, isOptimized.Val, function.Val,
3637  templateParams.Val, declaration.Val, variables.Val));
3638  return false;
3639 }
3640 
3641 /// ParseDILexicalBlock:
3642 /// ::= !DILexicalBlock(scope: !0, file: !2, line: 7, column: 9)
3643 bool LLParser::ParseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
3644 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3645  REQUIRED(scope, MDField, (/* AllowNull */ false)); \
3646  OPTIONAL(file, MDField, ); \
3647  OPTIONAL(line, LineField, ); \
3648  OPTIONAL(column, ColumnField, );
3649  PARSE_MD_FIELDS();
3650 #undef VISIT_MD_FIELDS
3651 
3652  Result = GET_OR_DISTINCT(
3653  DILexicalBlock, (Context, scope.Val, file.Val, line.Val, column.Val));
3654  return false;
3655 }
3656 
3657 /// ParseDILexicalBlockFile:
3658 /// ::= !DILexicalBlockFile(scope: !0, file: !2, discriminator: 9)
3659 bool LLParser::ParseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) {
3660 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3661  REQUIRED(scope, MDField, (/* AllowNull */ false)); \
3662  OPTIONAL(file, MDField, ); \
3663  REQUIRED(discriminator, MDUnsignedField, (0, UINT32_MAX));
3664  PARSE_MD_FIELDS();
3665 #undef VISIT_MD_FIELDS
3666 
3668  (Context, scope.Val, file.Val, discriminator.Val));
3669  return false;
3670 }
3671 
3672 /// ParseDINamespace:
3673 /// ::= !DINamespace(scope: !0, file: !2, name: "SomeNamespace", line: 9)
3674 bool LLParser::ParseDINamespace(MDNode *&Result, bool IsDistinct) {
3675 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3676  REQUIRED(scope, MDField, ); \
3677  OPTIONAL(file, MDField, ); \
3678  OPTIONAL(name, MDStringField, ); \
3679  OPTIONAL(line, LineField, );
3680  PARSE_MD_FIELDS();
3681 #undef VISIT_MD_FIELDS
3682 
3683  Result = GET_OR_DISTINCT(DINamespace,
3684  (Context, scope.Val, file.Val, name.Val, line.Val));
3685  return false;
3686 }
3687 
3688 /// ParseDIModule:
3689 /// ::= !DIModule(scope: !0, name: "SomeModule", configMacros: "-DNDEBUG",
3690 /// includePath: "/usr/include", isysroot: "/")
3691 bool LLParser::ParseDIModule(MDNode *&Result, bool IsDistinct) {
3692 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3693  REQUIRED(scope, MDField, ); \
3694  REQUIRED(name, MDStringField, ); \
3695  OPTIONAL(configMacros, MDStringField, ); \
3696  OPTIONAL(includePath, MDStringField, ); \
3697  OPTIONAL(isysroot, MDStringField, );
3698  PARSE_MD_FIELDS();
3699 #undef VISIT_MD_FIELDS
3700 
3701  Result = GET_OR_DISTINCT(DIModule, (Context, scope.Val, name.Val,
3702  configMacros.Val, includePath.Val, isysroot.Val));
3703  return false;
3704 }
3705 
3706 /// ParseDITemplateTypeParameter:
3707 /// ::= !DITemplateTypeParameter(name: "Ty", type: !1)
3708 bool LLParser::ParseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) {
3709 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3710  OPTIONAL(name, MDStringField, ); \
3711  REQUIRED(type, MDField, );
3712  PARSE_MD_FIELDS();
3713 #undef VISIT_MD_FIELDS
3714 
3715  Result =
3716  GET_OR_DISTINCT(DITemplateTypeParameter, (Context, name.Val, type.Val));
3717  return false;
3718 }
3719 
3720 /// ParseDITemplateValueParameter:
3721 /// ::= !DITemplateValueParameter(tag: DW_TAG_template_value_parameter,
3722 /// name: "V", type: !1, value: i32 7)
3723 bool LLParser::ParseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) {
3724 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3725  OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_template_value_parameter)); \
3726  OPTIONAL(name, MDStringField, ); \
3727  OPTIONAL(type, MDField, ); \
3728  REQUIRED(value, MDField, );
3729  PARSE_MD_FIELDS();
3730 #undef VISIT_MD_FIELDS
3731 
3733  (Context, tag.Val, name.Val, type.Val, value.Val));
3734  return false;
3735 }
3736 
3737 /// ParseDIGlobalVariable:
3738 /// ::= !DIGlobalVariable(scope: !0, name: "foo", linkageName: "foo",
3739 /// file: !1, line: 7, type: !2, isLocal: false,
3740 /// isDefinition: true, variable: i32* @foo,
3741 /// declaration: !3)
3742 bool LLParser::ParseDIGlobalVariable(MDNode *&Result, bool IsDistinct) {
3743 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3744  REQUIRED(name, MDStringField, (/* AllowEmpty */ false)); \
3745  OPTIONAL(scope, MDField, ); \
3746  OPTIONAL(linkageName, MDStringField, ); \
3747  OPTIONAL(file, MDField, ); \
3748  OPTIONAL(line, LineField, ); \
3749  OPTIONAL(type, MDField, ); \
3750  OPTIONAL(isLocal, MDBoolField, ); \
3751  OPTIONAL(isDefinition, MDBoolField, (true)); \
3752  OPTIONAL(variable, MDConstant, ); \
3753  OPTIONAL(declaration, MDField, );
3754  PARSE_MD_FIELDS();
3755 #undef VISIT_MD_FIELDS
3756 
3758  (Context, scope.Val, name.Val, linkageName.Val,
3759  file.Val, line.Val, type.Val, isLocal.Val,
3760  isDefinition.Val, variable.Val, declaration.Val));
3761  return false;
3762 }
3763 
3764 /// ParseDILocalVariable:
3765 /// ::= !DILocalVariable(tag: DW_TAG_arg_variable, scope: !0, name: "foo",
3766 /// file: !1, line: 7, type: !2, arg: 2, flags: 7)
3767 bool LLParser::ParseDILocalVariable(MDNode *&Result, bool IsDistinct) {
3768 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3769  REQUIRED(tag, DwarfTagField, ); \
3770  REQUIRED(scope, MDField, (/* AllowNull */ false)); \
3771  OPTIONAL(name, MDStringField, ); \
3772  OPTIONAL(file, MDField, ); \
3773  OPTIONAL(line, LineField, ); \
3774  OPTIONAL(type, MDField, ); \
3775  OPTIONAL(arg, MDUnsignedField, (0, UINT16_MAX)); \
3776  OPTIONAL(flags, DIFlagField, );
3777  PARSE_MD_FIELDS();
3778 #undef VISIT_MD_FIELDS
3779 
3781  (Context, tag.Val, scope.Val, name.Val, file.Val,
3782  line.Val, type.Val, arg.Val, flags.Val));
3783  return false;
3784 }
3785 
3786 /// ParseDIExpression:
3787 /// ::= !DIExpression(0, 7, -1)
3788 bool LLParser::ParseDIExpression(MDNode *&Result, bool IsDistinct) {
3789  assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
3790  Lex.Lex();
3791 
3792  if (ParseToken(lltok::lparen, "expected '(' here"))
3793  return true;
3794 
3795  SmallVector<uint64_t, 8> Elements;
3796  if (Lex.getKind() != lltok::rparen)
3797  do {
3798  if (Lex.getKind() == lltok::DwarfOp) {
3799  if (unsigned Op = dwarf::getOperationEncoding(Lex.getStrVal())) {
3800  Lex.Lex();
3801  Elements.push_back(Op);
3802  continue;
3803  }
3804  return TokError(Twine("invalid DWARF op '") + Lex.getStrVal() + "'");
3805  }
3806 
3807  if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
3808  return TokError("expected unsigned integer");
3809 
3810  auto &U = Lex.getAPSIntVal();
3811  if (U.ugt(UINT64_MAX))
3812  return TokError("element too large, limit is " + Twine(UINT64_MAX));
3813  Elements.push_back(U.getZExtValue());
3814  Lex.Lex();
3815  } while (EatIfPresent(lltok::comma));
3816 
3817  if (ParseToken(lltok::rparen, "expected ')' here"))
3818  return true;
3819 
3820  Result = GET_OR_DISTINCT(DIExpression, (Context, Elements));
3821  return false;
3822 }
3823 
3824 /// ParseDIObjCProperty:
3825 /// ::= !DIObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
3826 /// getter: "getFoo", attributes: 7, type: !2)
3827 bool LLParser::ParseDIObjCProperty(MDNode *&Result, bool IsDistinct) {
3828 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3829  OPTIONAL(name, MDStringField, ); \
3830  OPTIONAL(file, MDField, ); \
3831  OPTIONAL(line, LineField, ); \
3832  OPTIONAL(setter, MDStringField, ); \
3833  OPTIONAL(getter, MDStringField, ); \
3834  OPTIONAL(attributes, MDUnsignedField, (0, UINT32_MAX)); \
3835  OPTIONAL(type, MDField, );
3836  PARSE_MD_FIELDS();
3837 #undef VISIT_MD_FIELDS
3838 
3840  (Context, name.Val, file.Val, line.Val, setter.Val,
3841  getter.Val, attributes.Val, type.Val));
3842  return false;
3843 }
3844 
3845 /// ParseDIImportedEntity:
3846 /// ::= !DIImportedEntity(tag: DW_TAG_imported_module, scope: !0, entity: !1,
3847 /// line: 7, name: "foo")
3848 bool LLParser::ParseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
3849 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
3850  REQUIRED(tag, DwarfTagField, ); \
3851  REQUIRED(scope, MDField, ); \
3852  OPTIONAL(entity, MDField, ); \
3853  OPTIONAL(line, LineField, ); \
3854  OPTIONAL(name, MDStringField, );
3855  PARSE_MD_FIELDS();
3856 #undef VISIT_MD_FIELDS
3857 
3858  Result = GET_OR_DISTINCT(DIImportedEntity, (Context, tag.Val, scope.Val,
3859  entity.Val, line.Val, name.Val));
3860  return false;
3861 }
3862 
3863 #undef PARSE_MD_FIELD
3864 #undef NOP_FIELD
3865 #undef REQUIRE_FIELD
3866 #undef DECLARE_FIELD
3867 
3868 /// ParseMetadataAsValue
3869 /// ::= metadata i32 %local
3870 /// ::= metadata i32 @global
3871 /// ::= metadata i32 7
3872 /// ::= metadata !0
3873 /// ::= metadata !{...}
3874 /// ::= metadata !"string"
3875 bool LLParser::ParseMetadataAsValue(Value *&V, PerFunctionState &PFS) {
3876  // Note: the type 'metadata' has already been parsed.
3877  Metadata *MD;
3878  if (ParseMetadata(MD, &PFS))
3879  return true;
3880 
3881  V = MetadataAsValue::get(Context, MD);
3882  return false;
3883 }
3884 
3885 /// ParseValueAsMetadata
3886 /// ::= i32 %local
3887 /// ::= i32 @global
3888 /// ::= i32 7
3889 bool LLParser::ParseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
3890  PerFunctionState *PFS) {
3891  Type *Ty;
3892  LocTy Loc;
3893  if (ParseType(Ty, TypeMsg, Loc))
3894  return true;
3895  if (Ty->isMetadataTy())
3896  return Error(Loc, "invalid metadata-value-metadata roundtrip");
3897 
3898  Value *V;
3899  if (ParseValue(Ty, V, PFS))
3900  return true;
3901 
3902  MD = ValueAsMetadata::get(V);
3903  return false;
3904 }
3905 
3906 /// ParseMetadata
3907 /// ::= i32 %local
3908 /// ::= i32 @global
3909 /// ::= i32 7
3910 /// ::= !42
3911 /// ::= !{...}
3912 /// ::= !"string"
3913 /// ::= !DILocation(...)
3914 bool LLParser::ParseMetadata(Metadata *&MD, PerFunctionState *PFS) {
3915  if (Lex.getKind() == lltok::MetadataVar) {
3916  MDNode *N;
3917  if (ParseSpecializedMDNode(N))
3918  return true;
3919  MD = N;
3920  return false;
3921  }
3922 
3923  // ValueAsMetadata:
3924  // <type> <value>
3925  if (Lex.getKind() != lltok::exclaim)
3926  return ParseValueAsMetadata(MD, "expected metadata operand", PFS);
3927 
3928  // '!'.
3929  assert(Lex.getKind() == lltok::exclaim && "Expected '!' here");
3930  Lex.Lex();
3931 
3932  // MDString:
3933  // ::= '!' STRINGCONSTANT
3934  if (Lex.getKind() == lltok::StringConstant) {
3935  MDString *S;
3936  if (ParseMDString(S))
3937  return true;
3938  MD = S;
3939  return false;
3940  }
3941 
3942  // MDNode:
3943  // !{ ... }
3944  // !7
3945  MDNode *N;
3946  if (ParseMDNodeTail(N))
3947  return true;
3948  MD = N;
3949  return false;
3950 }
3951 
3952 
3953 //===----------------------------------------------------------------------===//
3954 // Function Parsing.
3955 //===----------------------------------------------------------------------===//
3956 
3957 bool LLParser::ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
3958  PerFunctionState *PFS) {
3959  if (Ty->isFunctionTy())
3960  return Error(ID.Loc, "functions are not values, refer to them as pointers");
3961 
3962  switch (ID.Kind) {
3963  case ValID::t_LocalID:
3964  if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
3965  V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc);
3966  return V == nullptr;
3967  case ValID::t_LocalName:
3968  if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
3969  V = PFS->GetVal(ID.StrVal, Ty, ID.Loc);
3970  return V == nullptr;
3971  case ValID::t_InlineAsm: {
3972  PointerType *PTy = dyn_cast<PointerType>(Ty);
3973  FunctionType *FTy =
3974  PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : nullptr;
3975  if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2))
3976  return Error(ID.Loc, "invalid type for inline asm constraint string");
3977  V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1,
3978  (ID.UIntVal>>1)&1, (InlineAsm::AsmDialect(ID.UIntVal>>2)));
3979  return false;
3980  }
3981  case ValID::t_GlobalName:
3982  V = GetGlobalVal(ID.StrVal, Ty, ID.Loc);
3983  return V == nullptr;
3984  case ValID::t_GlobalID:
3985  V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc);
3986  return V == nullptr;
3987  case ValID::t_APSInt:
3988  if (!Ty->isIntegerTy())
3989  return Error(ID.Loc, "integer constant must have integer type");
3991  V = ConstantInt::get(Context, ID.APSIntVal);
3992  return false;
3993  case ValID::t_APFloat:
3994  if (!Ty->isFloatingPointTy() ||
3996  return Error(ID.Loc, "floating point constant invalid for type");
3997 
3998  // The lexer has no type info, so builds all half, float, and double FP
3999  // constants as double. Fix this here. Long double does not need this.
4001  bool Ignored;
4002  if (Ty->isHalfTy())
4004  &Ignored);
4005  else if (Ty->isFloatTy())
4007  &Ignored);
4008  }
4009  V = ConstantFP::get(Context, ID.APFloatVal);
4010 
4011  if (V->getType() != Ty)
4012  return Error(ID.Loc, "floating point constant does not have type '" +
4013  getTypeString(Ty) + "'");
4014 
4015  return false;
4016  case ValID::t_Null:
4017  if (!Ty->isPointerTy())
4018  return Error(ID.Loc, "null must be a pointer type");
4019  V = ConstantPointerNull::get(cast<PointerType>(Ty));
4020  return false;
4021  case ValID::t_Undef:
4022  // FIXME: LabelTy should not be a first-class type.
4023  if (!Ty->isFirstClassType() || Ty->isLabelTy())
4024  return Error(ID.Loc, "invalid type for undef constant");
4025  V = UndefValue::get(Ty);
4026  return false;
4027  case ValID::t_EmptyArray:
4028  if (!Ty->isArrayTy() || cast<ArrayType>(Ty)->getNumElements() != 0)
4029  return Error(ID.Loc, "invalid empty array initializer");
4030  V = UndefValue::get(Ty);
4031  return false;
4032  case ValID::t_Zero:
4033  // FIXME: LabelTy should not be a first-class type.
4034  if (!Ty->isFirstClassType() || Ty->isLabelTy())
4035  return Error(ID.Loc, "invalid type for null constant");
4036  V = Constant::getNullValue(Ty);
4037  return false;
4038  case ValID::t_Constant:
4039  if (ID.ConstantVal->getType() != Ty)
4040  return Error(ID.Loc, "constant expression type mismatch");
4041 
4042  V = ID.ConstantVal;
4043  return false;
4046  if (StructType *ST = dyn_cast<StructType>(Ty)) {
4047  if (ST->getNumElements() != ID.UIntVal)
4048  return Error(ID.Loc,
4049  "initializer with struct type has wrong # elements");
4050  if (ST->isPacked() != (ID.Kind == ValID::t_PackedConstantStruct))
4051  return Error(ID.Loc, "packed'ness of initializer and type don't match");
4052 
4053  // Verify that the elements are compatible with the structtype.
4054  for (unsigned i = 0, e = ID.UIntVal; i != e; ++i)
4055  if (ID.ConstantStructElts[i]->getType() != ST->getElementType(i))
4056  return Error(ID.Loc, "element " + Twine(i) +
4057  " of struct initializer doesn't match struct element type");
4058 
4060  ID.UIntVal));
4061  } else
4062  return Error(ID.Loc, "constant expression type mismatch");
4063  return false;
4064  }
4065  llvm_unreachable("Invalid ValID");
4066 }
4067 
4068 bool LLParser::ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
4069  V = nullptr;
4070  ValID ID;
4071  return ParseValID(ID, PFS) ||
4072  ConvertValIDToValue(Ty, ID, V, PFS);
4073 }
4074 
4075 bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState *PFS) {
4076  Type *Ty = nullptr;
4077  return ParseType(Ty) ||
4078  ParseValue(Ty, V, PFS);
4079 }
4080 
4081 bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
4082  PerFunctionState &PFS) {
4083  Value *V;
4084  Loc = Lex.getLoc();
4085  if (ParseTypeAndValue(V, PFS)) return true;
4086  if (!isa<BasicBlock>(V))
4087  return Error(Loc, "expected a basic block");
4088  BB = cast<BasicBlock>(V);
4089  return false;
4090 }
4091 
4092 
4093 /// FunctionHeader
4094 /// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs
4095 /// OptUnnamedAddr Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection
4096 /// OptionalAlign OptGC OptionalPrefix OptionalPrologue OptPersonalityFn
4097 bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
4098  // Parse the linkage.
4099  LocTy LinkageLoc = Lex.getLoc();
4100  unsigned Linkage;
4101 
4102  unsigned Visibility;
4103  unsigned DLLStorageClass;
4104  AttrBuilder RetAttrs;
4105  unsigned CC;
4106  Type *RetType = nullptr;
4107  LocTy RetTypeLoc = Lex.getLoc();
4108  if (ParseOptionalLinkage(Linkage) ||
4109  ParseOptionalVisibility(Visibility) ||
4110  ParseOptionalDLLStorageClass(DLLStorageClass) ||
4111  ParseOptionalCallingConv(CC) ||
4112  ParseOptionalReturnAttrs(RetAttrs) ||
4113  ParseType(RetType, RetTypeLoc, true /*void allowed*/))
4114  return true;
4115 
4116  // Verify that the linkage is ok.
4117  switch ((GlobalValue::LinkageTypes)Linkage) {
4119  break; // always ok.
4121  if (isDefine)
4122  return Error(LinkageLoc, "invalid linkage for function definition");
4123  break;
4131  if (!isDefine)
4132  return Error(LinkageLoc, "invalid linkage for function declaration");
4133  break;
4136  return Error(LinkageLoc, "invalid function linkage type");
4137  }
4138 
4139  if (!isValidVisibilityForLinkage(Visibility, Linkage))
4140  return Error(LinkageLoc,
4141  "symbol with local linkage must have default visibility");
4142 
4143  if (!FunctionType::isValidReturnType(RetType))
4144  return Error(RetTypeLoc, "invalid function return type");
4145 
4146  LocTy NameLoc = Lex.getLoc();
4147 
4148  std::string FunctionName;
4149  if (Lex.getKind() == lltok::GlobalVar) {
4150  FunctionName = Lex.getStrVal();
4151  } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok.
4152  unsigned NameID = Lex.getUIntVal();
4153 
4154  if (NameID != NumberedVals.size())
4155  return TokError("function expected to be numbered '%" +
4156  Twine(NumberedVals.size()) + "'");
4157  } else {
4158  return TokError("expected function name");
4159  }
4160 
4161  Lex.Lex();
4162 
4163  if (Lex.getKind() != lltok::lparen)
4164  return TokError("expected '(' in function argument list");
4165 
4166  SmallVector<ArgInfo, 8> ArgList;
4167  bool isVarArg;
4168  AttrBuilder FuncAttrs;
4169  std::vector<unsigned> FwdRefAttrGrps;
4170  LocTy BuiltinLoc;
4171  std::string Section;
4172  unsigned Alignment;
4173  std::string GC;
4174  bool UnnamedAddr;
4175  LocTy UnnamedAddrLoc;
4176  Constant *Prefix = nullptr;
4177  Constant *Prologue = nullptr;
4178  Constant *PersonalityFn = nullptr;
4179  Comdat *C;
4180 
4181  if (ParseArgumentList(ArgList, isVarArg) ||
4182  ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr,
4183  &UnnamedAddrLoc) ||
4184  ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
4185  BuiltinLoc) ||
4186  (EatIfPresent(lltok::kw_section) &&
4187  ParseStringConstant(Section)) ||
4188  parseOptionalComdat(FunctionName, C) ||
4189  ParseOptionalAlignment(Alignment) ||
4190  (EatIfPresent(lltok::kw_gc) &&
4191  ParseStringConstant(GC)) ||
4192  (EatIfPresent(lltok::kw_prefix) &&
4193  ParseGlobalTypeAndValue(Prefix)) ||
4194  (EatIfPresent(lltok::kw_prologue) &&
4195  ParseGlobalTypeAndValue(Prologue)) ||
4196  (EatIfPresent(lltok::kw_personality) &&
4197  ParseGlobalTypeAndValue(PersonalityFn)))
4198  return true;
4199 
4200  if (FuncAttrs.contains(Attribute::Builtin))
4201  return Error(BuiltinLoc, "'builtin' attribute not valid on function");
4202 
4203  // If the alignment was parsed as an attribute, move to the alignment field.
4204  if (FuncAttrs.hasAlignmentAttr()) {
4205  Alignment = FuncAttrs.getAlignment();
4207  }
4208 
4209  // Okay, if we got here, the function is syntactically valid. Convert types
4210  // and do semantic checks.
4211  std::vector<Type*> ParamTypeList;
4213 
4214  if (RetAttrs.hasAttributes())
4215  Attrs.push_back(AttributeSet::get(RetType->getContext(),
4217  RetAttrs));
4218 
4219  for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
4220  ParamTypeList.push_back(ArgList[i].Ty);
4221  if (ArgList[i].Attrs.hasAttributes(i + 1)) {
4222  AttrBuilder B(ArgList[i].Attrs, i + 1);
4223  Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B));
4224  }
4225  }
4226 
4227  if (FuncAttrs.hasAttributes())
4228  Attrs.push_back(AttributeSet::get(RetType->getContext(),
4230  FuncAttrs));
4231 
4232  AttributeSet PAL = AttributeSet::get(Context, Attrs);
4233 
4234  if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy())
4235  return Error(RetTypeLoc, "functions with 'sret' argument must return void");
4236 
4237  FunctionType *FT =
4238  FunctionType::get(RetType, ParamTypeList, isVarArg);
4240 
4241  Fn = nullptr;
4242  if (!FunctionName.empty()) {
4243  // If this was a definition of a forward reference, remove the definition
4244  // from the forward reference table and fill in the forward ref.
4245  std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator FRVI =
4246  ForwardRefVals.find(FunctionName);
4247  if (FRVI != ForwardRefVals.end()) {
4248  Fn = M->getFunction(FunctionName);
4249  if (!Fn)
4250  return Error(FRVI->second.second, "invalid forward reference to "
4251  "function as global value!");
4252  if (Fn->getType() != PFT)
4253  return Error(FRVI->second.second, "invalid forward reference to "
4254  "function '" + FunctionName + "' with wrong type!");
4255 
4256  ForwardRefVals.erase(FRVI);
4257  } else if ((Fn = M->getFunction(FunctionName))) {
4258  // Reject redefinitions.
4259  return Error(NameLoc, "invalid redefinition of function '" +
4260  FunctionName + "'");
4261  } else if (M->getNamedValue(FunctionName)) {
4262  return Error(NameLoc, "redefinition of function '@" + FunctionName + "'");
4263  }
4264 
4265  } else {
4266  // If this is a definition of a forward referenced function, make sure the
4267  // types agree.
4268  std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator I
4269  = ForwardRefValIDs.find(NumberedVals.size());
4270  if (I != ForwardRefValIDs.end()) {
4271  Fn = cast<Function>(I->second.first);
4272  if (Fn->getType() != PFT)
4273  return Error(NameLoc, "type of definition and forward reference of '@" +
4274  Twine(NumberedVals.size()) + "' disagree");
4275  ForwardRefValIDs.erase(I);
4276  }
4277  }
4278 
4279  if (!Fn)
4280  Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
4281  else // Move the forward-reference to the correct spot in the module.
4282  M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
4283 
4284  if (FunctionName.empty())
4285  NumberedVals.push_back(Fn);
4286 
4287  Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
4290  Fn->setCallingConv(CC);
4291  Fn->setAttributes(PAL);
4292  Fn->setUnnamedAddr(UnnamedAddr);
4293  Fn->setAlignment(Alignment);
4294  Fn->setSection(Section);
4295  Fn->setComdat(C);
4296  Fn->setPersonalityFn(PersonalityFn);
4297  if (!GC.empty()) Fn->setGC(GC.c_str());
4298  Fn->setPrefixData(Prefix);
4299  Fn->setPrologueData(Prologue);
4300  ForwardRefAttrGroups[Fn] = FwdRefAttrGrps;
4301 
4302  // Add all of the arguments we parsed to the function.
4303  Function::arg_iterator ArgIt = Fn->arg_begin();
4304  for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
4305  // If the argument has a name, insert it into the argument symbol table.
4306  if (ArgList[i].Name.empty()) continue;
4307 
4308  // Set the name, if it conflicted, it will be auto-renamed.
4309  ArgIt->setName(ArgList[i].Name);
4310 
4311  if (ArgIt->getName() != ArgList[i].Name)
4312  return Error(ArgList[i].Loc, "redefinition of argument '%" +
4313  ArgList[i].Name + "'");
4314  }
4315 
4316  if (isDefine)
4317  return false;
4318 
4319  // Check the declaration has no block address forward references.
4320  ValID ID;
4321  if (FunctionName.empty()) {
4322  ID.Kind = ValID::t_GlobalID;
4323  ID.UIntVal = NumberedVals.size() - 1;
4324  } else {
4326  ID.StrVal = FunctionName;
4327  }
4328  auto Blocks = ForwardRefBlockAddresses.find(ID);
4329  if (Blocks != ForwardRefBlockAddresses.end())
4330  return Error(Blocks->first.Loc,
4331  "cannot take blockaddress inside a declaration");
4332  return false;
4333 }
4334 
4335 bool LLParser::PerFunctionState::resolveForwardRefBlockAddresses() {
4336  ValID ID;
4337  if (FunctionNumber == -1) {
4339  ID.StrVal = F.getName();
4340  } else {
4341  ID.Kind = ValID::t_GlobalID;
4342  ID.UIntVal = FunctionNumber;
4343  }
4344 
4345  auto Blocks = P.ForwardRefBlockAddresses.find(ID);
4346  if (Blocks == P.ForwardRefBlockAddresses.end())
4347  return false;
4348 
4349  for (const auto &I : Blocks->second) {
4350  const ValID &BBID = I.first;
4351  GlobalValue *GV = I.second;
4352 
4353  assert((BBID.Kind == ValID::t_LocalID || BBID.Kind == ValID::t_LocalName) &&
4354  "Expected local id or name");
4355  BasicBlock *BB;
4356  if (BBID.Kind == ValID::t_LocalName)
4357  BB = GetBB(BBID.StrVal, BBID.Loc);
4358  else
4359  BB = GetBB(BBID.UIntVal, BBID.Loc);
4360  if (!BB)
4361  return P.Error(BBID.Loc, "referenced value is not a basic block");
4362 
4364  GV->eraseFromParent();
4365  }
4366 
4367  P.ForwardRefBlockAddresses.erase(Blocks);
4368  return false;
4369 }
4370 
4371 /// ParseFunctionBody
4372 /// ::= '{' BasicBlock+ UseListOrderDirective* '}'
4373 bool LLParser::ParseFunctionBody(Function &Fn) {
4374  if (Lex.getKind() != lltok::lbrace)
4375  return TokError("expected '{' in function body");
4376  Lex.Lex(); // eat the {.
4377 
4378  int FunctionNumber = -1;
4379  if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1;
4380 
4381  PerFunctionState PFS(*this, Fn, FunctionNumber);
4382 
4383  // Resolve block addresses and allow basic blocks to be forward-declared
4384  // within this function.
4385  if (PFS.resolveForwardRefBlockAddresses())
4386  return true;
4387  SaveAndRestore<PerFunctionState *> ScopeExit(BlockAddressPFS, &PFS);
4388 
4389  // We need at least one basic block.
4390  if (Lex.getKind() == lltok::rbrace || Lex.getKind() == lltok::kw_uselistorder)
4391  return TokError("function body requires at least one basic block");
4392 
4393  while (Lex.getKind() != lltok::rbrace &&
4395  if (ParseBasicBlock(PFS)) return true;
4396 
4397  while (Lex.getKind() != lltok::rbrace)
4398  if (ParseUseListOrder(&PFS))
4399  return true;
4400 
4401  // Eat the }.
4402  Lex.Lex();
4403 
4404  // Verify function is ok.
4405  return PFS.FinishFunction();
4406 }
4407 
4408 /// ParseBasicBlock
4409 /// ::= LabelStr? Instruction*
4410 bool LLParser::ParseBasicBlock(PerFunctionState &PFS) {
4411  // If this basic block starts out with a name, remember it.
4412  std::string Name;
4413  LocTy NameLoc = Lex.getLoc();
4414  if (Lex.getKind() == lltok::LabelStr) {
4415  Name = Lex.getStrVal();
4416  Lex.Lex();
4417  }
4418 
4419  BasicBlock *BB = PFS.DefineBB(Name, NameLoc);
4420  if (!BB)
4421  return Error(NameLoc,
4422  "unable to create block named '" + Name + "'");
4423 
4424  std::string NameStr;
4425 
4426  // Parse the instructions in this block until we get a terminator.
4427  Instruction *Inst;
4428  do {
4429  // This instruction may have three possibilities for a name: a) none
4430  // specified, b) name specified "%foo =", c) number specified: "%4 =".
4431  LocTy NameLoc = Lex.getLoc();
4432  int NameID = -1;
4433  NameStr = "";
4434 
4435  if (Lex.getKind() == lltok::LocalVarID) {
4436  NameID = Lex.getUIntVal();
4437  Lex.Lex();
4438  if (ParseToken(lltok::equal, "expected '=' after instruction id"))
4439  return true;
4440  } else if (Lex.getKind() == lltok::LocalVar) {
4441  NameStr = Lex.getStrVal();
4442  Lex.Lex();
4443  if (ParseToken(lltok::equal, "expected '=' after instruction name"))
4444  return true;
4445  }
4446 
4447  switch (ParseInstruction(Inst, BB, PFS)) {
4448  default: llvm_unreachable("Unknown ParseInstruction result!");
4449  case InstError: return true;
4450  case InstNormal:
4451  BB->getInstList().push_back(Inst);
4452 
4453  // With a normal result, we check to see if the instruction is followed by
4454  // a comma and metadata.
4455  if (EatIfPresent(lltok::comma))
4456  if (ParseInstructionMetadata(*Inst))
4457  return true;
4458  break;
4459  case InstExtraComma:
4460  BB->getInstList().push_back(Inst);
4461 
4462  // If the instruction parser ate an extra comma at the end of it, it
4463  // *must* be followed by metadata.
4464  if (ParseInstructionMetadata(*Inst))
4465  return true;
4466  break;
4467  }
4468 
4469  // Set the name on the instruction.
4470  if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true;
4471  } while (!isa<TerminatorInst>(Inst));
4472 
4473  return false;
4474 }
4475 
4476 //===----------------------------------------------------------------------===//
4477 // Instruction Parsing.
4478 //===----------------------------------------------------------------------===//
4479 
4480 /// ParseInstruction - Parse one of the many different instructions.
4481 ///
4482 int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB,
4483  PerFunctionState &PFS) {
4484  lltok::Kind Token = Lex.getKind();
4485  if (Token == lltok::Eof)
4486  return TokError("found end of file when expecting more instructions");
4487  LocTy Loc = Lex.getLoc();
4488  unsigned KeywordVal = Lex.getUIntVal();
4489  Lex.Lex(); // Eat the keyword.
4490 
4491  switch (Token) {
4492  default: return Error(Loc, "expected instruction opcode");
4493  // Terminator Instructions.
4494  case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
4495  case lltok::kw_ret: return ParseRet(Inst, BB, PFS);
4496  case lltok::kw_br: return ParseBr(Inst, PFS);
4497  case lltok::kw_switch: return ParseSwitch(Inst, PFS);
4498  case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS);
4499  case lltok::kw_invoke: return ParseInvoke(Inst, PFS);
4500  case lltok::kw_resume: return ParseResume(Inst, PFS);
4501  // Binary Operators.
4502  case lltok::kw_add:
4503  case lltok::kw_sub:
4504  case lltok::kw_mul:
4505  case lltok::kw_shl: {
4506  bool NUW = EatIfPresent(lltok::kw_nuw);
4507  bool NSW = EatIfPresent(lltok::kw_nsw);
4508  if (!NUW) NUW = EatIfPresent(lltok::kw_nuw);
4509 
4510  if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
4511 
4512  if (NUW) cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
4513  if (NSW) cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
4514  return false;
4515  }
4516  case lltok::kw_fadd:
4517  case lltok::kw_fsub:
4518  case lltok::kw_fmul:
4519  case lltok::kw_fdiv:
4520  case lltok::kw_frem: {
4521  FastMathFlags FMF = EatFastMathFlagsIfPresent();
4522  int Res = ParseArithmetic(Inst, PFS, KeywordVal, 2);
4523  if (Res != 0)
4524  return Res;
4525  if (FMF.any())
4526  Inst->setFastMathFlags(FMF);
4527  return 0;
4528  }
4529 
4530  case lltok::kw_sdiv:
4531  case lltok::kw_udiv:
4532  case lltok::kw_lshr:
4533  case lltok::kw_ashr: {
4534  bool Exact = EatIfPresent(lltok::kw_exact);
4535 
4536  if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
4537  if (Exact) cast<BinaryOperator>(Inst)->setIsExact(true);
4538  return false;
4539  }
4540 
4541  case lltok::kw_urem:
4542  case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1);
4543  case lltok::kw_and:
4544  case lltok::kw_or:
4545  case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal);
4546  case lltok::kw_icmp: return ParseCompare(Inst, PFS, KeywordVal);
4547  case lltok::kw_fcmp: {
4548  FastMathFlags FMF = EatFastMathFlagsIfPresent();
4549  int Res = ParseCompare(Inst, PFS, KeywordVal);
4550  if (Res != 0)
4551  return Res;
4552  if (FMF.any())
4553  Inst->setFastMathFlags(FMF);
4554  return 0;
4555  }
4556 
4557  // Casts.
4558  case lltok::kw_trunc:
4559  case lltok::kw_zext:
4560  case lltok::kw_sext:
4561  case lltok::kw_fptrunc:
4562  case lltok::kw_fpext:
4563  case lltok::kw_bitcast:
4565  case lltok::kw_uitofp:
4566  case lltok::kw_sitofp:
4567  case lltok::kw_fptoui:
4568  case lltok::kw_fptosi:
4569  case lltok::kw_inttoptr:
4570  case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal);
4571  // Other.
4572  case lltok::kw_select: return ParseSelect(Inst, PFS);
4573  case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS);
4574  case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS);
4575  case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS);
4576  case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS);
4577  case lltok::kw_phi: return ParsePHI(Inst, PFS);
4578  case lltok::kw_landingpad: return ParseLandingPad(Inst, PFS);
4579  // Call.
4580  case lltok::kw_call: return ParseCall(Inst, PFS, CallInst::TCK_None);
4581  case lltok::kw_tail: return ParseCall(Inst, PFS, CallInst::TCK_Tail);
4582  case lltok::kw_musttail: return ParseCall(Inst, PFS, CallInst::TCK_MustTail);
4583  // Memory.
4584  case lltok::kw_alloca: return ParseAlloc(Inst, PFS);
4585  case lltok::kw_load: return ParseLoad(Inst, PFS);
4586  case lltok::kw_store: return ParseStore(Inst, PFS);
4587  case lltok::kw_cmpxchg: return ParseCmpXchg(Inst, PFS);
4588  case lltok::kw_atomicrmw: return ParseAtomicRMW(Inst, PFS);
4589  case lltok::kw_fence: return ParseFence(Inst, PFS);
4590  case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS);
4591  case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS);
4592  case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS);
4593  }
4594 }
4595 
4596 /// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind.
4597 bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) {
4598  if (Opc == Instruction::FCmp) {
4599  switch (Lex.getKind()) {
4600  default: return TokError("expected fcmp predicate (e.g. 'oeq')");
4601  case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
4602  case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
4603  case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
4604  case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break;
4605  case lltok::kw_ole: P = CmpInst::FCMP_OLE; break;
4606  case lltok::kw_oge: P = CmpInst::FCMP_OGE; break;
4607  case lltok::kw_ord: P = CmpInst::FCMP_ORD; break;
4608  case lltok::kw_uno: P = CmpInst::FCMP_UNO; break;
4609  case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break;
4610  case lltok::kw_une: P = CmpInst::FCMP_UNE; break;
4611  case lltok::kw_ult: P = CmpInst::FCMP_ULT; break;
4612  case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break;
4613  case lltok::kw_ule: P = CmpInst::FCMP_ULE; break;
4614  case lltok::kw_uge: P = CmpInst::FCMP_UGE; break;
4615  case lltok::kw_true: P = CmpInst::FCMP_TRUE; break;
4616  case lltok::kw_false: P = CmpInst::FCMP_FALSE; break;
4617  }
4618  } else {
4619  switch (Lex.getKind()) {
4620  default: return TokError("expected icmp predicate (e.g. 'eq')");
4621  case lltok::kw_eq: P = CmpInst::ICMP_EQ; break;
4622  case lltok::kw_ne: P = CmpInst::ICMP_NE; break;
4623  case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
4624  case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break;
4625  case lltok::kw_sle: P = CmpInst::ICMP_SLE; break;
4626  case lltok::kw_sge: P = CmpInst::ICMP_SGE; break;
4627  case lltok::kw_ult: P = CmpInst::ICMP_ULT; break;
4628  case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break;
4629  case lltok::kw_ule: P = CmpInst::ICMP_ULE; break;
4630  case lltok::kw_uge: P = CmpInst::ICMP_UGE; break;
4631  }
4632  }
4633  Lex.Lex();
4634  return false;
4635 }
4636 
4637 //===----------------------------------------------------------------------===//
4638 // Terminator Instructions.
4639 //===----------------------------------------------------------------------===//
4640 
4641 /// ParseRet - Parse a return instruction.
4642 /// ::= 'ret' void (',' !dbg, !1)*
4643 /// ::= 'ret' TypeAndValue (',' !dbg, !1)*
4644 bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB,
4645  PerFunctionState &PFS) {
4646  SMLoc TypeLoc = Lex.getLoc();
4647  Type *Ty = nullptr;
4648  if (ParseType(Ty, true /*void allowed*/)) return true;
4649 
4650  Type *ResType = PFS.getFunction().getReturnType();
4651 
4652  if (Ty->isVoidTy()) {
4653  if (!ResType->isVoidTy())
4654  return Error(TypeLoc, "value doesn't match function result type '" +
4655  getTypeString(ResType) + "'");
4656 
4657  Inst = ReturnInst::Create(Context);
4658  return false;
4659  }
4660 
4661  Value *RV;
4662  if (ParseValue(Ty, RV, PFS)) return true;
4663 
4664  if (ResType != RV->getType())
4665  return Error(TypeLoc, "value doesn't match function result type '" +
4666  getTypeString(ResType) + "'");
4667 
4668  Inst = ReturnInst::Create(Context, RV);
4669  return false;
4670 }
4671 
4672 
4673 /// ParseBr
4674 /// ::= 'br' TypeAndValue
4675 /// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue
4676 bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) {
4677  LocTy Loc, Loc2;
4678  Value *Op0;
4679  BasicBlock *Op1, *Op2;
4680  if (ParseTypeAndValue(Op0, Loc, PFS)) return true;
4681 
4682  if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) {
4683  Inst = BranchInst::Create(BB);
4684  return false;
4685  }
4686 
4687  if (Op0->getType() != Type::getInt1Ty(Context))
4688  return Error(Loc, "branch condition must have 'i1' type");
4689 
4690  if (ParseToken(lltok::comma, "expected ',' after branch condition") ||
4691  ParseTypeAndBasicBlock(Op1, Loc, PFS) ||
4692  ParseToken(lltok::comma, "expected ',' after true destination") ||
4693  ParseTypeAndBasicBlock(Op2, Loc2, PFS))
4694  return true;
4695 
4696  Inst = BranchInst::Create(Op1, Op2, Op0);
4697  return false;
4698 }
4699 
4700 /// ParseSwitch
4701 /// Instruction
4702 /// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']'
4703 /// JumpTable
4704 /// ::= (TypeAndValue ',' TypeAndValue)*
4705 bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
4706  LocTy CondLoc, BBLoc;
4707  Value *Cond;
4708  BasicBlock *DefaultBB;
4709  if (ParseTypeAndValue(Cond, CondLoc, PFS) ||
4710  ParseToken(lltok::comma, "expected ',' after switch condition") ||
4711  ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
4712  ParseToken(lltok::lsquare, "expected '[' with switch table"))
4713  return true;
4714 
4715  if (!Cond->getType()->isIntegerTy())
4716  return Error(CondLoc, "switch condition must have integer type");
4717 
4718  // Parse the jump table pairs.
4719  SmallPtrSet<Value*, 32> SeenCases;
4721  while (Lex.getKind() != lltok::rsquare) {
4722  Value *Constant;
4723  BasicBlock *DestBB;
4724 
4725  if (ParseTypeAndValue(Constant, CondLoc, PFS) ||
4726  ParseToken(lltok::comma, "expected ',' after case value") ||
4727  ParseTypeAndBasicBlock(DestBB, PFS))
4728  return true;
4729 
4730  if (!SeenCases.insert(Constant).second)
4731  return Error(CondLoc, "duplicate case value in switch");
4732  if (!isa<ConstantInt>(Constant))
4733  return Error(CondLoc, "case value is not a constant integer");
4734 
4735  Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
4736  }
4737 
4738  Lex.Lex(); // Eat the ']'.
4739 
4740  SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size());
4741  for (unsigned i = 0, e = Table.size(); i != e; ++i)
4742  SI->addCase(Table[i].first, Table[i].second);
4743  Inst = SI;
4744  return false;
4745 }
4746 
4747 /// ParseIndirectBr
4748 /// Instruction
4749 /// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']'
4750 bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
4751  LocTy AddrLoc;
4752  Value *Address;
4753  if (ParseTypeAndValue(Address, AddrLoc, PFS) ||
4754  ParseToken(lltok::comma, "expected ',' after indirectbr address") ||
4755  ParseToken(lltok::lsquare, "expected '[' with indirectbr"))
4756  return true;
4757 
4758  if (!Address->getType()->isPointerTy())
4759  return Error(AddrLoc, "indirectbr address must have pointer type");
4760 
4761  // Parse the destination list.
4763 
4764  if (Lex.getKind() != lltok::rsquare) {
4765  BasicBlock *DestBB;
4766  if (ParseTypeAndBasicBlock(DestBB, PFS))
4767  return true;
4768  DestList.push_back(DestBB);
4769 
4770  while (EatIfPresent(lltok::comma)) {
4771  if (ParseTypeAndBasicBlock(DestBB, PFS))
4772  return true;
4773  DestList.push_back(DestBB);
4774  }
4775  }
4776 
4777  if (ParseToken(lltok::rsquare, "expected ']' at end of block list"))
4778  return true;
4779 
4780  IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size());
4781  for (unsigned i = 0, e = DestList.size(); i != e; ++i)
4782  IBI->addDestination(DestList[i]);
4783  Inst = IBI;
4784  return false;
4785 }
4786 
4787 
4788 /// ParseInvoke
4789 /// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList
4790 /// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
4791 bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
4792  LocTy CallLoc = Lex.getLoc();
4793  AttrBuilder RetAttrs, FnAttrs;
4794  std::vector<unsigned> FwdRefAttrGrps;
4795  LocTy NoBuiltinLoc;
4796  unsigned CC;
4797  Type *RetType = nullptr;
4798  LocTy RetTypeLoc;
4799  ValID CalleeID;
4801 
4802  BasicBlock *NormalBB, *UnwindBB;
4803  if (ParseOptionalCallingConv(CC) ||
4804  ParseOptionalReturnAttrs(RetAttrs) ||
4805  ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
4806  ParseValID(CalleeID) ||
4807  ParseParameterList(ArgList, PFS) ||
4808  ParseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false,
4809  NoBuiltinLoc) ||
4810  ParseToken(lltok::kw_to, "expected 'to' in invoke") ||
4811  ParseTypeAndBasicBlock(NormalBB, PFS) ||
4812  ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") ||
4813  ParseTypeAndBasicBlock(UnwindBB, PFS))
4814  return true;
4815 
4816  // If RetType is a non-function pointer type, then this is the short syntax
4817  // for the call, which means that RetType is just the return type. Infer the
4818  // rest of the function argument types from the arguments that are present.
4819  FunctionType *Ty = dyn_cast<FunctionType>(RetType);
4820  if (!Ty) {
4821  // Pull out the types of all of the arguments...
4822  std::vector<Type*> ParamTypes;
4823  for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
4824  ParamTypes.push_back(ArgList[i].V->getType());
4825 
4826  if (!FunctionType::isValidReturnType(RetType))
4827  return Error(RetTypeLoc, "Invalid result type for LLVM function");
4828 
4829  Ty = FunctionType::get(RetType, ParamTypes, false);
4830  }
4831 
4832  // Look up the callee.
4833  Value *Callee;
4834  if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS))
4835  return true;
4836 
4837  // Set up the Attribute for the function.
4839  if (RetAttrs.hasAttributes())
4840  Attrs.push_back(AttributeSet::get(RetType->getContext(),
4842  RetAttrs));
4843 
4845 
4846  // Loop through FunctionType's arguments and ensure they are specified
4847  // correctly. Also, gather any parameter attributes.
4850  for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
4851  Type *ExpectedTy = nullptr;
4852  if (I != E) {
4853  ExpectedTy = *I++;
4854  } else if (!Ty->isVarArg()) {
4855  return Error(ArgList[i].Loc, "too many arguments specified");
4856  }
4857 
4858  if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
4859  return Error(ArgList[i].Loc, "argument is not of expected type '" +
4860  getTypeString(ExpectedTy) + "'");
4861  Args.push_back(ArgList[i].V);
4862  if (ArgList[i].Attrs.hasAttributes(i + 1)) {
4863  AttrBuilder B(ArgList[i].Attrs, i + 1);
4864  Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B));
4865  }
4866  }
4867 
4868  if (I != E)
4869  return Error(CallLoc, "not enough parameters specified for call");
4870 
4871  if (FnAttrs.hasAttributes()) {
4872  if (FnAttrs.hasAlignmentAttr())
4873  return Error(CallLoc, "invoke instructions may not have an alignment");
4874 
4875  Attrs.push_back(AttributeSet::get(RetType->getContext(),
4877  FnAttrs));
4878  }
4879 
4880  // Finish off the Attribute and check them
4881  AttributeSet PAL = AttributeSet::get(Context, Attrs);
4882 
4883  InvokeInst *II = InvokeInst::Create(Ty, Callee, NormalBB, UnwindBB, Args);
4884  II->setCallingConv(CC);
4885  II->setAttributes(PAL);
4886  ForwardRefAttrGroups[II] = FwdRefAttrGrps;
4887  Inst = II;
4888  return false;
4889 }
4890 
4891 /// ParseResume
4892 /// ::= 'resume' TypeAndValue
4893 bool LLParser::ParseResume(Instruction *&Inst, PerFunctionState &PFS) {
4894  Value *Exn; LocTy ExnLoc;
4895  if (ParseTypeAndValue(Exn, ExnLoc, PFS))
4896  return true;
4897 
4898  ResumeInst *RI = ResumeInst::Create(Exn);
4899  Inst = RI;
4900  return false;
4901 }
4902 
4903 //===----------------------------------------------------------------------===//
4904 // Binary Operators.
4905 //===----------------------------------------------------------------------===//
4906 
4907 /// ParseArithmetic
4908 /// ::= ArithmeticOps TypeAndValue ',' Value
4909 ///
4910 /// If OperandType is 0, then any FP or integer operand is allowed. If it is 1,
4911 /// then any integer operand is allowed, if it is 2, any fp operand is allowed.
4912 bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
4913  unsigned Opc, unsigned OperandType) {
4914  LocTy Loc; Value *LHS, *RHS;
4915  if (ParseTypeAndValue(LHS, Loc, PFS) ||
4916  ParseToken(lltok::comma, "expected ',' in arithmetic operation") ||
4917  ParseValue(LHS->getType(), RHS, PFS))
4918  return true;
4919 
4920  bool Valid;
4921  switch (OperandType) {
4922  default: llvm_unreachable("Unknown operand type!");
4923  case 0: // int or FP.
4924  Valid = LHS->getType()->isIntOrIntVectorTy() ||
4925  LHS->getType()->isFPOrFPVectorTy();
4926  break;
4927  case 1: Valid = LHS->getType()->isIntOrIntVectorTy(); break;
4928  case 2: Valid = LHS->getType()->isFPOrFPVectorTy(); break;
4929  }
4930 
4931  if (!Valid)
4932  return Error(Loc, "invalid operand type for instruction");
4933 
4934  Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
4935  return false;
4936 }
4937 
4938 /// ParseLogical
4939 /// ::= ArithmeticOps TypeAndValue ',' Value {
4940 bool LLParser::ParseLogical(Instruction *&Inst, PerFunctionState &PFS,
4941  unsigned Opc) {
4942  LocTy Loc; Value *LHS, *RHS;
4943  if (ParseTypeAndValue(LHS, Loc, PFS) ||
4944  ParseToken(lltok::comma, "expected ',' in logical operation") ||
4945  ParseValue(LHS->getType(), RHS, PFS))
4946  return true;
4947 
4948  if (!LHS->getType()->isIntOrIntVectorTy())
4949  return Error(Loc,"instruction requires integer or integer vector operands");
4950 
4951  Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
4952  return false;
4953 }
4954 
4955 
4956 /// ParseCompare
4957 /// ::= 'icmp' IPredicates TypeAndValue ',' Value
4958 /// ::= 'fcmp' FPredicates TypeAndValue ',' Value
4959 bool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS,
4960  unsigned Opc) {
4961  // Parse the integer/fp comparison predicate.
4962  LocTy Loc;
4963  unsigned Pred;
4964  Value *LHS, *RHS;
4965  if (ParseCmpPredicate(Pred, Opc) ||
4966  ParseTypeAndValue(LHS, Loc, PFS) ||
4967  ParseToken(lltok::comma, "expected ',' after compare value") ||
4968  ParseValue(LHS->getType(), RHS, PFS))
4969  return true;
4970 
4971  if (Opc == Instruction::FCmp) {
4972  if (!LHS->getType()->isFPOrFPVectorTy())
4973  return Error(Loc, "fcmp requires floating point operands");
4974  Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS);
4975  } else {
4976  assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!");
4977  if (!LHS->getType()->isIntOrIntVectorTy() &&
4978  !LHS->getType()->getScalarType()->isPointerTy())
4979  return Error(Loc, "icmp requires integer operands");
4980  Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS);
4981  }
4982  return false;
4983 }
4984 
4985 //===----------------------------------------------------------------------===//
4986 // Other Instructions.
4987 //===----------------------------------------------------------------------===//
4988 
4989 
4990 /// ParseCast
4991 /// ::= CastOpc TypeAndValue 'to' Type
4992 bool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS,
4993  unsigned Opc) {
4994  LocTy Loc;
4995  Value *Op;
4996  Type *DestTy = nullptr;
4997  if (ParseTypeAndValue(Op, Loc, PFS) ||
4998  ParseToken(lltok::kw_to, "expected 'to' after cast value") ||
4999  ParseType(DestTy))
5000  return true;
5001 
5002  if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) {
5003  CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy);
5004  return Error(Loc, "invalid cast opcode for cast from '" +
5005  getTypeString(Op->getType()) + "' to '" +
5006  getTypeString(DestTy) + "'");
5007  }
5008  Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy);
5009  return false;
5010 }
5011 
5012 /// ParseSelect
5013 /// ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue
5014 bool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) {
5015  LocTy Loc;
5016  Value *Op0, *Op1, *Op2;
5017  if (ParseTypeAndValue(Op0, Loc, PFS) ||
5018  ParseToken(lltok::comma, "expected ',' after select condition") ||
5019  ParseTypeAndValue(Op1, PFS) ||
5020  ParseToken(lltok::comma, "expected ',' after select value") ||
5021  ParseTypeAndValue(Op2, PFS))
5022  return true;
5023 
5024  if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2))
5025  return Error(Loc, Reason);
5026 
5027  Inst = SelectInst::Create(Op0, Op1, Op2);
5028  return false;
5029 }
5030 
5031 /// ParseVA_Arg
5032 /// ::= 'va_arg' TypeAndValue ',' Type
5033 bool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) {
5034  Value *Op;
5035  Type *EltTy = nullptr;
5036  LocTy TypeLoc;
5037  if (ParseTypeAndValue(Op, PFS) ||
5038  ParseToken(lltok::comma, "expected ',' after vaarg operand") ||
5039  ParseType(EltTy, TypeLoc))
5040  return true;
5041 
5042  if (!EltTy->isFirstClassType())
5043  return Error(TypeLoc, "va_arg requires operand with first class type");
5044 
5045  Inst = new VAArgInst(Op, EltTy);
5046  return false;
5047 }
5048 
5049 /// ParseExtractElement
5050 /// ::= 'extractelement' TypeAndValue ',' TypeAndValue
5051 bool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) {
5052  LocTy Loc;
5053  Value *Op0, *Op1;
5054  if (ParseTypeAndValue(Op0, Loc, PFS) ||
5055  ParseToken(lltok::comma, "expected ',' after extract value") ||
5056  ParseTypeAndValue(Op1, PFS))
5057  return true;
5058 
5059  if (!ExtractElementInst::isValidOperands(Op0, Op1))
5060  return Error(Loc, "invalid extractelement operands");
5061 
5062  Inst = ExtractElementInst::Create(Op0, Op1);
5063  return false;
5064 }
5065 
5066 /// ParseInsertElement
5067 /// ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue
5068 bool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) {
5069  LocTy Loc;
5070  Value *Op0, *Op1, *Op2;
5071  if (ParseTypeAndValue(Op0, Loc, PFS) ||
5072  ParseToken(lltok::comma, "expected ',' after insertelement value") ||
5073  ParseTypeAndValue(Op1, PFS) ||
5074  ParseToken(lltok::comma, "expected ',' after insertelement value") ||
5075  ParseTypeAndValue(Op2, PFS))
5076  return true;
5077 
5078  if (!InsertElementInst::isValidOperands(Op0, Op1, Op2))
5079  return Error(Loc, "invalid insertelement operands");
5080 
5081  Inst = InsertElementInst::Create(Op0, Op1, Op2);
5082  return false;
5083 }
5084 
5085 /// ParseShuffleVector
5086 /// ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue
5087 bool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) {
5088  LocTy Loc;
5089  Value *Op0, *Op1, *Op2;
5090  if (ParseTypeAndValue(Op0, Loc, PFS) ||
5091  ParseToken(lltok::comma, "expected ',' after shuffle mask") ||
5092  ParseTypeAndValue(Op1, PFS) ||
5093  ParseToken(lltok::comma, "expected ',' after shuffle value") ||
5094  ParseTypeAndValue(Op2, PFS))
5095  return true;
5096 
5097  if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2))
5098  return Error(Loc, "invalid shufflevector operands");
5099 
5100  Inst = new ShuffleVectorInst(Op0, Op1, Op2);
5101  return false;
5102 }
5103 
5104 /// ParsePHI
5105 /// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')*
5106 int LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) {
5107  Type *Ty = nullptr; LocTy TypeLoc;
5108  Value *Op0, *Op1;
5109 
5110  if (ParseType(Ty, TypeLoc) ||
5111  ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
5112  ParseValue(Ty, Op0, PFS) ||
5113  ParseToken(lltok::comma, "expected ',' after insertelement value") ||
5114  ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
5115  ParseToken(lltok::rsquare, "expected ']' in phi value list"))
5116  return true;
5117 
5118  bool AteExtraComma = false;
5120  while (1) {
5121  PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1)));
5122 
5123  if (!EatIfPresent(lltok::comma))
5124  break;
5125 
5126  if (Lex.getKind() == lltok::MetadataVar) {
5127  AteExtraComma = true;
5128  break;
5129  }
5130 
5131  if (ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
5132  ParseValue(Ty, Op0, PFS) ||
5133  ParseToken(lltok::comma, "expected ',' after insertelement value") ||
5134  ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
5135  ParseToken(lltok::rsquare, "expected ']' in phi value list"))
5136  return true;
5137  }
5138 
5139  if (!Ty->isFirstClassType())
5140  return Error(TypeLoc, "phi node must have first class type");
5141 
5142  PHINode *PN = PHINode::Create(Ty, PHIVals.size());
5143  for (unsigned i = 0, e = PHIVals.size(); i != e; ++i)
5144  PN->addIncoming(PHIVals[i].first, PHIVals[i].second);
5145  Inst = PN;
5146  return AteExtraComma ? InstExtraComma : InstNormal;
5147 }
5148 
5149 /// ParseLandingPad
5150 /// ::= 'landingpad' Type 'personality' TypeAndValue 'cleanup'? Clause+
5151 /// Clause
5152 /// ::= 'catch' TypeAndValue
5153 /// ::= 'filter'
5154 /// ::= 'filter' TypeAndValue ( ',' TypeAndValue )*
5155 bool LLParser::ParseLandingPad(Instruction *&Inst, PerFunctionState &PFS) {
5156  Type *Ty = nullptr; LocTy TyLoc;
5157 
5158  if (ParseType(Ty, TyLoc))
5159  return true;
5160 
5161  std::unique_ptr<LandingPadInst> LP(LandingPadInst::Create(Ty, 0));
5162  LP->setCleanup(EatIfPresent(lltok::kw_cleanup));
5163 
5164  while (Lex.getKind() == lltok::kw_catch || Lex.getKind() == lltok::kw_filter){
5166  if (EatIfPresent(lltok::kw_catch))
5167  CT = LandingPadInst::Catch;
5168  else if (EatIfPresent(lltok::kw_filter))
5170  else
5171  return TokError("expected 'catch' or 'filter' clause type");
5172 
5173  Value *V;
5174  LocTy VLoc;
5175  if (ParseTypeAndValue(V, VLoc, PFS))
5176  return true;
5177 
5178  // A 'catch' type expects a non-array constant. A filter clause expects an
5179  // array constant.
5180  if (CT == LandingPadInst::Catch) {
5181  if (isa<ArrayType>(V->getType()))
5182  Error(VLoc, "'catch' clause has an invalid type");
5183  } else {
5184  if (!isa<ArrayType>(V->getType()))
5185  Error(VLoc, "'filter' clause has an invalid type");
5186  }
5187 
5188  Constant *CV = dyn_cast<Constant>(V);
5189  if (!CV)
5190  return Error(VLoc, "clause argument must be a constant");
5191  LP->addClause(CV);
5192  }
5193 
5194  Inst = LP.release();
5195  return false;
5196 }
5197 
5198 /// ParseCall
5199 /// ::= 'call' OptionalCallingConv OptionalAttrs Type Value
5200 /// ParameterList OptionalAttrs
5201 /// ::= 'tail' 'call' OptionalCallingConv OptionalAttrs Type Value
5202 /// ParameterList OptionalAttrs
5203 /// ::= 'musttail' 'call' OptionalCallingConv OptionalAttrs Type Value
5204 /// ParameterList OptionalAttrs
5205 bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
5206  CallInst::TailCallKind TCK) {
5207  AttrBuilder RetAttrs, FnAttrs;
5208  std::vector<unsigned> FwdRefAttrGrps;
5209  LocTy BuiltinLoc;
5210  unsigned CC;
5211  Type *RetType = nullptr;
5212  LocTy RetTypeLoc;
5213  ValID CalleeID;
5215  LocTy CallLoc = Lex.getLoc();
5216 
5217  if ((TCK != CallInst::TCK_None &&
5218  ParseToken(lltok::kw_call, "expected 'tail call'")) ||
5219  ParseOptionalCallingConv(CC) ||
5220  ParseOptionalReturnAttrs(RetAttrs) ||
5221  ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
5222  ParseValID(CalleeID) ||
5223  ParseParameterList(ArgList, PFS, TCK == CallInst::TCK_MustTail,
5224  PFS.getFunction().isVarArg()) ||
5225  ParseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false,
5226  BuiltinLoc))
5227  return true;
5228 
5229  // If RetType is a non-function pointer type, then this is the short syntax
5230  // for the call, which means that RetType is just the return type. Infer the
5231  // rest of the function argument types from the arguments that are present.
5232  FunctionType *Ty = dyn_cast<FunctionType>(RetType);
5233  if (!Ty) {
5234  // Pull out the types of all of the arguments...
5235  std::vector<Type*> ParamTypes;
5236  for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
5237  ParamTypes.push_back(ArgList[i].V->getType());
5238 
5239  if (!FunctionType::isValidReturnType(RetType))
5240  return Error(RetTypeLoc, "Invalid result type for LLVM function");
5241 
5242  Ty = FunctionType::get(RetType, ParamTypes, false);
5243  }
5244 
5245  // Look up the callee.
5246  Value *Callee;
5247  if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS))
5248  return true;
5249 
5250  // Set up the Attribute for the function.
5252  if (RetAttrs.hasAttributes())
5253  Attrs.push_back(AttributeSet::get(RetType->getContext(),
5255  RetAttrs));
5256 
5258 
5259  // Loop through FunctionType's arguments and ensure they are specified
5260  // correctly. Also, gather any parameter attributes.
5263  for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
5264  Type *ExpectedTy = nullptr;
5265  if (I != E) {
5266  ExpectedTy = *I++;
5267  } else if (!Ty->isVarArg()) {
5268  return Error(ArgList[i].Loc, "too many arguments specified");
5269  }
5270 
5271  if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
5272  return Error(ArgList[i].Loc, "argument is not of expected type '" +
5273  getTypeString(ExpectedTy) + "'");
5274  Args.push_back(ArgList[i].V);
5275  if (ArgList[i].Attrs.hasAttributes(i + 1)) {
5276  AttrBuilder B(ArgList[i].Attrs, i + 1);
5277  Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B));
5278  }
5279  }
5280 
5281  if (I != E)
5282  return Error(CallLoc, "not enough parameters specified for call");
5283 
5284  if (FnAttrs.hasAttributes()) {
5285  if (FnAttrs.hasAlignmentAttr())
5286  return Error(CallLoc, "call instructions may not have an alignment");
5287 
5288  Attrs.push_back(AttributeSet::get(RetType->getContext(),
5290  FnAttrs));
5291  }
5292 
5293  // Finish off the Attribute and check them
5294  AttributeSet PAL = AttributeSet::get(Context, Attrs);
5295 
5296  CallInst *CI = CallInst::Create(Ty, Callee, Args);
5297  CI->setTailCallKind(TCK);
5298  CI->setCallingConv(CC);
5299  CI->setAttributes(PAL);
5300  ForwardRefAttrGroups[CI] = FwdRefAttrGrps;
5301  Inst = CI;
5302  return false;
5303 }
5304 
5305 //===----------------------------------------------------------------------===//
5306 // Memory Instructions.
5307 //===----------------------------------------------------------------------===//
5308 
5309 /// ParseAlloc
5310 /// ::= 'alloca' 'inalloca'? Type (',' TypeAndValue)? (',' 'align' i32)?
5311 int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
5312  Value *Size = nullptr;
5313  LocTy SizeLoc, TyLoc;
5314  unsigned Alignment = 0;
5315  Type *Ty = nullptr;
5316 
5317  bool IsInAlloca = EatIfPresent(lltok::kw_inalloca);
5318 
5319  if (ParseType(Ty, TyLoc)) return true;
5320 
5322  return Error(TyLoc, "invalid type for alloca");
5323 
5324  bool AteExtraComma = false;
5325  if (EatIfPresent(lltok::comma)) {
5326  if (Lex.getKind() == lltok::kw_align) {
5327  if (ParseOptionalAlignment(Alignment)) return true;
5328  } else if (Lex.getKind() == lltok::MetadataVar) {
5329  AteExtraComma = true;
5330  } else {
5331  if (ParseTypeAndValue(Size, SizeLoc, PFS) ||
5332  ParseOptionalCommaAlign(Alignment, AteExtraComma))
5333  return true;
5334  }
5335  }
5336 
5337  if (Size && !Size->getType()->isIntegerTy())
5338  return Error(SizeLoc, "element count must have integer type");
5339 
5340  AllocaInst *AI = new AllocaInst(Ty, Size, Alignment);
5341  AI->setUsedWithInAlloca(IsInAlloca);
5342  Inst = AI;
5343  return AteExtraComma ? InstExtraComma : InstNormal;
5344 }
5345 
5346 /// ParseLoad
5347 /// ::= 'load' 'volatile'? TypeAndValue (',' 'align' i32)?
5348 /// ::= 'load' 'atomic' 'volatile'? TypeAndValue
5349 /// 'singlethread'? AtomicOrdering (',' 'align' i32)?
5350 int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS) {
5351  Value *Val; LocTy Loc;
5352  unsigned Alignment = 0;
5353  bool AteExtraComma = false;
5354  bool isAtomic = false;
5355  AtomicOrdering Ordering = NotAtomic;
5357 
5358  if (Lex.getKind() == lltok::kw_atomic) {
5359  isAtomic = true;
5360  Lex.Lex();
5361  }
5362 
5363  bool isVolatile = false;
5364  if (Lex.getKind() == lltok::kw_volatile) {
5365  isVolatile = true;
5366  Lex.Lex();
5367  }
5368 
5369  Type *Ty;
5370  LocTy ExplicitTypeLoc = Lex.getLoc();
5371  if (ParseType(Ty) ||
5372  ParseToken(lltok::comma, "expected comma after load's type") ||
5373  ParseTypeAndValue(Val, Loc, PFS) ||
5374  ParseScopeAndOrdering(isAtomic, Scope, Ordering) ||
5375  ParseOptionalCommaAlign(Alignment, AteExtraComma))
5376  return true;
5377 
5378  if (!Val->getType()->isPointerTy() || !Ty->isFirstClassType())
5379  return Error(Loc, "load operand must be a pointer to a first class type");
5380  if (isAtomic && !Alignment)
5381  return Error(Loc, "atomic load must have explicit non-zero alignment");
5382  if (Ordering == Release || Ordering == AcquireRelease)
5383  return Error(Loc, "atomic load cannot use Release ordering");
5384 
5385  if (Ty != cast<PointerType>(Val->getType())->getElementType())
5386  return Error(ExplicitTypeLoc,
5387  "explicit pointee type doesn't match operand's pointee type");
5388 
5389  Inst = new LoadInst(Ty, Val, "", isVolatile, Alignment, Ordering, Scope);
5390  return AteExtraComma ? InstExtraComma : InstNormal;
5391 }
5392 
5393 /// ParseStore
5394 
5395 /// ::= 'store' 'volatile'? TypeAndValue ',' TypeAndValue (',' 'align' i32)?
5396 /// ::= 'store' 'atomic' 'volatile'? TypeAndValue ',' TypeAndValue
5397 /// 'singlethread'? AtomicOrdering (',' 'align' i32)?
5398 int LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS) {
5399  Value *Val, *Ptr; LocTy Loc, PtrLoc;
5400  unsigned Alignment = 0;
5401  bool AteExtraComma = false;
5402  bool isAtomic = false;
5403  AtomicOrdering Ordering = NotAtomic;
5405 
5406  if (Lex.getKind() == lltok::kw_atomic) {
5407  isAtomic = true;
5408  Lex.Lex();
5409  }
5410 
5411  bool isVolatile = false;
5412  if (Lex.getKind() == lltok::kw_volatile) {
5413  isVolatile = true;
5414  Lex.Lex();
5415  }
5416 
5417  if (ParseTypeAndValue(Val, Loc, PFS) ||
5418  ParseToken(lltok::comma, "expected ',' after store operand") ||
5419  ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
5420  ParseScopeAndOrdering(isAtomic, Scope, Ordering) ||
5421  ParseOptionalCommaAlign(Alignment, AteExtraComma))
5422  return true;
5423 
5424  if (!Ptr->getType()->isPointerTy())
5425  return Error(PtrLoc, "store operand must be a pointer");
5426  if (!Val->getType()->isFirstClassType())
5427  return Error(Loc, "store operand must be a first class value");
5428  if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
5429  return Error(Loc, "stored value and pointer type do not match");
5430  if (isAtomic && !Alignment)
5431  return Error(Loc, "atomic store must have explicit non-zero alignment");
5432  if (Ordering == Acquire || Ordering == AcquireRelease)
5433  return Error(Loc, "atomic store cannot use Acquire ordering");
5434 
5435  Inst = new StoreInst(Val, Ptr, isVolatile, Alignment, Ordering, Scope);
5436  return AteExtraComma ? InstExtraComma : InstNormal;
5437 }
5438 
5439 /// ParseCmpXchg
5440 /// ::= 'cmpxchg' 'weak'? 'volatile'? TypeAndValue ',' TypeAndValue ','
5441 /// TypeAndValue 'singlethread'? AtomicOrdering AtomicOrdering
5442 int LLParser::ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
5443  Value *Ptr, *Cmp, *New; LocTy PtrLoc, CmpLoc, NewLoc;
5444  bool AteExtraComma = false;
5445  AtomicOrdering SuccessOrdering = NotAtomic;
5446  AtomicOrdering FailureOrdering = NotAtomic;
5448  bool isVolatile = false;
5449  bool isWeak = false;
5450 
5451  if (EatIfPresent(lltok::kw_weak))
5452  isWeak = true;
5453 
5454  if (EatIfPresent(lltok::kw_volatile))
5455  isVolatile = true;
5456 
5457  if (ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
5458  ParseToken(lltok::comma, "expected ',' after cmpxchg address") ||
5459  ParseTypeAndValue(Cmp, CmpLoc, PFS) ||
5460  ParseToken(lltok::comma, "expected ',' after cmpxchg cmp operand") ||
5461  ParseTypeAndValue(New, NewLoc, PFS) ||
5462  ParseScopeAndOrdering(true /*Always atomic*/, Scope, SuccessOrdering) ||
5463  ParseOrdering(FailureOrdering))
5464  return true;
5465 
5466  if (SuccessOrdering == Unordered || FailureOrdering == Unordered)
5467  return TokError("cmpxchg cannot be unordered");
5468  if (SuccessOrdering < FailureOrdering)
5469  return TokError("cmpxchg must be at least as ordered on success as failure");
5470  if (FailureOrdering == Release || FailureOrdering == AcquireRelease)
5471  return TokError("cmpxchg failure ordering cannot include release semantics");
5472  if (!Ptr->getType()->isPointerTy())
5473  return Error(PtrLoc, "cmpxchg operand must be a pointer");
5474  if (cast<PointerType>(Ptr->getType())->getElementType() != Cmp->getType())
5475  return Error(CmpLoc, "compare value and pointer type do not match");
5476  if (cast<PointerType>(Ptr->getType())->getElementType() != New->getType())
5477  return Error(NewLoc, "new value and pointer type do not match");
5478  if (!New->getType()->isIntegerTy())
5479  return Error(NewLoc, "cmpxchg operand must be an integer");
5480  unsigned Size = New->getType()->getPrimitiveSizeInBits();
5481  if (Size < 8 || (Size & (Size - 1)))
5482  return Error(NewLoc, "cmpxchg operand must be power-of-two byte-sized"
5483  " integer");
5484 
5486  Ptr, Cmp, New, SuccessOrdering, FailureOrdering, Scope);
5487  CXI->setVolatile(isVolatile);
5488  CXI->setWeak(isWeak);
5489  Inst = CXI;
5490  return AteExtraComma ? InstExtraComma : InstNormal;
5491 }
5492 
5493 /// ParseAtomicRMW
5494 /// ::= 'atomicrmw' 'volatile'? BinOp TypeAndValue ',' TypeAndValue
5495 /// 'singlethread'? AtomicOrdering
5496 int LLParser::ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
5497  Value *Ptr, *Val; LocTy PtrLoc, ValLoc;
5498  bool AteExtraComma = false;
5499  AtomicOrdering Ordering = NotAtomic;
5501  bool isVolatile = false;
5502  AtomicRMWInst::BinOp Operation;
5503 
5504  if (EatIfPresent(lltok::kw_volatile))
5505  isVolatile = true;
5506 
5507  switch (Lex.getKind()) {
5508  default: return TokError("expected binary operation in atomicrmw");
5509  case lltok::kw_xchg: Operation = AtomicRMWInst::Xchg; break;
5510  case lltok::kw_add: Operation = AtomicRMWInst::Add; break;
5511  case lltok::kw_sub: Operation = AtomicRMWInst::Sub; break;
5512  case lltok::kw_and: Operation = AtomicRMWInst::And; break;
5513  case lltok::kw_nand: Operation = AtomicRMWInst::Nand; break;
5514  case lltok::kw_or: Operation = AtomicRMWInst::Or; break;
5515  case lltok::kw_xor: Operation = AtomicRMWInst::Xor; break;
5516  case lltok::kw_max: Operation = AtomicRMWInst::Max; break;
5517  case lltok::kw_min: Operation = AtomicRMWInst::Min; break;
5518  case lltok::kw_umax: Operation = AtomicRMWInst::UMax; break;
5519  case lltok::kw_umin: Operation = AtomicRMWInst::UMin; break;
5520  }
5521  Lex.Lex(); // Eat the operation.
5522 
5523  if (ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
5524  ParseToken(lltok::comma, "expected ',' after atomicrmw address") ||
5525  ParseTypeAndValue(Val, ValLoc, PFS) ||
5526  ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
5527  return true;
5528 
5529  if (Ordering == Unordered)
5530  return TokError("atomicrmw cannot be unordered");
5531  if (!Ptr->getType()->isPointerTy())
5532  return Error(PtrLoc, "atomicrmw operand must be a pointer");
5533  if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
5534  return Error(ValLoc, "atomicrmw value and pointer type do not match");
5535  if (!Val->getType()->isIntegerTy())
5536  return Error(ValLoc, "atomicrmw operand must be an integer");
5537  unsigned Size = Val->getType()->getPrimitiveSizeInBits();
5538  if (Size < 8 || (Size & (Size - 1)))
5539  return Error(ValLoc, "atomicrmw operand must be power-of-two byte-sized"
5540  " integer");
5541 
5542  AtomicRMWInst *RMWI =
5543  new AtomicRMWInst(Operation, Ptr, Val, Ordering, Scope);
5544  RMWI->setVolatile(isVolatile);
5545  Inst = RMWI;
5546  return AteExtraComma ? InstExtraComma : InstNormal;
5547 }
5548 
5549 /// ParseFence
5550 /// ::= 'fence' 'singlethread'? AtomicOrdering
5551 int LLParser::ParseFence(Instruction *&Inst, PerFunctionState &PFS) {
5552  AtomicOrdering Ordering = NotAtomic;
5554  if (ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
5555  return true;
5556 
5557  if (Ordering == Unordered)
5558  return TokError("fence cannot be unordered");
5559  if (Ordering == Monotonic)
5560  return TokError("fence cannot be monotonic");
5561 
5562  Inst = new FenceInst(Context, Ordering, Scope);
5563  return InstNormal;
5564 }
5565 
5566 /// ParseGetElementPtr
5567 /// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)*
5568 int LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
5569  Value *Ptr = nullptr;
5570  Value *Val = nullptr;
5571  LocTy Loc, EltLoc;
5572 
5573  bool InBounds = EatIfPresent(lltok::kw_inbounds);
5574 
5575  Type *Ty = nullptr;
5576  LocTy ExplicitTypeLoc = Lex.getLoc();
5577  if (ParseType(Ty) ||
5578  ParseToken(lltok::comma, "expected comma after getelementptr's type") ||
5579  ParseTypeAndValue(Ptr, Loc, PFS))
5580  return true;
5581 
5582  Type *BaseType = Ptr->getType();
5583  PointerType *BasePointerType = dyn_cast<PointerType>(BaseType->getScalarType());
5584  if (!BasePointerType)
5585  return Error(Loc, "base of getelementptr must be a pointer");
5586 
5587  if (Ty != BasePointerType->getElementType())
5588  return Error(ExplicitTypeLoc,
5589  "explicit pointee type doesn't match operand's pointee type");
5590 
5591  SmallVector<Value*, 16> Indices;
5592  bool AteExtraComma = false;
5593  // GEP returns a vector of pointers if at least one of parameters is a vector.
5594  // All vector parameters should have the same vector width.
5595  unsigned GEPWidth = BaseType->isVectorTy() ?
5596  BaseType->getVectorNumElements() : 0;
5597 
5598  while (EatIfPresent(lltok::comma)) {
5599  if (Lex.getKind() == lltok::MetadataVar) {
5600  AteExtraComma = true;
5601  break;
5602  }
5603  if (ParseTypeAndValue(Val, EltLoc, PFS)) return true;
5604  if (!Val->getType()->getScalarType()->isIntegerTy())
5605  return Error(EltLoc, "getelementptr index must be an integer");
5606 
5607  if (Val->getType()->isVectorTy()) {
5608  unsigned ValNumEl = Val->getType()->getVectorNumElements();
5609  if (GEPWidth && GEPWidth != ValNumEl)
5610  return Error(EltLoc,
5611  "getelementptr vector index has a wrong number of elements");
5612  GEPWidth = ValNumEl;
5613  }
5614  Indices.push_back(Val);
5615  }
5616 
5618  if (!Indices.empty() && !Ty->isSized(&Visited))
5619  return Error(Loc, "base element of getelementptr must be sized");
5620 
5621  if (!GetElementPtrInst::getIndexedType(Ty, Indices))
5622  return Error(Loc, "invalid getelementptr indices");
5623  Inst = GetElementPtrInst::Create(Ty, Ptr, Indices);
5624  if (InBounds)
5625  cast<GetElementPtrInst>(Inst)->setIsInBounds(true);
5626  return AteExtraComma ? InstExtraComma : InstNormal;
5627 }
5628 
5629 /// ParseExtractValue
5630 /// ::= 'extractvalue' TypeAndValue (',' uint32)+
5631 int LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
5632  Value *Val; LocTy Loc;
5633  SmallVector<unsigned, 4> Indices;
5634  bool AteExtraComma;
5635  if (ParseTypeAndValue(Val, Loc, PFS) ||
5636  ParseIndexList(Indices, AteExtraComma))
5637  return true;
5638 
5639  if (!Val->getType()->isAggregateType())
5640  return Error(Loc, "extractvalue operand must be aggregate type");
5641 
5642  if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
5643  return Error(Loc, "invalid indices for extractvalue");
5644  Inst = ExtractValueInst::Create(Val, Indices);
5645  return AteExtraComma ? InstExtraComma : InstNormal;
5646 }
5647 
5648 /// ParseInsertValue
5649 /// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+
5650 int LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
5651  Value *Val0, *Val1; LocTy Loc0, Loc1;
5652  SmallVector<unsigned, 4> Indices;
5653  bool AteExtraComma;
5654  if (ParseTypeAndValue(Val0, Loc0, PFS) ||
5655  ParseToken(lltok::comma, "expected comma after insertvalue operand") ||
5656  ParseTypeAndValue(Val1, Loc1, PFS) ||
5657  ParseIndexList(Indices, AteExtraComma))
5658  return true;
5659 
5660  if (!Val0->getType()->isAggregateType())
5661  return Error(Loc0, "insertvalue operand must be aggregate type");
5662 
5663  Type *IndexedType = ExtractValueInst::getIndexedType(Val0->getType(), Indices);
5664  if (!IndexedType)
5665  return Error(Loc0, "invalid indices for insertvalue");
5666  if (IndexedType != Val1->getType())
5667  return Error(Loc1, "insertvalue operand and field disagree in type: '" +
5668  getTypeString(Val1->getType()) + "' instead of '" +
5669  getTypeString(IndexedType) + "'");
5670  Inst = InsertValueInst::Create(Val0, Val1, Indices);
5671  return AteExtraComma ? InstExtraComma : InstNormal;
5672 }
5673 
5674 //===----------------------------------------------------------------------===//
5675 // Embedded metadata.
5676 //===----------------------------------------------------------------------===//
5677 
5678 /// ParseMDNodeVector
5679 /// ::= { Element (',' Element)* }
5680 /// Element
5681 /// ::= 'null' | TypeAndValue
5682 bool LLParser::ParseMDNodeVector(SmallVectorImpl<Metadata *> &Elts) {
5683  if (ParseToken(lltok::lbrace, "expected '{' here"))
5684  return true;
5685 
5686  // Check for an empty list.
5687  if (EatIfPresent(lltok::rbrace))
5688  return false;
5689 
5690  do {
5691  // Null is a special case since it is typeless.
5692  if (EatIfPresent(lltok::kw_null)) {
5693  Elts.push_back(nullptr);
5694  continue;
5695  }
5696 
5697  Metadata *MD;
5698  if (ParseMetadata(MD, nullptr))
5699  return true;
5700  Elts.push_back(MD);
5701  } while (EatIfPresent(lltok::comma));
5702 
5703  return ParseToken(lltok::rbrace, "expected end of metadata node");
5704 }
5705 
5706 //===----------------------------------------------------------------------===//
5707 // Use-list order directives.
5708 //===----------------------------------------------------------------------===//
5709 bool LLParser::sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes,
5710  SMLoc Loc) {
5711  if (V->use_empty())
5712  return Error(Loc, "value has no uses");
5713 
5714  unsigned NumUses = 0;
5716  for (const Use &U : V->uses()) {
5717  if (++NumUses > Indexes.size())
5718  break;
5719  Order[&U] = Indexes[NumUses - 1];
5720  }
5721  if (NumUses < 2)
5722  return Error(Loc, "value only has one use");
5723  if (Order.size() != Indexes.size() || NumUses > Indexes.size())
5724  return Error(Loc, "wrong number of indexes, expected " +
5725  Twine(std::distance(V->use_begin(), V->use_end())));
5726 
5727  V->sortUseList([&](const Use &L, const Use &R) {
5728  return Order.lookup(&L) < Order.lookup(&R);
5729  });
5730  return false;
5731 }
5732 
5733 /// ParseUseListOrderIndexes
5734 /// ::= '{' uint32 (',' uint32)+ '}'
5735 bool LLParser::ParseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes) {
5736  SMLoc Loc = Lex.getLoc();
5737  if (ParseToken(lltok::lbrace, "expected '{' here"))
5738  return true;
5739  if (Lex.getKind() == lltok::rbrace)
5740  return Lex.Error("expected non-empty list of uselistorder indexes");
5741 
5742  // Use Offset, Max, and IsOrdered to check consistency of indexes. The
5743  // indexes should be distinct numbers in the range [0, size-1], and should
5744  // not be in order.
5745  unsigned Offset = 0;
5746  unsigned Max = 0;
5747  bool IsOrdered = true;
5748  assert(Indexes.empty() && "Expected empty order vector");
5749  do {
5750  unsigned Index;
5751  if (ParseUInt32(Index))
5752  return true;
5753 
5754  // Update consistency checks.
5755  Offset += Index - Indexes.size();
5756  Max = std::max(Max, Index);
5757  IsOrdered &= Index == Indexes.size();
5758 
5759  Indexes.push_back(Index);
5760  } while (EatIfPresent(lltok::comma));
5761 
5762  if (ParseToken(lltok::rbrace, "expected '}' here"))
5763  return true;
5764 
5765  if (Indexes.size() < 2)
5766  return Error(Loc, "expected >= 2 uselistorder indexes");
5767  if (Offset != 0 || Max >= Indexes.size())
5768  return Error(Loc, "expected distinct uselistorder indexes in range [0, size)");
5769  if (IsOrdered)
5770  return Error(Loc, "expected uselistorder indexes to change the order");
5771 
5772  return false;
5773 }
5774 
5775 /// ParseUseListOrder
5776 /// ::= 'uselistorder' Type Value ',' UseListOrderIndexes
5777 bool LLParser::ParseUseListOrder(PerFunctionState *PFS) {
5778  SMLoc Loc = Lex.getLoc();
5779  if (ParseToken(lltok::kw_uselistorder, "expected uselistorder directive"))
5780  return true;
5781 
5782  Value *V;
5783  SmallVector<unsigned, 16> Indexes;
5784  if (ParseTypeAndValue(V, PFS) ||
5785  ParseToken(lltok::comma, "expected comma in uselistorder directive") ||
5786  ParseUseListOrderIndexes(Indexes))
5787  return true;
5788 
5789  return sortUseListOrder(V, Indexes, Loc);
5790 }
5791 
5792 /// ParseUseListOrderBB
5793 /// ::= 'uselistorder_bb' @foo ',' %bar ',' UseListOrderIndexes
5794 bool LLParser::ParseUseListOrderBB() {
5795  assert(Lex.getKind() == lltok::kw_uselistorder_bb);
5796  SMLoc Loc = Lex.getLoc();
5797  Lex.Lex();
5798 
5799  ValID Fn, Label;
5800  SmallVector<unsigned, 16> Indexes;
5801  if (ParseValID(Fn) ||
5802  ParseToken(lltok::comma, "expected comma in uselistorder_bb directive") ||
5803  ParseValID(Label) ||
5804  ParseToken(lltok::comma, "expected comma in uselistorder_bb directive") ||
5805  ParseUseListOrderIndexes(Indexes))
5806  return true;
5807 
5808  // Check the function.
5809  GlobalValue *GV;
5810  if (Fn.Kind == ValID::t_GlobalName)
5811  GV = M->getNamedValue(Fn.StrVal);
5812  else if (Fn.Kind == ValID::t_GlobalID)
5813  GV = Fn.UIntVal < NumberedVals.size() ? NumberedVals[Fn.UIntVal] : nullptr;
5814  else
5815  return Error(Fn.Loc, "expected function name in uselistorder_bb");
5816  if (!GV)
5817  return Error(Fn.Loc, "invalid function forward reference in uselistorder_bb");
5818  auto *F = dyn_cast<Function>(GV);
5819  if (!F)
5820  return Error(Fn.Loc, "expected function name in uselistorder_bb");
5821  if (F->isDeclaration())
5822  return Error(Fn.Loc, "invalid declaration in uselistorder_bb");
5823 
5824  // Check the basic block.
5825  if (Label.Kind == ValID::t_LocalID)
5826  return Error(Label.Loc, "invalid numeric label in uselistorder_bb");
5827  if (Label.Kind != ValID::t_LocalName)
5828  return Error(Label.Loc, "expected basic block name in uselistorder_bb");
5829  Value *V = F->getValueSymbolTable().lookup(Label.StrVal);
5830  if (!V)
5831  return Error(Label.Loc, "invalid basic block in uselistorder_bb");
5832  if (!isa<BasicBlock>(V))
5833  return Error(Label.Loc, "expected basic block in uselistorder_bb");
5834 
5835  return sortUseListOrder(V, Indexes, Loc);
5836 }
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:145
LLLexer::LocTy Loc
Definition: LLParser.h:60
void setPersonalityFn(Constant *C)
Definition: Function.cpp:1001
void setAttributes(const AttributeSet &Attrs)
setAttributes - Set the parameter attributes for this invoke.
void sortUseList(Compare Cmp)
Sort the use-list.
Definition: Value.h:522
void push_back(const T &Elt)
Definition: SmallVector.h:222
use_iterator use_end()
Definition: Value.h:281
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:537
Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins.
Definition: CallingConv.h:133
The C convention as specified in the x86-64 supplement to the System V ABI, used on most non-Windows ...
Definition: CallingConv.h:137
const ValueSymbolTable & getValueSymbolTable() const
Get the symbol table of global variable and function identifiers.
Definition: Module.h:540
static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
getString - This method constructs a CDS and initializes it with a text string.
Definition: Constants.cpp:2612
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
iterator_range< use_iterator > uses()
Definition: Value.h:283
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:236
void addIncoming(Value *V, BasicBlock *BB)
addIncoming - Add an incoming value to the end of the PHI list
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:46
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:223
*p = old <signed v ? old : v
Definition: Instructions.h:704
LLVM Argument representation.
Definition: Argument.h:35
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1327
bool hasName() const
Definition: Value.h:228
ValueT lookup(const KeyT &Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:159
const APFloat & getAPFloatVal() const
Definition: LLLexer.h:60
Sign extended before/after call.
Definition: Attributes.h:105
static bool isValidOperands(const Value *Vec, const Value *NewElt, const Value *Idx)
isValidOperands - Return true if an insertelement instruction can be formed with the specified operan...
static const fltSemantics IEEEdouble
Definition: APFloat.h:133
Force argument to be passed in register.
Definition: Attributes.h:78
Function is called early and/or often, so lazy binding isn't worthwhile.
Definition: Attributes.h:89
static ResumeInst * Create(Value *Exn, Instruction *InsertBefore=nullptr)
FenceInst - an instruction for ordering other memory operations.
Definition: Instructions.h:445
ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete, but still used on some target...
Definition: CallingConv.h:89
iterator end()
Definition: Function.h:459
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:45
AtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory lo...
Definition: Instructions.h:515
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:360
Type::TypeID TypeID
unsigned getUIntVal() const
Definition: LLLexer.h:58
const GlobalListType & getGlobalList() const
Get the Module's list of global variables (constant).
Definition: Module.h:512
Available for inspection, not emission.
Definition: GlobalValue.h:41
Nested function static chain.
Definition: Attributes.h:82
Type::subtype_iterator param_iterator
Definition: DerivedTypes.h:123
void addCase(ConstantInt *OnVal, BasicBlock *Dest)
addCase - Add an entry to the switch instruction...
PTX_Device - Call to a PTX device function.
Definition: CallingConv.h:112
Type * getValueType() const
Definition: GlobalValue.h:187
uint64_t getAlignment() const
Retrieve the alignment attribute, if it exists.
Definition: Attributes.h:509
void addOperand(MDNode *M)
Definition: Metadata.cpp:971
CallInst - This class represents a function call, abstracting a target machine's calling convention...
void UpgradeMDStringConstant(std::string &String)
Upgrade a metadata string constant in place.
static PointerType * get(Type *ElementType, unsigned AddressSpace)
PointerType::get - This constructs a pointer to an object of the specified type in a numbered address...
Definition: Type.cpp:738
unsigned less or equal
Definition: InstrTypes.h:723
unsigned less than
Definition: InstrTypes.h:722
*p = old <unsigned v ? old : v
Definition: Instructions.h:708
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1092
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2123
void setVolatile(bool V)
setVolatile - Specify whether this is a volatile cmpxchg.
Definition: Instructions.h:550
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:703
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:48
iterator find(StringRef Key)
Definition: StringMap.h:265
Source said inlining was desirable.
Definition: Attributes.h:77
*p = old >unsigned v ? old : v
Definition: Instructions.h:706
ShuffleVectorInst - This instruction constructs a fixed permutation of two input vectors.
Externally visible function.
Definition: GlobalValue.h:40
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
Definition: Module.cpp:262
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
If this value is smaller than the specified limit, return it, otherwise return the limit value...
Definition: APInt.h:404
void setDataLayout(StringRef Desc)
Set the data layout.
Definition: Module.cpp:366
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:713
The data referenced by the COMDAT must be the same size.
Definition: Comdat.h:38
AttrBuilder & addDereferenceableAttr(uint64_t Bytes)
This turns the number of dereferenceable bytes into the form used internally in Attribute.
arg_iterator arg_end()
Definition: Function.h:480
Metadata node.
Definition: Metadata.h:740
F(f)
static bool isValidReturnType(Type *RetTy)
isValidReturnType - Return true if the specified type is valid as a return type.
Definition: Type.cpp:387
unsigned UIntVal
Definition: LLParser.h:61
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:472
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
ELFYAML::ELF_STV Visibility
Definition: ELFYAML.cpp:590
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:822
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
AtomicRMWInst - an instruction that atomically reads a memory location, combines it with another valu...
Definition: Instructions.h:674
static bool isValidArgumentType(Type *ArgTy)
isValidArgumentType - Return true if the specified type is valid as an argument type.
Definition: Type.cpp:394
void setAlignment(unsigned Align)
Definition: Globals.cpp:77
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
Definition: Attributes.cpp:956
unsigned getVirtuality(StringRef VirtualityString)
Definition: Dwarf.cpp:333
const AliasListType & getAliasList() const
Get the Module's list of aliases (constant).
Definition: Module.h:526
bool hasAlignmentAttr() const
Return true if the builder has an alignment attribute.
*p = old >signed v ? old : v
Definition: Instructions.h:702
bool isSigned() const
Definition: APSInt.h:58
bool contains(Attribute::AttrKind A) const
Return true if the builder has the specified attribute.
Definition: Attributes.h:489
Naked function.
Definition: Attributes.h:81
Tentative definitions.
Definition: GlobalValue.h:50
static LandingPadInst * Create(Type *RetTy, unsigned NumReservedClauses, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedClauses is a hint for the number of incoming clauses that this landingpad w...
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:226
static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2145
void setVolatile(bool V)
setVolatile - Specify whether this is a volatile RMW or not.
Definition: Instructions.h:744
static Constant * getNullValue(Type *Ty)
Definition: Constants.cpp:178
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
global Merge global variables
void setCallingConv(CallingConv::ID CC)
static ReturnInst * Create(LLVMContext &C, Value *retVal=nullptr, Instruction *InsertBefore=nullptr)
bool Run()
Run: module ::= toplevelentity*.
Definition: LLParser.cpp:43
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:708
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:707
std::map< unsigned, TrackingMDNodeRef > MetadataNodes
Definition: SlotMapping.h:29
A tuple of MDNodes.
Definition: Metadata.h:1127
AttributeSet removeAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Attr) const
Remove the specified attribute at the specified index from this attribute list.
Definition: Attributes.cpp:822
static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy)
This method can be used to determine if a cast from S to DstTy using Opcode op is valid or not...
void push_back(NodeTy *val)
Definition: ilist.h:554
static Type * getIndexedType(Type *Agg, ArrayRef< unsigned > Idxs)
getIndexedType - Returns the type of the element that would be extracted with an extractvalue instruc...
AttrBuilder & addDereferenceableOrNullAttr(uint64_t Bytes)
This turns the number of dereferenceable_or_null bytes into the form used internally in Attribute...
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
static CallInst * Create(Value *Func, ArrayRef< Value * > Args, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
void UpgradeCallsToIntrinsic(Function *F)
This is an auto-upgrade hook for any old intrinsic function syntaxes which need to have both the func...
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:308
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:198
MSP430_INTR - Calling convention used for MSP430 interrupt routines.
Definition: CallingConv.h:99
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
Array subrange.
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
param_iterator param_end() const
Definition: DerivedTypes.h:125
static Constant * get(ArrayRef< Constant * > V)
Definition: Constants.cpp:1057
void setThreadLocalMode(ThreadLocalMode Val)
Definition: GlobalValue.h:156
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If Reload the main corpus periodically to get new units discovered by other processes Read the given input file
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:704
void setMetadata(unsigned KindID, MDNode *MD)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1191
TypeID
Definitions of all of the base types for the Type system.
Definition: Type.h:54
bool isSized(SmallPtrSetImpl< const Type * > *Visited=nullptr) const
isSized - Return true if it makes sense to take the size of this type.
Definition: Type.h:268
The linker may choose any COMDAT.
Definition: Comdat.h:34
lltok::Kind Lex()
Definition: LLLexer.h:49
SynchronizationScope
Definition: Instructions.h:49
Function must be in a unwind table.
Definition: Attributes.h:118
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:250
static ConstantInt * ExtractElement(Constant *V, Constant *Idx)
static const unsigned MaximumAlignment
Definition: Value.h:463
void setDLLStorageClass(DLLStorageClassTypes C)
Definition: GlobalValue.h:173
Function does not access memory.
Definition: Attributes.h:99
Hidden pointer to structure to return.
Definition: Attributes.h:114
Function creates no aliases of pointer.
Definition: Attributes.h:85
AtomicOrdering
Definition: Instructions.h:38
static bool isValidOperands(const Value *V1, const Value *V2, const Value *Mask)
isValidOperands - Return true if a shufflevector instruction can be formed with the specified operand...
static Constant * get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)
get - Return a binary or shift operator constant expression, folding if possible. ...
Definition: Constants.cpp:1868
Subprogram description.
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a distinct node.
Definition: Metadata.h:1008
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
static Type * getLabelTy(LLVMContext &C)
Definition: Type.cpp:226
globalsmodref Simple mod ref analysis for globals
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
LLVMContext & getContext() const
getContext - Return the LLVMContext in which this type was uniqued.
Definition: Type.h:125
Safe Stack protection.
Definition: Attributes.h:113
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
BinOp
This enumeration lists the possible modifications atomicrmw can make.
Definition: Instructions.h:686
bool isHalfTy() const
isHalfTy - Return true if this is 'half', a 16-bit IEEE fp type.
Definition: Type.h:140
#define T
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:54
static bool isValidElementType(Type *ElemTy)
isValidElementType - Return true if the specified type is valid as a element type.
Definition: Type.cpp:729
Enumeration value.
This instruction compares its operands according to the predicate given to the constructor.
PTX_Kernel - Call to a PTX kernel.
Definition: CallingConv.h:108
static Constant * getSelect(Constant *C, Constant *V1, Constant *V2, Type *OnlyIfReducedTy=nullptr)
Select constant expr.
Definition: Constants.cpp:2012
void setComdat(Comdat *C)
Definition: GlobalObject.h:63
bool isFirstClassType() const
isFirstClassType - Return true if the type is "first class", meaning it is a valid type for a Value...
Definition: Type.h:242
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
FunctionType::get - This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:361
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:31
std::string StrVal
Definition: LLParser.h:62
bool isFloatingPointTy() const
isFloatingPointTy - Return true if this is one of the six floating point types
Definition: Type.h:159
Pass structure by value.
Definition: Attributes.h:73
static bool Verify(FunctionType *Ty, StringRef Constraints)
Verify - This static method can be used by the parser to check to see if the specified constraint str...
Definition: InlineAsm.cpp:245
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
bool isArrayTy() const
isArrayTy - True if this is an instance of ArrayType.
Definition: Type.h:213
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
Definition: Metadata.h:1017
Debug location.
Stack protection.
Definition: Attributes.h:110
ValueSymbolTable & getValueSymbolTable()
getSymbolTable() - Return the symbol table...
Definition: Function.h:450
Type * getElementType() const
Definition: DerivedTypes.h:323
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:134
Considered to not alias after call.
Definition: Attributes.h:83
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:188
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:75
ExternalWeak linkage description.
Definition: GlobalValue.h:49
static Constant * getInsertValue(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2191
void setCallingConv(CallingConv::ID CC)
Definition: Function.h:175
bool isIntOrIntVectorTy() const
isIntOrIntVectorTy - Return true if this is an integer type or a vector of integer types...
Definition: Type.h:201
#define P(N)
StringRef filename(StringRef path)
Get filename.
Definition: Path.cpp:548
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:43
SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
Definition: CallingConv.h:122
No other Module may specify this COMDAT.
Definition: Comdat.h:37
static ConstantPointerNull * get(PointerType *T)
get() - Static factory methods - Return objects of the specified value
Definition: Constants.cpp:1455
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
Definition: CallingConv.h:96
static ExtractValueInst * Create(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
bool isVectorTy() const
isVectorTy - True if this is an instance of VectorType.
Definition: Type.h:226
static GlobalAlias * create(PointerType *Ty, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
Definition: Globals.cpp:243
static BlockAddress * get(Function *F, BasicBlock *BB)
get - Return a BlockAddress for the specified function and basic block.
Definition: Constants.cpp:1496
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:998
UnreachableInst - This function has undefined behavior.
This is an important base class in LLVM.
Definition: Constant.h:41
ResumeInst - Resume the propagation of an exception.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
void setUsedWithInAlloca(bool V)
Specify whether this alloca is used to represent the arguments to a call.
Definition: Instructions.h:149
param_iterator param_begin() const
Definition: DerivedTypes.h:124
IndirectBrInst - Indirect Branch Instruction.
bool isFloatTy() const
isFloatTy - Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:143
void setExternallyInitialized(bool Val)
unsigned getOperationEncoding(StringRef OperationEncodingString)
Definition: Dwarf.cpp:257
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:873
bool UpgradeDebugInfo(Module &M)
Check the debug info version number, if it is out-dated, drop the debug info.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
X86_StdCall - stdcall is the calling conventions mostly used by the Win32 API.
Definition: CallingConv.h:80
Constant * ConstantVal
Definition: LLParser.h:65
Return value is always equal to this argument.
Definition: Attributes.h:103
static bool isValidLinkage(LinkageTypes L)
Definition: GlobalAlias.h:103
static Constant * getShuffleVector(Constant *V1, Constant *V2, Constant *Mask, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2168
Pass structure in an alloca.
Definition: Attributes.h:74
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:252
LocTy getLoc() const
Definition: LLLexer.h:54
This instruction compares its operands according to the predicate given to the constructor.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:697
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1273
opStatus convert(const fltSemantics &, roundingMode, bool *)
APFloat::convert - convert a value of one floating point type to another.
Definition: APFloat.cpp:1972
return false
Definition: LLParser.cpp:1205
DLLStorageClassTypes
Storage classes of global values for PE targets.
Definition: GlobalValue.h:61
Zero extended before/after call.
Definition: Attributes.h:119
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:706
static bool isValueValidForType(Type *Ty, const APFloat &V)
isValueValidForType - return true if Ty is big enough to represent V.
Definition: Constants.cpp:1326
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:103
arg_iterator arg_begin()
Definition: Function.h:472
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
Definition: Constants.cpp:2074
APFloat APFloatVal
Definition: LLParser.h:64
Function doesn't unwind stack.
Definition: Attributes.h:96
static Constant * get(StructType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:1008
The data referenced by the COMDAT must be the same.
Definition: Comdat.h:35
void setTailCallKind(TailCallKind TCK)
Marks function as being in a cold path.
Definition: Attributes.h:75
std::vector< GlobalValue * > GlobalValues
Definition: SlotMapping.h:28
void setConstant(bool Val)
unsigned getLanguage(StringRef LanguageString)
Definition: Dwarf.cpp:352
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:714
Mark the function as not returning.
Definition: Attributes.h:95
static bool isValidElementType(Type *ElemTy)
isValidElementType - Return true if the specified type is valid as a element type.
Definition: Type.cpp:603
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
static UndefValue * get(Type *T)
get() - Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1473
bool Error(LocTy L, const Twine &Msg) const
Definition: LLLexer.cpp:32
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Definition: Module.cpp:465
VAArgInst - This class represents the va_arg llvm instruction, which returns an argument of the speci...
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
static bool isAtomic(Instruction *I)
bool isFPOrFPVectorTy() const
isFPOrFPVectorTy - Return true if this is a FP type or a vector of FP.
Definition: Type.h:183
ARM_AAPCS - ARM Architecture Procedure Calling Standard calling convention (aka EABI).
Definition: CallingConv.h:93
static bool isValidOperands(const Value *Vec, const Value *Idx)
isValidOperands - Return true if an extractelement instruction can be formed with the specified opera...
void setBody(ArrayRef< Type * > Elements, bool isPacked=false)
setBody - Specify a body for an opaque identified type.
Definition: Type.cpp:424
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:854
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:712
static const fltSemantics IEEEhalf
Definition: APFloat.h:131
std::string & str()
Flushes the stream contents to the target string and returns the string's reference.
Definition: raw_ostream.h:480
Call cannot be duplicated.
Definition: Attributes.h:86
void setMetadata(unsigned KindID, MDNode *Node)
setMetadata - Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1083
static IndirectBrInst * Create(Value *Address, unsigned NumDests, Instruction *InsertBefore=nullptr)
signed greater than
Definition: InstrTypes.h:724
Pointer is known to be not null.
Definition: Attributes.h:91
An imported module (C++ using directive or similar).
Constant ** ConstantStructElts
Definition: LLParser.h:66
unsigned getTag(StringRef TagString)
Definition: Dwarf.cpp:31
global_iterator global_end()
Definition: Module.h:554
const FunctionListType & getFunctionList() const
Get the Module's list of functions (constant).
Definition: Module.h:519
static Constant * getFCmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
Definition: Constants.cpp:2099
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:701
static InvokeInst * Create(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
const BasicBlockListType & getBasicBlockList() const
Definition: Function.h:436
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
APSInt APSIntVal
Definition: LLParser.h:63
static PointerType * getUnqual(Type *ElementType)
PointerType::getUnqual - This constructs a pointer to an object of the specified type in the generic ...
Definition: DerivedTypes.h:460
static bool isValidElementType(Type *ElemTy)
isValidElementType - Return true if the specified type is valid as a element type.
Definition: Type.cpp:768
static bool isValidVisibilityForLinkage(unsigned V, unsigned L)
Definition: LLParser.cpp:619
void setSelectionKind(SelectionKind Val)
Definition: Comdat.h:43
SPIR_KERNEL - Calling convention for SPIR kernel functions.
Definition: CallingConv.h:130
bool isFunctionTy() const
isFunctionTy - True if this is an instance of FunctionType.
Definition: Type.h:205
APSInt LLVM_ATTRIBUTE_UNUSED_RESULT extOrTrunc(uint32_t width) const
Definition: APSInt.h:91
const std::string & getStrVal() const
Definition: LLLexer.h:56
unsigned getVectorNumElements() const
Definition: Type.cpp:212
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
StructType::get - This static method is the primary way to create a literal StructType.
Definition: Type.cpp:404
static SwitchInst * Create(Value *Value, BasicBlock *Default, unsigned NumCases, Instruction *InsertBefore=nullptr)
AttrBuilder & removeAttribute(Attribute::AttrKind Val)
Remove an attribute from the builder.
static ValueAsMetadata * get(Value *V)
Definition: Metadata.cpp:251
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:711
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:42
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
Callee is recognized as a builtin, despite nobuiltin attribute on its declaration.
Definition: Attributes.h:71
void setUnnamedAddr(bool Val)
Definition: GlobalValue.h:131
signed less than
Definition: InstrTypes.h:726
#define GET_OR_DISTINCT(CLASS, ARGS)
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:582
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
The linker will choose the largest COMDAT.
Definition: Comdat.h:36
X86_FastCall - 'fast' analog of X86_StdCall.
Definition: CallingConv.h:85
bool any() const
Whether any flag is set.
Definition: Operator.h:183
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
static Constant * get(Type *Ty, double V)
get() - This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in the specified type.
Definition: Constants.cpp:652
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:530
DWARF expression.
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:284
void splice(iterator where, iplist &L2)
Definition: ilist.h:570
Alignment of parameter (5 bits) stored as log2 of alignment with +1 bias 0 means unaligned (different...
Definition: Attributes.h:67
AttributeSet removeAttributes(LLVMContext &C, unsigned Index, AttributeSet Attrs) const
Remove the specified attributes at the specified index from this attribute list.
Definition: Attributes.cpp:828
signed less or equal
Definition: InstrTypes.h:727
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:214
static bool isWeak(const MCSymbolELF &Sym)
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:39
A (clang) module that has been imported by the compile unit.
Function must not be optimized.
Definition: Attributes.h:98
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
void setWeak(bool IsWeak)
Definition: Instructions.h:560
Function only reads from memory.
Definition: Attributes.h:100
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:1591
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
void setGC(const char *Str)
Definition: Function.cpp:390
Generic tagged DWARF-like metadata node.
A utility class that uses RAII to save and restore the value of a variable.
FunctionNumber(functionNumber)
Definition: LLParser.cpp:2146
const Type * getScalarType() const LLVM_READONLY
getScalarType - If this is a vector type, return the element type, otherwise return 'this'...
Definition: Type.cpp:51
static unsigned getFlag(StringRef Flag)
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
getIndexedType - Returns the type of the element that would be loaded with a load instruction with th...
Disable redzone.
Definition: Attributes.h:94
Type array for a subprogram.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1030
ThreadSanitizer is on.
Definition: Attributes.h:116
use_iterator use_begin()
Definition: Value.h:279
static std::string getTypeString(Type *T)
Definition: LLParser.cpp:35
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
Function to be accessible from DLL.
Definition: GlobalValue.h:64
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:185
static const fltSemantics IEEEsingle
Definition: APFloat.h:132
void emplace_back(ArgTypes &&...Args)
Definition: SmallVector.h:652
ValID - Represents a reference of a definition of some sort with no type.
Definition: LLParser.h:47
iterator end()
Definition: Module.h:571
pointer data()
Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:134
bool isAggregateType() const
isAggregateType - Return true if the type is an aggregate type.
Definition: Type.h:260
OperandType
Types of operands to CF instructions.
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:128
unsigned greater or equal
Definition: InstrTypes.h:721
static bool isValidElementType(Type *ElemTy)
isValidElementType - Return true if the specified type is valid as a element type.
Definition: Type.cpp:699
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
Definition: CallingConv.h:147
Callee isn't recognized as a builtin.
Definition: Attributes.h:84
const ComdatSymTabType & getComdatSymbolTable() const
Get the Module's symbol table for COMDATs (constant).
Definition: Module.h:544
AddressSanitizer is on.
Definition: Attributes.h:115
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
Strong Stack protection.
Definition: Attributes.h:112
enum llvm::ValID::@195 Kind
Fast - This calling convention attempts to make calls as fast as possible (e.g.
Definition: CallingConv.h:42
void setPrologueData(Constant *PrologueData)
Definition: Function.cpp:964
iterator begin()
Definition: Module.h:569
void appendModuleInlineAsm(StringRef Asm)
Append to the module-scope inline assembly blocks.
Definition: Module.h:307
lltok::Kind getKind() const
Definition: LLLexer.h:55
Deduce function attributes
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:705
static ArrayType * get(Type *ElementType, uint64_t NumElements)
ArrayType::get - This static method is the primary way to construct an ArrayType. ...
Definition: Type.cpp:686
void size_t size
void setTargetTriple(StringRef T)
Set the target triple.
Definition: Module.h:294
X86_ThisCall - Similar to X86_StdCall.
Definition: CallingConv.h:104
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:44
Rename collisions when linking (static functions).
Definition: GlobalValue.h:47
static InlineAsm * get(FunctionType *Ty, StringRef AsmString, StringRef Constraints, bool hasSideEffects, bool isAlignStack=false, AsmDialect asmDialect=AD_ATT)
InlineAsm::get - Return the specified uniqued inline asm string.
Definition: InlineAsm.cpp:28
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:709
void setAttributes(AttributeSet attrs)
Set the attribute list for this Function.
Definition: Function.h:184
Function to be imported from DLL.
Definition: GlobalValue.h:63
Funciton can access memory only using pointers based on its arguments.
Definition: Attributes.h:101
const APSInt & getAPSIntVal() const
Definition: LLLexer.h:59
void addDestination(BasicBlock *Dest)
addDestination - Add a destination.
bool isVarArg() const
Definition: DerivedTypes.h:120
AttrBuilder & merge(const AttrBuilder &B)
Add the attributes from the builder.
SwitchInst - Multiway switch.
bool use_empty() const
Definition: Value.h:275
void setAttributes(const AttributeSet &Attrs)
setAttributes - Set the parameter attributes for this call.
Function can return twice.
Definition: Attributes.h:104
const ARM::ArchExtKind Kind
std::string StrVal2
Definition: LLParser.h:62
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:465
LLLexer::LocTy LocTy
Definition: LLParser.h:86
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
getPrimitiveSizeInBits - Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:121
bool isLabelTy() const
isLabelTy - Return true if this is 'label'.
Definition: Type.h:186
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:700
LLVM Value Representation.
Definition: Value.h:69
static const char * name
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:710
bool hasAttributes() const
Return true if the builder has IR-level attributes.
static VectorType * get(Type *ElementType, unsigned NumElements)
VectorType::get - This static method is the primary way to construct an VectorType.
Definition: Type.cpp:713
static StructType * create(LLVMContext &Context, StringRef Name)
StructType::create - This creates an identified struct.
Definition: Type.cpp:490
Disable implicit floating point insts.
Definition: Attributes.h:87
virtual void eraseFromParent()=0
This method unlinks 'this' from the containing module and deletes it.
unsigned getAttributeEncoding(StringRef EncodingString)
Definition: Dwarf.cpp:274
AttrBuilder & addStackAlignmentAttr(unsigned Align)
This turns an int stack alignment (which must be a power of 2) into the form used internally in Attri...
This file provides utility classes that use RAII to save and restore values.
void setCallingConv(CallingConv::ID CC)
The C convention as implemented on Windows/x86-64.
Definition: CallingConv.h:143
InvokeInst - Invoke instruction.
void UpgradeInstWithTBAATag(Instruction *I)
If the TBAA tag for the given instruction uses the scalar TBAA format, we upgrade it to the struct-pa...
#define PARSE_MD_FIELDS()
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
bool isPowerOf2_32(uint32_t Value)
isPowerOf2_32 - This function returns true if the argument is a power of two > 0. ...
Definition: MathExtras.h:354
static Constant * getExtractValue(Constant *Agg, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2215
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:164
unsigned greater than
Definition: InstrTypes.h:720
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
A single uniqued string.
Definition: Metadata.h:508
AttrBuilder & addAlignmentAttr(unsigned Align)
This turns an int alignment (which must be a power of 2) into the form used internally in Attribute...
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:121
Type * getTyVal() const
Definition: LLLexer.h:57
static bool isVolatile(Instruction *Inst)
Represents a location in source code.
Definition: SMLoc.h:23
static ExtractElementInst * Create(Value *Vec, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
AttributeSet addAttributes(LLVMContext &C, unsigned Index, AttributeSet Attrs) const
Add attributes to the attribute set at the given index.
Definition: Attributes.cpp:773
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:702
Can only be moved to control-equivalent blocks.
Definition: Attributes.h:76
unsigned getMDKindID(StringRef Name) const
Return a unique non-zero ID for the specified metadata kind.
Definition: Module.cpp:94
Stack protection required.
Definition: Attributes.h:111
Root of the metadata hierarchy.
Definition: Metadata.h:45
MemorySanitizer is on.
Definition: Attributes.h:117
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:237
void setSection(StringRef S)
Definition: Globals.cpp:126
const fltSemantics & getSemantics() const
Definition: APFloat.h:435
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:88
iterator end()
Definition: StringMap.h:255
Value * lookup(StringRef Name) const
This method finds the value with the given Name in the the symbol table.
Build jump-instruction tables and replace refs.
Definition: Attributes.h:79
TLM
Definition: LLParser.cpp:1199
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:699
signed greater or equal
Definition: InstrTypes.h:725
bool isVoidTy() const
isVoidTy - Return true if this is 'void'.
Definition: Type.h:137
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:110
Basic type, like 'int' or 'float'.
bool isMetadataTy() const
isMetadataTy - Return true if this is 'metadata'.
Definition: Type.h:189
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:935
AttributeSet getFnAttributes() const
The function attributes are returned.
Definition: Attributes.cpp:947
static const char * areInvalidOperands(Value *Cond, Value *True, Value *False)
areInvalidOperands - Return a string if the specified operands are invalid for a select operation...
Function must be optimized for size first.
Definition: Attributes.h:80