/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 |