LLParser.h

Go to the documentation of this file.

//===-- LLParser.h - Parser Class -------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
//  This file defines the parser class for .ll files.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_ASMPARSER_LLPARSER_H
#define LLVM_ASMPARSER_LLPARSER_H
 
#include "LLLexer.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/FMF.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include <map>
#include <optional>
 
namespace llvm {
  class Module;
  class ConstantRange;
  class FunctionType;
  class GlobalObject;
  class SMDiagnostic;
  class SMLoc;
  class SourceMgr;
  class Type;
  struct MaybeAlign;
  class Function;
  class Value;
  class BasicBlock;
  class Instruction;
  class Constant;
  class GlobalValue;
  class Comdat;
  class MDString;
  class MDNode;
  class MemoryEffects;
  struct SlotMapping;
 
  /// ValID - Represents a reference of a definition of some sort with no type.
  /// There are several cases where we have to parse the value but where the
  /// type can depend on later context.  This may either be a numeric reference
  /// or a symbolic (%var) reference.  This is just a discriminated union.
  struct ValID {
    enum {
      t_LocalID, t_GlobalID,           // ID in UIntVal.
      t_LocalName, t_GlobalName,       // Name in StrVal.
      t_APSInt, t_APFloat,             // Value in APSIntVal/APFloatVal.
      t_Null, t_Undef, t_Zero, t_None, t_Poison, // No value.
      t_EmptyArray,                    // No value:  []
      t_Constant,                      // Value in ConstantVal.
      t_InlineAsm,                     // Value in FTy/StrVal/StrVal2/UIntVal.
      t_ConstantStruct,                // Value in ConstantStructElts.
      t_PackedConstantStruct           // Value in ConstantStructElts.
    } Kind = t_LocalID;
 
    LLLexer::LocTy Loc;
    unsigned UIntVal;
    FunctionType *FTy = nullptr;
    std::string StrVal, StrVal2;
    APSInt APSIntVal;
    APFloat APFloatVal{0.0};
    Constant *ConstantVal;
    std::unique_ptr<Constant *[]> ConstantStructElts;
    bool NoCFI = false;
 
    ValID() = default;
    ValID(const ValID &RHS)
        : Kind(RHS.Kind), Loc(RHS.Loc), UIntVal(RHS.UIntVal), FTy(RHS.FTy),
          StrVal(RHS.StrVal), StrVal2(RHS.StrVal2), APSIntVal(RHS.APSIntVal),
          APFloatVal(RHS.APFloatVal), ConstantVal(RHS.ConstantVal),
          NoCFI(RHS.NoCFI) {
      assert(!RHS.ConstantStructElts);
    }
 
    bool operator<(const ValID &RHS) const {
      assert(Kind == RHS.Kind && "Comparing ValIDs of different kinds");
      if (Kind == t_LocalID || Kind == t_GlobalID)
        return UIntVal < RHS.UIntVal;
      assert((Kind == t_LocalName || Kind == t_GlobalName ||
              Kind == t_ConstantStruct || Kind == t_PackedConstantStruct) &&
             "Ordering not defined for this ValID kind yet");
      return StrVal < RHS.StrVal;
    }
  };
 
  class LLParser {
  public:
    typedef LLLexer::LocTy LocTy;
  private:
    LLVMContext &Context;
    // Lexer to determine whether to use opaque pointers or not.
    LLLexer OPLex;
    LLLexer Lex;
    // Module being parsed, null if we are only parsing summary index.
    Module *M;
    // Summary index being parsed, null if we are only parsing Module.
    ModuleSummaryIndex *Index;
    SlotMapping *Slots;
 
    SmallVector<Instruction*, 64> InstsWithTBAATag;
 
    /// DIAssignID metadata does not support temporary RAUW so we cannot use
    /// the normal metadata forward reference resolution method. Instead,
    /// non-temporary DIAssignID are attached to instructions (recorded here)
    /// then replaced later.
    DenseMap<MDNode *, SmallVector<Instruction *, 2>> TempDIAssignIDAttachments;
 
    // Type resolution handling data structures.  The location is set when we
    // have processed a use of the type but not a definition yet.
    StringMap<std::pair<Type*, LocTy> > NamedTypes;
    std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
 
    std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;
    std::map<unsigned, std::pair<TempMDTuple, LocTy>> ForwardRefMDNodes;
 
    // Global Value reference information.
    std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;
    std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
    std::vector<GlobalValue*> NumberedVals;
 
    // Comdat forward reference information.
    std::map<std::string, LocTy> ForwardRefComdats;
 
    // References to blockaddress.  The key is the function ValID, the value is
    // a list of references to blocks in that function.
    std::map<ValID, std::map<ValID, GlobalValue *>> ForwardRefBlockAddresses;
    class PerFunctionState;
    /// Reference to per-function state to allow basic blocks to be
    /// forward-referenced by blockaddress instructions within the same
    /// function.
    PerFunctionState *BlockAddressPFS;
 
    // References to dso_local_equivalent. The key is the global's ValID, the
    // value is a placeholder value that will be replaced. Note there are two
    // maps for tracking ValIDs that are GlobalNames and ValIDs that are
    // GlobalIDs. These are needed because "operator<" doesn't discriminate
    // between the two.
    std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentNames;
    std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentIDs;
 
    // Attribute builder reference information.
    std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
    std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
 
    // Summary global value reference information.
    std::map<unsigned, std::vector<std::pair<ValueInfo *, LocTy>>>
        ForwardRefValueInfos;
    std::map<unsigned, std::vector<std::pair<AliasSummary *, LocTy>>>
        ForwardRefAliasees;
    std::vector<ValueInfo> NumberedValueInfos;
 
    // Summary type id reference information.
    std::map<unsigned, std::vector<std::pair<GlobalValue::GUID *, LocTy>>>
        ForwardRefTypeIds;
 
    // Map of module ID to path.
    std::map<unsigned, StringRef> ModuleIdMap;
 
    /// Only the llvm-as tool may set this to false to bypass
    /// UpgradeDebuginfo so it can generate broken bitcode.
    bool UpgradeDebugInfo;
 
    std::string SourceFileName;
 
  public:
    LLParser(StringRef F, SourceMgr &SM, SMDiagnostic &Err, Module *M,
             ModuleSummaryIndex *Index, LLVMContext &Context,
             SlotMapping *Slots = nullptr)
        : Context(Context), OPLex(F, SM, Err, Context),
          Lex(F, SM, Err, Context), M(M), Index(Index), Slots(Slots),
          BlockAddressPFS(nullptr) {}
    bool Run(
        bool UpgradeDebugInfo,
        DataLayoutCallbackTy DataLayoutCallback = [](StringRef, StringRef) {
          return std::nullopt;
        });
 
    bool parseStandaloneConstantValue(Constant *&C, const SlotMapping *Slots);
 
    bool parseTypeAtBeginning(Type *&Ty, unsigned &Read,
                              const SlotMapping *Slots);
 
    LLVMContext &getContext() { return Context; }
 
  private:
    bool error(LocTy L, const Twine &Msg) const { return Lex.Error(L, Msg); }
    bool tokError(const Twine &Msg) const { return error(Lex.getLoc(), Msg); }
 
    /// Restore the internal name and slot mappings using the mappings that
    /// were created at an earlier parsing stage.
    void restoreParsingState(const SlotMapping *Slots);
 
    /// getGlobalVal - Get a value with the specified name or ID, creating a
    /// forward reference record if needed.  This can return null if the value
    /// exists but does not have the right type.
    GlobalValue *getGlobalVal(const std::string &N, Type *Ty, LocTy Loc);
    GlobalValue *getGlobalVal(unsigned ID, Type *Ty, LocTy Loc);
 
    /// Get a Comdat with the specified name, creating a forward reference
    /// record if needed.
    Comdat *getComdat(const std::string &Name, LocTy Loc);
 
    // Helper Routines.
    bool parseToken(lltok::Kind T, const char *ErrMsg);
    bool EatIfPresent(lltok::Kind T) {
      if (Lex.getKind() != T) return false;
      Lex.Lex();
      return true;
    }
 
    FastMathFlags EatFastMathFlagsIfPresent() {
      FastMathFlags FMF;
      while (true)
        switch (Lex.getKind()) {
        case lltok::kw_fast: FMF.setFast();            Lex.Lex(); continue;
        case lltok::kw_nnan: FMF.setNoNaNs();          Lex.Lex(); continue;
        case lltok::kw_ninf: FMF.setNoInfs();          Lex.Lex(); continue;
        case lltok::kw_nsz:  FMF.setNoSignedZeros();   Lex.Lex(); continue;
        case lltok::kw_arcp: FMF.setAllowReciprocal(); Lex.Lex(); continue;
        case lltok::kw_contract:
          FMF.setAllowContract(true);
          Lex.Lex();
          continue;
        case lltok::kw_reassoc: FMF.setAllowReassoc(); Lex.Lex(); continue;
        case lltok::kw_afn:     FMF.setApproxFunc();   Lex.Lex(); continue;
        default: return FMF;
        }
      return FMF;
    }
 
    bool parseOptionalToken(lltok::Kind T, bool &Present,
                            LocTy *Loc = nullptr) {
      if (Lex.getKind() != T) {
        Present = false;
      } else {
        if (Loc)
          *Loc = Lex.getLoc();
        Lex.Lex();
        Present = true;
      }
      return false;
    }
    bool parseStringConstant(std::string &Result);
    bool parseUInt32(unsigned &Val);
    bool parseUInt32(unsigned &Val, LocTy &Loc) {
      Loc = Lex.getLoc();
      return parseUInt32(Val);
    }
    bool parseUInt64(uint64_t &Val);
    bool parseUInt64(uint64_t &Val, LocTy &Loc) {
      Loc = Lex.getLoc();
      return parseUInt64(Val);
    }
    bool parseFlag(unsigned &Val);
 
    bool parseStringAttribute(AttrBuilder &B);
 
    bool parseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
    bool parseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
    bool parseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
    bool parseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS = 0);
    bool parseOptionalProgramAddrSpace(unsigned &AddrSpace) {
      return parseOptionalAddrSpace(
          AddrSpace, M->getDataLayout().getProgramAddressSpace());
    };
    bool parseEnumAttribute(Attribute::AttrKind Attr, AttrBuilder &B,
                            bool InAttrGroup);
    bool parseOptionalParamOrReturnAttrs(AttrBuilder &B, bool IsParam);
    bool parseOptionalParamAttrs(AttrBuilder &B) {
      return parseOptionalParamOrReturnAttrs(B, true);
    }
    bool parseOptionalReturnAttrs(AttrBuilder &B) {
      return parseOptionalParamOrReturnAttrs(B, false);
    }
    bool parseOptionalLinkage(unsigned &Res, bool &HasLinkage,
                              unsigned &Visibility, unsigned &DLLStorageClass,
                              bool &DSOLocal);
    void parseOptionalDSOLocal(bool &DSOLocal);
    void parseOptionalVisibility(unsigned &Res);
    void parseOptionalDLLStorageClass(unsigned &Res);
    bool parseOptionalCallingConv(unsigned &CC);
    bool parseOptionalAlignment(MaybeAlign &Alignment,
                                bool AllowParens = false);
    bool parseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
    bool parseOptionalUWTableKind(UWTableKind &Kind);
    bool parseAllocKind(AllocFnKind &Kind);
    std::optional<MemoryEffects> parseMemoryAttr();
    bool parseScopeAndOrdering(bool IsAtomic, SyncScope::ID &SSID,
                               AtomicOrdering &Ordering);
    bool parseScope(SyncScope::ID &SSID);
    bool parseOrdering(AtomicOrdering &Ordering);
    bool parseOptionalStackAlignment(unsigned &Alignment);
    bool parseOptionalCommaAlign(MaybeAlign &Alignment, bool &AteExtraComma);
    bool parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
                                     bool &AteExtraComma);
    bool parseAllocSizeArguments(unsigned &BaseSizeArg,
                                 std::optional<unsigned> &HowManyArg);
    bool parseVScaleRangeArguments(unsigned &MinValue, unsigned &MaxValue);
    bool parseIndexList(SmallVectorImpl<unsigned> &Indices,
                        bool &AteExtraComma);
    bool parseIndexList(SmallVectorImpl<unsigned> &Indices) {
      bool AteExtraComma;
      if (parseIndexList(Indices, AteExtraComma))
        return true;
      if (AteExtraComma)
        return tokError("expected index");
      return false;
    }
 
    // Top-Level Entities
    bool parseTopLevelEntities();
    bool validateEndOfModule(bool UpgradeDebugInfo);
    bool validateEndOfIndex();
    bool parseTargetDefinitions(DataLayoutCallbackTy DataLayoutCallback);
    bool parseTargetDefinition(std::string &TentativeDLStr, LocTy &DLStrLoc);
    bool parseModuleAsm();
    bool parseSourceFileName();
    bool parseUnnamedType();
    bool parseNamedType();
    bool parseDeclare();
    bool parseDefine();
 
    bool parseGlobalType(bool &IsConstant);
    bool parseUnnamedGlobal();
    bool parseNamedGlobal();
    bool parseGlobal(const std::string &Name, LocTy NameLoc, unsigned Linkage,
                     bool HasLinkage, unsigned Visibility,
                     unsigned DLLStorageClass, bool DSOLocal,
                     GlobalVariable::ThreadLocalMode TLM,
                     GlobalVariable::UnnamedAddr UnnamedAddr);
    bool parseAliasOrIFunc(const std::string &Name, LocTy NameLoc, unsigned L,
                           unsigned Visibility, unsigned DLLStorageClass,
                           bool DSOLocal, GlobalVariable::ThreadLocalMode TLM,
                           GlobalVariable::UnnamedAddr UnnamedAddr);
    bool parseComdat();
    bool parseStandaloneMetadata();
    bool parseNamedMetadata();
    bool parseMDString(MDString *&Result);
    bool parseMDNodeID(MDNode *&Result);
    bool parseUnnamedAttrGrp();
    bool parseFnAttributeValuePairs(AttrBuilder &B,
                                    std::vector<unsigned> &FwdRefAttrGrps,
                                    bool inAttrGrp, LocTy &BuiltinLoc);
    bool parseRequiredTypeAttr(AttrBuilder &B, lltok::Kind AttrToken,
                               Attribute::AttrKind AttrKind);
 
    // Module Summary Index Parsing.
    bool skipModuleSummaryEntry();
    bool parseSummaryEntry();
    bool parseModuleEntry(unsigned ID);
    bool parseModuleReference(StringRef &ModulePath);
    bool parseGVReference(ValueInfo &VI, unsigned &GVId);
    bool parseSummaryIndexFlags();
    bool parseBlockCount();
    bool parseGVEntry(unsigned ID);
    bool parseFunctionSummary(std::string Name, GlobalValue::GUID, unsigned ID);
    bool parseVariableSummary(std::string Name, GlobalValue::GUID, unsigned ID);
    bool parseAliasSummary(std::string Name, GlobalValue::GUID, unsigned ID);
    bool parseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
    bool parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
    bool parseOptionalFFlags(FunctionSummary::FFlags &FFlags);
    bool parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls);
    bool parseHotness(CalleeInfo::HotnessType &Hotness);
    bool parseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
    bool parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
    bool parseVFuncIdList(lltok::Kind Kind,
                          std::vector<FunctionSummary::VFuncId> &VFuncIdList);
    bool parseConstVCallList(
        lltok::Kind Kind,
        std::vector<FunctionSummary::ConstVCall> &ConstVCallList);
    using IdToIndexMapType =
        std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;
    bool parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
                         IdToIndexMapType &IdToIndexMap, unsigned Index);
    bool parseVFuncId(FunctionSummary::VFuncId &VFuncId,
                      IdToIndexMapType &IdToIndexMap, unsigned Index);
    bool parseOptionalVTableFuncs(VTableFuncList &VTableFuncs);
    bool parseOptionalParamAccesses(
        std::vector<FunctionSummary::ParamAccess> &Params);
    bool parseParamNo(uint64_t &ParamNo);
    using IdLocListType = std::vector<std::pair<unsigned, LocTy>>;
    bool parseParamAccess(FunctionSummary::ParamAccess &Param,
                          IdLocListType &IdLocList);
    bool parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call,
                              IdLocListType &IdLocList);
    bool parseParamAccessOffset(ConstantRange &Range);
    bool parseOptionalRefs(std::vector<ValueInfo> &Refs);
    bool parseTypeIdEntry(unsigned ID);
    bool parseTypeIdSummary(TypeIdSummary &TIS);
    bool parseTypeIdCompatibleVtableEntry(unsigned ID);
    bool parseTypeTestResolution(TypeTestResolution &TTRes);
    bool parseOptionalWpdResolutions(
        std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);
    bool parseWpdRes(WholeProgramDevirtResolution &WPDRes);
    bool parseOptionalResByArg(
        std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
            &ResByArg);
    bool parseArgs(std::vector<uint64_t> &Args);
    void addGlobalValueToIndex(std::string Name, GlobalValue::GUID,
                               GlobalValue::LinkageTypes Linkage, unsigned ID,
                               std::unique_ptr<GlobalValueSummary> Summary);
    bool parseOptionalAllocs(std::vector<AllocInfo> &Allocs);
    bool parseMemProfs(std::vector<MIBInfo> &MIBs);
    bool parseAllocType(uint8_t &AllocType);
    bool parseOptionalCallsites(std::vector<CallsiteInfo> &Callsites);
 
    // Type Parsing.
    bool parseType(Type *&Result, const Twine &Msg, bool AllowVoid = false);
    bool parseType(Type *&Result, bool AllowVoid = false) {
      return parseType(Result, "expected type", AllowVoid);
    }
    bool parseType(Type *&Result, const Twine &Msg, LocTy &Loc,
                   bool AllowVoid = false) {
      Loc = Lex.getLoc();
      return parseType(Result, Msg, AllowVoid);
    }
    bool parseType(Type *&Result, LocTy &Loc, bool AllowVoid = false) {
      Loc = Lex.getLoc();
      return parseType(Result, AllowVoid);
    }
    bool parseAnonStructType(Type *&Result, bool Packed);
    bool parseStructBody(SmallVectorImpl<Type *> &Body);
    bool parseStructDefinition(SMLoc TypeLoc, StringRef Name,
                               std::pair<Type *, LocTy> &Entry,
                               Type *&ResultTy);
 
    bool parseArrayVectorType(Type *&Result, bool IsVector);
    bool parseFunctionType(Type *&Result);
    bool parseTargetExtType(Type *&Result);
 
    // Function Semantic Analysis.
    class PerFunctionState {
      LLParser &P;
      Function &F;
      std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
      std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
      std::vector<Value*> NumberedVals;
 
      /// FunctionNumber - If this is an unnamed function, this is the slot
      /// number of it, otherwise it is -1.
      int FunctionNumber;
    public:
      PerFunctionState(LLParser &p, Function &f, int functionNumber);
      ~PerFunctionState();
 
      Function &getFunction() const { return F; }
 
      bool finishFunction();
 
      /// GetVal - Get a value with the specified name or ID, creating a
      /// forward reference record if needed.  This can return null if the value
      /// exists but does not have the right type.
      Value *getVal(const std::string &Name, Type *Ty, LocTy Loc);
      Value *getVal(unsigned ID, Type *Ty, LocTy Loc);
 
      /// setInstName - After an instruction is parsed and inserted into its
      /// basic block, this installs its name.
      bool setInstName(int NameID, const std::string &NameStr, LocTy NameLoc,
                       Instruction *Inst);
 
      /// GetBB - Get a basic block with the specified name or ID, creating a
      /// forward reference record if needed.  This can return null if the value
      /// is not a BasicBlock.
      BasicBlock *getBB(const std::string &Name, LocTy Loc);
      BasicBlock *getBB(unsigned ID, LocTy Loc);
 
      /// DefineBB - Define the specified basic block, which is either named or
      /// unnamed.  If there is an error, this returns null otherwise it returns
      /// the block being defined.
      BasicBlock *defineBB(const std::string &Name, int NameID, LocTy Loc);
 
      bool resolveForwardRefBlockAddresses();
    };
 
    bool convertValIDToValue(Type *Ty, ValID &ID, Value *&V,
                             PerFunctionState *PFS);
 
    Value *checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
                                  Value *Val);
 
    bool parseConstantValue(Type *Ty, Constant *&C);
    bool parseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
    bool parseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
      return parseValue(Ty, V, &PFS);
    }
 
    bool parseValue(Type *Ty, Value *&V, LocTy &Loc, PerFunctionState &PFS) {
      Loc = Lex.getLoc();
      return parseValue(Ty, V, &PFS);
    }
 
    bool parseTypeAndValue(Value *&V, PerFunctionState *PFS);
    bool parseTypeAndValue(Value *&V, PerFunctionState &PFS) {
      return parseTypeAndValue(V, &PFS);
    }
    bool parseTypeAndValue(Value *&V, LocTy &Loc, PerFunctionState &PFS) {
      Loc = Lex.getLoc();
      return parseTypeAndValue(V, PFS);
    }
    bool parseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
                                PerFunctionState &PFS);
    bool parseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
      LocTy Loc;
      return parseTypeAndBasicBlock(BB, Loc, PFS);
    }
 
    struct ParamInfo {
      LocTy Loc;
      Value *V;
      AttributeSet Attrs;
      ParamInfo(LocTy loc, Value *v, AttributeSet attrs)
          : Loc(loc), V(v), Attrs(attrs) {}
    };
    bool parseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
                            PerFunctionState &PFS, bool IsMustTailCall = false,
                            bool InVarArgsFunc = false);
 
    bool
    parseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
                                PerFunctionState &PFS);
 
    bool parseExceptionArgs(SmallVectorImpl<Value *> &Args,
                            PerFunctionState &PFS);
 
    bool resolveFunctionType(Type *RetType,
                             const SmallVector<ParamInfo, 16> &ArgList,
                             FunctionType *&FuncTy);
 
    // Constant Parsing.
    bool parseValID(ValID &ID, PerFunctionState *PFS,
                    Type *ExpectedTy = nullptr);
    bool parseGlobalValue(Type *Ty, Constant *&C);
    bool parseGlobalTypeAndValue(Constant *&V);
    bool parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
                                std::optional<unsigned> *InRangeOp = nullptr);
    bool parseOptionalComdat(StringRef GlobalName, Comdat *&C);
    bool parseSanitizer(GlobalVariable *GV);
    bool parseMetadataAsValue(Value *&V, PerFunctionState &PFS);
    bool parseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
                              PerFunctionState *PFS);
    bool parseMetadata(Metadata *&MD, PerFunctionState *PFS);
    bool parseMDTuple(MDNode *&MD, bool IsDistinct = false);
    bool parseMDNode(MDNode *&N);
    bool parseMDNodeTail(MDNode *&N);
    bool parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
    bool parseMetadataAttachment(unsigned &Kind, MDNode *&MD);
    bool parseInstructionMetadata(Instruction &Inst);
    bool parseGlobalObjectMetadataAttachment(GlobalObject &GO);
    bool parseOptionalFunctionMetadata(Function &F);
 
    template <class FieldTy>
    bool parseMDField(LocTy Loc, StringRef Name, FieldTy &Result);
    template <class FieldTy> bool parseMDField(StringRef Name, FieldTy &Result);
    template <class ParserTy> bool parseMDFieldsImplBody(ParserTy ParseField);
    template <class ParserTy>
    bool parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc);
    bool parseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);
 
#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)                                  \
  bool parse##CLASS(MDNode *&Result, bool IsDistinct);
#include "llvm/IR/Metadata.def"
    bool parseDIArgList(MDNode *&Result, bool IsDistinct,
                        PerFunctionState *PFS);
 
    // Function Parsing.
    struct ArgInfo {
      LocTy Loc;
      Type *Ty;
      AttributeSet Attrs;
      std::string Name;
      ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N)
          : Loc(L), Ty(ty), Attrs(Attr), Name(N) {}
    };
    bool parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, bool &IsVarArg);
    bool parseFunctionHeader(Function *&Fn, bool IsDefine);
    bool parseFunctionBody(Function &Fn);
    bool parseBasicBlock(PerFunctionState &PFS);
 
    enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
 
    // Instruction Parsing.  Each instruction parsing routine can return with a
    // normal result, an error result, or return having eaten an extra comma.
    enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
    int parseInstruction(Instruction *&Inst, BasicBlock *BB,
                         PerFunctionState &PFS);
    bool parseCmpPredicate(unsigned &P, unsigned Opc);
 
    bool parseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
    bool parseBr(Instruction *&Inst, PerFunctionState &PFS);
    bool parseSwitch(Instruction *&Inst, PerFunctionState &PFS);
    bool parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
    bool parseInvoke(Instruction *&Inst, PerFunctionState &PFS);
    bool parseResume(Instruction *&Inst, PerFunctionState &PFS);
    bool parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
    bool parseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
    bool parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
    bool parseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
    bool parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
    bool parseCallBr(Instruction *&Inst, PerFunctionState &PFS);
 
    bool parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,
                      bool IsFP);
    bool parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
                         unsigned Opc, bool IsFP);
    bool parseLogical(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
    bool parseCompare(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
    bool parseCast(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
    bool parseSelect(Instruction *&Inst, PerFunctionState &PFS);
    bool parseVAArg(Instruction *&Inst, PerFunctionState &PFS);
    bool parseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
    bool parseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
    bool parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
    int parsePHI(Instruction *&Inst, PerFunctionState &PFS);
    bool parseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
    bool parseCall(Instruction *&Inst, PerFunctionState &PFS,
                   CallInst::TailCallKind TCK);
    int parseAlloc(Instruction *&Inst, PerFunctionState &PFS);
    int parseLoad(Instruction *&Inst, PerFunctionState &PFS);
    int parseStore(Instruction *&Inst, PerFunctionState &PFS);
    int parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
    int parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
    int parseFence(Instruction *&Inst, PerFunctionState &PFS);
    int parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
    int parseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
    int parseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
    bool parseFreeze(Instruction *&I, PerFunctionState &PFS);
 
    // Use-list order directives.
    bool parseUseListOrder(PerFunctionState *PFS = nullptr);
    bool parseUseListOrderBB();
    bool parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
    bool sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);
  };
} // End llvm namespace
 
#endif