Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/AsmParser/LLParser.h
Line
Count
Source (jump to first uncovered line)
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
4.76M
    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
1.23k
          APFloatVal(RHS.APFloatVal), ConstantVal(RHS.ConstantVal) {
74
1.23k
      assert(!RHS.ConstantStructElts);
75
1.23k
    }
76
77
2.08k
    bool operator<(const ValID &RHS) const {
78
2.08k
      if (Kind == t_LocalID || 
Kind == t_GlobalID2.05k
)
79
30
        return UIntVal < RHS.UIntVal;
80
2.05k
      assert((Kind == t_LocalName || Kind == t_GlobalName ||
81
2.05k
              Kind == t_ConstantStruct || Kind == t_PackedConstantStruct) &&
82
2.05k
             "Ordering not defined for this ValID kind yet");
83
2.05k
      return StrVal < RHS.StrVal;
84
2.05k
    }
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
40.2k
          UpgradeDebugInfo(UpgradeDebugInfo), DataLayoutStr(DataLayoutString) {
176
40.2k
      if (!DataLayoutStr.empty())
177
84
        M->setDataLayout(DataLayoutStr);
178
40.2k
    }
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
0
    LLVMContext &getContext() { return Context; }
187
188
  private:
189
190
224
    bool Error(LocTy L, const Twine &Msg) const {
191
224
      return Lex.Error(L, Msg);
192
224
    }
193
51
    bool TokError(const Twine &Msg) const {
194
51
      return Error(Lex.getLoc(), Msg);
195
51
    }
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
11.8M
    bool EatIfPresent(lltok::Kind T) {
215
11.8M
      if (Lex.getKind() != T) 
return false8.88M
;
216
2.94M
      Lex.Lex();
217
2.94M
      return true;
218
2.94M
    }
219
220
278k
    FastMathFlags EatFastMathFlagsIfPresent() {
221
278k
      FastMathFlags FMF;
222
287k
      while (true)
223
287k
        switch (Lex.getKind()) {
224
287k
        
case lltok::kw_fast: FMF.setFast(); Lex.Lex(); continue4.99k
;
225
287k
        
case lltok::kw_nnan: FMF.setNoNaNs(); Lex.Lex(); continue1.36k
;
226
287k
        
case lltok::kw_ninf: FMF.setNoInfs(); Lex.Lex(); continue347
;
227
287k
        
case lltok::kw_nsz: FMF.setNoSignedZeros(); Lex.Lex(); continue829
;
228
287k
        
case lltok::kw_arcp: FMF.setAllowReciprocal(); Lex.Lex(); continue222
;
229
287k
        case lltok::kw_contract:
230
251
          FMF.setAllowContract(true);
231
251
          Lex.Lex();
232
251
          continue;
233
287k
        
case lltok::kw_reassoc: FMF.setAllowReassoc(); Lex.Lex(); continue493
;
234
287k
        
case lltok::kw_afn: FMF.setApproxFunc(); Lex.Lex(); continue142
;
235
287k
        
default: return FMF278k
;
236
287k
        }
237
278k
      
return FMF0
;
238
278k
    }
239
240
    bool ParseOptionalToken(lltok::Kind T, bool &Present,
241
62.2k
                            LocTy *Loc = nullptr) {
242
62.2k
      if (Lex.getKind() != T) {
243
52.9k
        Present = false;
244
52.9k
      } else {
245
9.25k
        if (Loc)
246
44
          *Loc = Lex.getLoc();
247
9.25k
        Lex.Lex();
248
9.25k
        Present = true;
249
9.25k
      }
250
62.2k
      return false;
251
62.2k
    }
252
    bool ParseStringConstant(std::string &Result);
253
    bool ParseUInt32(unsigned &Val);
254
0
    bool ParseUInt32(unsigned &Val, LocTy &Loc) {
255
0
      Loc = Lex.getLoc();
256
0
      return ParseUInt32(Val);
257
0
    }
258
    bool ParseUInt64(uint64_t &Val);
259
0
    bool ParseUInt64(uint64_t &Val, LocTy &Loc) {
260
0
      Loc = Lex.getLoc();
261
0
      return ParseUInt64(Val);
262
0
    }
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
569k
    bool ParseOptionalProgramAddrSpace(unsigned &AddrSpace) {
272
569k
      return ParseOptionalAddrSpace(
273
569k
          AddrSpace, M->getDataLayout().getProgramAddressSpace());
274
569k
    };
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
21
    bool ParseIndexList(SmallVectorImpl<unsigned> &Indices) {
300
21
      bool AteExtraComma;
301
21
      if (ParseIndexList(Indices, AteExtraComma)) 
return true0
;
302
21
      if (AteExtraComma)
303
0
        return TokError("expected index");
304
21
      return false;
305
21
    }
306
307
    // Top-Level Entities
308
    bool ParseTopLevelEntities();
309
    bool ValidateEndOfModule();
310
    bool ValidateEndOfIndex();
311
    bool ParseTargetDefinition();
312
    bool ParseModuleAsm();
313
    bool ParseSourceFileName();
314
    bool ParseDepLibs();        // FIXME: Remove in 4.0.
315
    bool ParseUnnamedType();
316
    bool ParseNamedType();
317
    bool ParseDeclare();
318
    bool ParseDefine();
319
320
    bool ParseGlobalType(bool &IsConstant);
321
    bool ParseUnnamedGlobal();
322
    bool ParseNamedGlobal();
323
    bool ParseGlobal(const std::string &Name, LocTy NameLoc, unsigned Linkage,
324
                     bool HasLinkage, unsigned Visibility,
325
                     unsigned DLLStorageClass, bool DSOLocal,
326
                     GlobalVariable::ThreadLocalMode TLM,
327
                     GlobalVariable::UnnamedAddr UnnamedAddr);
328
    bool parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
329
                             unsigned L, unsigned Visibility,
330
                             unsigned DLLStorageClass, bool DSOLocal,
331
                             GlobalVariable::ThreadLocalMode TLM,
332
                             GlobalVariable::UnnamedAddr UnnamedAddr);
333
    bool parseComdat();
334
    bool ParseStandaloneMetadata();
335
    bool ParseNamedMetadata();
336
    bool ParseMDString(MDString *&Result);
337
    bool ParseMDNodeID(MDNode *&Result);
338
    bool ParseUnnamedAttrGrp();
339
    bool ParseFnAttributeValuePairs(AttrBuilder &B,
340
                                    std::vector<unsigned> &FwdRefAttrGrps,
341
                                    bool inAttrGrp, LocTy &BuiltinLoc);
342
    bool ParseByValWithOptionalType(Type *&Result);
343
344
    // Module Summary Index Parsing.
345
    bool SkipModuleSummaryEntry();
346
    bool ParseSummaryEntry();
347
    bool ParseModuleEntry(unsigned ID);
348
    bool ParseModuleReference(StringRef &ModulePath);
349
    bool ParseGVReference(ValueInfo &VI, unsigned &GVId);
350
    bool ParseGVEntry(unsigned ID);
351
    bool ParseFunctionSummary(std::string Name, GlobalValue::GUID, unsigned ID);
352
    bool ParseVariableSummary(std::string Name, GlobalValue::GUID, unsigned ID);
353
    bool ParseAliasSummary(std::string Name, GlobalValue::GUID, unsigned ID);
354
    bool ParseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
355
    bool ParseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
356
    bool ParseOptionalFFlags(FunctionSummary::FFlags &FFlags);
357
    bool ParseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls);
358
    bool ParseHotness(CalleeInfo::HotnessType &Hotness);
359
    bool ParseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
360
    bool ParseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
361
    bool ParseVFuncIdList(lltok::Kind Kind,
362
                          std::vector<FunctionSummary::VFuncId> &VFuncIdList);
363
    bool ParseConstVCallList(
364
        lltok::Kind Kind,
365
        std::vector<FunctionSummary::ConstVCall> &ConstVCallList);
366
    using IdToIndexMapType =
367
        std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;
368
    bool ParseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
369
                         IdToIndexMapType &IdToIndexMap, unsigned Index);
370
    bool ParseVFuncId(FunctionSummary::VFuncId &VFuncId,
371
                      IdToIndexMapType &IdToIndexMap, unsigned Index);
372
    bool ParseOptionalVTableFuncs(VTableFuncList &VTableFuncs);
373
    bool ParseOptionalRefs(std::vector<ValueInfo> &Refs);
374
    bool ParseTypeIdEntry(unsigned ID);
375
    bool ParseTypeIdSummary(TypeIdSummary &TIS);
376
    bool ParseTypeIdCompatibleVtableEntry(unsigned ID);
377
    bool ParseTypeTestResolution(TypeTestResolution &TTRes);
378
    bool ParseOptionalWpdResolutions(
379
        std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);
380
    bool ParseWpdRes(WholeProgramDevirtResolution &WPDRes);
381
    bool ParseOptionalResByArg(
382
        std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
383
            &ResByArg);
384
    bool ParseArgs(std::vector<uint64_t> &Args);
385
    void AddGlobalValueToIndex(std::string Name, GlobalValue::GUID,
386
                               GlobalValue::LinkageTypes Linkage, unsigned ID,
387
                               std::unique_ptr<GlobalValueSummary> Summary);
388
389
    // Type Parsing.
390
    bool ParseType(Type *&Result, const Twine &Msg, bool AllowVoid = false);
391
7.58M
    bool ParseType(Type *&Result, bool AllowVoid = false) {
392
7.58M
      return ParseType(Result, "expected type", AllowVoid);
393
7.58M
    }
394
    bool ParseType(Type *&Result, const Twine &Msg, LocTy &Loc,
395
30.6k
                   bool AllowVoid = false) {
396
30.6k
      Loc = Lex.getLoc();
397
30.6k
      return ParseType(Result, Msg, AllowVoid);
398
30.6k
    }
399
1.07M
    bool ParseType(Type *&Result, LocTy &Loc, bool AllowVoid = false) {
400
1.07M
      Loc = Lex.getLoc();
401
1.07M
      return ParseType(Result, AllowVoid);
402
1.07M
    }
403
    bool ParseAnonStructType(Type *&Result, bool Packed);
404
    bool ParseStructBody(SmallVectorImpl<Type*> &Body);
405
    bool ParseStructDefinition(SMLoc TypeLoc, StringRef Name,
406
                               std::pair<Type*, LocTy> &Entry,
407
                               Type *&ResultTy);
408
409
    bool ParseArrayVectorType(Type *&Result, bool isVector);
410
    bool ParseFunctionType(Type *&Result);
411
412
    // Function Semantic Analysis.
413
    class PerFunctionState {
414
      LLParser &P;
415
      Function &F;
416
      std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
417
      std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
418
      std::vector<Value*> NumberedVals;
419
420
      /// FunctionNumber - If this is an unnamed function, this is the slot
421
      /// number of it, otherwise it is -1.
422
      int FunctionNumber;
423
    public:
424
      PerFunctionState(LLParser &p, Function &f, int functionNumber);
425
      ~PerFunctionState();
426
427
490k
      Function &getFunction() const { return F; }
428
429
      bool FinishFunction();
430
431
      /// GetVal - Get a value with the specified name or ID, creating a
432
      /// forward reference record if needed.  This can return null if the value
433
      /// exists but does not have the right type.
434
      Value *GetVal(const std::string &Name, Type *Ty, LocTy Loc, bool IsCall);
435
      Value *GetVal(unsigned ID, Type *Ty, LocTy Loc, bool IsCall);
436
437
      /// SetInstName - After an instruction is parsed and inserted into its
438
      /// basic block, this installs its name.
439
      bool SetInstName(int NameID, const std::string &NameStr, LocTy NameLoc,
440
                       Instruction *Inst);
441
442
      /// GetBB - Get a basic block with the specified name or ID, creating a
443
      /// forward reference record if needed.  This can return null if the value
444
      /// is not a BasicBlock.
445
      BasicBlock *GetBB(const std::string &Name, LocTy Loc);
446
      BasicBlock *GetBB(unsigned ID, LocTy Loc);
447
448
      /// DefineBB - Define the specified basic block, which is either named or
449
      /// unnamed.  If there is an error, this returns null otherwise it returns
450
      /// the block being defined.
451
      BasicBlock *DefineBB(const std::string &Name, int NameID, LocTy Loc);
452
453
      bool resolveForwardRefBlockAddresses();
454
    };
455
456
    bool ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
457
                             PerFunctionState *PFS, bool IsCall);
458
459
    Value *checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
460
                                  Value *Val, bool IsCall);
461
462
    bool parseConstantValue(Type *Ty, Constant *&C);
463
    bool ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
464
1.00M
    bool ParseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
465
1.00M
      return ParseValue(Ty, V, &PFS);
466
1.00M
    }
467
468
    bool ParseValue(Type *Ty, Value *&V, LocTy &Loc,
469
0
                    PerFunctionState &PFS) {
470
0
      Loc = Lex.getLoc();
471
0
      return ParseValue(Ty, V, &PFS);
472
0
    }
473
474
    bool ParseTypeAndValue(Value *&V, PerFunctionState *PFS);
475
1.84M
    bool ParseTypeAndValue(Value *&V, PerFunctionState &PFS) {
476
1.84M
      return ParseTypeAndValue(V, &PFS);
477
1.84M
    }
478
1.47M
    bool ParseTypeAndValue(Value *&V, LocTy &Loc, PerFunctionState &PFS) {
479
1.47M
      Loc = Lex.getLoc();
480
1.47M
      return ParseTypeAndValue(V, PFS);
481
1.47M
    }
482
    bool ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
483
                                PerFunctionState &PFS);
484
15.5k
    bool ParseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
485
15.5k
      LocTy Loc;
486
15.5k
      return ParseTypeAndBasicBlock(BB, Loc, PFS);
487
15.5k
    }
488
489
490
    struct ParamInfo {
491
      LocTy Loc;
492
      Value *V;
493
      AttributeSet Attrs;
494
      ParamInfo(LocTy loc, Value *v, AttributeSet attrs)
495
388k
          : Loc(loc), V(v), Attrs(attrs) {}
496
    };
497
    bool ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
498
                            PerFunctionState &PFS,
499
                            bool IsMustTailCall = false,
500
                            bool InVarArgsFunc = false);
501
502
    bool
503
    ParseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
504
                                PerFunctionState &PFS);
505
506
    bool ParseExceptionArgs(SmallVectorImpl<Value *> &Args,
507
                            PerFunctionState &PFS);
508
509
    // Constant Parsing.
510
    bool ParseValID(ValID &ID, PerFunctionState *PFS = nullptr);
511
    bool ParseGlobalValue(Type *Ty, Constant *&C);
512
    bool ParseGlobalTypeAndValue(Constant *&V);
513
    bool ParseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
514
                                Optional<unsigned> *InRangeOp = nullptr);
515
    bool parseOptionalComdat(StringRef GlobalName, Comdat *&C);
516
    bool ParseMetadataAsValue(Value *&V, PerFunctionState &PFS);
517
    bool ParseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
518
                              PerFunctionState *PFS);
519
    bool ParseMetadata(Metadata *&MD, PerFunctionState *PFS);
520
    bool ParseMDTuple(MDNode *&MD, bool IsDistinct = false);
521
    bool ParseMDNode(MDNode *&N);
522
    bool ParseMDNodeTail(MDNode *&N);
523
    bool ParseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
524
    bool ParseMetadataAttachment(unsigned &Kind, MDNode *&MD);
525
    bool ParseInstructionMetadata(Instruction &Inst);
526
    bool ParseGlobalObjectMetadataAttachment(GlobalObject &GO);
527
    bool ParseOptionalFunctionMetadata(Function &F);
528
529
    template <class FieldTy>
530
    bool ParseMDField(LocTy Loc, StringRef Name, FieldTy &Result);
531
    template <class FieldTy> bool ParseMDField(StringRef Name, FieldTy &Result);
532
    template <class ParserTy>
533
    bool ParseMDFieldsImplBody(ParserTy parseField);
534
    template <class ParserTy>
535
    bool ParseMDFieldsImpl(ParserTy parseField, LocTy &ClosingLoc);
536
    bool ParseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);
537
538
#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)                                  \
539
  bool Parse##CLASS(MDNode *&Result, bool IsDistinct);
540
#include "llvm/IR/Metadata.def"
541
542
    // Function Parsing.
543
    struct ArgInfo {
544
      LocTy Loc;
545
      Type *Ty;
546
      AttributeSet Attrs;
547
      std::string Name;
548
      ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N)
549
679k
          : Loc(L), Ty(ty), Attrs(Attr), Name(N) {}
550
    };
551
    bool ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, bool &isVarArg);
552
    bool ParseFunctionHeader(Function *&Fn, bool isDefine);
553
    bool ParseFunctionBody(Function &Fn);
554
    bool ParseBasicBlock(PerFunctionState &PFS);
555
556
    enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
557
558
    // Instruction Parsing.  Each instruction parsing routine can return with a
559
    // normal result, an error result, or return having eaten an extra comma.
560
    enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
561
    int ParseInstruction(Instruction *&Inst, BasicBlock *BB,
562
                         PerFunctionState &PFS);
563
    bool ParseCmpPredicate(unsigned &P, unsigned Opc);
564
565
    bool ParseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
566
    bool ParseBr(Instruction *&Inst, PerFunctionState &PFS);
567
    bool ParseSwitch(Instruction *&Inst, PerFunctionState &PFS);
568
    bool ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
569
    bool ParseInvoke(Instruction *&Inst, PerFunctionState &PFS);
570
    bool ParseResume(Instruction *&Inst, PerFunctionState &PFS);
571
    bool ParseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
572
    bool ParseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
573
    bool ParseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
574
    bool ParseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
575
    bool ParseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
576
    bool ParseCallBr(Instruction *&Inst, PerFunctionState &PFS);
577
578
    bool ParseUnaryOp(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,
579
                      bool IsFP);
580
    bool ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,
581
                         bool IsFP);
582
    bool ParseLogical(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
583
    bool ParseCompare(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
584
    bool ParseCast(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
585
    bool ParseSelect(Instruction *&Inst, PerFunctionState &PFS);
586
    bool ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS);
587
    bool ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
588
    bool ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
589
    bool ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
590
    int ParsePHI(Instruction *&Inst, PerFunctionState &PFS);
591
    bool ParseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
592
    bool ParseCall(Instruction *&Inst, PerFunctionState &PFS,
593
                   CallInst::TailCallKind TCK);
594
    int ParseAlloc(Instruction *&Inst, PerFunctionState &PFS);
595
    int ParseLoad(Instruction *&Inst, PerFunctionState &PFS);
596
    int ParseStore(Instruction *&Inst, PerFunctionState &PFS);
597
    int ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
598
    int ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
599
    int ParseFence(Instruction *&Inst, PerFunctionState &PFS);
600
    int ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
601
    int ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
602
    int ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
603
604
    // Use-list order directives.
605
    bool ParseUseListOrder(PerFunctionState *PFS = nullptr);
606
    bool ParseUseListOrderBB();
607
    bool ParseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
608
    bool sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);
609
  };
610
} // End llvm namespace
611
612
#endif