131 std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
133 std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;
134 std::map<unsigned, std::pair<TempMDTuple, LocTy>> ForwardRefMDNodes;
137 std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;
138 std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
142 std::map<std::string, LocTy> ForwardRefComdats;
146 std::map<ValID, std::map<ValID, GlobalValue *>> ForwardRefBlockAddresses;
147 class PerFunctionState;
151 PerFunctionState *BlockAddressPFS;
158 std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentNames;
159 std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentIDs;
162 std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
163 std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
166 std::map<unsigned, std::vector<std::pair<ValueInfo *, LocTy>>>
167 ForwardRefValueInfos;
168 std::map<unsigned, std::vector<std::pair<AliasSummary *, LocTy>>>
170 std::vector<ValueInfo> NumberedValueInfos;
173 std::map<unsigned, std::vector<std::pair<GlobalValue::GUID *, LocTy>>>
177 std::map<unsigned, StringRef> ModuleIdMap;
191 bool SeenNewDbgInfoFormat =
false;
192 bool SeenOldDbgInfoFormat =
false;
194 std::string SourceFileName;
196 FileLoc getTokLineColumnPos() {
198 return Lex.getTokLineColumnPos();
202 FileLoc getPrevTokEndLineColumnPos() {
213 : Context(Context), OPLex(
F, SM, Err, Context),
214 Lex(
F, SM, Err, Context), M(M), Index(Index), Slots(Slots),
215 BlockAddressPFS(nullptr), ParserContext(ParserContext) {}
223 const SlotMapping *Slots);
226 const SlotMapping *Slots);
230 const SlotMapping *Slots);
241 bool checkValueID(
LocTy L, StringRef Kind, StringRef Prefix,
242 unsigned NextID,
unsigned ID);
246 void restoreParsingState(
const SlotMapping *Slots);
251 GlobalValue *getGlobalVal(
const std::string &
N,
Type *Ty,
LocTy Loc);
252 GlobalValue *getGlobalVal(
unsigned ID,
Type *Ty,
LocTy Loc);
256 Comdat *getComdat(
const std::string &Name,
LocTy Loc);
261 if (Lex.getKind() !=
T)
return false;
266 FastMathFlags EatFastMathFlagsIfPresent() {
269 switch (Lex.getKind()) {
273 case lltok::kw_nsz: FMF.setNoSignedZeros(); Lex.Lex();
continue;
274 case lltok::kw_arcp: FMF.setAllowReciprocal(); Lex.Lex();
continue;
276 FMF.setAllowContract(
true);
280 case lltok::kw_afn: FMF.setApproxFunc(); Lex.Lex();
continue;
287 LocTy *Loc =
nullptr) {
288 if (Lex.getKind() !=
T) {
298 bool parseStringConstant(std::string &Result);
299 LLVM_ABI bool parseUInt32(
unsigned &Val);
300 bool parseUInt32(
unsigned &Val,
LocTy &Loc) {
302 return parseUInt32(Val);
307 return parseUInt64(Val);
309 bool parseFlag(
unsigned &Val);
311 bool parseStringAttribute(AttrBuilder &
B);
316 LLVM_ABI bool parseOptionalAddrSpace(
unsigned &AddrSpace,
317 unsigned DefaultAS = 0);
318 bool parseOptionalProgramAddrSpace(
unsigned &AddrSpace) {
319 return parseOptionalAddrSpace(
320 AddrSpace, M->getDataLayout().getProgramAddressSpace());
324 LLVM_ABI bool parseOptionalParamOrReturnAttrs(AttrBuilder &
B,
bool IsParam);
325 bool parseOptionalParamAttrs(AttrBuilder &
B) {
326 return parseOptionalParamOrReturnAttrs(
B,
true);
328 bool parseOptionalReturnAttrs(AttrBuilder &
B) {
329 return parseOptionalParamOrReturnAttrs(
B,
false);
331 bool parseOptionalLinkage(
unsigned &Res,
bool &HasLinkage,
332 unsigned &Visibility,
unsigned &DLLStorageClass,
334 void parseOptionalDSOLocal(
bool &DSOLocal);
335 void parseOptionalVisibility(
unsigned &Res);
338 void parseOptionalDLLStorageClass(
unsigned &Res);
339 bool parseOptionalCallingConv(
unsigned &
CC);
340 bool parseOptionalAlignment(MaybeAlign &Alignment,
341 bool AllowParens =
false);
342 bool parseOptionalPrefAlignment(MaybeAlign &Alignment);
345 std::optional<uint64_t> &Bytes,
346 bool ErrorNoBytes =
true);
349 std::optional<MemoryEffects> parseMemoryAttr();
350 std::optional<DenormalMode> parseDenormalFPEnvEntry();
351 std::optional<DenormalFPEnv> parseDenormalFPEnvAttr();
352 unsigned parseNoFPClassAttr();
353 bool parseScopeAndOrdering(
bool IsAtomic,
SyncScope::ID &SSID,
357 bool parseOptionalStackAlignment(
unsigned &Alignment);
358 bool parseOptionalCommaAlign(MaybeAlign &Alignment,
bool &AteExtraComma);
359 bool parseOptionalCommaAddrSpace(
unsigned &AddrSpace,
LocTy &Loc,
360 bool &AteExtraComma);
361 bool parseAllocSizeArguments(
unsigned &BaseSizeArg,
362 std::optional<unsigned> &HowManyArg);
363 bool parseVScaleRangeArguments(
unsigned &MinValue,
unsigned &MaxValue);
364 LLVM_ABI bool parseIndexList(SmallVectorImpl<unsigned> &Indices,
365 bool &AteExtraComma);
366 bool parseIndexList(SmallVectorImpl<unsigned> &Indices) {
368 if (parseIndexList(Indices, AteExtraComma))
371 return tokError(
"expected index");
376 bool parseTopLevelEntities();
377 void dropUnknownMetadataReferences();
379 bool validateEndOfIndex();
381 bool parseTargetDefinition(std::string &TentativeDLStr,
LocTy &DLStrLoc);
382 bool parseModuleAsm();
383 bool parseSourceFileName();
384 bool parseUnnamedType();
385 bool parseNamedType();
389 bool parseGlobalType(
bool &IsConstant);
390 bool parseUnnamedGlobal();
391 bool parseNamedGlobal();
392 bool parseGlobal(
const std::string &Name,
unsigned NameID,
LocTy NameLoc,
393 unsigned Linkage,
bool HasLinkage,
unsigned Visibility,
394 unsigned DLLStorageClass,
bool DSOLocal,
397 bool parseAliasOrIFunc(
const std::string &Name,
unsigned NameID,
398 LocTy NameLoc,
unsigned L,
unsigned Visibility,
399 unsigned DLLStorageClass,
bool DSOLocal,
403 bool parseStandaloneMetadata();
404 bool parseNamedMetadata();
405 bool parseMDString(MDString *&Result);
406 bool parseMDNodeID(MDNode *&Result);
407 bool parseUnnamedAttrGrp();
408 bool parseFnAttributeValuePairs(AttrBuilder &
B,
409 std::vector<unsigned> &FwdRefAttrGrps,
410 bool inAttrGrp,
LocTy &BuiltinLoc);
411 bool parseRangeAttr(AttrBuilder &
B);
412 bool parseInitializesAttr(AttrBuilder &
B);
413 bool parseCapturesAttr(AttrBuilder &
B);
414 bool parseRequiredTypeAttr(AttrBuilder &
B,
lltok::Kind AttrToken,
418 bool skipModuleSummaryEntry();
419 bool parseSummaryEntry();
420 bool parseModuleEntry(
unsigned ID);
421 bool parseModuleReference(StringRef &ModulePath);
422 bool parseGVReference(ValueInfo &VI,
unsigned &GVId);
423 bool parseSummaryIndexFlags();
424 bool parseBlockCount();
425 bool parseCfiFunctions();
426 bool parseGVEntry(
unsigned ID);
430 bool parseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
431 bool parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
432 bool parseOptionalFFlags(FunctionSummary::FFlags &FFlags);
433 bool parseOptionalCalls(SmallVectorImpl<FunctionSummary::EdgeTy> &Calls);
435 bool parseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
436 bool parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
438 std::vector<FunctionSummary::VFuncId> &VFuncIdList);
439 bool parseConstVCallList(
441 std::vector<FunctionSummary::ConstVCall> &ConstVCallList);
442 using IdToIndexMapType =
443 std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;
444 bool parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
445 IdToIndexMapType &IdToIndexMap,
unsigned Index);
446 bool parseVFuncId(FunctionSummary::VFuncId &VFuncId,
447 IdToIndexMapType &IdToIndexMap,
unsigned Index);
449 bool parseOptionalParamAccesses(
450 std::vector<FunctionSummary::ParamAccess> &Params);
451 bool parseParamNo(
uint64_t &ParamNo);
452 using IdLocListType = std::vector<std::pair<unsigned, LocTy>>;
453 bool parseParamAccess(FunctionSummary::ParamAccess &Param,
454 IdLocListType &IdLocList);
455 bool parseParamAccessCall(FunctionSummary::ParamAccess::Call &
Call,
456 IdLocListType &IdLocList);
457 bool parseParamAccessOffset(ConstantRange &
Range);
458 bool parseOptionalRefs(SmallVectorImpl<ValueInfo> &Refs);
459 bool parseTypeIdEntry(
unsigned ID);
460 bool parseTypeIdSummary(TypeIdSummary &TIS);
461 bool parseTypeIdCompatibleVtableEntry(
unsigned ID);
462 bool parseTypeTestResolution(TypeTestResolution &TTRes);
463 bool parseOptionalWpdResolutions(
464 std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);
465 bool parseWpdRes(WholeProgramDevirtResolution &WPDRes);
466 bool parseOptionalResByArg(
467 std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
469 bool parseArgs(std::vector<uint64_t> &Args);
472 std::unique_ptr<GlobalValueSummary> Summary,
474 bool parseOptionalAllocs(std::vector<AllocInfo> &Allocs);
475 bool parseMemProfs(std::vector<MIBInfo> &MIBs);
477 bool parseOptionalCallsites(std::vector<CallsiteInfo> &Callsites);
481 bool AllowVoid =
false);
482 bool parseType(
Type *&Result,
bool AllowVoid =
false) {
483 return parseType(Result,
"expected type", AllowVoid);
485 bool parseType(
Type *&Result,
const Twine &
Msg,
LocTy &Loc,
486 bool AllowVoid =
false) {
488 return parseType(Result,
Msg, AllowVoid);
490 bool parseType(
Type *&Result,
LocTy &Loc,
bool AllowVoid =
false) {
492 return parseType(Result, AllowVoid);
494 bool parseAnonStructType(
Type *&Result,
bool Packed);
495 bool parseStructBody(SmallVectorImpl<Type *> &Body);
496 bool parseStructDefinition(SMLoc TypeLoc, StringRef Name,
497 std::pair<Type *, LocTy> &Entry,
500 bool parseArrayVectorType(
Type *&Result,
bool IsVector);
501 bool parseFunctionType(
Type *&Result);
502 bool parseTargetExtType(
Type *&Result);
505 class PerFunctionState {
508 std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
509 std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
510 NumberedValues<Value *> NumberedVals;
518 ArrayRef<unsigned> UnnamedArgNums);
521 Function &getFunction()
const {
return F; }
533 LLVM_ABI bool setInstName(
int NameID,
const std::string &NameStr,
534 LocTy NameLoc, Instruction *Inst);
548 LLVM_ABI bool resolveForwardRefBlockAddresses();
551 bool convertValIDToValue(
Type *Ty, ValID &ID,
Value *&
V,
552 PerFunctionState *PFS);
554 Value *checkValidVariableType(
LocTy Loc,
const Twine &Name,
Type *Ty,
557 bool parseConstantValue(
Type *Ty, Constant *&
C);
559 bool parseValue(
Type *Ty,
Value *&
V, PerFunctionState &PFS) {
560 return parseValue(Ty,
V, &PFS);
563 bool parseValue(
Type *Ty,
Value *&
V,
LocTy &Loc, PerFunctionState &PFS) {
565 return parseValue(Ty,
V, &PFS);
568 LLVM_ABI bool parseTypeAndValue(
Value *&
V, PerFunctionState *PFS);
569 bool parseTypeAndValue(
Value *&
V, PerFunctionState &PFS) {
570 return parseTypeAndValue(
V, &PFS);
572 bool parseTypeAndValue(
Value *&
V,
LocTy &Loc, PerFunctionState &PFS) {
574 return parseTypeAndValue(
V, PFS);
576 LLVM_ABI bool parseTypeAndBasicBlock(BasicBlock *&BB,
LocTy &Loc,
577 PerFunctionState &PFS);
578 bool parseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
580 return parseTypeAndBasicBlock(BB, Loc, PFS);
587 ParamInfo(
LocTy loc,
Value *v, AttributeSet attrs)
588 : Loc(loc), V(
v), Attrs(attrs) {}
590 bool parseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
591 PerFunctionState &PFS,
bool IsMustTailCall =
false,
592 bool InVarArgsFunc =
false);
595 parseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
596 PerFunctionState &PFS);
598 bool parseExceptionArgs(SmallVectorImpl<Value *> &Args,
599 PerFunctionState &PFS);
602 FunctionType *&FuncTy);
605 bool parseValID(ValID &ID, PerFunctionState *PFS,
606 Type *ExpectedTy =
nullptr);
607 bool parseGlobalValue(
Type *Ty, Constant *&
C);
608 bool parseGlobalTypeAndValue(Constant *&
V);
609 bool parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts);
610 bool parseOptionalComdat(StringRef GlobalName, Comdat *&
C);
611 bool parseSanitizer(GlobalVariable *GV);
612 bool parseMetadataAsValue(
Value *&
V, PerFunctionState &PFS);
613 bool parseValueAsMetadata(
Metadata *&MD,
const Twine &TypeMsg,
614 PerFunctionState *PFS);
615 bool parseDIArgList(
Metadata *&MD, PerFunctionState *PFS);
616 bool parseMetadata(
Metadata *&MD, PerFunctionState *PFS);
617 bool parseMDTuple(MDNode *&MD,
bool IsDistinct =
false);
618 bool parseMDNode(MDNode *&
N);
619 bool parseMDNodeTail(MDNode *&
N);
620 bool parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
621 bool parseMetadataAttachment(
unsigned &Kind, MDNode *&MD);
622 bool parseDebugRecord(DbgRecord *&DR, PerFunctionState &PFS);
623 bool parseInstructionMetadata(Instruction &Inst);
624 bool parseGlobalObjectMetadataAttachment(GlobalObject &GO);
625 bool parseOptionalFunctionMetadata(
Function &
F);
627 template <
class FieldTy>
628 bool parseMDField(
LocTy Loc, StringRef Name, FieldTy &Result);
629 template <
class FieldTy>
bool parseMDField(StringRef Name, FieldTy &Result);
630 template <
class ParserTy>
bool parseMDFieldsImplBody(ParserTy ParseField);
631 template <
class ParserTy>
632 bool parseMDFieldsImpl(ParserTy ParseField,
LocTy &ClosingLoc);
633 bool parseSpecializedMDNode(MDNode *&
N,
bool IsDistinct =
false);
634 bool parseDIExpressionBody(MDNode *&Result,
bool IsDistinct);
636#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
637 bool parse##CLASS(MDNode *&Result, bool IsDistinct);
638#include "llvm/IR/Metadata.def"
644 std::optional<FileLocRange> IdentLoc;
647 ArgInfo(
LocTy L, Type *ty, std::optional<FileLocRange> IdentLoc,
648 AttributeSet Attr,
const std::string &
N)
649 : Loc(L), Ty(ty), IdentLoc(IdentLoc), Attrs(Attr), Name(
N) {}
651 bool parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
652 SmallVectorImpl<unsigned> &UnnamedArgNums,
654 bool parseFunctionHeader(
Function *&Fn,
bool IsDefine,
655 unsigned &FunctionNumber,
656 SmallVectorImpl<unsigned> &UnnamedArgNums);
657 bool parseFunctionBody(
Function &Fn,
unsigned FunctionNumber,
658 ArrayRef<unsigned> UnnamedArgNums);
659 bool parseBasicBlock(PerFunctionState &PFS);
661 enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
665 enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
666 int parseInstruction(Instruction *&Inst, BasicBlock *BB,
667 PerFunctionState &PFS);
668 bool parseCmpPredicate(
unsigned &
P,
unsigned Opc);
670 bool parseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
671 bool parseBr(Instruction *&Inst, PerFunctionState &PFS);
672 bool parseSwitch(Instruction *&Inst, PerFunctionState &PFS);
673 bool parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
674 bool parseInvoke(Instruction *&Inst, PerFunctionState &PFS);
675 bool parseResume(Instruction *&Inst, PerFunctionState &PFS);
676 bool parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
677 bool parseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
678 bool parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
679 bool parseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
680 bool parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
681 bool parseCallBr(Instruction *&Inst, PerFunctionState &PFS);
683 bool parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc,
685 bool parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
686 unsigned Opc,
bool IsFP);
687 bool parseLogical(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
688 bool parseCompare(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
689 bool parseCast(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
690 bool parseSelect(Instruction *&Inst, PerFunctionState &PFS);
691 bool parseVAArg(Instruction *&Inst, PerFunctionState &PFS);
692 bool parseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
693 bool parseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
694 bool parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
695 bool parseBitExtract(Instruction *&Inst, PerFunctionState &PFS);
696 bool parseBitInsert(Instruction *&Inst, PerFunctionState &PFS);
697 int parsePHI(Instruction *&Inst, PerFunctionState &PFS);
698 bool parseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
699 bool parseCall(Instruction *&Inst, PerFunctionState &PFS,
701 int parseAlloc(Instruction *&Inst, PerFunctionState &PFS);
702 int parseLoad(Instruction *&Inst, PerFunctionState &PFS);
703 int parseStore(Instruction *&Inst, PerFunctionState &PFS);
704 int parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
705 int parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
706 int parseFence(Instruction *&Inst, PerFunctionState &PFS);
707 int parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
708 int parseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
709 int parseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
710 bool parseFreeze(Instruction *&
I, PerFunctionState &PFS);
713 bool parseUseListOrder(PerFunctionState *PFS =
nullptr);
714 bool parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
715 bool sortUseListOrder(
Value *
V, ArrayRef<unsigned> Indexes, SMLoc Loc);