LLVM  7.0.0svn
LLParser.h
Go to the documentation of this file.
1 //===-- LLParser.h - Parser Class -------------------------------*- C++ -*-===//
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 #ifndef LLVM_LIB_ASMPARSER_LLPARSER_H
15 #define LLVM_LIB_ASMPARSER_LLPARSER_H
16 
17 #include "LLLexer.h"
18 #include "llvm/ADT/Optional.h"
19 #include "llvm/ADT/StringMap.h"
20 #include "llvm/IR/Attributes.h"
21 #include "llvm/IR/Instructions.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/IR/Operator.h"
24 #include "llvm/IR/Type.h"
25 #include "llvm/IR/ValueHandle.h"
26 #include <map>
27 
28 namespace llvm {
29  class Module;
30  class OpaqueType;
31  class Function;
32  class Value;
33  class BasicBlock;
34  class Instruction;
35  class Constant;
36  class GlobalValue;
37  class Comdat;
38  class MDString;
39  class MDNode;
40  struct SlotMapping;
41  class StructType;
42 
43  /// ValID - Represents a reference of a definition of some sort with no type.
44  /// There are several cases where we have to parse the value but where the
45  /// type can depend on later context. This may either be a numeric reference
46  /// or a symbolic (%var) reference. This is just a discriminated union.
47  struct ValID {
48  enum {
49  t_LocalID, t_GlobalID, // ID in UIntVal.
50  t_LocalName, t_GlobalName, // Name in StrVal.
51  t_APSInt, t_APFloat, // Value in APSIntVal/APFloatVal.
52  t_Null, t_Undef, t_Zero, t_None, // No value.
53  t_EmptyArray, // No value: []
54  t_Constant, // Value in ConstantVal.
55  t_InlineAsm, // Value in FTy/StrVal/StrVal2/UIntVal.
56  t_ConstantStruct, // Value in ConstantStructElts.
57  t_PackedConstantStruct // Value in ConstantStructElts.
58  } Kind = t_LocalID;
59 
61  unsigned UIntVal;
62  FunctionType *FTy = nullptr;
63  std::string StrVal, StrVal2;
67  std::unique_ptr<Constant *[]> ConstantStructElts;
68 
69  ValID() = default;
70  ValID(const ValID &RHS)
71  : Kind(RHS.Kind), Loc(RHS.Loc), UIntVal(RHS.UIntVal), FTy(RHS.FTy),
72  StrVal(RHS.StrVal), StrVal2(RHS.StrVal2), APSIntVal(RHS.APSIntVal),
73  APFloatVal(RHS.APFloatVal), ConstantVal(RHS.ConstantVal) {
75  }
76 
77  bool operator<(const ValID &RHS) const {
78  if (Kind == t_LocalID || Kind == t_GlobalID)
79  return UIntVal < RHS.UIntVal;
80  assert((Kind == t_LocalName || Kind == t_GlobalName ||
81  Kind == t_ConstantStruct || Kind == t_PackedConstantStruct) &&
82  "Ordering not defined for this ValID kind yet");
83  return StrVal < RHS.StrVal;
84  }
85  };
86 
87  class LLParser {
88  public:
90  private:
92  LLLexer Lex;
93  Module *M;
94  SlotMapping *Slots;
95 
96  // Instruction metadata resolution. Each instruction can have a list of
97  // MDRef info associated with them.
98  //
99  // The simpler approach of just creating temporary MDNodes and then calling
100  // RAUW on them when the definition is processed doesn't work because some
101  // instruction metadata kinds, such as dbg, get stored in the IR in an
102  // "optimized" format which doesn't participate in the normal value use
103  // lists. This means that RAUW doesn't work, even on temporary MDNodes
104  // which otherwise support RAUW. Instead, we defer resolving MDNode
105  // references until the definitions have been processed.
106  struct MDRef {
107  SMLoc Loc;
108  unsigned MDKind, MDSlot;
109  };
110 
111  SmallVector<Instruction*, 64> InstsWithTBAATag;
112 
113  // Type resolution handling data structures. The location is set when we
114  // have processed a use of the type but not a definition yet.
116  std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
117 
118  std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;
119  std::map<unsigned, std::pair<TempMDTuple, LocTy>> ForwardRefMDNodes;
120 
121  // Global Value reference information.
122  std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;
123  std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
124  std::vector<GlobalValue*> NumberedVals;
125 
126  // Comdat forward reference information.
127  std::map<std::string, LocTy> ForwardRefComdats;
128 
129  // References to blockaddress. The key is the function ValID, the value is
130  // a list of references to blocks in that function.
131  std::map<ValID, std::map<ValID, GlobalValue *>> ForwardRefBlockAddresses;
132  class PerFunctionState;
133  /// Reference to per-function state to allow basic blocks to be
134  /// forward-referenced by blockaddress instructions within the same
135  /// function.
136  PerFunctionState *BlockAddressPFS;
137 
138  // Attribute builder reference information.
139  std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
140  std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
141 
142  /// Only the llvm-as tool may set this to false to bypass
143  /// UpgradeDebuginfo so it can generate broken bitcode.
144  bool UpgradeDebugInfo;
145 
146  /// DataLayout string to override that in LLVM assembly.
147  StringRef DataLayoutStr;
148 
149  public:
151  SlotMapping *Slots = nullptr, bool UpgradeDebugInfo = true,
152  StringRef DataLayoutString = "")
153  : Context(M->getContext()), Lex(F, SM, Err, M->getContext()), M(M),
154  Slots(Slots), BlockAddressPFS(nullptr),
155  UpgradeDebugInfo(UpgradeDebugInfo), DataLayoutStr(DataLayoutString) {
156  if (!DataLayoutStr.empty())
157  M->setDataLayout(DataLayoutStr);
158  }
159  bool Run();
160 
161  bool parseStandaloneConstantValue(Constant *&C, const SlotMapping *Slots);
162 
163  bool parseTypeAtBeginning(Type *&Ty, unsigned &Read,
164  const SlotMapping *Slots);
165 
167 
168  private:
169 
170  bool Error(LocTy L, const Twine &Msg) const {
171  return Lex.Error(L, Msg);
172  }
173  bool TokError(const Twine &Msg) const {
174  return Error(Lex.getLoc(), Msg);
175  }
176 
177  /// Restore the internal name and slot mappings using the mappings that
178  /// were created at an earlier parsing stage.
179  void restoreParsingState(const SlotMapping *Slots);
180 
181  /// GetGlobalVal - Get a value with the specified name or ID, creating a
182  /// forward reference record if needed. This can return null if the value
183  /// exists but does not have the right type.
184  GlobalValue *GetGlobalVal(const std::string &N, Type *Ty, LocTy Loc);
185  GlobalValue *GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc);
186 
187  /// Get a Comdat with the specified name, creating a forward reference
188  /// record if needed.
189  Comdat *getComdat(const std::string &N, LocTy Loc);
190 
191  // Helper Routines.
192  bool ParseToken(lltok::Kind T, const char *ErrMsg);
193  bool EatIfPresent(lltok::Kind T) {
194  if (Lex.getKind() != T) return false;
195  Lex.Lex();
196  return true;
197  }
198 
199  FastMathFlags EatFastMathFlagsIfPresent() {
200  FastMathFlags FMF;
201  while (true)
202  switch (Lex.getKind()) {
203  case lltok::kw_fast: FMF.setFast(); Lex.Lex(); continue;
204  case lltok::kw_nnan: FMF.setNoNaNs(); Lex.Lex(); continue;
205  case lltok::kw_ninf: FMF.setNoInfs(); Lex.Lex(); continue;
206  case lltok::kw_nsz: FMF.setNoSignedZeros(); Lex.Lex(); continue;
207  case lltok::kw_arcp: FMF.setAllowReciprocal(); Lex.Lex(); continue;
208  case lltok::kw_contract:
209  FMF.setAllowContract(true);
210  Lex.Lex();
211  continue;
212  case lltok::kw_reassoc: FMF.setAllowReassoc(); Lex.Lex(); continue;
213  case lltok::kw_afn: FMF.setApproxFunc(); Lex.Lex(); continue;
214  default: return FMF;
215  }
216  return FMF;
217  }
218 
219  bool ParseOptionalToken(lltok::Kind T, bool &Present,
220  LocTy *Loc = nullptr) {
221  if (Lex.getKind() != T) {
222  Present = false;
223  } else {
224  if (Loc)
225  *Loc = Lex.getLoc();
226  Lex.Lex();
227  Present = true;
228  }
229  return false;
230  }
231  bool ParseStringConstant(std::string &Result);
232  bool ParseUInt32(unsigned &Val);
233  bool ParseUInt32(unsigned &Val, LocTy &Loc) {
234  Loc = Lex.getLoc();
235  return ParseUInt32(Val);
236  }
237  bool ParseUInt64(uint64_t &Val);
238  bool ParseUInt64(uint64_t &Val, LocTy &Loc) {
239  Loc = Lex.getLoc();
240  return ParseUInt64(Val);
241  }
242 
243  bool ParseStringAttribute(AttrBuilder &B);
244 
245  bool ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
246  bool ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
247  bool ParseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
248  bool ParseOptionalAddrSpace(unsigned &AddrSpace);
249  bool ParseOptionalParamAttrs(AttrBuilder &B);
250  bool ParseOptionalReturnAttrs(AttrBuilder &B);
251  bool ParseOptionalLinkage(unsigned &Linkage, bool &HasLinkage,
252  unsigned &Visibility, unsigned &DLLStorageClass,
253  bool &DSOLocal);
254  void ParseOptionalDSOLocal(bool &DSOLocal);
255  void ParseOptionalVisibility(unsigned &Visibility);
256  void ParseOptionalDLLStorageClass(unsigned &DLLStorageClass);
257  bool ParseOptionalCallingConv(unsigned &CC);
258  bool ParseOptionalAlignment(unsigned &Alignment);
259  bool ParseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
260  bool ParseScopeAndOrdering(bool isAtomic, SyncScope::ID &SSID,
261  AtomicOrdering &Ordering);
262  bool ParseScope(SyncScope::ID &SSID);
263  bool ParseOrdering(AtomicOrdering &Ordering);
264  bool ParseOptionalStackAlignment(unsigned &Alignment);
265  bool ParseOptionalCommaAlign(unsigned &Alignment, bool &AteExtraComma);
266  bool ParseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
267  bool &AteExtraComma);
268  bool ParseOptionalCommaInAlloca(bool &IsInAlloca);
269  bool parseAllocSizeArguments(unsigned &ElemSizeArg,
270  Optional<unsigned> &HowManyArg);
271  bool ParseIndexList(SmallVectorImpl<unsigned> &Indices,
272  bool &AteExtraComma);
273  bool ParseIndexList(SmallVectorImpl<unsigned> &Indices) {
274  bool AteExtraComma;
275  if (ParseIndexList(Indices, AteExtraComma)) return true;
276  if (AteExtraComma)
277  return TokError("expected index");
278  return false;
279  }
280 
281  // Top-Level Entities
282  bool ParseTopLevelEntities();
283  bool ValidateEndOfModule();
284  bool ParseTargetDefinition();
285  bool ParseModuleAsm();
286  bool ParseSourceFileName();
287  bool ParseDepLibs(); // FIXME: Remove in 4.0.
288  bool ParseUnnamedType();
289  bool ParseNamedType();
290  bool ParseDeclare();
291  bool ParseDefine();
292 
293  bool ParseGlobalType(bool &IsConstant);
294  bool ParseUnnamedGlobal();
295  bool ParseNamedGlobal();
296  bool ParseGlobal(const std::string &Name, LocTy Loc, unsigned Linkage,
297  bool HasLinkage, unsigned Visibility,
298  unsigned DLLStorageClass, bool DSOLocal,
300  GlobalVariable::UnnamedAddr UnnamedAddr);
301  bool parseIndirectSymbol(const std::string &Name, LocTy Loc,
302  unsigned Linkage, unsigned Visibility,
303  unsigned DLLStorageClass, bool DSOLocal,
305  GlobalVariable::UnnamedAddr UnnamedAddr);
306  bool parseComdat();
307  bool ParseStandaloneMetadata();
308  bool ParseNamedMetadata();
309  bool ParseMDString(MDString *&Result);
310  bool ParseMDNodeID(MDNode *&Result);
311  bool ParseUnnamedAttrGrp();
312  bool ParseFnAttributeValuePairs(AttrBuilder &B,
313  std::vector<unsigned> &FwdRefAttrGrps,
314  bool inAttrGrp, LocTy &BuiltinLoc);
315 
316  // Type Parsing.
317  bool ParseType(Type *&Result, const Twine &Msg, bool AllowVoid = false);
318  bool ParseType(Type *&Result, bool AllowVoid = false) {
319  return ParseType(Result, "expected type", AllowVoid);
320  }
321  bool ParseType(Type *&Result, const Twine &Msg, LocTy &Loc,
322  bool AllowVoid = false) {
323  Loc = Lex.getLoc();
324  return ParseType(Result, Msg, AllowVoid);
325  }
326  bool ParseType(Type *&Result, LocTy &Loc, bool AllowVoid = false) {
327  Loc = Lex.getLoc();
328  return ParseType(Result, AllowVoid);
329  }
330  bool ParseAnonStructType(Type *&Result, bool Packed);
331  bool ParseStructBody(SmallVectorImpl<Type*> &Body);
332  bool ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
333  std::pair<Type*, LocTy> &Entry,
334  Type *&ResultTy);
335 
336  bool ParseArrayVectorType(Type *&Result, bool isVector);
337  bool ParseFunctionType(Type *&Result);
338 
339  // Function Semantic Analysis.
340  class PerFunctionState {
341  LLParser &P;
342  Function &F;
343  std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
344  std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
345  std::vector<Value*> NumberedVals;
346 
347  /// FunctionNumber - If this is an unnamed function, this is the slot
348  /// number of it, otherwise it is -1.
349  int FunctionNumber;
350  public:
351  PerFunctionState(LLParser &p, Function &f, int FunctionNumber);
352  ~PerFunctionState();
353 
354  Function &getFunction() const { return F; }
355 
356  bool FinishFunction();
357 
358  /// GetVal - Get a value with the specified name or ID, creating a
359  /// forward reference record if needed. This can return null if the value
360  /// exists but does not have the right type.
361  Value *GetVal(const std::string &Name, Type *Ty, LocTy Loc);
362  Value *GetVal(unsigned ID, Type *Ty, LocTy Loc);
363 
364  /// SetInstName - After an instruction is parsed and inserted into its
365  /// basic block, this installs its name.
366  bool SetInstName(int NameID, const std::string &NameStr, LocTy NameLoc,
367  Instruction *Inst);
368 
369  /// GetBB - Get a basic block with the specified name or ID, creating a
370  /// forward reference record if needed. This can return null if the value
371  /// is not a BasicBlock.
372  BasicBlock *GetBB(const std::string &Name, LocTy Loc);
373  BasicBlock *GetBB(unsigned ID, LocTy Loc);
374 
375  /// DefineBB - Define the specified basic block, which is either named or
376  /// unnamed. If there is an error, this returns null otherwise it returns
377  /// the block being defined.
378  BasicBlock *DefineBB(const std::string &Name, LocTy Loc);
379 
380  bool resolveForwardRefBlockAddresses();
381  };
382 
383  bool ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
384  PerFunctionState *PFS);
385 
386  bool parseConstantValue(Type *Ty, Constant *&C);
387  bool ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
388  bool ParseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
389  return ParseValue(Ty, V, &PFS);
390  }
391 
392  bool ParseValue(Type *Ty, Value *&V, LocTy &Loc,
393  PerFunctionState &PFS) {
394  Loc = Lex.getLoc();
395  return ParseValue(Ty, V, &PFS);
396  }
397 
398  bool ParseTypeAndValue(Value *&V, PerFunctionState *PFS);
399  bool ParseTypeAndValue(Value *&V, PerFunctionState &PFS) {
400  return ParseTypeAndValue(V, &PFS);
401  }
402  bool ParseTypeAndValue(Value *&V, LocTy &Loc, PerFunctionState &PFS) {
403  Loc = Lex.getLoc();
404  return ParseTypeAndValue(V, PFS);
405  }
406  bool ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
407  PerFunctionState &PFS);
408  bool ParseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
409  LocTy Loc;
410  return ParseTypeAndBasicBlock(BB, Loc, PFS);
411  }
412 
413 
414  struct ParamInfo {
415  LocTy Loc;
416  Value *V;
418  ParamInfo(LocTy loc, Value *v, AttributeSet attrs)
419  : Loc(loc), V(v), Attrs(attrs) {}
420  };
421  bool ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
422  PerFunctionState &PFS,
423  bool IsMustTailCall = false,
424  bool InVarArgsFunc = false);
425 
426  bool
427  ParseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
428  PerFunctionState &PFS);
429 
430  bool ParseExceptionArgs(SmallVectorImpl<Value *> &Args,
431  PerFunctionState &PFS);
432 
433  // Constant Parsing.
434  bool ParseValID(ValID &ID, PerFunctionState *PFS = nullptr);
435  bool ParseGlobalValue(Type *Ty, Constant *&V);
436  bool ParseGlobalTypeAndValue(Constant *&V);
437  bool ParseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
438  Optional<unsigned> *InRangeOp = nullptr);
439  bool parseOptionalComdat(StringRef GlobalName, Comdat *&C);
440  bool ParseMetadataAsValue(Value *&V, PerFunctionState &PFS);
441  bool ParseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
442  PerFunctionState *PFS);
443  bool ParseMetadata(Metadata *&MD, PerFunctionState *PFS);
444  bool ParseMDTuple(MDNode *&MD, bool IsDistinct = false);
445  bool ParseMDNode(MDNode *&MD);
446  bool ParseMDNodeTail(MDNode *&MD);
447  bool ParseMDNodeVector(SmallVectorImpl<Metadata *> &MDs);
448  bool ParseMetadataAttachment(unsigned &Kind, MDNode *&MD);
449  bool ParseInstructionMetadata(Instruction &Inst);
450  bool ParseGlobalObjectMetadataAttachment(GlobalObject &GO);
451  bool ParseOptionalFunctionMetadata(Function &F);
452 
453  template <class FieldTy>
454  bool ParseMDField(LocTy Loc, StringRef Name, FieldTy &Result);
455  template <class FieldTy> bool ParseMDField(StringRef Name, FieldTy &Result);
456  template <class ParserTy>
457  bool ParseMDFieldsImplBody(ParserTy parseField);
458  template <class ParserTy>
459  bool ParseMDFieldsImpl(ParserTy parseField, LocTy &ClosingLoc);
460  bool ParseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);
461 
462 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
463  bool Parse##CLASS(MDNode *&Result, bool IsDistinct);
464 #include "llvm/IR/Metadata.def"
465 
466  // Function Parsing.
467  struct ArgInfo {
468  LocTy Loc;
469  Type *Ty;
470  AttributeSet Attrs;
471  std::string Name;
472  ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N)
473  : Loc(L), Ty(ty), Attrs(Attr), Name(N) {}
474  };
475  bool ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, bool &isVarArg);
476  bool ParseFunctionHeader(Function *&Fn, bool isDefine);
477  bool ParseFunctionBody(Function &Fn);
478  bool ParseBasicBlock(PerFunctionState &PFS);
479 
480  enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
481 
482  // Instruction Parsing. Each instruction parsing routine can return with a
483  // normal result, an error result, or return having eaten an extra comma.
484  enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
485  int ParseInstruction(Instruction *&Inst, BasicBlock *BB,
486  PerFunctionState &PFS);
487  bool ParseCmpPredicate(unsigned &Pred, unsigned Opc);
488 
489  bool ParseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
490  bool ParseBr(Instruction *&Inst, PerFunctionState &PFS);
491  bool ParseSwitch(Instruction *&Inst, PerFunctionState &PFS);
492  bool ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
493  bool ParseInvoke(Instruction *&Inst, PerFunctionState &PFS);
494  bool ParseResume(Instruction *&Inst, PerFunctionState &PFS);
495  bool ParseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
496  bool ParseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
497  bool ParseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
498  bool ParseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
499  bool ParseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
500 
501  bool ParseArithmetic(Instruction *&I, PerFunctionState &PFS, unsigned Opc,
502  unsigned OperandType);
503  bool ParseLogical(Instruction *&I, PerFunctionState &PFS, unsigned Opc);
504  bool ParseCompare(Instruction *&I, PerFunctionState &PFS, unsigned Opc);
505  bool ParseCast(Instruction *&I, PerFunctionState &PFS, unsigned Opc);
506  bool ParseSelect(Instruction *&I, PerFunctionState &PFS);
507  bool ParseVA_Arg(Instruction *&I, PerFunctionState &PFS);
508  bool ParseExtractElement(Instruction *&I, PerFunctionState &PFS);
509  bool ParseInsertElement(Instruction *&I, PerFunctionState &PFS);
510  bool ParseShuffleVector(Instruction *&I, PerFunctionState &PFS);
511  int ParsePHI(Instruction *&I, PerFunctionState &PFS);
512  bool ParseLandingPad(Instruction *&I, PerFunctionState &PFS);
513  bool ParseCall(Instruction *&I, PerFunctionState &PFS,
514  CallInst::TailCallKind IsTail);
515  int ParseAlloc(Instruction *&I, PerFunctionState &PFS);
516  int ParseLoad(Instruction *&I, PerFunctionState &PFS);
517  int ParseStore(Instruction *&I, PerFunctionState &PFS);
518  int ParseCmpXchg(Instruction *&I, PerFunctionState &PFS);
519  int ParseAtomicRMW(Instruction *&I, PerFunctionState &PFS);
520  int ParseFence(Instruction *&I, PerFunctionState &PFS);
521  int ParseGetElementPtr(Instruction *&I, PerFunctionState &PFS);
522  int ParseExtractValue(Instruction *&I, PerFunctionState &PFS);
523  int ParseInsertValue(Instruction *&I, PerFunctionState &PFS);
524 
525  // Use-list order directives.
526  bool ParseUseListOrder(PerFunctionState *PFS = nullptr);
527  bool ParseUseListOrderBB();
528  bool ParseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
529  bool sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);
530  };
531 } // End llvm namespace
532 
533 #endif
LLLexer::LocTy Loc
Definition: LLParser.h:60
enum llvm::ValID::@303 Kind
uint64_t CallInst * C
LLParser(StringRef F, SourceMgr &SM, SMDiagnostic &Err, Module *M, SlotMapping *Slots=nullptr, bool UpgradeDebugInfo=true, StringRef DataLayoutString="")
Definition: LLParser.h:150
LLVMContext & Context
void setNoSignedZeros()
Definition: Operator.h:213
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Various leaf nodes.
Definition: ISDOpcodes.h:60
Constant * parseConstantValue(StringRef Asm, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots=nullptr)
Parse a type and a constant value in the given string.
Definition: Parser.cpp:75
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
bool operator<(const ValID &RHS) const
Definition: LLParser.h:77
void setAllowContract(bool B)
Definition: Operator.h:216
LLVMContext & getContext()
Definition: LLParser.h:166
bool Error(LocTy L, const Twine &Msg) const
Definition: LLLexer.cpp:29
void setDataLayout(StringRef Desc)
Set the data layout.
Definition: Module.cpp:355
Metadata node.
Definition: Metadata.h:862
F(f)
unsigned UIntVal
Definition: LLParser.h:61
ELFYAML::ELF_STV Visibility
Definition: ELFYAML.cpp:765
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
This file contains the simple types necessary to represent the attributes associated with functions a...
lltok::Kind Lex()
Definition: LLLexer.h:49
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
ValID(const ValID &RHS)
Definition: LLParser.h:70
Class to represent function types.
Definition: DerivedTypes.h:103
#define T
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
std::string StrVal
Definition: LLParser.h:63
Type * parseTypeAtBeginning(StringRef Asm, unsigned &Read, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots=nullptr)
Parse a string Asm that starts with a type.
Definition: Parser.cpp:103
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
#define P(N)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
This is an important base class in LLVM.
Definition: Constant.h:42
bool UpgradeDebugInfo(Module &M)
Check the debug info version number, if it is out-dated, drop the debug info.
Constant * ConstantVal
Definition: LLParser.h:66
APFloat APFloatVal
Definition: LLParser.h:65
void setAllowReassoc()
Flag setters.
Definition: Operator.h:210
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling...
Definition: SourceMgr.h:41
lltok::Kind getKind() const
Definition: LLLexer.h:55
static bool isAtomic(Instruction *I)
LocTy getLoc() const
Definition: LLLexer.h:54
APSInt APSIntVal
Definition: LLParser.h:64
void setAllowReciprocal()
Definition: Operator.h:214
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:862
Module.h This file contains the declarations for the Module class.
bool isVector(MCInstrInfo const &MCII, MCInst const &MCI)
void setApproxFunc()
Definition: Operator.h:219
ValID()=default
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:222
This struct contains the mappings from the slot numbers to unnamed metadata nodes, global values and types.
Definition: SlotMapping.h:33
FunctionNumber(functionNumber)
Definition: LLParser.cpp:2575
ValID - Represents a reference of a definition of some sort with no type.
Definition: LLParser.h:47
OperandType
Types of operands to CF instructions.
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
std::unique_ptr< Constant *[]> ConstantStructElts
Definition: LLParser.h:67
FunctionType * FTy
Definition: LLParser.h:62
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
std::string StrVal2
Definition: LLParser.h:63
LLLexer::LocTy LocTy
Definition: LLParser.h:89
LLVM Value Representation.
Definition: Value.h:73
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:160
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A single uniqued string.
Definition: Metadata.h:602
Represents a location in source code.
Definition: SMLoc.h:24
Root of the metadata hierarchy.
Definition: Metadata.h:58
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
TLM
Definition: LLParser.cpp:1368
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:233
static bool parseField(amd_kernel_code_t &C, MCAsmParser &MCParser, raw_ostream &Err)