13 #ifndef LLVM_ASMPARSER_LLPARSER_H
14 #define LLVM_ASMPARSER_LLPARSER_H
35 template <
typename T>
class Optional;
88 "Ordering not defined for this ValID kind yet");
112 std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
114 std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;
115 std::map<unsigned, std::pair<TempMDTuple, LocTy>> ForwardRefMDNodes;
118 std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;
119 std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
120 std::vector<GlobalValue*> NumberedVals;
123 std::map<std::string, LocTy> ForwardRefComdats;
127 std::map<ValID, std::map<ValID, GlobalValue *>> ForwardRefBlockAddresses;
128 class PerFunctionState;
132 PerFunctionState *BlockAddressPFS;
135 std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
136 std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
139 std::map<unsigned, std::vector<std::pair<ValueInfo *, LocTy>>>
140 ForwardRefValueInfos;
141 std::map<unsigned, std::vector<std::pair<AliasSummary *, LocTy>>>
143 std::vector<ValueInfo> NumberedValueInfos;
146 std::map<unsigned, std::vector<std::pair<GlobalValue::GUID *, LocTy>>>
150 std::map<unsigned, StringRef> ModuleIdMap;
156 std::string SourceFileName;
164 BlockAddressPFS(nullptr) {}
172 const SlotMapping *Slots);
182 void restoreParsingState(
const SlotMapping *Slots);
187 GlobalValue *getGlobalVal(
const std::string &
N,
Type *Ty,
LocTy Loc);
188 GlobalValue *getGlobalVal(
unsigned ID,
Type *Ty,
LocTy Loc);
192 Comdat *getComdat(
const std::string &
Name,
LocTy Loc);
197 if (Lex.
getKind() !=
T)
return false;
202 FastMathFlags EatFastMathFlagsIfPresent() {
212 FMF.setAllowContract(
true);
223 LocTy *Loc =
nullptr) {
234 bool parseStringConstant(std::string &Result);
235 bool parseUInt32(
unsigned &Val);
236 bool parseUInt32(
unsigned &Val,
LocTy &Loc) {
238 return parseUInt32(Val);
243 return parseUInt64(Val);
245 bool parseFlag(
unsigned &Val);
247 bool parseStringAttribute(AttrBuilder &
B);
252 bool parseOptionalAddrSpace(
unsigned &AddrSpace,
unsigned DefaultAS = 0);
253 bool parseOptionalProgramAddrSpace(
unsigned &AddrSpace) {
254 return parseOptionalAddrSpace(
255 AddrSpace,
M->getDataLayout().getProgramAddressSpace());
259 bool parseOptionalParamOrReturnAttrs(AttrBuilder &
B,
bool IsParam);
260 bool parseOptionalParamAttrs(AttrBuilder &
B) {
261 return parseOptionalParamOrReturnAttrs(
B,
true);
263 bool parseOptionalReturnAttrs(AttrBuilder &
B) {
264 return parseOptionalParamOrReturnAttrs(
B,
false);
266 bool parseOptionalLinkage(
unsigned &Res,
bool &HasLinkage,
267 unsigned &Visibility,
unsigned &DLLStorageClass,
269 void parseOptionalDSOLocal(
bool &DSOLocal);
270 void parseOptionalVisibility(
unsigned &Res);
271 void parseOptionalDLLStorageClass(
unsigned &Res);
272 bool parseOptionalCallingConv(
unsigned &CC);
273 bool parseOptionalAlignment(MaybeAlign &Alignment,
274 bool AllowParens =
false);
278 bool parseScopeAndOrdering(
bool IsAtomic,
SyncScope::ID &SSID,
282 bool parseOptionalStackAlignment(
unsigned &Alignment);
283 bool parseOptionalCommaAlign(MaybeAlign &Alignment,
bool &AteExtraComma);
284 bool parseOptionalCommaAddrSpace(
unsigned &AddrSpace,
LocTy &Loc,
285 bool &AteExtraComma);
286 bool parseAllocSizeArguments(
unsigned &BaseSizeArg,
287 Optional<unsigned> &HowManyArg);
288 bool parseVScaleRangeArguments(
unsigned &MinValue,
unsigned &MaxValue);
289 bool parseIndexList(SmallVectorImpl<unsigned> &Indices,
290 bool &AteExtraComma);
291 bool parseIndexList(SmallVectorImpl<unsigned> &Indices) {
293 if (parseIndexList(Indices, AteExtraComma))
296 return tokError(
"expected index");
301 bool parseTopLevelEntities();
303 bool validateEndOfIndex();
304 bool parseTargetDefinitions();
305 bool parseTargetDefinition();
306 bool parseModuleAsm();
307 bool parseSourceFileName();
308 bool parseUnnamedType();
309 bool parseNamedType();
313 bool parseGlobalType(
bool &IsConstant);
314 bool parseUnnamedGlobal();
315 bool parseNamedGlobal();
317 bool HasLinkage,
unsigned Visibility,
318 unsigned DLLStorageClass,
bool DSOLocal,
321 bool parseAliasOrIFunc(
const std::string &
Name,
LocTy NameLoc,
unsigned L,
322 unsigned Visibility,
unsigned DLLStorageClass,
326 bool parseStandaloneMetadata();
327 bool parseNamedMetadata();
328 bool parseMDString(MDString *&Result);
329 bool parseMDNodeID(MDNode *&Result);
330 bool parseUnnamedAttrGrp();
331 bool parseFnAttributeValuePairs(AttrBuilder &
B,
332 std::vector<unsigned> &FwdRefAttrGrps,
333 bool inAttrGrp,
LocTy &BuiltinLoc);
334 bool parseRequiredTypeAttr(AttrBuilder &
B,
lltok::Kind AttrToken,
338 bool skipModuleSummaryEntry();
339 bool parseSummaryEntry();
340 bool parseModuleEntry(
unsigned ID);
341 bool parseModuleReference(StringRef &ModulePath);
342 bool parseGVReference(ValueInfo &
VI,
unsigned &GVId);
343 bool parseSummaryIndexFlags();
344 bool parseBlockCount();
345 bool parseGVEntry(
unsigned ID);
349 bool parseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
350 bool parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
351 bool parseOptionalFFlags(FunctionSummary::FFlags &FFlags);
352 bool parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls);
354 bool parseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
355 bool parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
357 std::vector<FunctionSummary::VFuncId> &VFuncIdList);
358 bool parseConstVCallList(
360 std::vector<FunctionSummary::ConstVCall> &ConstVCallList);
361 using IdToIndexMapType =
362 std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;
363 bool parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
364 IdToIndexMapType &IdToIndexMap,
unsigned Index);
365 bool parseVFuncId(FunctionSummary::VFuncId &VFuncId,
366 IdToIndexMapType &IdToIndexMap,
unsigned Index);
368 bool parseOptionalParamAccesses(
369 std::vector<FunctionSummary::ParamAccess> &Params);
370 bool parseParamNo(
uint64_t &ParamNo);
371 using IdLocListType = std::vector<std::pair<unsigned, LocTy>>;
372 bool parseParamAccess(FunctionSummary::ParamAccess &
Param,
373 IdLocListType &IdLocList);
375 IdLocListType &IdLocList);
376 bool parseParamAccessOffset(ConstantRange &Range);
377 bool parseOptionalRefs(std::vector<ValueInfo> &Refs);
378 bool parseTypeIdEntry(
unsigned ID);
379 bool parseTypeIdSummary(TypeIdSummary &TIS);
380 bool parseTypeIdCompatibleVtableEntry(
unsigned ID);
381 bool parseTypeTestResolution(TypeTestResolution &TTRes);
382 bool parseOptionalWpdResolutions(
383 std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);
384 bool parseWpdRes(WholeProgramDevirtResolution &WPDRes);
385 bool parseOptionalResByArg(
386 std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
388 bool parseArgs(std::vector<uint64_t> &
Args);
391 std::unique_ptr<GlobalValueSummary> Summary);
396 return parseType(Result,
"expected type", AllowVoid);
399 bool AllowVoid =
false) {
407 bool parseAnonStructType(
Type *&Result,
bool Packed);
408 bool parseStructBody(SmallVectorImpl<Type *> &Body);
409 bool parseStructDefinition(SMLoc TypeLoc, StringRef
Name,
410 std::pair<Type *, LocTy> &Entry,
413 bool parseArrayVectorType(
Type *&Result,
bool IsVector);
414 bool parseFunctionType(
Type *&Result);
417 class PerFunctionState {
420 std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
421 std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
422 std::vector<Value*> NumberedVals;
428 PerFunctionState(
LLParser &
p, Function &
f,
int functionNumber);
433 bool finishFunction();
443 bool setInstName(
int NameID,
const std::string &NameStr,
LocTy NameLoc,
457 bool resolveForwardRefBlockAddresses();
460 bool convertValIDToValue(Type *Ty, ValID &
ID,
Value *&V,
461 PerFunctionState *PFS);
463 Value *checkValidVariableType(
LocTy Loc,
const Twine &
Name, Type *Ty,
466 bool parseConstantValue(Type *Ty, Constant *&
C);
467 bool parseValue(Type *Ty,
Value *&V, PerFunctionState *PFS);
468 bool parseValue(Type *Ty,
Value *&V, PerFunctionState &PFS) {
469 return parseValue(Ty, V, &PFS);
472 bool parseValue(Type *Ty,
Value *&V,
LocTy &Loc, PerFunctionState &PFS) {
474 return parseValue(Ty, V, &PFS);
477 bool parseTypeAndValue(
Value *&V, PerFunctionState *PFS);
478 bool parseTypeAndValue(
Value *&V, PerFunctionState &PFS) {
479 return parseTypeAndValue(V, &PFS);
481 bool parseTypeAndValue(
Value *&V,
LocTy &Loc, PerFunctionState &PFS) {
483 return parseTypeAndValue(V, PFS);
486 PerFunctionState &PFS);
487 bool parseTypeAndBasicBlock(
BasicBlock *&
BB, PerFunctionState &PFS) {
489 return parseTypeAndBasicBlock(
BB, Loc, PFS);
499 bool parseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
500 PerFunctionState &PFS,
bool IsMustTailCall =
false,
501 bool InVarArgsFunc =
false);
504 parseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
505 PerFunctionState &PFS);
507 bool parseExceptionArgs(SmallVectorImpl<Value *> &
Args,
508 PerFunctionState &PFS);
511 bool parseValID(ValID &
ID, PerFunctionState *PFS,
512 Type *ExpectedTy =
nullptr);
513 bool parseGlobalValue(Type *Ty, Constant *&
C);
514 bool parseGlobalTypeAndValue(Constant *&V);
515 bool parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
516 Optional<unsigned> *InRangeOp =
nullptr);
517 bool parseOptionalComdat(StringRef GlobalName, Comdat *&
C);
518 bool parseSanitizer(GlobalVariable *GV);
519 bool parseMetadataAsValue(
Value *&V, PerFunctionState &PFS);
520 bool parseValueAsMetadata(Metadata *&MD,
const Twine &TypeMsg,
521 PerFunctionState *PFS);
522 bool parseMetadata(Metadata *&MD, PerFunctionState *PFS);
523 bool parseMDTuple(MDNode *&MD,
bool IsDistinct =
false);
524 bool parseMDNode(MDNode *&
N);
525 bool parseMDNodeTail(MDNode *&
N);
526 bool parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
527 bool parseMetadataAttachment(
unsigned &
Kind, MDNode *&MD);
528 bool parseInstructionMetadata(Instruction &Inst);
529 bool parseGlobalObjectMetadataAttachment(GlobalObject &GO);
530 bool parseOptionalFunctionMetadata(Function &
F);
532 template <
class FieldTy>
533 bool parseMDField(
LocTy Loc, StringRef
Name, FieldTy &Result);
534 template <
class FieldTy>
bool parseMDField(StringRef
Name, FieldTy &Result);
535 template <
class ParserTy>
bool parseMDFieldsImplBody(ParserTy ParseField);
536 template <
class ParserTy>
537 bool parseMDFieldsImpl(ParserTy ParseField,
LocTy &ClosingLoc);
538 bool parseSpecializedMDNode(MDNode *&
N,
bool IsDistinct =
false);
540 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
541 bool parse##CLASS(MDNode *&Result, bool IsDistinct);
542 #include "llvm/IR/Metadata.def"
543 bool parseDIArgList(MDNode *&Result,
bool IsDistinct,
544 PerFunctionState *PFS);
552 ArgInfo(
LocTy L, Type *ty, AttributeSet Attr,
const std::string &
N)
555 bool parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
bool &IsVarArg);
556 bool parseFunctionHeader(Function *&Fn,
bool IsDefine);
557 bool parseFunctionBody(Function &Fn);
558 bool parseBasicBlock(PerFunctionState &PFS);
560 enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
564 enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
565 int parseInstruction(Instruction *&Inst,
BasicBlock *
BB,
566 PerFunctionState &PFS);
567 bool parseCmpPredicate(
unsigned &
P,
unsigned Opc);
569 bool parseRet(Instruction *&Inst,
BasicBlock *
BB, PerFunctionState &PFS);
570 bool parseBr(Instruction *&Inst, PerFunctionState &PFS);
571 bool parseSwitch(Instruction *&Inst, PerFunctionState &PFS);
572 bool parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
573 bool parseInvoke(Instruction *&Inst, PerFunctionState &PFS);
574 bool parseResume(Instruction *&Inst, PerFunctionState &PFS);
575 bool parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
576 bool parseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
577 bool parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
578 bool parseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
579 bool parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
580 bool parseCallBr(Instruction *&Inst, PerFunctionState &PFS);
582 bool parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc,
584 bool parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
585 unsigned Opc,
bool IsFP);
586 bool parseLogical(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
587 bool parseCompare(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
588 bool parseCast(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc);
589 bool parseSelect(Instruction *&Inst, PerFunctionState &PFS);
590 bool parseVAArg(Instruction *&Inst, PerFunctionState &PFS);
591 bool parseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
592 bool parseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
593 bool parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
594 int parsePHI(Instruction *&Inst, PerFunctionState &PFS);
595 bool parseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
596 bool parseCall(Instruction *&Inst, PerFunctionState &PFS,
598 int parseAlloc(Instruction *&Inst, PerFunctionState &PFS);
599 int parseLoad(Instruction *&Inst, PerFunctionState &PFS);
600 int parseStore(Instruction *&Inst, PerFunctionState &PFS);
601 int parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
602 int parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
603 int parseFence(Instruction *&Inst, PerFunctionState &PFS);
604 int parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
605 int parseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
606 int parseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
607 bool parseFreeze(Instruction *&
I, PerFunctionState &PFS);
610 bool parseUseListOrder(PerFunctionState *PFS =
nullptr);
611 bool parseUseListOrderBB();
612 bool parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
613 bool sortUseListOrder(
Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);