13#ifndef LLVM_ASMPARSER_LLPARSER_H
14#define LLVM_ASMPARSER_LLPARSER_H
94 assert(
Kind ==
RHS.Kind &&
"Comparing ValIDs of different kinds");
99 "Ordering not defined for this ValID kind yet");
129 std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
131 std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;
132 std::map<unsigned, std::pair<TempMDTuple, LocTy>> ForwardRefMDNodes;
135 std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;
136 std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
140 std::map<std::string, LocTy> ForwardRefComdats;
144 std::map<ValID, std::map<ValID, GlobalValue *>> ForwardRefBlockAddresses;
145 class PerFunctionState;
149 PerFunctionState *BlockAddressPFS;
156 std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentNames;
157 std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentIDs;
160 std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
161 std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
164 std::map<unsigned, std::vector<std::pair<ValueInfo *, LocTy>>>
165 ForwardRefValueInfos;
166 std::map<unsigned, std::vector<std::pair<AliasSummary *, LocTy>>>
168 std::vector<ValueInfo> NumberedValueInfos;
171 std::map<unsigned, std::vector<std::pair<GlobalValue::GUID *, LocTy>>>
175 std::map<unsigned, StringRef> ModuleIdMap;
179 bool UpgradeDebugInfo;
181 bool SeenNewDbgInfoFormat =
false;
182 bool SeenOldDbgInfoFormat =
false;
184 std::string SourceFileName;
192 BlockAddressPFS(nullptr) {}
194 bool UpgradeDebugInfo,
202 const SlotMapping *Slots);
208 bool tokError(
const Twine &Msg)
const {
return error(Lex.
getLoc(), Msg); }
210 bool checkValueID(
LocTy L, StringRef Kind, StringRef Prefix,
211 unsigned NextID,
unsigned ID)
const;
215 void restoreParsingState(
const SlotMapping *Slots);
220 GlobalValue *getGlobalVal(
const std::string &
N,
Type *Ty,
LocTy Loc);
221 GlobalValue *getGlobalVal(
unsigned ID,
Type *Ty,
LocTy Loc);
225 Comdat *getComdat(
const std::string &
Name,
LocTy Loc);
230 if (Lex.
getKind() !=
T)
return false;
235 FastMathFlags EatFastMathFlagsIfPresent() {
245 FMF.setAllowContract(
true);
256 LocTy *Loc =
nullptr) {
267 bool parseStringConstant(std::string &Result);
268 bool parseUInt32(
unsigned &Val);
269 bool parseUInt32(
unsigned &Val,
LocTy &Loc) {
271 return parseUInt32(Val);
276 return parseUInt64(Val);
278 bool parseFlag(
unsigned &Val);
280 bool parseStringAttribute(AttrBuilder &
B);
285 bool parseOptionalAddrSpace(
unsigned &AddrSpace,
unsigned DefaultAS = 0);
286 bool parseOptionalProgramAddrSpace(
unsigned &AddrSpace) {
287 return parseOptionalAddrSpace(
288 AddrSpace,
M->getDataLayout().getProgramAddressSpace());
292 bool parseOptionalParamOrReturnAttrs(AttrBuilder &
B,
bool IsParam);
293 bool parseOptionalParamAttrs(AttrBuilder &
B) {
294 return parseOptionalParamOrReturnAttrs(
B,
true);
296 bool parseOptionalReturnAttrs(AttrBuilder &
B) {
297 return parseOptionalParamOrReturnAttrs(
B,
false);
299 bool parseOptionalLinkage(
unsigned &Res,
bool &HasLinkage,
300 unsigned &Visibility,
unsigned &DLLStorageClass,
302 void parseOptionalDSOLocal(
bool &DSOLocal);
303 void parseOptionalVisibility(
unsigned &Res);
304 void parseOptionalDLLStorageClass(
unsigned &Res);
305 bool parseOptionalCallingConv(
unsigned &
CC);
306 bool parseOptionalAlignment(MaybeAlign &Alignment,
307 bool AllowParens =
false);
312 std::optional<MemoryEffects> parseMemoryAttr();
313 unsigned parseNoFPClassAttr();
314 bool parseScopeAndOrdering(
bool IsAtomic,
SyncScope::ID &SSID,
318 bool parseOptionalStackAlignment(
unsigned &Alignment);
319 bool parseOptionalCommaAlign(MaybeAlign &Alignment,
bool &AteExtraComma);
320 bool parseOptionalCommaAddrSpace(
unsigned &AddrSpace,
LocTy &Loc,
321 bool &AteExtraComma);
322 bool parseAllocSizeArguments(
unsigned &BaseSizeArg,
323 std::optional<unsigned> &HowManyArg);
324 bool parseVScaleRangeArguments(
unsigned &MinValue,
unsigned &MaxValue);
325 bool parseIndexList(SmallVectorImpl<unsigned> &Indices,
326 bool &AteExtraComma);
327 bool parseIndexList(SmallVectorImpl<unsigned> &Indices) {
329 if (parseIndexList(Indices, AteExtraComma))
332 return tokError(
"expected index");
337 bool parseTopLevelEntities();
338 void dropUnknownMetadataReferences();
339 bool validateEndOfModule(
bool UpgradeDebugInfo);
340 bool validateEndOfIndex();
342 bool parseTargetDefinition(std::string &TentativeDLStr,
LocTy &DLStrLoc);
343 bool parseModuleAsm();
344 bool parseSourceFileName();
345 bool parseUnnamedType();
346 bool parseNamedType();
350 bool parseGlobalType(
bool &IsConstant);
351 bool parseUnnamedGlobal();
352 bool parseNamedGlobal();
353 bool parseGlobal(
const std::string &
Name,
unsigned NameID,
LocTy NameLoc,
354 unsigned Linkage,
bool HasLinkage,
unsigned Visibility,
355 unsigned DLLStorageClass,
bool DSOLocal,
358 bool parseAliasOrIFunc(
const std::string &
Name,
unsigned NameID,
359 LocTy NameLoc,
unsigned L,
unsigned Visibility,
360 unsigned DLLStorageClass,
bool DSOLocal,
364 bool parseStandaloneMetadata();
365 bool parseNamedMetadata();
366 bool parseMDString(MDString *&Result);
367 bool parseMDNodeID(MDNode *&Result);
368 bool parseUnnamedAttrGrp();
369 bool parseFnAttributeValuePairs(AttrBuilder &
B,
370 std::vector<unsigned> &FwdRefAttrGrps,
371 bool inAttrGrp,
LocTy &BuiltinLoc);
372 bool parseRangeAttr(AttrBuilder &
B);
373 bool parseRequiredTypeAttr(AttrBuilder &
B,
lltok::Kind AttrToken,
377 bool skipModuleSummaryEntry();
378 bool parseSummaryEntry();
379 bool parseModuleEntry(
unsigned ID);
380 bool parseModuleReference(StringRef &ModulePath);
381 bool parseGVReference(ValueInfo &VI,
unsigned &GVId);
382 bool parseSummaryIndexFlags();
383 bool parseBlockCount();
384 bool parseGVEntry(
unsigned ID);
388 bool parseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
389 bool parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
390 bool parseOptionalFFlags(FunctionSummary::FFlags &FFlags);
391 bool parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls);
393 bool parseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
394 bool parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
396 std::vector<FunctionSummary::VFuncId> &VFuncIdList);
397 bool parseConstVCallList(
399 std::vector<FunctionSummary::ConstVCall> &ConstVCallList);
400 using IdToIndexMapType =
401 std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;
402 bool parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
403 IdToIndexMapType &IdToIndexMap,
unsigned Index);
404 bool parseVFuncId(FunctionSummary::VFuncId &VFuncId,
405 IdToIndexMapType &IdToIndexMap,
unsigned Index);
407 bool parseOptionalParamAccesses(
408 std::vector<FunctionSummary::ParamAccess> &Params);
409 bool parseParamNo(
uint64_t &ParamNo);
410 using IdLocListType = std::vector<std::pair<unsigned, LocTy>>;
411 bool parseParamAccess(FunctionSummary::ParamAccess &Param,
412 IdLocListType &IdLocList);
413 bool parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call,
414 IdLocListType &IdLocList);
415 bool parseParamAccessOffset(ConstantRange &Range);
416 bool parseOptionalRefs(std::vector<ValueInfo> &Refs);
417 bool parseTypeIdEntry(
unsigned ID);
418 bool parseTypeIdSummary(TypeIdSummary &TIS);
419 bool parseTypeIdCompatibleVtableEntry(
unsigned ID);
420 bool parseTypeTestResolution(TypeTestResolution &TTRes);
421 bool parseOptionalWpdResolutions(
422 std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);
423 bool parseWpdRes(WholeProgramDevirtResolution &WPDRes);
424 bool parseOptionalResByArg(
425 std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
427 bool parseArgs(std::vector<uint64_t> &Args);
430 std::unique_ptr<GlobalValueSummary> Summary,
432 bool parseOptionalAllocs(std::vector<AllocInfo> &Allocs);
433 bool parseMemProfs(std::vector<MIBInfo> &MIBs);
435 bool parseOptionalCallsites(std::vector<CallsiteInfo> &Callsites);
438 bool parseType(
Type *&Result,
const Twine &Msg,
bool AllowVoid =
false);
439 bool parseType(
Type *&Result,
bool AllowVoid =
false) {
440 return parseType(Result,
"expected type", AllowVoid);
442 bool parseType(
Type *&Result,
const Twine &Msg,
LocTy &Loc,
443 bool AllowVoid =
false) {
445 return parseType(Result, Msg, AllowVoid);
447 bool parseType(
Type *&Result,
LocTy &Loc,
bool AllowVoid =
false) {
449 return parseType(Result, AllowVoid);
451 bool parseAnonStructType(
Type *&Result,
bool Packed);
452 bool parseStructBody(SmallVectorImpl<Type *> &Body);
453 bool parseStructDefinition(SMLoc TypeLoc, StringRef
Name,
454 std::pair<Type *, LocTy> &Entry,
457 bool parseArrayVectorType(
Type *&Result,
bool IsVector);
458 bool parseFunctionType(
Type *&Result);
459 bool parseTargetExtType(
Type *&Result);
462 class PerFunctionState {
465 std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
466 std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
467 NumberedValues<Value *> NumberedVals;
474 PerFunctionState(LLParser &p, Function &f,
int functionNumber,
475 ArrayRef<unsigned> UnnamedArgNums);
478 Function &getFunction()
const {
return F; }
480 bool finishFunction();
490 bool setInstName(
int NameID,
const std::string &NameStr,
LocTy NameLoc,
504 bool resolveForwardRefBlockAddresses();
507 bool convertValIDToValue(Type *Ty, ValID &
ID, Value *&V,
508 PerFunctionState *PFS);
510 Value *checkValidVariableType(
LocTy Loc,
const Twine &
Name, Type *Ty,
513 bool parseConstantValue(Type *Ty, Constant *&
C);
514 bool parseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
515 bool parseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
516 return parseValue(Ty, V, &PFS);
519 bool parseValue(Type *Ty, Value *&V,
LocTy &Loc, PerFunctionState &PFS) {
521 return parseValue(Ty, V, &PFS);
524 bool parseTypeAndValue(Value *&V, PerFunctionState *PFS);
525 bool parseTypeAndValue(Value *&V, PerFunctionState &PFS) {
526 return parseTypeAndValue(V, &PFS);
528 bool parseTypeAndValue(Value *&V,
LocTy &Loc, PerFunctionState &PFS) {
530 return parseTypeAndValue(V, PFS);
532 bool parseTypeAndBasicBlock(BasicBlock *&BB,
LocTy &Loc,
533 PerFunctionState &PFS);
534 bool parseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
536 return parseTypeAndBasicBlock(BB, Loc, PFS);
543 ParamInfo(
LocTy loc, Value *v, AttributeSet attrs)
544 : Loc(loc),
V(
v),
Attrs(attrs) {}
546 bool parseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
547 PerFunctionState &PFS,
bool IsMustTailCall =
false,
548 bool InVarArgsFunc =
false);
551 parseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
552 PerFunctionState &PFS);
554 bool parseExceptionArgs(SmallVectorImpl<Value *> &Args,
555 PerFunctionState &PFS);
557 bool resolveFunctionType(Type *RetType,
558 const SmallVector<ParamInfo, 16> &ArgList,
562 bool parseValID(ValID &
ID, PerFunctionState *PFS,
563 Type *ExpectedTy =
nullptr);
564 bool parseGlobalValue(Type *Ty, Constant *&
C);
565 bool parseGlobalTypeAndValue(Constant *&V);
566 bool parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts);
567 bool parseOptionalComdat(StringRef GlobalName, Comdat *&
C);
568 bool parseSanitizer(GlobalVariable *GV);
569 bool parseMetadataAsValue(Value *&V, PerFunctionState &PFS);
570 bool parseValueAsMetadata(Metadata *&MD,
const Twine &TypeMsg,
571 PerFunctionState *PFS);
572 bool parseDIArgList(Metadata *&MD, PerFunctionState *PFS);
573 bool parseMetadata(Metadata *&MD, PerFunctionState *PFS);
574 bool parseMDTuple(MDNode *&MD,
bool IsDistinct =
false);
575 bool parseMDNode(MDNode *&
N);
576 bool parseMDNodeTail(MDNode *&
N);
577 bool parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
578 bool parseMetadataAttachment(
unsigned &Kind, MDNode *&MD);
579 bool parseDebugRecord(DbgRecord *&DR, PerFunctionState &PFS);
580 bool parseInstructionMetadata(Instruction &Inst);
581 bool parseGlobalObjectMetadataAttachment(GlobalObject &GO);
582 bool parseOptionalFunctionMetadata(Function &
F);
584 template <
class FieldTy>
585 bool parseMDField(
LocTy Loc, StringRef
Name, FieldTy &Result);
586 template <
class FieldTy>
bool parseMDField(StringRef
Name, FieldTy &Result);
587 template <
class ParserTy>
bool parseMDFieldsImplBody(ParserTy ParseField);
588 template <
class ParserTy>
589 bool parseMDFieldsImpl(ParserTy ParseField,
LocTy &ClosingLoc);
590 bool parseSpecializedMDNode(MDNode *&
N,
bool IsDistinct =
false);
592#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
593 bool parse##CLASS(MDNode *&Result, bool IsDistinct);
594#include "llvm/IR/Metadata.def"
602 ArgInfo(
LocTy L, Type *ty, AttributeSet Attr,
const std::string &
N)
603 : Loc(L), Ty(ty), Attrs(Attr), Name(
N) {}
605 bool parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
606 SmallVectorImpl<unsigned> &UnnamedArgNums,
608 bool parseFunctionHeader(Function *&Fn,
bool IsDefine,
609 unsigned &FunctionNumber,
610 SmallVectorImpl<unsigned> &UnnamedArgNums);
611 bool parseFunctionBody(Function &Fn,
unsigned FunctionNumber,
612 ArrayRef<unsigned> UnnamedArgNums);
613 bool parseBasicBlock(PerFunctionState &PFS);
615 enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
619 enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
620 int parseInstruction(Instruction *&Inst, BasicBlock *BB,
621 PerFunctionState &PFS);
622 bool parseCmpPredicate(
unsigned &
P,
unsigned Opc);
624 bool parseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
625 bool parseBr(Instruction *&Inst, PerFunctionState &PFS);
626 bool parseSwitch(Instruction *&Inst, PerFunctionState &PFS);
627 bool parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
628 bool parseInvoke(Instruction *&Inst, PerFunctionState &PFS);
629 bool parseResume(Instruction *&Inst, PerFunctionState &PFS);
630 bool parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
631 bool parseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
632 bool parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
633 bool parseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
634 bool parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
635 bool parseCallBr(Instruction *&Inst, PerFunctionState &PFS);
637 bool parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc,
639 bool parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
640 unsigned Opc,
bool IsFP);
641 bool parseLogical(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
642 bool parseCompare(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
643 bool parseCast(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
644 bool parseSelect(Instruction *&Inst, PerFunctionState &PFS);
645 bool parseVAArg(Instruction *&Inst, PerFunctionState &PFS);
646 bool parseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
647 bool parseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
648 bool parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
649 int parsePHI(Instruction *&Inst, PerFunctionState &PFS);
650 bool parseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
651 bool parseCall(Instruction *&Inst, PerFunctionState &PFS,
653 int parseAlloc(Instruction *&Inst, PerFunctionState &PFS);
654 int parseLoad(Instruction *&Inst, PerFunctionState &PFS);
655 int parseStore(Instruction *&Inst, PerFunctionState &PFS);
656 int parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
657 int parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
658 int parseFence(Instruction *&Inst, PerFunctionState &PFS);
659 int parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
660 int parseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
661 int parseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
662 bool parseFreeze(Instruction *&
I, PerFunctionState &PFS);
665 bool parseUseListOrder(PerFunctionState *PFS =
nullptr);
666 bool parseUseListOrderBB();
667 bool parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
668 bool sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);
This file defines the StringMap class.
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Machine Check Debug Module
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
An arbitrary precision integer that knows its signedness.
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
This is an important base class in LLVM.
Class to represent function types.
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
LinkageTypes
An enumeration for the kinds of linkage for global values.
lltok::Kind getKind() const
bool Error(LocTy ErrorLoc, const Twine &Msg) const
LLVMContext & getContext()
LLParser(StringRef F, SourceMgr &SM, SMDiagnostic &Err, Module *M, ModuleSummaryIndex *Index, LLVMContext &Context, SlotMapping *Slots=nullptr)
bool parseTypeAtBeginning(Type *&Ty, unsigned &Read, const SlotMapping *Slots)
bool parseStandaloneConstantValue(Constant *&C, const SlotMapping *Slots)
This is an important class for using LLVM in a threaded context.
Class to hold module path string table and global value map, and encapsulate methods for operating on...
A Module instance is used to store all the information related to an LLVM module.
Mapping from value ID to value, which also remembers what the next unused ID is.
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Represents a location in source code.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
StringRef - Represent a constant reference to a string, i.e.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
An efficient, type-erasing, non-owning reference to a callable.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
@ BasicBlock
Various leaf nodes.
This is an optimization pass for GlobalISel generic memory operations.
std::vector< VirtFuncOffset > VTableFuncList
List of functions referenced by a particular vtable definition.
AtomicOrdering
Atomic ordering for LLVM's memory model.
llvm::function_ref< std::optional< std::string >(StringRef, StringRef)> DataLayoutCallbackTy
This struct contains the mappings from the slot numbers to unnamed metadata nodes,...
ValID - Represents a reference of a definition of some sort with no type.
std::unique_ptr< Constant *[]> ConstantStructElts
bool operator<(const ValID &RHS) const
enum llvm::ValID::@36 Kind