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
 343     // Module Summary Index Parsing.
 344     bool SkipModuleSummaryEntry();
 345     bool ParseSummaryEntry();
 346     bool ParseModuleEntry(unsigned ID);
 347     bool ParseModuleReference(StringRef &ModulePath);
 348     bool ParseGVReference(ValueInfo &VI, unsigned &GVId);
 349     bool ParseGVEntry(unsigned ID);
 350     bool ParseFunctionSummary(std::string Name, GlobalValue::GUID, unsigned ID);
 351     bool ParseVariableSummary(std::string Name, GlobalValue::GUID, unsigned ID);
 352     bool ParseAliasSummary(std::string Name, GlobalValue::GUID, unsigned ID);
 353     bool ParseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
 354     bool ParseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
 355     bool ParseOptionalFFlags(FunctionSummary::FFlags &FFlags);
 356     bool ParseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls);
 357     bool ParseHotness(CalleeInfo::HotnessType &Hotness);
 358     bool ParseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
 359     bool ParseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
 360     bool ParseVFuncIdList(lltok::Kind Kind,
 361                           std::vector<FunctionSummary::VFuncId> &VFuncIdList);
 362     bool ParseConstVCallList(
 363         lltok::Kind Kind,
 364         std::vector<FunctionSummary::ConstVCall> &ConstVCallList);
 365     using IdToIndexMapType =
 366         std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;
 367     bool ParseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
 368                          IdToIndexMapType &IdToIndexMap, unsigned Index);
 369     bool ParseVFuncId(FunctionSummary::VFuncId &VFuncId,
 370                       IdToIndexMapType &IdToIndexMap, unsigned Index);
 371     bool ParseOptionalRefs(std::vector<ValueInfo> &Refs);
 372     bool ParseTypeIdEntry(unsigned ID);
 373     bool ParseTypeIdSummary(TypeIdSummary &TIS);
 374     bool ParseTypeTestResolution(TypeTestResolution &TTRes);
 375     bool ParseOptionalWpdResolutions(
 376         std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);
 377     bool ParseWpdRes(WholeProgramDevirtResolution &WPDRes);
 378     bool ParseOptionalResByArg(
 379         std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
 380             &ResByArg);
 381     bool ParseArgs(std::vector<uint64_t> &Args);
 382     void AddGlobalValueToIndex(std::string Name, GlobalValue::GUID,
 383                                GlobalValue::LinkageTypes Linkage, unsigned ID,
 384                                std::unique_ptr<GlobalValueSummary> Summary);
 385
 386     // Type Parsing.
 387     bool ParseType(Type *&Result, const Twine &Msg, bool AllowVoid = false);
 388     bool ParseType(Type *&Result, bool AllowVoid = false) {
 389       return ParseType(Result, "expected type", AllowVoid);
 390     }
 391     bool ParseType(Type *&Result, const Twine &Msg, LocTy &Loc,
 392                    bool AllowVoid = false) {
 393       Loc = Lex.getLoc();
 394       return ParseType(Result, Msg, AllowVoid);
 395     }
 396     bool ParseType(Type *&Result, LocTy &Loc, bool AllowVoid = false) {
 397       Loc = Lex.getLoc();
 398       return ParseType(Result, AllowVoid);
 399     }
 400     bool ParseAnonStructType(Type *&Result, bool Packed);
 401     bool ParseStructBody(SmallVectorImpl<Type*> &Body);
 402     bool ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
 403                                std::pair<Type*, LocTy> &Entry,
 404                                Type *&ResultTy);
 405
 406     bool ParseArrayVectorType(Type *&Result, bool isVector);
 407     bool ParseFunctionType(Type *&Result);
 408
 409     // Function Semantic Analysis.
 410     class PerFunctionState {
 411       LLParser &P;
 412       Function &F;
 413       std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
 414       std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
 415       std::vector<Value*> NumberedVals;
 416
 417       /// FunctionNumber - If this is an unnamed function, this is the slot
 418       /// number of it, otherwise it is -1.
 419       int FunctionNumber;
 420     public:
 421       PerFunctionState(LLParser &p, Function &f, int functionNumber);
 422       ~PerFunctionState();
 423
 424       Function &getFunction() const { return F; }
 425
 426       bool FinishFunction();
 427
 428       /// GetVal - Get a value with the specified name or ID, creating a
 429       /// forward reference record if needed.  This can return null if the value
 430       /// exists but does not have the right type.
 431       Value *GetVal(const std::string &Name, Type *Ty, LocTy Loc, bool IsCall);
 432       Value *GetVal(unsigned ID, Type *Ty, LocTy Loc, bool IsCall);
 433
 434       /// SetInstName - After an instruction is parsed and inserted into its
 435       /// basic block, this installs its name.
 436       bool SetInstName(int NameID, const std::string &NameStr, LocTy NameLoc,
 437                        Instruction *Inst);
 438
 439       /// GetBB - Get a basic block with the specified name or ID, creating a
 440       /// forward reference record if needed.  This can return null if the value
 441       /// is not a BasicBlock.
 442       BasicBlock *GetBB(const std::string &Name, LocTy Loc);
 443       BasicBlock *GetBB(unsigned ID, LocTy Loc);
 444
 445       /// DefineBB - Define the specified basic block, which is either named or
 446       /// unnamed.  If there is an error, this returns null otherwise it returns
 447       /// the block being defined.
 448       BasicBlock *DefineBB(const std::string &Name, int NameID, LocTy Loc);
 449
 450       bool resolveForwardRefBlockAddresses();
 451     };
 452
 453     bool ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
 454                              PerFunctionState *PFS, bool IsCall);
 455
 456     Value *checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
 457                                   Value *Val, bool IsCall);
 458
 459     bool parseConstantValue(Type *Ty, Constant *&C);
 460     bool ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
 461     bool ParseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
 462       return ParseValue(Ty, V, &PFS);
 463     }
 464
 465     bool ParseValue(Type *Ty, Value *&V, LocTy &Loc,
 466                     PerFunctionState &PFS) {
 467       Loc = Lex.getLoc();
 468       return ParseValue(Ty, V, &PFS);
 469     }
 470
 471     bool ParseTypeAndValue(Value *&V, PerFunctionState *PFS);
 472     bool ParseTypeAndValue(Value *&V, PerFunctionState &PFS) {
 473       return ParseTypeAndValue(V, &PFS);
 474     }
 475     bool ParseTypeAndValue(Value *&V, LocTy &Loc, PerFunctionState &PFS) {
 476       Loc = Lex.getLoc();
 477       return ParseTypeAndValue(V, PFS);
 478     }
 479     bool ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
 480                                 PerFunctionState &PFS);
 481     bool ParseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
 482       LocTy Loc;
 483       return ParseTypeAndBasicBlock(BB, Loc, PFS);
 484     }
 485
 486
 487     struct ParamInfo {
 488       LocTy Loc;
 489       Value *V;
 490       AttributeSet Attrs;
 491       ParamInfo(LocTy loc, Value *v, AttributeSet attrs)
 492           : Loc(loc), V(v), Attrs(attrs) {}
 493     };
 494     bool ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
 495                             PerFunctionState &PFS,
 496                             bool IsMustTailCall = false,
 497                             bool InVarArgsFunc = false);
 498
 499     bool
 500     ParseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
 501                                 PerFunctionState &PFS);
 502
 503     bool ParseExceptionArgs(SmallVectorImpl<Value *> &Args,
 504                             PerFunctionState &PFS);
 505
 506     // Constant Parsing.
 507     bool ParseValID(ValID &ID, PerFunctionState *PFS = nullptr);
 508     bool ParseGlobalValue(Type *Ty, Constant *&C);
 509     bool ParseGlobalTypeAndValue(Constant *&V);
 510     bool ParseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
 511                                 Optional<unsigned> *InRangeOp = nullptr);
 512     bool parseOptionalComdat(StringRef GlobalName, Comdat *&C);
 513     bool ParseMetadataAsValue(Value *&V, PerFunctionState &PFS);
 514     bool ParseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
 515                               PerFunctionState *PFS);
 516     bool ParseMetadata(Metadata *&MD, PerFunctionState *PFS);
 517     bool ParseMDTuple(MDNode *&MD, bool IsDistinct = false);
 518     bool ParseMDNode(MDNode *&N);
 519     bool ParseMDNodeTail(MDNode *&N);
 520     bool ParseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
 521     bool ParseMetadataAttachment(unsigned &Kind, MDNode *&MD);
 522     bool ParseInstructionMetadata(Instruction &Inst);
 523     bool ParseGlobalObjectMetadataAttachment(GlobalObject &GO);
 524     bool ParseOptionalFunctionMetadata(Function &F);
 525
 526     template <class FieldTy>
 527     bool ParseMDField(LocTy Loc, StringRef Name, FieldTy &Result);
 528     template <class FieldTy> bool ParseMDField(StringRef Name, FieldTy &Result);
 529     template <class ParserTy>
 530     bool ParseMDFieldsImplBody(ParserTy parseField);
 531     template <class ParserTy>
 532     bool ParseMDFieldsImpl(ParserTy parseField, LocTy &ClosingLoc);
 533     bool ParseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);
 534
 535 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)                                  \
 536   bool Parse##CLASS(MDNode *&Result, bool IsDistinct);
 537 #include "llvm/IR/Metadata.def"
 538
 539     // Function Parsing.
 540     struct ArgInfo {
 541       LocTy Loc;
 542       Type *Ty;
 543       AttributeSet Attrs;
 544       std::string Name;
 545       ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N)
 546           : Loc(L), Ty(ty), Attrs(Attr), Name(N) {}
 547     };
 548     bool ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, bool &isVarArg);
 549     bool ParseFunctionHeader(Function *&Fn, bool isDefine);
 550     bool ParseFunctionBody(Function &Fn);
 551     bool ParseBasicBlock(PerFunctionState &PFS);
 552
 553     enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
 554
 555     // Instruction Parsing.  Each instruction parsing routine can return with a
 556     // normal result, an error result, or return having eaten an extra comma.
 557     enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
 558     int ParseInstruction(Instruction *&Inst, BasicBlock *BB,
 559                          PerFunctionState &PFS);
 560     bool ParseCmpPredicate(unsigned &P, unsigned Opc);
 561
 562     bool ParseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
 563     bool ParseBr(Instruction *&Inst, PerFunctionState &PFS);
 564     bool ParseSwitch(Instruction *&Inst, PerFunctionState &PFS);
 565     bool ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
 566     bool ParseInvoke(Instruction *&Inst, PerFunctionState &PFS);
 567     bool ParseResume(Instruction *&Inst, PerFunctionState &PFS);
 568     bool ParseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
 569     bool ParseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
 570     bool ParseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
 571     bool ParseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
 572     bool ParseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
 573     bool ParseCallBr(Instruction *&Inst, PerFunctionState &PFS);
 574
 575     bool ParseUnaryOp(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,
 576                       unsigned OperandType);
 577     bool ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,
 578                          unsigned OperandType);
 579     bool ParseLogical(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
 580     bool ParseCompare(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
 581     bool ParseCast(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
 582     bool ParseSelect(Instruction *&Inst, PerFunctionState &PFS);
 583     bool ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS);
 584     bool ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
 585     bool ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
 586     bool ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
 587     int ParsePHI(Instruction *&Inst, PerFunctionState &PFS);
 588     bool ParseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
 589     bool ParseCall(Instruction *&Inst, PerFunctionState &PFS,
 590                    CallInst::TailCallKind TCK);
 591     int ParseAlloc(Instruction *&Inst, PerFunctionState &PFS);
 592     int ParseLoad(Instruction *&Inst, PerFunctionState &PFS);
 593     int ParseStore(Instruction *&Inst, PerFunctionState &PFS);
 594     int ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
 595     int ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
 596     int ParseFence(Instruction *&Inst, PerFunctionState &PFS);
 597     int ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
 598     int ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
 599     int ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
 600
 601     // Use-list order directives.
 602     bool ParseUseListOrder(PerFunctionState *PFS = nullptr);
 603     bool ParseUseListOrderBB();
 604     bool ParseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
 605     bool sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);
 606   };
 607 } // End llvm namespace
 608
 609 #endif