LCOV - code coverage report
Current view: top level - lib/AsmParser - LLParser.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 51 53 96.2 %
Date: 2018-10-14 09:39:32 Functions: 7 8 87.5 %
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             :   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    12163290 :     ValID() = default;
      71        1208 :     ValID(const ValID &RHS)
      72        3624 :         : Kind(RHS.Kind), Loc(RHS.Loc), UIntVal(RHS.UIntVal), FTy(RHS.FTy),
      73             :           StrVal(RHS.StrVal), StrVal2(RHS.StrVal2), APSIntVal(RHS.APSIntVal),
      74        1208 :           APFloatVal(RHS.APFloatVal), ConstantVal(RHS.ConstantVal) {
      75             :       assert(!RHS.ConstantStructElts);
      76        1208 :     }
      77             : 
      78             :     bool operator<(const ValID &RHS) const {
      79        1756 :       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        1723 :       return StrVal < RHS.StrVal;
      85             :     }
      86             :   };
      87             : 
      88             :   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       35573 :     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       35573 :         : Context(Context), Lex(F, SM, Err, Context), M(M), Index(Index),
     175             :           Slots(Slots), BlockAddressPFS(nullptr),
     176       35573 :           UpgradeDebugInfo(UpgradeDebugInfo), DataLayoutStr(DataLayoutString) {
     177       35573 :       if (!DataLayoutStr.empty())
     178          70 :         M->setDataLayout(DataLayoutStr);
     179       35572 :     }
     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         167 :       return Lex.Error(L, Msg);
     193             :     }
     194             :     bool TokError(const Twine &Msg) const {
     195          31 :       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             :                               bool IsCall);
     207             :     GlobalValue *GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc, bool IsCall);
     208             : 
     209             :     /// Get a Comdat with the specified name, creating a forward reference
     210             :     /// record if needed.
     211             :     Comdat *getComdat(const std::string &Name, LocTy Loc);
     212             : 
     213             :     // Helper Routines.
     214             :     bool ParseToken(lltok::Kind T, const char *ErrMsg);
     215             :     bool EatIfPresent(lltok::Kind T) {
     216     8149215 :       if (Lex.getKind() != T) return false;
     217     1967358 :       Lex.Lex();
     218             :       return true;
     219             :     }
     220             : 
     221      205233 :     FastMathFlags EatFastMathFlagsIfPresent() {
     222             :       FastMathFlags FMF;
     223             :       while (true)
     224      212027 :         switch (Lex.getKind()) {
     225        4203 :         case lltok::kw_fast: FMF.setFast();            Lex.Lex(); continue;
     226         896 :         case lltok::kw_nnan: FMF.setNoNaNs();          Lex.Lex(); continue;
     227         215 :         case lltok::kw_ninf: FMF.setNoInfs();          Lex.Lex(); continue;
     228         648 :         case lltok::kw_nsz:  FMF.setNoSignedZeros();   Lex.Lex(); continue;
     229         156 :         case lltok::kw_arcp: FMF.setAllowReciprocal(); Lex.Lex(); continue;
     230             :         case lltok::kw_contract:
     231             :           FMF.setAllowContract(true);
     232         220 :           Lex.Lex();
     233         220 :           continue;
     234         389 :         case lltok::kw_reassoc: FMF.setAllowReassoc(); Lex.Lex(); continue;
     235          67 :         case lltok::kw_afn:     FMF.setApproxFunc();   Lex.Lex(); continue;
     236      205233 :         default: return FMF;
     237             :         }
     238             :       return FMF;
     239             :     }
     240             : 
     241             :     bool ParseOptionalToken(lltok::Kind T, bool &Present,
     242             :                             LocTy *Loc = nullptr) {
     243       59028 :       if (Lex.getKind() != T) {
     244             :         Present = false;
     245             :       } else {
     246             :         if (Loc)
     247             :           *Loc = Lex.getLoc();
     248          34 :         Lex.Lex();
     249             :         Present = true;
     250             :       }
     251             :       return false;
     252             :     }
     253             :     bool ParseStringConstant(std::string &Result);
     254             :     bool ParseUInt32(unsigned &Val);
     255             :     bool ParseUInt32(unsigned &Val, LocTy &Loc) {
     256             :       Loc = Lex.getLoc();
     257             :       return ParseUInt32(Val);
     258             :     }
     259             :     bool ParseUInt64(uint64_t &Val);
     260             :     bool ParseUInt64(uint64_t &Val, LocTy &Loc) {
     261             :       Loc = Lex.getLoc();
     262             :       return ParseUInt64(Val);
     263             :     }
     264             :     bool ParseFlag(unsigned &Val);
     265             : 
     266             :     bool ParseStringAttribute(AttrBuilder &B);
     267             : 
     268             :     bool ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
     269             :     bool ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
     270             :     bool ParseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
     271             :     bool ParseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS = 0);
     272      478875 :     bool ParseOptionalProgramAddrSpace(unsigned &AddrSpace) {
     273      478875 :       return ParseOptionalAddrSpace(
     274      478875 :           AddrSpace, M->getDataLayout().getProgramAddressSpace());
     275             :     };
     276             :     bool ParseOptionalParamAttrs(AttrBuilder &B);
     277             :     bool ParseOptionalReturnAttrs(AttrBuilder &B);
     278             :     bool ParseOptionalLinkage(unsigned &Res, bool &HasLinkage,
     279             :                               unsigned &Visibility, unsigned &DLLStorageClass,
     280             :                               bool &DSOLocal);
     281             :     void ParseOptionalDSOLocal(bool &DSOLocal);
     282             :     void ParseOptionalVisibility(unsigned &Res);
     283             :     void ParseOptionalDLLStorageClass(unsigned &Res);
     284             :     bool ParseOptionalCallingConv(unsigned &CC);
     285             :     bool ParseOptionalAlignment(unsigned &Alignment);
     286             :     bool ParseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
     287             :     bool ParseScopeAndOrdering(bool isAtomic, SyncScope::ID &SSID,
     288             :                                AtomicOrdering &Ordering);
     289             :     bool ParseScope(SyncScope::ID &SSID);
     290             :     bool ParseOrdering(AtomicOrdering &Ordering);
     291             :     bool ParseOptionalStackAlignment(unsigned &Alignment);
     292             :     bool ParseOptionalCommaAlign(unsigned &Alignment, bool &AteExtraComma);
     293             :     bool ParseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
     294             :                                      bool &AteExtraComma);
     295             :     bool ParseOptionalCommaInAlloca(bool &IsInAlloca);
     296             :     bool parseAllocSizeArguments(unsigned &BaseSizeArg,
     297             :                                  Optional<unsigned> &HowManyArg);
     298             :     bool ParseIndexList(SmallVectorImpl<unsigned> &Indices,
     299             :                         bool &AteExtraComma);
     300          21 :     bool ParseIndexList(SmallVectorImpl<unsigned> &Indices) {
     301             :       bool AteExtraComma;
     302          21 :       if (ParseIndexList(Indices, AteExtraComma)) return true;
     303          21 :       if (AteExtraComma)
     304           0 :         return TokError("expected index");
     305             :       return false;
     306             :     }
     307             : 
     308             :     // Top-Level Entities
     309             :     bool ParseTopLevelEntities();
     310             :     bool ValidateEndOfModule();
     311             :     bool ValidateEndOfIndex();
     312             :     bool ParseTargetDefinition();
     313             :     bool ParseModuleAsm();
     314             :     bool ParseSourceFileName();
     315             :     bool ParseDepLibs();        // FIXME: Remove in 4.0.
     316             :     bool ParseUnnamedType();
     317             :     bool ParseNamedType();
     318             :     bool ParseDeclare();
     319             :     bool ParseDefine();
     320             : 
     321             :     bool ParseGlobalType(bool &IsConstant);
     322             :     bool ParseUnnamedGlobal();
     323             :     bool ParseNamedGlobal();
     324             :     bool ParseGlobal(const std::string &Name, LocTy NameLoc, unsigned Linkage,
     325             :                      bool HasLinkage, unsigned Visibility,
     326             :                      unsigned DLLStorageClass, bool DSOLocal,
     327             :                      GlobalVariable::ThreadLocalMode TLM,
     328             :                      GlobalVariable::UnnamedAddr UnnamedAddr);
     329             :     bool parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
     330             :                              unsigned L, unsigned Visibility,
     331             :                              unsigned DLLStorageClass, bool DSOLocal,
     332             :                              GlobalVariable::ThreadLocalMode TLM,
     333             :                              GlobalVariable::UnnamedAddr UnnamedAddr);
     334             :     bool parseComdat();
     335             :     bool ParseStandaloneMetadata();
     336             :     bool ParseNamedMetadata();
     337             :     bool ParseMDString(MDString *&Result);
     338             :     bool ParseMDNodeID(MDNode *&Result);
     339             :     bool ParseUnnamedAttrGrp();
     340             :     bool ParseFnAttributeValuePairs(AttrBuilder &B,
     341             :                                     std::vector<unsigned> &FwdRefAttrGrps,
     342             :                                     bool inAttrGrp, LocTy &BuiltinLoc);
     343             : 
     344             :     // Module Summary Index Parsing.
     345             :     bool SkipModuleSummaryEntry();
     346             :     bool ParseSummaryEntry();
     347             :     bool ParseModuleEntry(unsigned ID);
     348             :     bool ParseModuleReference(StringRef &ModulePath);
     349             :     bool ParseGVReference(ValueInfo &VI, unsigned &GVId);
     350             :     bool ParseGVEntry(unsigned ID);
     351             :     bool ParseFunctionSummary(std::string Name, GlobalValue::GUID, unsigned ID);
     352             :     bool ParseVariableSummary(std::string Name, GlobalValue::GUID, unsigned ID);
     353             :     bool ParseAliasSummary(std::string Name, GlobalValue::GUID, unsigned ID);
     354             :     bool ParseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
     355             :     bool 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      586462 :     bool ParseType(Type *&Result, bool AllowVoid = false) {
     389     7007883 :       return ParseType(Result, "expected type", AllowVoid);
     390             :     }
     391             :     bool ParseType(Type *&Result, const Twine &Msg, LocTy &Loc,
     392             :                    bool AllowVoid = false) {
     393       23336 :       Loc = Lex.getLoc();
     394       23336 :       return ParseType(Result, Msg, AllowVoid);
     395             :     }
     396             :     bool ParseType(Type *&Result, LocTy &Loc, bool AllowVoid = false) {
     397      880044 :       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           0 :       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, 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      842078 :       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      337667 :       return ParseTypeAndValue(V, &PFS);
     474             :     }
     475             :     bool ParseTypeAndValue(Value *&V, LocTy &Loc, PerFunctionState &PFS) {
     476     1285678 :       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       13140 :       LocTy Loc;
     483       13140 :       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      298154 :           : 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      628556 :     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      586460 :           : 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             : 
     574             :     bool ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,
     575             :                          unsigned OperandType);
     576             :     bool ParseLogical(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
     577             :     bool ParseCompare(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
     578             :     bool ParseCast(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
     579             :     bool ParseSelect(Instruction *&Inst, PerFunctionState &PFS);
     580             :     bool ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS);
     581             :     bool ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
     582             :     bool ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
     583             :     bool ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
     584             :     int ParsePHI(Instruction *&Inst, PerFunctionState &PFS);
     585             :     bool ParseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
     586             :     bool ParseCall(Instruction *&Inst, PerFunctionState &PFS,
     587             :                    CallInst::TailCallKind TCK);
     588             :     int ParseAlloc(Instruction *&Inst, PerFunctionState &PFS);
     589             :     int ParseLoad(Instruction *&Inst, PerFunctionState &PFS);
     590             :     int ParseStore(Instruction *&Inst, PerFunctionState &PFS);
     591             :     int ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
     592             :     int ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
     593             :     int ParseFence(Instruction *&Inst, PerFunctionState &PFS);
     594             :     int ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
     595             :     int ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
     596             :     int ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
     597             : 
     598             :     // Use-list order directives.
     599             :     bool ParseUseListOrder(PerFunctionState *PFS = nullptr);
     600             :     bool ParseUseListOrderBB();
     601             :     bool ParseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
     602             :     bool sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);
     603             :   };
     604             : } // End llvm namespace
     605             : 
     606             : #endif

Generated by: LCOV version 1.13