lib/AsmParser/LLParser.h

   1 //===-- LLParser.h - Parser Class -------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  This file defines the parser class for .ll files.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_LIB_ASMPARSER_LLPARSER_H
  14 #define LLVM_LIB_ASMPARSER_LLPARSER_H
  15
  16 #include "LLLexer.h"
  17 #include "llvm/ADT/Optional.h"
  18 #include "llvm/ADT/StringMap.h"
  19 #include "llvm/IR/Attributes.h"
  20 #include "llvm/IR/Instructions.h"
  21 #include "llvm/IR/Module.h"
  22 #include "llvm/IR/ModuleSummaryIndex.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
  60     LLLexer::LocTy Loc;
  61     unsigned UIntVal;
  62     FunctionType *FTy = nullptr;
  63     std::string StrVal, StrVal2;
  64     APSInt APSIntVal;
  65     APFloat APFloatVal{0.0};
  66     Constant *ConstantVal;
  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) {
  74       assert(!RHS.ConstantStructElts);
  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:
  89     typedef LLLexer::LocTy LocTy;
  90   private:
  91     LLVMContext &Context;
  92     LLLexer Lex;
  93     // Module being parsed, null if we are only parsing summary index.
  94     Module *M;
  95     // Summary index being parsed, null if we are only parsing Module.
  96     ModuleSummaryIndex *Index;
  97     SlotMapping *Slots;
  98
  99     // Instruction metadata resolution.  Each instruction can have a list of
 100     // MDRef info associated with them.
 101     //
 102     // The simpler approach of just creating temporary MDNodes and then calling
 103     // RAUW on them when the definition is processed doesn't work because some
 104     // instruction metadata kinds, such as dbg, get stored in the IR in an
 105     // "optimized" format which doesn't participate in the normal value use
 106     // lists. This means that RAUW doesn't work, even on temporary MDNodes
 107     // which otherwise support RAUW. Instead, we defer resolving MDNode
 108     // references until the definitions have been processed.
 109     struct MDRef {
 110       SMLoc Loc;
 111       unsigned MDKind, MDSlot;
 112     };
 113
 114     SmallVector<Instruction*, 64> InstsWithTBAATag;
 115
 116     // Type resolution handling data structures.  The location is set when we
 117     // have processed a use of the type but not a definition yet.
 118     StringMap<std::pair<Type*, LocTy> > NamedTypes;
 119     std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
 120
 121     std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;
 122     std::map<unsigned, std::pair<TempMDTuple, LocTy>> ForwardRefMDNodes;
 123
 124     // Global Value reference information.
 125     std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;
 126     std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
 127     std::vector<GlobalValue*> NumberedVals;
 128
 129     // Comdat forward reference information.
 130     std::map<std::string, LocTy> ForwardRefComdats;
 131
 132     // References to blockaddress.  The key is the function ValID, the value is
 133     // a list of references to blocks in that function.
 134     std::map<ValID, std::map<ValID, GlobalValue *>> ForwardRefBlockAddresses;
 135     class PerFunctionState;
 136     /// Reference to per-function state to allow basic blocks to be
 137     /// forward-referenced by blockaddress instructions within the same
 138     /// function.
 139     PerFunctionState *BlockAddressPFS;
 140
 141     // Attribute builder reference information.
 142     std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
 143     std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
 144
 145     // Summary global value reference information.
 146     std::map<unsigned, std::vector<std::pair<ValueInfo *, LocTy>>>
 147         ForwardRefValueInfos;
 148     std::map<unsigned, std::vector<std::pair<AliasSummary *, LocTy>>>
 149         ForwardRefAliasees;
 150     std::vector<ValueInfo> NumberedValueInfos;
 151
 152     // Summary type id reference information.
 153     std::map<unsigned, std::vector<std::pair<GlobalValue::GUID *, LocTy>>>
 154         ForwardRefTypeIds;
 155
 156     // Map of module ID to path.
 157     std::map<unsigned, StringRef> ModuleIdMap;
 158
 159     /// Only the llvm-as tool may set this to false to bypass
 160     /// UpgradeDebuginfo so it can generate broken bitcode.
 161     bool UpgradeDebugInfo;
 162
 163     /// DataLayout string to override that in LLVM assembly.
 164     StringRef DataLayoutStr;
 165
 166     std::string SourceFileName;
 167
 168   public:
 169     LLParser(StringRef F, SourceMgr &SM, SMDiagnostic &Err, Module *M,
 170              ModuleSummaryIndex *Index, LLVMContext &Context,
 171              SlotMapping *Slots = nullptr, bool UpgradeDebugInfo = true,
 172              StringRef DataLayoutString = "")
 173         : Context(Context), Lex(F, SM, Err, Context), M(M), Index(Index),
 174           Slots(Slots), BlockAddressPFS(nullptr),
 175           UpgradeDebugInfo(UpgradeDebugInfo), DataLayoutStr(DataLayoutString) {
 176       if (!DataLayoutStr.empty())
 177         M->setDataLayout(DataLayoutStr);
 178     }
 179     bool Run();
 180
 181     bool parseStandaloneConstantValue(Constant *&C, const SlotMapping *Slots);
 182
 183     bool parseTypeAtBeginning(Type *&Ty, unsigned &Read,
 184                               const SlotMapping *Slots);
 185
 186     LLVMContext &getContext() { return Context; }
 187
 188   private:
 189
 190     bool Error(LocTy L, const Twine &Msg) const {
 191       return Lex.Error(L, Msg);
 192     }
 193     bool TokError(const Twine &Msg) const {
 194       return Error(Lex.getLoc(), Msg);
 195     }
 196
 197     /// Restore the internal name and slot mappings using the mappings that
 198     /// were created at an earlier parsing stage.
 199     void restoreParsingState(const SlotMapping *Slots);
 200
 201     /// GetGlobalVal - Get a value with the specified name or ID, creating a
 202     /// forward reference record if needed.  This can return null if the value
 203     /// exists but does not have the right type.
 204     GlobalValue *GetGlobalVal(const std::string &N, Type *Ty, LocTy Loc,
 205                               bool IsCall);
 206     GlobalValue *GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc, bool IsCall);
 207
 208     /// Get a Comdat with the specified name, creating a forward reference
 209     /// record if needed.
 210     Comdat *getComdat(const std::string &Name, LocTy Loc);
 211
 212     // Helper Routines.
 213     bool ParseToken(lltok::Kind T, const char *ErrMsg);
 214     bool EatIfPresent(lltok::Kind T) {
 215       if (Lex.getKind() != T) return false;
 216       Lex.Lex();
 217       return true;
 218     }
 219
 220     FastMathFlags EatFastMathFlagsIfPresent() {
 221       FastMathFlags FMF;
 222       while (true)
 223         switch (Lex.getKind()) {
 224         case lltok::kw_fast: FMF.setFast();            Lex.Lex(); continue;
 225         case lltok::kw_nnan: FMF.setNoNaNs();          Lex.Lex(); continue;
 226         case lltok::kw_ninf: FMF.setNoInfs();          Lex.Lex(); continue;
 227         case lltok::kw_nsz:  FMF.setNoSignedZeros();   Lex.Lex(); continue;
 228         case lltok::kw_arcp: FMF.setAllowReciprocal(); Lex.Lex(); continue;
 229         case lltok::kw_contract:
 230           FMF.setAllowContract(true);
 231           Lex.Lex();
 232           continue;
 233         case lltok::kw_reassoc: FMF.setAllowReassoc(); Lex.Lex(); continue;
 234         case lltok::kw_afn:     FMF.setApproxFunc();   Lex.Lex(); continue;
 235         default: return FMF;
 236         }
 237       return FMF;
 238     }
 239
 240     bool ParseOptionalToken(lltok::Kind T, bool &Present,
 241                             LocTy *Loc = nullptr) {
 242       if (Lex.getKind() != T) {
 243         Present = false;
 244       } else {
 245         if (Loc)
 246           *Loc = Lex.getLoc();
 247         Lex.Lex();
 248         Present = true;
 249       }
 250       return false;
 251     }
 252     bool ParseStringConstant(std::string &Result);
 253     bool ParseUInt32(unsigned &Val);
 254     bool ParseUInt32(unsigned &Val, LocTy &Loc) {
 255       Loc = Lex.getLoc();
 256       return ParseUInt32(Val);
 257     }
 258     bool ParseUInt64(uint64_t &Val);
 259     bool ParseUInt64(uint64_t &Val, LocTy &Loc) {
 260       Loc = Lex.getLoc();
 261       return ParseUInt64(Val);
 262     }
 263     bool ParseFlag(unsigned &Val);
 264
 265     bool ParseStringAttribute(AttrBuilder &B);
 266
 267     bool ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
 268     bool ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
 269     bool ParseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
 270     bool ParseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS = 0);
 271     bool ParseOptionalProgramAddrSpace(unsigned &AddrSpace) {
 272       return ParseOptionalAddrSpace(
 273           AddrSpace, M->getDataLayout().getProgramAddressSpace());
 274     };
 275     bool ParseOptionalParamAttrs(AttrBuilder &B);
 276     bool ParseOptionalReturnAttrs(AttrBuilder &B);
 277     bool ParseOptionalLinkage(unsigned &Res, bool &HasLinkage,
 278                               unsigned &Visibility, unsigned &DLLStorageClass,
 279                               bool &DSOLocal);
 280     void ParseOptionalDSOLocal(bool &DSOLocal);
 281     void ParseOptionalVisibility(unsigned &Res);
 282     void ParseOptionalDLLStorageClass(unsigned &Res);
 283     bool ParseOptionalCallingConv(unsigned &CC);
 284     bool ParseOptionalAlignment(unsigned &Alignment);
 285     bool ParseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
 286     bool ParseScopeAndOrdering(bool isAtomic, SyncScope::ID &SSID,
 287                                AtomicOrdering &Ordering);
 288     bool ParseScope(SyncScope::ID &SSID);
 289     bool ParseOrdering(AtomicOrdering &Ordering);
 290     bool ParseOptionalStackAlignment(unsigned &Alignment);
 291     bool ParseOptionalCommaAlign(unsigned &Alignment, bool &AteExtraComma);
 292     bool ParseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
 293                                      bool &AteExtraComma);
 294     bool ParseOptionalCommaInAlloca(bool &IsInAlloca);
 295     bool parseAllocSizeArguments(unsigned &BaseSizeArg,
 296                                  Optional<unsigned> &HowManyArg);
 297     bool ParseIndexList(SmallVectorImpl<unsigned> &Indices,
 298                         bool &AteExtraComma);
 299     bool ParseIndexList(SmallVectorImpl<unsigned> &Indices) {
 300       bool AteExtraComma;
 301       if (ParseIndexList(Indices, AteExtraComma)) return true;
 302       if (AteExtraComma)
 303         return TokError("expected index");
 304       return false;
 305     }
 306
 307     // Top-Level Entities
 308     bool ParseTopLevelEntities();
 309     bool ValidateEndOfModule();
 310     bool ValidateEndOfIndex();
 311     bool ParseTargetDefinition();
 312     bool ParseModuleAsm();
 313     bool ParseSourceFileName();
 314     bool ParseDepLibs();        // FIXME: Remove in 4.0.
 315     bool ParseUnnamedType();
 316     bool ParseNamedType();
 317     bool ParseDeclare();
 318     bool ParseDefine();
 319
 320     bool ParseGlobalType(bool &IsConstant);
 321     bool ParseUnnamedGlobal();
 322     bool ParseNamedGlobal();
 323     bool ParseGlobal(const std::string &Name, LocTy NameLoc, unsigned Linkage,
 324                      bool HasLinkage, unsigned Visibility,
 325                      unsigned DLLStorageClass, bool DSOLocal,
 326                      GlobalVariable::ThreadLocalMode TLM,
 327                      GlobalVariable::UnnamedAddr UnnamedAddr);
 328     bool parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
 329                              unsigned L, unsigned Visibility,
 330                              unsigned DLLStorageClass, bool DSOLocal,
 331                              GlobalVariable::ThreadLocalMode TLM,
 332                              GlobalVariable::UnnamedAddr UnnamedAddr);
 333     bool parseComdat();
 334     bool ParseStandaloneMetadata();
 335     bool ParseNamedMetadata();
 336     bool ParseMDString(MDString *&Result);
 337     bool ParseMDNodeID(MDNode *&Result);
 338     bool ParseUnnamedAttrGrp();
 339     bool ParseFnAttributeValuePairs(AttrBuilder &B,
 340                                     std::vector<unsigned> &FwdRefAttrGrps,
 341                                     bool inAttrGrp, LocTy &BuiltinLoc);
 342     bool ParseByValWithOptionalType(Type *&Result);
 343
 344     // Module Summary Index Parsing.
 345     bool SkipModuleSummaryEntry();
 346     bool ParseSummaryEntry();
 347     bool ParseModuleEntry(unsigned ID);
 348     bool ParseModuleReference(StringRef &ModulePath);
 349     bool ParseGVReference(ValueInfo &VI, unsigned &GVId);
 350     bool ParseGVEntry(unsigned ID);
 351     bool ParseFunctionSummary(std::string Name, GlobalValue::GUID, unsigned ID);
 352     bool ParseVariableSummary(std::string Name, GlobalValue::GUID, unsigned ID);
 353     bool ParseAliasSummary(std::string Name, GlobalValue::GUID, unsigned ID);
 354     bool ParseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
 355     bool ParseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
 356     bool ParseOptionalFFlags(FunctionSummary::FFlags &FFlags);
 357     bool ParseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls);
 358     bool ParseHotness(CalleeInfo::HotnessType &Hotness);
 359     bool ParseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
 360     bool ParseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
 361     bool ParseVFuncIdList(lltok::Kind Kind,
 362                           std::vector<FunctionSummary::VFuncId> &VFuncIdList);
 363     bool ParseConstVCallList(
 364         lltok::Kind Kind,
 365         std::vector<FunctionSummary::ConstVCall> &ConstVCallList);
 366     using IdToIndexMapType =
 367         std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;
 368     bool ParseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
 369                          IdToIndexMapType &IdToIndexMap, unsigned Index);
 370     bool ParseVFuncId(FunctionSummary::VFuncId &VFuncId,
 371                       IdToIndexMapType &IdToIndexMap, unsigned Index);
 372     bool ParseOptionalVTableFuncs(VTableFuncList &VTableFuncs);
 373     bool ParseOptionalRefs(std::vector<ValueInfo> &Refs);
 374     bool ParseTypeIdEntry(unsigned ID);
 375     bool ParseTypeIdSummary(TypeIdSummary &TIS);
 376     bool ParseTypeIdCompatibleVtableEntry(unsigned ID);
 377     bool ParseTypeTestResolution(TypeTestResolution &TTRes);
 378     bool ParseOptionalWpdResolutions(
 379         std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);
 380     bool ParseWpdRes(WholeProgramDevirtResolution &WPDRes);
 381     bool ParseOptionalResByArg(
 382         std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
 383             &ResByArg);
 384     bool ParseArgs(std::vector<uint64_t> &Args);
 385     void AddGlobalValueToIndex(std::string Name, GlobalValue::GUID,
 386                                GlobalValue::LinkageTypes Linkage, unsigned ID,
 387                                std::unique_ptr<GlobalValueSummary> Summary);
 388
 389     // Type Parsing.
 390     bool ParseType(Type *&Result, const Twine &Msg, bool AllowVoid = false);
 391     bool ParseType(Type *&Result, bool AllowVoid = false) {
 392       return ParseType(Result, "expected type", AllowVoid);
 393     }
 394     bool ParseType(Type *&Result, const Twine &Msg, LocTy &Loc,
 395                    bool AllowVoid = false) {
 396       Loc = Lex.getLoc();
 397       return ParseType(Result, Msg, AllowVoid);
 398     }
 399     bool ParseType(Type *&Result, LocTy &Loc, bool AllowVoid = false) {
 400       Loc = Lex.getLoc();
 401       return ParseType(Result, AllowVoid);
 402     }
 403     bool ParseAnonStructType(Type *&Result, bool Packed);
 404     bool ParseStructBody(SmallVectorImpl<Type*> &Body);
 405     bool ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
 406                                std::pair<Type*, LocTy> &Entry,
 407                                Type *&ResultTy);
 408
 409     bool ParseArrayVectorType(Type *&Result, bool isVector);
 410     bool ParseFunctionType(Type *&Result);
 411
 412     // Function Semantic Analysis.
 413     class PerFunctionState {
 414       LLParser &P;
 415       Function &F;
 416       std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
 417       std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
 418       std::vector<Value*> NumberedVals;
 419
 420       /// FunctionNumber - If this is an unnamed function, this is the slot
 421       /// number of it, otherwise it is -1.
 422       int FunctionNumber;
 423     public:
 424       PerFunctionState(LLParser &p, Function &f, int functionNumber);
 425       ~PerFunctionState();
 426
 427       Function &getFunction() const { return F; }
 428
 429       bool FinishFunction();
 430
 431       /// GetVal - Get a value with the specified name or ID, creating a
 432       /// forward reference record if needed.  This can return null if the value
 433       /// exists but does not have the right type.
 434       Value *GetVal(const std::string &Name, Type *Ty, LocTy Loc, bool IsCall);
 435       Value *GetVal(unsigned ID, Type *Ty, LocTy Loc, bool IsCall);
 436
 437       /// SetInstName - After an instruction is parsed and inserted into its
 438       /// basic block, this installs its name.
 439       bool SetInstName(int NameID, const std::string &NameStr, LocTy NameLoc,
 440                        Instruction *Inst);
 441
 442       /// GetBB - Get a basic block with the specified name or ID, creating a
 443       /// forward reference record if needed.  This can return null if the value
 444       /// is not a BasicBlock.
 445       BasicBlock *GetBB(const std::string &Name, LocTy Loc);
 446       BasicBlock *GetBB(unsigned ID, LocTy Loc);
 447
 448       /// DefineBB - Define the specified basic block, which is either named or
 449       /// unnamed.  If there is an error, this returns null otherwise it returns
 450       /// the block being defined.
 451       BasicBlock *DefineBB(const std::string &Name, int NameID, LocTy Loc);
 452
 453       bool resolveForwardRefBlockAddresses();
 454     };
 455
 456     bool ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
 457                              PerFunctionState *PFS, bool IsCall);
 458
 459     Value *checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
 460                                   Value *Val, bool IsCall);
 461
 462     bool parseConstantValue(Type *Ty, Constant *&C);
 463     bool ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
 464     bool ParseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
 465       return ParseValue(Ty, V, &PFS);
 466     }
 467
 468     bool ParseValue(Type *Ty, Value *&V, LocTy &Loc,
 469                     PerFunctionState &PFS) {
 470       Loc = Lex.getLoc();
 471       return ParseValue(Ty, V, &PFS);
 472     }
 473
 474     bool ParseTypeAndValue(Value *&V, PerFunctionState *PFS);
 475     bool ParseTypeAndValue(Value *&V, PerFunctionState &PFS) {
 476       return ParseTypeAndValue(V, &PFS);
 477     }
 478     bool ParseTypeAndValue(Value *&V, LocTy &Loc, PerFunctionState &PFS) {
 479       Loc = Lex.getLoc();
 480       return ParseTypeAndValue(V, PFS);
 481     }
 482     bool ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
 483                                 PerFunctionState &PFS);
 484     bool ParseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
 485       LocTy Loc;
 486       return ParseTypeAndBasicBlock(BB, Loc, PFS);
 487     }
 488
 489
 490     struct ParamInfo {
 491       LocTy Loc;
 492       Value *V;
 493       AttributeSet Attrs;
 494       ParamInfo(LocTy loc, Value *v, AttributeSet attrs)
 495           : Loc(loc), V(v), Attrs(attrs) {}
 496     };
 497     bool ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
 498                             PerFunctionState &PFS,
 499                             bool IsMustTailCall = false,
 500                             bool InVarArgsFunc = false);
 501
 502     bool
 503     ParseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
 504                                 PerFunctionState &PFS);
 505
 506     bool ParseExceptionArgs(SmallVectorImpl<Value *> &Args,
 507                             PerFunctionState &PFS);
 508
 509     // Constant Parsing.
 510     bool ParseValID(ValID &ID, PerFunctionState *PFS = nullptr);
 511     bool ParseGlobalValue(Type *Ty, Constant *&C);
 512     bool ParseGlobalTypeAndValue(Constant *&V);
 513     bool ParseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
 514                                 Optional<unsigned> *InRangeOp = nullptr);
 515     bool parseOptionalComdat(StringRef GlobalName, Comdat *&C);
 516     bool ParseMetadataAsValue(Value *&V, PerFunctionState &PFS);
 517     bool ParseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
 518                               PerFunctionState *PFS);
 519     bool ParseMetadata(Metadata *&MD, PerFunctionState *PFS);
 520     bool ParseMDTuple(MDNode *&MD, bool IsDistinct = false);
 521     bool ParseMDNode(MDNode *&N);
 522     bool ParseMDNodeTail(MDNode *&N);
 523     bool ParseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
 524     bool ParseMetadataAttachment(unsigned &Kind, MDNode *&MD);
 525     bool ParseInstructionMetadata(Instruction &Inst);
 526     bool ParseGlobalObjectMetadataAttachment(GlobalObject &GO);
 527     bool ParseOptionalFunctionMetadata(Function &F);
 528
 529     template <class FieldTy>
 530     bool ParseMDField(LocTy Loc, StringRef Name, FieldTy &Result);
 531     template <class FieldTy> bool ParseMDField(StringRef Name, FieldTy &Result);
 532     template <class ParserTy>
 533     bool ParseMDFieldsImplBody(ParserTy parseField);
 534     template <class ParserTy>
 535     bool ParseMDFieldsImpl(ParserTy parseField, LocTy &ClosingLoc);
 536     bool ParseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);
 537
 538 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)                                  \
 539   bool Parse##CLASS(MDNode *&Result, bool IsDistinct);
 540 #include "llvm/IR/Metadata.def"
 541
 542     // Function Parsing.
 543     struct ArgInfo {
 544       LocTy Loc;
 545       Type *Ty;
 546       AttributeSet Attrs;
 547       std::string Name;
 548       ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N)
 549           : Loc(L), Ty(ty), Attrs(Attr), Name(N) {}
 550     };
 551     bool ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, bool &isVarArg);
 552     bool ParseFunctionHeader(Function *&Fn, bool isDefine);
 553     bool ParseFunctionBody(Function &Fn);
 554     bool ParseBasicBlock(PerFunctionState &PFS);
 555
 556     enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
 557
 558     // Instruction Parsing.  Each instruction parsing routine can return with a
 559     // normal result, an error result, or return having eaten an extra comma.
 560     enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
 561     int ParseInstruction(Instruction *&Inst, BasicBlock *BB,
 562                          PerFunctionState &PFS);
 563     bool ParseCmpPredicate(unsigned &P, unsigned Opc);
 564
 565     bool ParseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
 566     bool ParseBr(Instruction *&Inst, PerFunctionState &PFS);
 567     bool ParseSwitch(Instruction *&Inst, PerFunctionState &PFS);
 568     bool ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
 569     bool ParseInvoke(Instruction *&Inst, PerFunctionState &PFS);
 570     bool ParseResume(Instruction *&Inst, PerFunctionState &PFS);
 571     bool ParseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
 572     bool ParseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
 573     bool ParseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
 574     bool ParseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
 575     bool ParseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
 576     bool ParseCallBr(Instruction *&Inst, PerFunctionState &PFS);
 577
 578     bool ParseUnaryOp(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,
 579                       bool IsFP);
 580     bool ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,
 581                          bool IsFP);
 582     bool ParseLogical(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
 583     bool ParseCompare(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
 584     bool ParseCast(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
 585     bool ParseSelect(Instruction *&Inst, PerFunctionState &PFS);
 586     bool ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS);
 587     bool ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
 588     bool ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
 589     bool ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
 590     int ParsePHI(Instruction *&Inst, PerFunctionState &PFS);
 591     bool ParseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
 592     bool ParseCall(Instruction *&Inst, PerFunctionState &PFS,
 593                    CallInst::TailCallKind TCK);
 594     int ParseAlloc(Instruction *&Inst, PerFunctionState &PFS);
 595     int ParseLoad(Instruction *&Inst, PerFunctionState &PFS);
 596     int ParseStore(Instruction *&Inst, PerFunctionState &PFS);
 597     int ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
 598     int ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
 599     int ParseFence(Instruction *&Inst, PerFunctionState &PFS);
 600     int ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
 601     int ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
 602     int ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
 603
 604     // Use-list order directives.
 605     bool ParseUseListOrder(PerFunctionState *PFS = nullptr);
 606     bool ParseUseListOrderBB();
 607     bool ParseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
 608     bool sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);
 609   };
 610 } // End llvm namespace
 611
 612 #endif