LLVM: include/llvm/AsmParser/LLParser.h Source File (original) (raw)

55 enum {

70 t_InlineAsm,

74

84

93

99 "Comparing ValIDs of different kinds");

105 }

106 };

109 public:

111 private:

113

116

118

121

123

124

125

126

127

129

130

131

133 std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;

134

135 std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;

136 std::map<unsigned, std::pair<TempMDTuple, LocTy>> ForwardRefMDNodes;

137

138

139 std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;

140 std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;

142

143

144 std::map<std::string, LocTy> ForwardRefComdats;

145

146

147

148 std::map<ValID, std::map<ValID, GlobalValue *>> ForwardRefBlockAddresses;

149 class PerFunctionState;

150

151

152

153 PerFunctionState *BlockAddressPFS;

154

155

156

157

158

159

160 std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentNames;

161 std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentIDs;

162

163

164 std::map<Value*, std::vector > ForwardRefAttrGroups;

165 std::map<unsigned, AttrBuilder> NumberedAttrBuilders;

166

167

168 std::map<unsigned, std::vector<std::pair<ValueInfo *, LocTy>>>

169 ForwardRefValueInfos;

170 std::map<unsigned, std::vector<std::pair<AliasSummary *, LocTy>>>

171 ForwardRefAliasees;

172 std::vector NumberedValueInfos;

173

174

175 std::map<unsigned, std::vector<std::pair<GlobalValue::GUID *, LocTy>>>

176 ForwardRefTypeIds;

177

178

179 std::map<unsigned, StringRef> ModuleIdMap;

180

181

183

184

185

186 bool UpgradeDebugInfo;

187

188 bool SeenNewDbgInfoFormat = false;

189 bool SeenOldDbgInfoFormat = false;

190

191 std::string SourceFileName;

192

193 public:

198 : Context(Context), OPLex(F, SM, Err, Context),

199 Lex(F, SM, Err, Context), M(M), Index(Index), Slots(Slots),

200 BlockAddressPFS(nullptr), ParserContext(ParserContext) {}

201 bool Run(

204 return std::nullopt;

205 });

206

208

210 const SlotMapping *Slots);

211

213 const SlotMapping *Slots);

214

216

217 private:

219 bool tokError(const Twine &Msg) { return error(Lex.getLoc(), Msg); }

220

221 bool checkValueID(LocTy L, StringRef Kind, StringRef Prefix,

222 unsigned NextID, unsigned ID);

223

224

225

226 void restoreParsingState(const SlotMapping *Slots);

227

228

229

230

231 GlobalValue *getGlobalVal(const std::string &N, Type *Ty, LocTy Loc);

232 GlobalValue *getGlobalVal(unsigned ID, Type *Ty, LocTy Loc);

233

234

235

236 Comdat *getComdat(const std::string &Name, LocTy Loc);

237

238

239 bool parseToken(lltok::Kind T, const char *ErrMsg);

241 if (Lex.getKind() != T) return false;

242 Lex.Lex();

243 return true;

244 }

245

246 FastMathFlags EatFastMathFlagsIfPresent() {

247 FastMathFlags FMF;

248 while (true)

249 switch (Lex.getKind()) {

250 case lltok::kw_fast: FMF.setFast(); Lex.Lex(); continue;

251 case lltok::kw_nnan: FMF.setNoNaNs(); Lex.Lex(); continue;

252 case lltok::kw_ninf: FMF.setNoInfs(); Lex.Lex(); continue;

253 case lltok::kw_nsz: FMF.setNoSignedZeros(); Lex.Lex(); continue;

254 case lltok::kw_arcp: FMF.setAllowReciprocal(); Lex.Lex(); continue;

256 FMF.setAllowContract(true);

257 Lex.Lex();

258 continue;

259 case lltok::kw_reassoc: FMF.setAllowReassoc(); Lex.Lex(); continue;

260 case lltok::kw_afn: FMF.setApproxFunc(); Lex.Lex(); continue;

261 default: return FMF;

262 }

263 return FMF;

264 }

265

266 bool parseOptionalToken(lltok::Kind T, bool &Present,

267 LocTy *Loc = nullptr) {

268 if (Lex.getKind() != T) {

269 Present = false;

270 } else {

271 if (Loc)

272 *Loc = Lex.getLoc();

273 Lex.Lex();

274 Present = true;

275 }

276 return false;

277 }

278 bool parseStringConstant(std::string &Result);

279 bool parseUInt32(unsigned &Val);

280 bool parseUInt32(unsigned &Val, LocTy &Loc) {

281 Loc = Lex.getLoc();

282 return parseUInt32(Val);

283 }

284 bool parseUInt64(uint64_t &Val);

285 bool parseUInt64(uint64_t &Val, LocTy &Loc) {

286 Loc = Lex.getLoc();

287 return parseUInt64(Val);

288 }

289 bool parseFlag(unsigned &Val);

290

291 bool parseStringAttribute(AttrBuilder &B);

292

296 bool parseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS = 0);

297 bool parseOptionalProgramAddrSpace(unsigned &AddrSpace) {

298 return parseOptionalAddrSpace(

299 AddrSpace, M->getDataLayout().getProgramAddressSpace());

300 };

302 bool InAttrGroup);

303 bool parseOptionalParamOrReturnAttrs(AttrBuilder &B, bool IsParam);

304 bool parseOptionalParamAttrs(AttrBuilder &B) {

305 return parseOptionalParamOrReturnAttrs(B, true);

306 }

307 bool parseOptionalReturnAttrs(AttrBuilder &B) {

308 return parseOptionalParamOrReturnAttrs(B, false);

309 }

310 bool parseOptionalLinkage(unsigned &Res, bool &HasLinkage,

311 unsigned &Visibility, unsigned &DLLStorageClass,

312 bool &DSOLocal);

313 void parseOptionalDSOLocal(bool &DSOLocal);

314 void parseOptionalVisibility(unsigned &Res);

315 bool parseOptionalImportType(lltok::Kind Kind,

317 void parseOptionalDLLStorageClass(unsigned &Res);

318 bool parseOptionalCallingConv(unsigned &CC);

319 bool parseOptionalAlignment(MaybeAlign &Alignment,

320 bool AllowParens = false);

322 bool parseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);

323 bool parseOptionalUWTableKind(UWTableKind &Kind);

325 std::optional parseMemoryAttr();

326 unsigned parseNoFPClassAttr();

327 bool parseScopeAndOrdering(bool IsAtomic, SyncScope::ID &SSID,

331 bool parseOptionalStackAlignment(unsigned &Alignment);

332 bool parseOptionalCommaAlign(MaybeAlign &Alignment, bool &AteExtraComma);

333 bool parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,

334 bool &AteExtraComma);

335 bool parseAllocSizeArguments(unsigned &BaseSizeArg,

336 std::optional &HowManyArg);

337 bool parseVScaleRangeArguments(unsigned &MinValue, unsigned &MaxValue);

338 bool parseIndexList(SmallVectorImpl &Indices,

339 bool &AteExtraComma);

340 bool parseIndexList(SmallVectorImpl &Indices) {

341 bool AteExtraComma;

342 if (parseIndexList(Indices, AteExtraComma))

343 return true;

344 if (AteExtraComma)

345 return tokError("expected index");

346 return false;

347 }

348

349

350 bool parseTopLevelEntities();

351 void dropUnknownMetadataReferences();

352 bool validateEndOfModule(bool UpgradeDebugInfo);

353 bool validateEndOfIndex();

355 bool parseTargetDefinition(std::string &TentativeDLStr, LocTy &DLStrLoc);

356 bool parseModuleAsm();

357 bool parseSourceFileName();

358 bool parseUnnamedType();

359 bool parseNamedType();

360 bool parseDeclare();

361 bool parseDefine();

362

363 bool parseGlobalType(bool &IsConstant);

364 bool parseUnnamedGlobal();

365 bool parseNamedGlobal();

366 bool parseGlobal(const std::string &Name, unsigned NameID, LocTy NameLoc,

367 unsigned Linkage, bool HasLinkage, unsigned Visibility,

368 unsigned DLLStorageClass, bool DSOLocal,

371 bool parseAliasOrIFunc(const std::string &Name, unsigned NameID,

372 LocTy NameLoc, unsigned L, unsigned Visibility,

373 unsigned DLLStorageClass, bool DSOLocal,

376 bool parseComdat();

377 bool parseStandaloneMetadata();

378 bool parseNamedMetadata();

379 bool parseMDString(MDString *&Result);

380 bool parseMDNodeID(MDNode *&Result);

381 bool parseUnnamedAttrGrp();

382 bool parseFnAttributeValuePairs(AttrBuilder &B,

383 std::vector &FwdRefAttrGrps,

384 bool inAttrGrp, LocTy &BuiltinLoc);

385 bool parseRangeAttr(AttrBuilder &B);

386 bool parseInitializesAttr(AttrBuilder &B);

387 bool parseCapturesAttr(AttrBuilder &B);

388 bool parseRequiredTypeAttr(AttrBuilder &B, lltok::Kind AttrToken,

390

391

392 bool skipModuleSummaryEntry();

393 bool parseSummaryEntry();

394 bool parseModuleEntry(unsigned ID);

395 bool parseModuleReference(StringRef &ModulePath);

396 bool parseGVReference(ValueInfo &VI, unsigned &GVId);

397 bool parseSummaryIndexFlags();

398 bool parseBlockCount();

399 bool parseGVEntry(unsigned ID);

400 bool parseFunctionSummary(std::string Name, GlobalValue::GUID, unsigned ID);

401 bool parseVariableSummary(std::string Name, GlobalValue::GUID, unsigned ID);

402 bool parseAliasSummary(std::string Name, GlobalValue::GUID, unsigned ID);

403 bool parseGVFlags(GlobalValueSummary::GVFlags &GVFlags);

404 bool parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);

405 bool parseOptionalFFlags(FunctionSummary::FFlags &FFlags);

406 bool parseOptionalCalls(SmallVectorImplFunctionSummary::EdgeTy &Calls);

408 bool parseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);

409 bool parseTypeTests(std::vectorGlobalValue::GUID &TypeTests);

411 std::vectorFunctionSummary::VFuncId &VFuncIdList);

412 bool parseConstVCallList(

414 std::vectorFunctionSummary::ConstVCall &ConstVCallList);

415 using IdToIndexMapType =

416 std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;

417 bool parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,

418 IdToIndexMapType &IdToIndexMap, unsigned Index);

419 bool parseVFuncId(FunctionSummary::VFuncId &VFuncId,

420 IdToIndexMapType &IdToIndexMap, unsigned Index);

421 bool parseOptionalVTableFuncs(VTableFuncList &VTableFuncs);

422 bool parseOptionalParamAccesses(

423 std::vectorFunctionSummary::ParamAccess &Params);

424 bool parseParamNo(uint64_t &ParamNo);

425 using IdLocListType = std::vector<std::pair<unsigned, LocTy>>;

426 bool parseParamAccess(FunctionSummary::ParamAccess &Param,

427 IdLocListType &IdLocList);

428 bool parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call,

429 IdLocListType &IdLocList);

430 bool parseParamAccessOffset(ConstantRange &Range);

431 bool parseOptionalRefs(SmallVectorImpl &Refs);

432 bool parseTypeIdEntry(unsigned ID);

433 bool parseTypeIdSummary(TypeIdSummary &TIS);

434 bool parseTypeIdCompatibleVtableEntry(unsigned ID);

435 bool parseTypeTestResolution(TypeTestResolution &TTRes);

436 bool parseOptionalWpdResolutions(

437 std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);

438 bool parseWpdRes(WholeProgramDevirtResolution &WPDRes);

439 bool parseOptionalResByArg(

440 std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>

441 &ResByArg);

442 bool parseArgs(std::vector<uint64_t> &Args);

445 std::unique_ptr Summary,

447 bool parseOptionalAllocs(std::vector &Allocs);

448 bool parseMemProfs(std::vector &MIBs);

449 bool parseAllocType(uint8_t &AllocType);

450 bool parseOptionalCallsites(std::vector &Callsites);

451

452

453 bool parseType(Type *&Result, const Twine &Msg, bool AllowVoid = false);

454 bool parseType(Type *&Result, bool AllowVoid = false) {

455 return parseType(Result, "expected type", AllowVoid);

456 }

457 bool parseType(Type *&Result, const Twine &Msg, LocTy &Loc,

458 bool AllowVoid = false) {

459 Loc = Lex.getLoc();

460 return parseType(Result, Msg, AllowVoid);

461 }

462 bool parseType(Type *&Result, LocTy &Loc, bool AllowVoid = false) {

463 Loc = Lex.getLoc();

464 return parseType(Result, AllowVoid);

465 }

466 bool parseAnonStructType(Type *&Result, bool Packed);

467 bool parseStructBody(SmallVectorImpl<Type *> &Body);

468 bool parseStructDefinition(SMLoc TypeLoc, StringRef Name,

469 std::pair<Type *, LocTy> &Entry,

470 Type *&ResultTy);

471

472 bool parseArrayVectorType(Type *&Result, bool IsVector);

473 bool parseFunctionType(Type *&Result);

474 bool parseTargetExtType(Type *&Result);

475

476

477 class PerFunctionState {

480 std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;

481 std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;

482 NumberedValues<Value *> NumberedVals;

483

484

485

486 int FunctionNumber;

487

488 public:

489 PerFunctionState(LLParser &p, Function &f, int functionNumber,

490 ArrayRef UnnamedArgNums);

491 ~PerFunctionState();

492

493 Function &getFunction() const { return F; }

494

495 bool finishFunction();

496

497

498

499

500 Value *getVal(const std::string &Name, Type *Ty, LocTy Loc);

502

503

504

505 bool setInstName(int NameID, const std::string &NameStr, LocTy NameLoc,

506 Instruction *Inst);

507

508

509

510

513

514

515

516

517 BasicBlock *defineBB(const std::string &Name, int NameID, LocTy Loc);

518

519 bool resolveForwardRefBlockAddresses();

520 };

521

522 bool convertValIDToValue(Type *Ty, ValID &ID, Value *&V,

523 PerFunctionState *PFS);

524

525 Value *checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,

527

528 bool parseConstantValue(Type *Ty, Constant *&C);

529 bool parseValue(Type *Ty, Value *&V, PerFunctionState *PFS);

530 bool parseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {

531 return parseValue(Ty, V, &PFS);

532 }

533

534 bool parseValue(Type *Ty, Value *&V, LocTy &Loc, PerFunctionState &PFS) {

535 Loc = Lex.getLoc();

536 return parseValue(Ty, V, &PFS);

537 }

538

539 bool parseTypeAndValue(Value *&V, PerFunctionState *PFS);

540 bool parseTypeAndValue(Value *&V, PerFunctionState &PFS) {

541 return parseTypeAndValue(V, &PFS);

542 }

543 bool parseTypeAndValue(Value *&V, LocTy &Loc, PerFunctionState &PFS) {

544 Loc = Lex.getLoc();

545 return parseTypeAndValue(V, PFS);

546 }

547 bool parseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,

548 PerFunctionState &PFS);

549 bool parseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {

551 return parseTypeAndBasicBlock(BB, Loc, PFS);

552 }

553

554 struct ParamInfo {

557 AttributeSet Attrs;

558 ParamInfo(LocTy loc, Value *v, AttributeSet attrs)

559 : Loc(loc), V(v), Attrs(attrs) {}

560 };

561 bool parseParameterList(SmallVectorImpl &ArgList,

562 PerFunctionState &PFS, bool IsMustTailCall = false,

563 bool InVarArgsFunc = false);

564

565 bool

566 parseOptionalOperandBundles(SmallVectorImpl &BundleList,

567 PerFunctionState &PFS);

568

569 bool parseExceptionArgs(SmallVectorImpl<Value *> &Args,

570 PerFunctionState &PFS);

571

573 FunctionType *&FuncTy);

574

575

576 bool parseValID(ValID &ID, PerFunctionState *PFS,

577 Type *ExpectedTy = nullptr);

578 bool parseGlobalValue(Type *Ty, Constant *&C);

579 bool parseGlobalTypeAndValue(Constant *&V);

580 bool parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts);

581 bool parseOptionalComdat(StringRef GlobalName, Comdat *&C);

582 bool parseSanitizer(GlobalVariable *GV);

583 bool parseMetadataAsValue(Value *&V, PerFunctionState &PFS);

584 bool parseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,

585 PerFunctionState *PFS);

586 bool parseDIArgList(Metadata *&MD, PerFunctionState *PFS);

587 bool parseMetadata(Metadata *&MD, PerFunctionState *PFS);

588 bool parseMDTuple(MDNode *&MD, bool IsDistinct = false);

589 bool parseMDNode(MDNode *&N);

590 bool parseMDNodeTail(MDNode *&N);

591 bool parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);

592 bool parseMetadataAttachment(unsigned &Kind, MDNode *&MD);

593 bool parseDebugRecord(DbgRecord *&DR, PerFunctionState &PFS);

594 bool parseInstructionMetadata(Instruction &Inst);

595 bool parseGlobalObjectMetadataAttachment(GlobalObject &GO);

596 bool parseOptionalFunctionMetadata(Function &F);

597

598 template

599 bool parseMDField(LocTy Loc, StringRef Name, FieldTy &Result);

600 template bool parseMDField(StringRef Name, FieldTy &Result);

601 template bool parseMDFieldsImplBody(ParserTy ParseField);

602 template

603 bool parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc);

604 bool parseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);

605 bool parseDIExpressionBody(MDNode *&Result, bool IsDistinct);

606

607#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \

608 bool parse##CLASS(MDNode *&Result, bool IsDistinct);

609#include "llvm/IR/Metadata.def"

610

611

612 struct ArgInfo {

614 Type *Ty;

615 AttributeSet Attrs;

616 std::string Name;

617 ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N)

618 : Loc(L), Ty(ty), Attrs(Attr), Name(N) {}

619 };

620 bool parseArgumentList(SmallVectorImpl &ArgList,

621 SmallVectorImpl &UnnamedArgNums,

622 bool &IsVarArg);

623 bool parseFunctionHeader(Function *&Fn, bool IsDefine,

624 unsigned &FunctionNumber,

625 SmallVectorImpl &UnnamedArgNums);

626 bool parseFunctionBody(Function &Fn, unsigned FunctionNumber,

627 ArrayRef UnnamedArgNums);

628 bool parseBasicBlock(PerFunctionState &PFS);

629

630 enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };

631

632

633

634 enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };

635 int parseInstruction(Instruction *&Inst, BasicBlock *BB,

636 PerFunctionState &PFS);

637 bool parseCmpPredicate(unsigned &P, unsigned Opc);

638

639 bool parseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);

640 bool parseBr(Instruction *&Inst, PerFunctionState &PFS);

641 bool parseSwitch(Instruction *&Inst, PerFunctionState &PFS);

642 bool parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);

643 bool parseInvoke(Instruction *&Inst, PerFunctionState &PFS);

644 bool parseResume(Instruction *&Inst, PerFunctionState &PFS);

645 bool parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);

646 bool parseCatchRet(Instruction *&Inst, PerFunctionState &PFS);

647 bool parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);

648 bool parseCatchPad(Instruction *&Inst, PerFunctionState &PFS);

649 bool parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);

650 bool parseCallBr(Instruction *&Inst, PerFunctionState &PFS);

651

652 bool parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,

653 bool IsFP);

654 bool parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,

655 unsigned Opc, bool IsFP);

656 bool parseLogical(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);

657 bool parseCompare(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);

658 bool parseCast(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);

659 bool parseSelect(Instruction *&Inst, PerFunctionState &PFS);

660 bool parseVAArg(Instruction *&Inst, PerFunctionState &PFS);

661 bool parseExtractElement(Instruction *&Inst, PerFunctionState &PFS);

662 bool parseInsertElement(Instruction *&Inst, PerFunctionState &PFS);

663 bool parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);

664 int parsePHI(Instruction *&Inst, PerFunctionState &PFS);

665 bool parseLandingPad(Instruction *&Inst, PerFunctionState &PFS);

666 bool parseCall(Instruction *&Inst, PerFunctionState &PFS,

668 int parseAlloc(Instruction *&Inst, PerFunctionState &PFS);

669 int parseLoad(Instruction *&Inst, PerFunctionState &PFS);

670 int parseStore(Instruction *&Inst, PerFunctionState &PFS);

671 int parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);

672 int parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);

673 int parseFence(Instruction *&Inst, PerFunctionState &PFS);

674 int parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);

675 int parseExtractValue(Instruction *&Inst, PerFunctionState &PFS);

676 int parseInsertValue(Instruction *&Inst, PerFunctionState &PFS);

677 bool parseFreeze(Instruction *&I, PerFunctionState &PFS);

678

679

680 bool parseUseListOrder(PerFunctionState *PFS = nullptr);

681 bool parseUseListOrderBB();

682 bool parseUseListOrderIndexes(SmallVectorImpl &Indexes);

683 bool sortUseListOrder(Value *V, ArrayRef Indexes, SMLoc Loc);

684 };