LCOV - code coverage report
Current view: top level - lib/AsmParser - LLParser.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 50 51 98.0 %
Date: 2018-07-13 00:08:38 Functions: 8 8 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13