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);
306 void parseOptionalDLLStorageClass(
unsigned &Res);
307 bool parseOptionalCallingConv(
unsigned &
CC);
308 bool parseOptionalAlignment(MaybeAlign &Alignment,
309 bool AllowParens =
false);
314 std::optional<MemoryEffects> parseMemoryAttr();
315 unsigned parseNoFPClassAttr();
316 bool parseScopeAndOrdering(
bool IsAtomic,
SyncScope::ID &SSID,
320 bool parseOptionalStackAlignment(
unsigned &Alignment);
321 bool parseOptionalCommaAlign(MaybeAlign &Alignment,
bool &AteExtraComma);
322 bool parseOptionalCommaAddrSpace(
unsigned &AddrSpace,
LocTy &Loc,
323 bool &AteExtraComma);
324 bool parseAllocSizeArguments(
unsigned &BaseSizeArg,
325 std::optional<unsigned> &HowManyArg);
326 bool parseVScaleRangeArguments(
unsigned &MinValue,
unsigned &MaxValue);
327 bool parseIndexList(SmallVectorImpl<unsigned> &Indices,
328 bool &AteExtraComma);
329 bool parseIndexList(SmallVectorImpl<unsigned> &Indices) {
331 if (parseIndexList(Indices, AteExtraComma))
334 return tokError(
"expected index");
339 bool parseTopLevelEntities();
340 void dropUnknownMetadataReferences();
341 bool validateEndOfModule(
bool UpgradeDebugInfo);
342 bool validateEndOfIndex();
344 bool parseTargetDefinition(std::string &TentativeDLStr,
LocTy &DLStrLoc);
345 bool parseModuleAsm();
346 bool parseSourceFileName();
347 bool parseUnnamedType();
348 bool parseNamedType();
352 bool parseGlobalType(
bool &IsConstant);
353 bool parseUnnamedGlobal();
354 bool parseNamedGlobal();
355 bool parseGlobal(
const std::string &
Name,
unsigned NameID,
LocTy NameLoc,
356 unsigned Linkage,
bool HasLinkage,
unsigned Visibility,
357 unsigned DLLStorageClass,
bool DSOLocal,
360 bool parseAliasOrIFunc(
const std::string &
Name,
unsigned NameID,
361 LocTy NameLoc,
unsigned L,
unsigned Visibility,
362 unsigned DLLStorageClass,
bool DSOLocal,
366 bool parseStandaloneMetadata();
367 bool parseNamedMetadata();
368 bool parseMDString(MDString *&Result);
369 bool parseMDNodeID(MDNode *&Result);
370 bool parseUnnamedAttrGrp();
371 bool parseFnAttributeValuePairs(AttrBuilder &
B,
372 std::vector<unsigned> &FwdRefAttrGrps,
373 bool inAttrGrp,
LocTy &BuiltinLoc);
374 bool parseRangeAttr(AttrBuilder &
B);
375 bool parseRequiredTypeAttr(AttrBuilder &
B,
lltok::Kind AttrToken,
379 bool skipModuleSummaryEntry();
380 bool parseSummaryEntry();
381 bool parseModuleEntry(
unsigned ID);
382 bool parseModuleReference(StringRef &ModulePath);
383 bool parseGVReference(ValueInfo &VI,
unsigned &GVId);
384 bool parseSummaryIndexFlags();
385 bool parseBlockCount();
386 bool parseGVEntry(
unsigned ID);
390 bool parseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
391 bool parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
392 bool parseOptionalFFlags(FunctionSummary::FFlags &FFlags);
393 bool parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls);
395 bool parseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
396 bool parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
398 std::vector<FunctionSummary::VFuncId> &VFuncIdList);
399 bool parseConstVCallList(
401 std::vector<FunctionSummary::ConstVCall> &ConstVCallList);
402 using IdToIndexMapType =
403 std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;
404 bool parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
405 IdToIndexMapType &IdToIndexMap,
unsigned Index);
406 bool parseVFuncId(FunctionSummary::VFuncId &VFuncId,
407 IdToIndexMapType &IdToIndexMap,
unsigned Index);
409 bool parseOptionalParamAccesses(
410 std::vector<FunctionSummary::ParamAccess> &Params);
411 bool parseParamNo(
uint64_t &ParamNo);
412 using IdLocListType = std::vector<std::pair<unsigned, LocTy>>;
413 bool parseParamAccess(FunctionSummary::ParamAccess &Param,
414 IdLocListType &IdLocList);
415 bool parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call,
416 IdLocListType &IdLocList);
417 bool parseParamAccessOffset(ConstantRange &Range);
418 bool parseOptionalRefs(std::vector<ValueInfo> &Refs);
419 bool parseTypeIdEntry(
unsigned ID);
420 bool parseTypeIdSummary(TypeIdSummary &TIS);
421 bool parseTypeIdCompatibleVtableEntry(
unsigned ID);
422 bool parseTypeTestResolution(TypeTestResolution &TTRes);
423 bool parseOptionalWpdResolutions(
424 std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);
425 bool parseWpdRes(WholeProgramDevirtResolution &WPDRes);
426 bool parseOptionalResByArg(
427 std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
429 bool parseArgs(std::vector<uint64_t> &Args);
432 std::unique_ptr<GlobalValueSummary> Summary,
434 bool parseOptionalAllocs(std::vector<AllocInfo> &Allocs);
435 bool parseMemProfs(std::vector<MIBInfo> &MIBs);
437 bool parseOptionalCallsites(std::vector<CallsiteInfo> &Callsites);
440 bool parseType(
Type *&Result,
const Twine &Msg,
bool AllowVoid =
false);
441 bool parseType(
Type *&Result,
bool AllowVoid =
false) {
442 return parseType(Result,
"expected type", AllowVoid);
444 bool parseType(
Type *&Result,
const Twine &Msg,
LocTy &Loc,
445 bool AllowVoid =
false) {
447 return parseType(Result, Msg, AllowVoid);
449 bool parseType(
Type *&Result,
LocTy &Loc,
bool AllowVoid =
false) {
451 return parseType(Result, AllowVoid);
453 bool parseAnonStructType(
Type *&Result,
bool Packed);
454 bool parseStructBody(SmallVectorImpl<Type *> &Body);
455 bool parseStructDefinition(SMLoc TypeLoc, StringRef
Name,
456 std::pair<Type *, LocTy> &Entry,
459 bool parseArrayVectorType(
Type *&Result,
bool IsVector);
460 bool parseFunctionType(
Type *&Result);
461 bool parseTargetExtType(
Type *&Result);
464 class PerFunctionState {
467 std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
468 std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
469 NumberedValues<Value *> NumberedVals;
476 PerFunctionState(LLParser &p, Function &f,
int functionNumber,
477 ArrayRef<unsigned> UnnamedArgNums);
480 Function &getFunction()
const {
return F; }
482 bool finishFunction();
492 bool setInstName(
int NameID,
const std::string &NameStr,
LocTy NameLoc,
506 bool resolveForwardRefBlockAddresses();
509 bool convertValIDToValue(Type *Ty, ValID &
ID, Value *&V,
510 PerFunctionState *PFS);
512 Value *checkValidVariableType(
LocTy Loc,
const Twine &
Name, Type *Ty,
515 bool parseConstantValue(Type *Ty, Constant *&
C);
516 bool parseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
517 bool parseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
518 return parseValue(Ty, V, &PFS);
521 bool parseValue(Type *Ty, Value *&V,
LocTy &Loc, PerFunctionState &PFS) {
523 return parseValue(Ty, V, &PFS);
526 bool parseTypeAndValue(Value *&V, PerFunctionState *PFS);
527 bool parseTypeAndValue(Value *&V, PerFunctionState &PFS) {
528 return parseTypeAndValue(V, &PFS);
530 bool parseTypeAndValue(Value *&V,
LocTy &Loc, PerFunctionState &PFS) {
532 return parseTypeAndValue(V, PFS);
534 bool parseTypeAndBasicBlock(BasicBlock *&BB,
LocTy &Loc,
535 PerFunctionState &PFS);
536 bool parseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
538 return parseTypeAndBasicBlock(BB, Loc, PFS);
545 ParamInfo(
LocTy loc, Value *v, AttributeSet attrs)
546 : Loc(loc),
V(
v),
Attrs(attrs) {}
548 bool parseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
549 PerFunctionState &PFS,
bool IsMustTailCall =
false,
550 bool InVarArgsFunc =
false);
553 parseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
554 PerFunctionState &PFS);
556 bool parseExceptionArgs(SmallVectorImpl<Value *> &Args,
557 PerFunctionState &PFS);
559 bool resolveFunctionType(Type *RetType,
560 const SmallVector<ParamInfo, 16> &ArgList,
564 bool parseValID(ValID &
ID, PerFunctionState *PFS,
565 Type *ExpectedTy =
nullptr);
566 bool parseGlobalValue(Type *Ty, Constant *&
C);
567 bool parseGlobalTypeAndValue(Constant *&V);
568 bool parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts);
569 bool parseOptionalComdat(StringRef GlobalName, Comdat *&
C);
570 bool parseSanitizer(GlobalVariable *GV);
571 bool parseMetadataAsValue(Value *&V, PerFunctionState &PFS);
572 bool parseValueAsMetadata(Metadata *&MD,
const Twine &TypeMsg,
573 PerFunctionState *PFS);
574 bool parseDIArgList(Metadata *&MD, PerFunctionState *PFS);
575 bool parseMetadata(Metadata *&MD, PerFunctionState *PFS);
576 bool parseMDTuple(MDNode *&MD,
bool IsDistinct =
false);
577 bool parseMDNode(MDNode *&
N);
578 bool parseMDNodeTail(MDNode *&
N);
579 bool parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
580 bool parseMetadataAttachment(
unsigned &Kind, MDNode *&MD);
581 bool parseDebugRecord(DbgRecord *&DR, PerFunctionState &PFS);
582 bool parseInstructionMetadata(Instruction &Inst);
583 bool parseGlobalObjectMetadataAttachment(GlobalObject &GO);
584 bool parseOptionalFunctionMetadata(Function &
F);
586 template <
class FieldTy>
587 bool parseMDField(
LocTy Loc, StringRef
Name, FieldTy &Result);
588 template <
class FieldTy>
bool parseMDField(StringRef
Name, FieldTy &Result);
589 template <
class ParserTy>
bool parseMDFieldsImplBody(ParserTy ParseField);
590 template <
class ParserTy>
591 bool parseMDFieldsImpl(ParserTy ParseField,
LocTy &ClosingLoc);
592 bool parseSpecializedMDNode(MDNode *&
N,
bool IsDistinct =
false);
594#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
595 bool parse##CLASS(MDNode *&Result, bool IsDistinct);
596#include "llvm/IR/Metadata.def"
604 ArgInfo(
LocTy L, Type *ty, AttributeSet Attr,
const std::string &
N)
605 : Loc(L), Ty(ty), Attrs(Attr), Name(
N) {}
607 bool parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
608 SmallVectorImpl<unsigned> &UnnamedArgNums,
610 bool parseFunctionHeader(Function *&Fn,
bool IsDefine,
611 unsigned &FunctionNumber,
612 SmallVectorImpl<unsigned> &UnnamedArgNums);
613 bool parseFunctionBody(Function &Fn,
unsigned FunctionNumber,
614 ArrayRef<unsigned> UnnamedArgNums);
615 bool parseBasicBlock(PerFunctionState &PFS);
617 enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
621 enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
622 int parseInstruction(Instruction *&Inst, BasicBlock *BB,
623 PerFunctionState &PFS);
624 bool parseCmpPredicate(
unsigned &
P,
unsigned Opc);
626 bool parseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
627 bool parseBr(Instruction *&Inst, PerFunctionState &PFS);
628 bool parseSwitch(Instruction *&Inst, PerFunctionState &PFS);
629 bool parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
630 bool parseInvoke(Instruction *&Inst, PerFunctionState &PFS);
631 bool parseResume(Instruction *&Inst, PerFunctionState &PFS);
632 bool parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
633 bool parseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
634 bool parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
635 bool parseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
636 bool parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
637 bool parseCallBr(Instruction *&Inst, PerFunctionState &PFS);
639 bool parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc,
641 bool parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
642 unsigned Opc,
bool IsFP);
643 bool parseLogical(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
644 bool parseCompare(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
645 bool parseCast(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
646 bool parseSelect(Instruction *&Inst, PerFunctionState &PFS);
647 bool parseVAArg(Instruction *&Inst, PerFunctionState &PFS);
648 bool parseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
649 bool parseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
650 bool parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
651 int parsePHI(Instruction *&Inst, PerFunctionState &PFS);
652 bool parseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
653 bool parseCall(Instruction *&Inst, PerFunctionState &PFS,
655 int parseAlloc(Instruction *&Inst, PerFunctionState &PFS);
656 int parseLoad(Instruction *&Inst, PerFunctionState &PFS);
657 int parseStore(Instruction *&Inst, PerFunctionState &PFS);
658 int parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
659 int parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
660 int parseFence(Instruction *&Inst, PerFunctionState &PFS);
661 int parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
662 int parseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
663 int parseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
664 bool parseFreeze(Instruction *&
I, PerFunctionState &PFS);
667 bool parseUseListOrder(PerFunctionState *PFS =
nullptr);
668 bool parseUseListOrderBB();
669 bool parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
670 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