Movatterモバイル変換

Go to the documentation of this file.

1//===- BitcodeAnalyzer.cpp - Internal BitcodeAnalyzer implementation ------===//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

9#include "llvm/Bitcode/BitcodeAnalyzer.h"

10#include "llvm/Bitcode/BitcodeReader.h"

11#include "llvm/Bitcode/LLVMBitCodes.h"

12#include "llvm/Bitstream/BitCodes.h"

13#include "llvm/Bitstream/BitstreamReader.h"

14#include "llvm/Support/Format.h"

15#include "llvm/Support/SHA1.h"

16#include <optional>

18using namespacellvm;

20staticError reportError(StringRef Message) {

21returncreateStringError(std::errc::illegal_byte_sequence, Message.data());

22}

24/// Return a symbolic block name if known, otherwise return null.

25static std::optional<const char *>

26GetBlockName(unsigned BlockID,constBitstreamBlockInfo &BlockInfo,

27CurStreamTypeType CurStreamType) {

28// Standard blocks for all bitcode files.

29if (BlockID <bitc::FIRST_APPLICATION_BLOCKID) {

30if (BlockID ==bitc::BLOCKINFO_BLOCK_ID)

31return"BLOCKINFO_BLOCK";

32return std::nullopt;

33 }

35// Check to see if we have a blockinfo record for this block, with a name.

36if (constBitstreamBlockInfo::BlockInfo *Info =

37 BlockInfo.getBlockInfo(BlockID)) {

38if (!Info->Name.empty())

39returnInfo->Name.c_str();

40 }

42if (CurStreamType !=LLVMIRBitstream)

43return std::nullopt;

45switch (BlockID) {

46default:

47return std::nullopt;

48casebitc::OPERAND_BUNDLE_TAGS_BLOCK_ID:

49return"OPERAND_BUNDLE_TAGS_BLOCK";

50casebitc::MODULE_BLOCK_ID:

51return"MODULE_BLOCK";

52casebitc::PARAMATTR_BLOCK_ID:

53return"PARAMATTR_BLOCK";

54casebitc::PARAMATTR_GROUP_BLOCK_ID:

55return"PARAMATTR_GROUP_BLOCK_ID";

56casebitc::TYPE_BLOCK_ID_NEW:

57return"TYPE_BLOCK_ID";

58casebitc::CONSTANTS_BLOCK_ID:

59return"CONSTANTS_BLOCK";

60casebitc::FUNCTION_BLOCK_ID:

61return"FUNCTION_BLOCK";

62casebitc::IDENTIFICATION_BLOCK_ID:

63return"IDENTIFICATION_BLOCK_ID";

64casebitc::VALUE_SYMTAB_BLOCK_ID:

65return"VALUE_SYMTAB";

66casebitc::METADATA_BLOCK_ID:

67return"METADATA_BLOCK";

68casebitc::METADATA_KIND_BLOCK_ID:

69return"METADATA_KIND_BLOCK";

70casebitc::METADATA_ATTACHMENT_ID:

71return"METADATA_ATTACHMENT_BLOCK";

72casebitc::USELIST_BLOCK_ID:

73return"USELIST_BLOCK_ID";

74casebitc::GLOBALVAL_SUMMARY_BLOCK_ID:

75return"GLOBALVAL_SUMMARY_BLOCK";

76casebitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID:

77return"FULL_LTO_GLOBALVAL_SUMMARY_BLOCK";

78casebitc::MODULE_STRTAB_BLOCK_ID:

79return"MODULE_STRTAB_BLOCK";

80casebitc::STRTAB_BLOCK_ID:

81return"STRTAB_BLOCK";

82casebitc::SYMTAB_BLOCK_ID:

83return"SYMTAB_BLOCK";

84 }

85}

87/// Return a symbolic code name if known, otherwise return null.

88static std::optional<const char *>

89GetCodeName(unsigned CodeID,unsigned BlockID,

90constBitstreamBlockInfo &BlockInfo,

91CurStreamTypeType CurStreamType) {

92// Standard blocks for all bitcode files.

93if (BlockID <bitc::FIRST_APPLICATION_BLOCKID) {

94if (BlockID ==bitc::BLOCKINFO_BLOCK_ID) {

95switch (CodeID) {

96default:

97return std::nullopt;

98casebitc::BLOCKINFO_CODE_SETBID:

99return"SETBID";

100casebitc::BLOCKINFO_CODE_BLOCKNAME:

101return"BLOCKNAME";

102casebitc::BLOCKINFO_CODE_SETRECORDNAME:

103return"SETRECORDNAME";

104 }

105 }

106return std::nullopt;

107 }

108

109// Check to see if we have a blockinfo record for this record, with a name.

110if (constBitstreamBlockInfo::BlockInfo *Info =

111 BlockInfo.getBlockInfo(BlockID)) {

112for (const std::pair<unsigned, std::string> &RN :Info->RecordNames)

113if (RN.first == CodeID)

114return RN.second.c_str();

115 }

116

117if (CurStreamType !=LLVMIRBitstream)

118return std::nullopt;

119

120#define STRINGIFY_CODE(PREFIX, CODE) \

121 case bitc::PREFIX##_##CODE: \

122 return #CODE;

123switch (BlockID) {

124default:

125return std::nullopt;

126casebitc::MODULE_BLOCK_ID:

127switch (CodeID) {

128default:

129return std::nullopt;

130STRINGIFY_CODE(MODULE_CODE, VERSION)

131STRINGIFY_CODE(MODULE_CODE, TRIPLE)

132STRINGIFY_CODE(MODULE_CODE, DATALAYOUT)

133STRINGIFY_CODE(MODULE_CODE, ASM)

134STRINGIFY_CODE(MODULE_CODE, SECTIONNAME)

135STRINGIFY_CODE(MODULE_CODE, DEPLIB)// Deprecated, present in old bitcode

136STRINGIFY_CODE(MODULE_CODE, GLOBALVAR)

137STRINGIFY_CODE(MODULE_CODE,FUNCTION)

138STRINGIFY_CODE(MODULE_CODE, ALIAS)

139STRINGIFY_CODE(MODULE_CODE, GCNAME)

140STRINGIFY_CODE(MODULE_CODE, COMDAT)

141STRINGIFY_CODE(MODULE_CODE, VSTOFFSET)

142STRINGIFY_CODE(MODULE_CODE, METADATA_VALUES_UNUSED)

143STRINGIFY_CODE(MODULE_CODE, SOURCE_FILENAME)

144STRINGIFY_CODE(MODULE_CODE, HASH)

145 }

146casebitc::IDENTIFICATION_BLOCK_ID:

147switch (CodeID) {

148default:

149return std::nullopt;

150STRINGIFY_CODE(IDENTIFICATION_CODE, STRING)

151STRINGIFY_CODE(IDENTIFICATION_CODE, EPOCH)

152 }

153casebitc::PARAMATTR_BLOCK_ID:

154switch (CodeID) {

155default:

156return std::nullopt;

157// FIXME: Should these be different?

158casebitc::PARAMATTR_CODE_ENTRY_OLD:

159return"ENTRY";

160casebitc::PARAMATTR_CODE_ENTRY:

161return"ENTRY";

162 }

163casebitc::PARAMATTR_GROUP_BLOCK_ID:

164switch (CodeID) {

165default:

166return std::nullopt;

167casebitc::PARAMATTR_GRP_CODE_ENTRY:

168return"ENTRY";

169 }

170casebitc::TYPE_BLOCK_ID_NEW:

171switch (CodeID) {

172default:

173return std::nullopt;

174STRINGIFY_CODE(TYPE_CODE, NUMENTRY)

175STRINGIFY_CODE(TYPE_CODE, VOID)

176STRINGIFY_CODE(TYPE_CODE, FLOAT)

177STRINGIFY_CODE(TYPE_CODE, DOUBLE)

178STRINGIFY_CODE(TYPE_CODE, LABEL)

179STRINGIFY_CODE(TYPE_CODE, OPAQUE)

180STRINGIFY_CODE(TYPE_CODE, INTEGER)

181STRINGIFY_CODE(TYPE_CODE, POINTER)

182STRINGIFY_CODE(TYPE_CODE, HALF)

183STRINGIFY_CODE(TYPE_CODE, ARRAY)

184STRINGIFY_CODE(TYPE_CODE, VECTOR)

185STRINGIFY_CODE(TYPE_CODE, X86_FP80)

186STRINGIFY_CODE(TYPE_CODE, FP128)

187STRINGIFY_CODE(TYPE_CODE, PPC_FP128)

188STRINGIFY_CODE(TYPE_CODE, METADATA)

189STRINGIFY_CODE(TYPE_CODE, X86_MMX)

190STRINGIFY_CODE(TYPE_CODE, STRUCT_ANON)

191STRINGIFY_CODE(TYPE_CODE, STRUCT_NAME)

192STRINGIFY_CODE(TYPE_CODE, STRUCT_NAMED)

193STRINGIFY_CODE(TYPE_CODE,FUNCTION)

194STRINGIFY_CODE(TYPE_CODE,TOKEN)

195STRINGIFY_CODE(TYPE_CODE, BFLOAT)

196 }

197

198casebitc::CONSTANTS_BLOCK_ID:

199switch (CodeID) {

200default:

201return std::nullopt;

202STRINGIFY_CODE(CST_CODE, SETTYPE)

203STRINGIFY_CODE(CST_CODE, NULL)

204STRINGIFY_CODE(CST_CODE, UNDEF)

205STRINGIFY_CODE(CST_CODE, INTEGER)

206STRINGIFY_CODE(CST_CODE, WIDE_INTEGER)

207STRINGIFY_CODE(CST_CODE, FLOAT)

208STRINGIFY_CODE(CST_CODE, AGGREGATE)

209STRINGIFY_CODE(CST_CODE, STRING)

210STRINGIFY_CODE(CST_CODE, CSTRING)

211STRINGIFY_CODE(CST_CODE, CE_BINOP)

212STRINGIFY_CODE(CST_CODE, CE_CAST)

213STRINGIFY_CODE(CST_CODE, CE_GEP)

214STRINGIFY_CODE(CST_CODE, CE_INBOUNDS_GEP)

215STRINGIFY_CODE(CST_CODE, CE_SELECT)

216STRINGIFY_CODE(CST_CODE, CE_EXTRACTELT)

217STRINGIFY_CODE(CST_CODE, CE_INSERTELT)

218STRINGIFY_CODE(CST_CODE, CE_SHUFFLEVEC)

219STRINGIFY_CODE(CST_CODE, CE_CMP)

220STRINGIFY_CODE(CST_CODE, INLINEASM)

221STRINGIFY_CODE(CST_CODE, CE_SHUFVEC_EX)

222STRINGIFY_CODE(CST_CODE, CE_UNOP)

223STRINGIFY_CODE(CST_CODE, DSO_LOCAL_EQUIVALENT)

224STRINGIFY_CODE(CST_CODE, NO_CFI_VALUE)

225STRINGIFY_CODE(CST_CODE, PTRAUTH)

226casebitc::CST_CODE_BLOCKADDRESS:

227return"CST_CODE_BLOCKADDRESS";

228STRINGIFY_CODE(CST_CODE, DATA)

229 }

230casebitc::FUNCTION_BLOCK_ID:

231switch (CodeID) {

232default:

233return std::nullopt;

234STRINGIFY_CODE(FUNC_CODE, DECLAREBLOCKS)

235STRINGIFY_CODE(FUNC_CODE, INST_BINOP)

236STRINGIFY_CODE(FUNC_CODE, INST_CAST)

237STRINGIFY_CODE(FUNC_CODE, INST_GEP_OLD)

238STRINGIFY_CODE(FUNC_CODE, INST_INBOUNDS_GEP_OLD)

239STRINGIFY_CODE(FUNC_CODE, INST_SELECT)

240STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTELT)

241STRINGIFY_CODE(FUNC_CODE, INST_INSERTELT)

242STRINGIFY_CODE(FUNC_CODE, INST_SHUFFLEVEC)

243STRINGIFY_CODE(FUNC_CODE, INST_CMP)

244STRINGIFY_CODE(FUNC_CODE, INST_RET)

245STRINGIFY_CODE(FUNC_CODE, INST_BR)

246STRINGIFY_CODE(FUNC_CODE, INST_SWITCH)

247STRINGIFY_CODE(FUNC_CODE, INST_INVOKE)

248STRINGIFY_CODE(FUNC_CODE, INST_UNOP)

249STRINGIFY_CODE(FUNC_CODE, INST_UNREACHABLE)

250STRINGIFY_CODE(FUNC_CODE, INST_CLEANUPRET)

251STRINGIFY_CODE(FUNC_CODE, INST_CATCHRET)

252STRINGIFY_CODE(FUNC_CODE, INST_CATCHPAD)

253STRINGIFY_CODE(FUNC_CODE, INST_PHI)

254STRINGIFY_CODE(FUNC_CODE, INST_ALLOCA)

255STRINGIFY_CODE(FUNC_CODE, INST_LOAD)

256STRINGIFY_CODE(FUNC_CODE, INST_VAARG)

257STRINGIFY_CODE(FUNC_CODE, INST_STORE)

258STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTVAL)

259STRINGIFY_CODE(FUNC_CODE, INST_INSERTVAL)

260STRINGIFY_CODE(FUNC_CODE, INST_CMP2)

261STRINGIFY_CODE(FUNC_CODE, INST_VSELECT)

262STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC_AGAIN)

263STRINGIFY_CODE(FUNC_CODE, INST_CALL)

264STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC)

265STRINGIFY_CODE(FUNC_CODE, INST_GEP)

266STRINGIFY_CODE(FUNC_CODE, OPERAND_BUNDLE)

267STRINGIFY_CODE(FUNC_CODE, INST_FENCE)

268STRINGIFY_CODE(FUNC_CODE, INST_ATOMICRMW)

269STRINGIFY_CODE(FUNC_CODE, INST_LOADATOMIC)

270STRINGIFY_CODE(FUNC_CODE, INST_STOREATOMIC)

271STRINGIFY_CODE(FUNC_CODE, INST_CMPXCHG)

272STRINGIFY_CODE(FUNC_CODE, INST_CALLBR)

273STRINGIFY_CODE(FUNC_CODE, BLOCKADDR_USERS)

274STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_DECLARE)

275STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_VALUE)

276STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_ASSIGN)

277STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_VALUE_SIMPLE)

278STRINGIFY_CODE(FUNC_CODE, DEBUG_RECORD_LABEL)

279 }

280casebitc::VALUE_SYMTAB_BLOCK_ID:

281switch (CodeID) {

282default:

283return std::nullopt;

284STRINGIFY_CODE(VST_CODE,ENTRY)

285STRINGIFY_CODE(VST_CODE, BBENTRY)

286STRINGIFY_CODE(VST_CODE, FNENTRY)

287STRINGIFY_CODE(VST_CODE, COMBINED_ENTRY)

288 }

289casebitc::MODULE_STRTAB_BLOCK_ID:

290switch (CodeID) {

291default:

292return std::nullopt;

293STRINGIFY_CODE(MST_CODE,ENTRY)

294STRINGIFY_CODE(MST_CODE, HASH)

295 }

296casebitc::GLOBALVAL_SUMMARY_BLOCK_ID:

297casebitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID:

298switch (CodeID) {

299default:

300return std::nullopt;

301STRINGIFY_CODE(FS, PERMODULE)

302STRINGIFY_CODE(FS, PERMODULE_PROFILE)

303STRINGIFY_CODE(FS, PERMODULE_RELBF)

304STRINGIFY_CODE(FS, PERMODULE_GLOBALVAR_INIT_REFS)

305STRINGIFY_CODE(FS, PERMODULE_VTABLE_GLOBALVAR_INIT_REFS)

306STRINGIFY_CODE(FS, COMBINED)

307STRINGIFY_CODE(FS, COMBINED_PROFILE)

308STRINGIFY_CODE(FS, COMBINED_GLOBALVAR_INIT_REFS)

309STRINGIFY_CODE(FS, ALIAS)

310STRINGIFY_CODE(FS, COMBINED_ALIAS)

311STRINGIFY_CODE(FS, COMBINED_ORIGINAL_NAME)

312STRINGIFY_CODE(FS, VERSION)

313STRINGIFY_CODE(FS, FLAGS)

314STRINGIFY_CODE(FS, TYPE_TESTS)

315STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_VCALLS)

316STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_VCALLS)

317STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_CONST_VCALL)

318STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_CONST_VCALL)

319STRINGIFY_CODE(FS, VALUE_GUID)

320STRINGIFY_CODE(FS, CFI_FUNCTION_DEFS)

321STRINGIFY_CODE(FS, CFI_FUNCTION_DECLS)

322STRINGIFY_CODE(FS, TYPE_ID)

323STRINGIFY_CODE(FS, TYPE_ID_METADATA)

324STRINGIFY_CODE(FS, BLOCK_COUNT)

325STRINGIFY_CODE(FS, PARAM_ACCESS)

326STRINGIFY_CODE(FS, PERMODULE_CALLSITE_INFO)

327STRINGIFY_CODE(FS, PERMODULE_ALLOC_INFO)

328STRINGIFY_CODE(FS, COMBINED_CALLSITE_INFO)

329STRINGIFY_CODE(FS, COMBINED_ALLOC_INFO)

330STRINGIFY_CODE(FS, STACK_IDS)

331STRINGIFY_CODE(FS, ALLOC_CONTEXT_IDS)

332STRINGIFY_CODE(FS, CONTEXT_RADIX_TREE_ARRAY)

333 }

334casebitc::METADATA_ATTACHMENT_ID:

335switch (CodeID) {

336default:

337return std::nullopt;

338STRINGIFY_CODE(METADATA, ATTACHMENT)

339 }

340casebitc::METADATA_BLOCK_ID:

341switch (CodeID) {

342default:

343return std::nullopt;

344STRINGIFY_CODE(METADATA, STRING_OLD)

345STRINGIFY_CODE(METADATA, VALUE)

346STRINGIFY_CODE(METADATA,NODE)

347STRINGIFY_CODE(METADATA, NAME)

348STRINGIFY_CODE(METADATA, DISTINCT_NODE)

349STRINGIFY_CODE(METADATA,KIND)// Older bitcode has it in a MODULE_BLOCK

350STRINGIFY_CODE(METADATA, LOCATION)

351STRINGIFY_CODE(METADATA, OLD_NODE)

352STRINGIFY_CODE(METADATA, OLD_FN_NODE)

353STRINGIFY_CODE(METADATA, NAMED_NODE)

354STRINGIFY_CODE(METADATA, GENERIC_DEBUG)

355STRINGIFY_CODE(METADATA, SUBRANGE)

356STRINGIFY_CODE(METADATA, ENUMERATOR)

357STRINGIFY_CODE(METADATA, BASIC_TYPE)

358STRINGIFY_CODE(METADATA, FILE)

359STRINGIFY_CODE(METADATA, DERIVED_TYPE)

360STRINGIFY_CODE(METADATA, COMPOSITE_TYPE)

361STRINGIFY_CODE(METADATA, SUBROUTINE_TYPE)

362STRINGIFY_CODE(METADATA, COMPILE_UNIT)

363STRINGIFY_CODE(METADATA, SUBPROGRAM)

364STRINGIFY_CODE(METADATA, LEXICAL_BLOCK)

365STRINGIFY_CODE(METADATA, LEXICAL_BLOCK_FILE)

366STRINGIFY_CODE(METADATA, NAMESPACE)

367STRINGIFY_CODE(METADATA, TEMPLATE_TYPE)

368STRINGIFY_CODE(METADATA, TEMPLATE_VALUE)

369STRINGIFY_CODE(METADATA, GLOBAL_VAR)

370STRINGIFY_CODE(METADATA, LOCAL_VAR)

371STRINGIFY_CODE(METADATA, EXPRESSION)

372STRINGIFY_CODE(METADATA, OBJC_PROPERTY)

373STRINGIFY_CODE(METADATA, IMPORTED_ENTITY)

374STRINGIFY_CODE(METADATA,MODULE)

375STRINGIFY_CODE(METADATA, MACRO)

376STRINGIFY_CODE(METADATA, MACRO_FILE)

377STRINGIFY_CODE(METADATA, STRINGS)

378STRINGIFY_CODE(METADATA, GLOBAL_DECL_ATTACHMENT)

379STRINGIFY_CODE(METADATA, GLOBAL_VAR_EXPR)

380STRINGIFY_CODE(METADATA, INDEX_OFFSET)

381STRINGIFY_CODE(METADATA, INDEX)

382STRINGIFY_CODE(METADATA, ARG_LIST)

383 }

384casebitc::METADATA_KIND_BLOCK_ID:

385switch (CodeID) {

386default:

387return std::nullopt;

388STRINGIFY_CODE(METADATA,KIND)

389 }

390casebitc::USELIST_BLOCK_ID:

391switch (CodeID) {

392default:

393return std::nullopt;

394casebitc::USELIST_CODE_DEFAULT:

395return"USELIST_CODE_DEFAULT";

396casebitc::USELIST_CODE_BB:

397return"USELIST_CODE_BB";

398 }

399

400casebitc::OPERAND_BUNDLE_TAGS_BLOCK_ID:

401switch (CodeID) {

402default:

403return std::nullopt;

404casebitc::OPERAND_BUNDLE_TAG:

405return"OPERAND_BUNDLE_TAG";

406 }

407casebitc::STRTAB_BLOCK_ID:

408switch (CodeID) {

409default:

410return std::nullopt;

411casebitc::STRTAB_BLOB:

412return"BLOB";

413 }

414casebitc::SYMTAB_BLOCK_ID:

415switch (CodeID) {

416default:

417return std::nullopt;

418casebitc::SYMTAB_BLOB:

419return"BLOB";

420 }

421 }

422#undef STRINGIFY_CODE

423}

424

425staticvoidprintSize(raw_ostream &OS,double Bits) {

426OS <<format("%.2f/%.2fB/%luW", Bits, Bits / 8, (unsignedlong)(Bits / 32));

427}

428staticvoidprintSize(raw_ostream &OS,uint64_t Bits) {

429OS <<format("%lub/%.2fB/%luW", (unsignedlong)Bits, (double)Bits / 8,

430 (unsignedlong)(Bits / 32));

431}

432

433staticExpected<CurStreamTypeType>ReadSignature(BitstreamCursor &Stream) {

434auto tryRead = [&Stream](char &Dest,size_tsize) ->Error {

435if (Expected<SimpleBitstreamCursor::word_t> MaybeWord = Stream.Read(size))

436 Dest = MaybeWord.get();

437else

438return MaybeWord.takeError();

439returnError::success();

440 };

441

442char Signature[6];

443if (Error Err = tryRead(Signature[0], 8))

444return std::move(Err);

445if (Error Err = tryRead(Signature[1], 8))

446return std::move(Err);

447

448// Autodetect the file contents, if it is one we know.

449if (Signature[0] =='C' && Signature[1] =='P') {

450if (Error Err = tryRead(Signature[2], 8))

451return std::move(Err);

452if (Error Err = tryRead(Signature[3], 8))

453return std::move(Err);

454if (Signature[2] =='C' && Signature[3] =='H')

455returnClangSerializedASTBitstream;

456 }elseif (Signature[0] =='D' && Signature[1] =='I') {

457if (Error Err = tryRead(Signature[2], 8))

458return std::move(Err);

459if (Error Err = tryRead(Signature[3], 8))

460return std::move(Err);

461if (Signature[2] =='A' && Signature[3] =='G')

462returnClangSerializedDiagnosticsBitstream;

463 }elseif (Signature[0] =='R' && Signature[1] =='M') {

464if (Error Err = tryRead(Signature[2], 8))

465return std::move(Err);

466if (Error Err = tryRead(Signature[3], 8))

467return std::move(Err);

468if (Signature[2] =='R' && Signature[3] =='K')

469returnLLVMBitstreamRemarks;

470 }else {

471if (Error Err = tryRead(Signature[2], 4))

472return std::move(Err);

473if (Error Err = tryRead(Signature[3], 4))

474return std::move(Err);

475if (Error Err = tryRead(Signature[4], 4))

476return std::move(Err);

477if (Error Err = tryRead(Signature[5], 4))

478return std::move(Err);

479if (Signature[0] =='B' && Signature[1] =='C' && Signature[2] == 0x0 &&

480 Signature[3] == 0xC && Signature[4] == 0xE && Signature[5] == 0xD)

481returnLLVMIRBitstream;

482 }

483returnUnknownBitstream;

484}

485

486staticExpected<CurStreamTypeType>analyzeHeader(std::optional<BCDumpOptions> O,

487BitstreamCursor &Stream) {

488ArrayRef<uint8_t> Bytes = Stream.getBitcodeBytes();

489constunsignedchar *BufPtr = (constunsignedchar *)Bytes.data();

490constunsignedchar *EndBufPtr = BufPtr + Bytes.size();

491

492// If we have a wrapper header, parse it and ignore the non-bc file

493// contents. The magic number is 0x0B17C0DE stored in little endian.

494if (isBitcodeWrapper(BufPtr, EndBufPtr)) {

495if (Bytes.size() <BWH_HeaderSize)

496returnreportError("Invalid bitcode wrapper header");

497

498if (O) {

499unsigned Magic =support::endian::read32le(&BufPtr[BWH_MagicField]);

500unsigned Version =support::endian::read32le(&BufPtr[BWH_VersionField]);

501unsignedOffset =support::endian::read32le(&BufPtr[BWH_OffsetField]);

502unsignedSize =support::endian::read32le(&BufPtr[BWH_SizeField]);

503unsigned CPUType =support::endian::read32le(&BufPtr[BWH_CPUTypeField]);

504

505 O->OS <<"<BITCODE_WRAPPER_HEADER"

506 <<" Magic=" <<format_hex(Magic, 10)

507 <<" Version=" <<format_hex(Version, 10)

508 <<" Offset=" <<format_hex(Offset, 10)

509 <<" Size=" <<format_hex(Size, 10)

510 <<" CPUType=" <<format_hex(CPUType, 10) <<"/>\n";

511 }

512

513if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr,true))

514returnreportError("Invalid bitcode wrapper header");

515 }

516

517// Use the cursor modified by skipping the wrapper header.

518 Stream =BitstreamCursor(ArrayRef<uint8_t>(BufPtr, EndBufPtr));

519

520returnReadSignature(Stream);

521}

522

523staticboolcanDecodeBlob(unsigned Code,unsigned BlockID) {

524return BlockID ==bitc::METADATA_BLOCK_ID && Code ==bitc::METADATA_STRINGS;

525}

526

527Error BitcodeAnalyzer::decodeMetadataStringsBlob(StringRef Indent,

528ArrayRef<uint64_t>Record,

529StringRef Blob,

530raw_ostream &OS) {

531if (Blob.empty())

532returnreportError("Cannot decode empty blob.");

533

534if (Record.size() != 2)

535returnreportError(

536"Decoding metadata strings blob needs two record entries.");

537

538unsigned NumStrings =Record[0];

539unsigned StringsOffset =Record[1];

540OS <<" num-strings = " << NumStrings <<" {\n";

541

542StringRef Lengths = Blob.slice(0, StringsOffset);

543SimpleBitstreamCursor R(Lengths);

544StringRef Strings = Blob.drop_front(StringsOffset);

545do {

546if (R.AtEndOfStream())

547returnreportError("bad length");

548

549uint32_t Size;

550if (Error E =R.ReadVBR(6).moveInto(Size))

551return E;

552if (Strings.size() <Size)

553returnreportError("truncated chars");

554

555OS << Indent <<" '";

556OS.write_escaped(Strings.slice(0,Size),/*hex=*/true);

557OS <<"'\n";

558 Strings = Strings.drop_front(Size);

559 }while (--NumStrings);

560

561OS << Indent <<" }";

562returnError::success();

563}

564

565BitcodeAnalyzer::BitcodeAnalyzer(StringRef Buffer,

566 std::optional<StringRef> BlockInfoBuffer)

567 : Stream(Buffer) {

568if (BlockInfoBuffer)

569 BlockInfoStream.emplace(*BlockInfoBuffer);

570}

571

572Error BitcodeAnalyzer::analyze(std::optional<BCDumpOptions> O,

573 std::optional<StringRef> CheckHash) {

574if (Error E =analyzeHeader(O, Stream).moveInto(CurStreamType))

575return E;

576

577 Stream.setBlockInfo(&BlockInfo);

578

579// Read block info from BlockInfoStream, if specified.

580// The block info must be a top-level block.

581if (BlockInfoStream) {

582BitstreamCursor BlockInfoCursor(*BlockInfoStream);

583if (Error E =analyzeHeader(O, BlockInfoCursor).takeError())

584return E;

585

586while (!BlockInfoCursor.AtEndOfStream()) {

587Expected<unsigned> MaybeCode = BlockInfoCursor.ReadCode();

588if (!MaybeCode)

589return MaybeCode.takeError();

590if (MaybeCode.get() !=bitc::ENTER_SUBBLOCK)

591returnreportError("Invalid record at top-level in block info file");

592

593Expected<unsigned> MaybeBlockID = BlockInfoCursor.ReadSubBlockID();

594if (!MaybeBlockID)

595return MaybeBlockID.takeError();

596if (MaybeBlockID.get() ==bitc::BLOCKINFO_BLOCK_ID) {

597 std::optional<BitstreamBlockInfo> NewBlockInfo;

598if (Error E =

599 BlockInfoCursor.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true)

600 .moveInto(NewBlockInfo))

601return E;

602if (!NewBlockInfo)

603returnreportError("Malformed BlockInfoBlock in block info file");

604 BlockInfo = std::move(*NewBlockInfo);

605break;

606 }

607

608if (Error Err = BlockInfoCursor.SkipBlock())

609return Err;

610 }

611 }

612

613// Parse the top-level structure. We only allow blocks at the top-level.

614while (!Stream.AtEndOfStream()) {

615Expected<unsigned> MaybeCode = Stream.ReadCode();

616if (!MaybeCode)

617return MaybeCode.takeError();

618if (MaybeCode.get() !=bitc::ENTER_SUBBLOCK)

619returnreportError("Invalid record at top-level");

620

621Expected<unsigned> MaybeBlockID = Stream.ReadSubBlockID();

622if (!MaybeBlockID)

623return MaybeBlockID.takeError();

624

625if (Error E = parseBlock(MaybeBlockID.get(), 0, O, CheckHash))

626return E;

627 ++NumTopBlocks;

628 }

629

630returnError::success();

631}

632

633voidBitcodeAnalyzer::printStats(BCDumpOptions O,

634 std::optional<StringRef> Filename) {

635uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT;

636// Print a summary of the read file.

637 O.OS <<"Summary ";

638if (Filename)

639 O.OS <<"of " << Filename->data() <<":\n";

640 O.OS <<" Total size: ";

641printSize(O.OS, BufferSizeBits);

642 O.OS <<"\n";

643 O.OS <<" Stream type: ";

644switch (CurStreamType) {

645caseUnknownBitstream:

646 O.OS <<"unknown\n";

647break;

648caseLLVMIRBitstream:

649 O.OS <<"LLVM IR\n";

650break;

651caseClangSerializedASTBitstream:

652 O.OS <<"Clang Serialized AST\n";

653break;

654caseClangSerializedDiagnosticsBitstream:

655 O.OS <<"Clang Serialized Diagnostics\n";

656break;

657caseLLVMBitstreamRemarks:

658 O.OS <<"LLVM Remarks\n";

659break;

660 }

661 O.OS <<" # Toplevel Blocks: " << NumTopBlocks <<"\n";

662 O.OS <<"\n";

663

664// Emit per-block stats.

665 O.OS <<"Per-block Summary:\n";

666for (constauto &Stat : BlockIDStats) {

667 O.OS <<" Block ID #" << Stat.first;

668if (std::optional<const char *> BlockName =

669GetBlockName(Stat.first, BlockInfo, CurStreamType))

670 O.OS <<" (" << *BlockName <<")";

671 O.OS <<":\n";

672

673const PerBlockIDStats &Stats = Stat.second;

674 O.OS <<" Num Instances: " <<Stats.NumInstances <<"\n";

675 O.OS <<" Total Size: ";

676printSize(O.OS,Stats.NumBits);

677 O.OS <<"\n";

678double pct = (Stats.NumBits * 100.0) / BufferSizeBits;

679 O.OS <<" Percent of file: " <<format("%2.4f%%", pct) <<"\n";

680if (Stats.NumInstances > 1) {

681 O.OS <<" Average Size: ";

682printSize(O.OS,Stats.NumBits / (double)Stats.NumInstances);

683 O.OS <<"\n";

684 O.OS <<" Tot/Avg SubBlocks: " <<Stats.NumSubBlocks <<"/"

685 <<Stats.NumSubBlocks / (double)Stats.NumInstances <<"\n";

686 O.OS <<" Tot/Avg Abbrevs: " <<Stats.NumAbbrevs <<"/"

687 <<Stats.NumAbbrevs / (double)Stats.NumInstances <<"\n";

688 O.OS <<" Tot/Avg Records: " <<Stats.NumRecords <<"/"

689 <<Stats.NumRecords / (double)Stats.NumInstances <<"\n";

690 }else {

691 O.OS <<" Num SubBlocks: " <<Stats.NumSubBlocks <<"\n";

692 O.OS <<" Num Abbrevs: " <<Stats.NumAbbrevs <<"\n";

693 O.OS <<" Num Records: " <<Stats.NumRecords <<"\n";

694 }

695if (Stats.NumRecords) {

696double pct = (Stats.NumAbbreviatedRecords * 100.0) /Stats.NumRecords;

697 O.OS <<" Percent Abbrevs: " <<format("%2.4f%%", pct) <<"\n";

698 }

699 O.OS <<"\n";

700

701// Print a histogram of the codes we see.

702if (O.Histogram && !Stats.CodeFreq.empty()) {

703 std::vector<std::pair<unsigned, unsigned>> FreqPairs;// <freq,code>

704for (unsigned i = 0, e =Stats.CodeFreq.size(); i != e; ++i)

705if (unsigned Freq =Stats.CodeFreq[i].NumInstances)

706 FreqPairs.push_back(std::make_pair(Freq, i));

707llvm::stable_sort(FreqPairs);

708 std::reverse(FreqPairs.begin(), FreqPairs.end());

709

710 O.OS <<"\tRecord Histogram:\n";

711 O.OS <<"\t\t Count # Bits b/Rec % Abv Record Kind\n";

712for (constauto &FreqPair : FreqPairs) {

713const PerRecordStats &RecStats =Stats.CodeFreq[FreqPair.second];

714

715 O.OS <<format("\t\t%7d %9lu", RecStats.NumInstances,

716 (unsignedlong)RecStats.TotalBits);

717

718if (RecStats.NumInstances > 1)

719 O.OS <<format(" %9.1f",

720 (double)RecStats.TotalBits / RecStats.NumInstances);

721else

722 O.OS <<" ";

723

724if (RecStats.NumAbbrev)

725 O.OS <<format(" %7.2f", (double)RecStats.NumAbbrev /

726 RecStats.NumInstances * 100);

727else

728 O.OS <<" ";

729

730 O.OS <<" ";

731if (std::optional<const char *> CodeName =GetCodeName(

732 FreqPair.second, Stat.first, BlockInfo, CurStreamType))

733 O.OS << *CodeName <<"\n";

734else

735 O.OS <<"UnknownCode" << FreqPair.second <<"\n";

736 }

737 O.OS <<"\n";

738 }

739 }

740}

741

742Error BitcodeAnalyzer::parseBlock(unsigned BlockID,unsigned IndentLevel,

743 std::optional<BCDumpOptions> O,

744 std::optional<StringRef> CheckHash) {

745 std::string Indent(IndentLevel * 2,' ');

746uint64_t BlockBitStart = Stream.GetCurrentBitNo();

747

748// Get the statistics for this BlockID.

749 PerBlockIDStats &BlockStats = BlockIDStats[BlockID];

750

751 BlockStats.NumInstances++;

752

753// BLOCKINFO is a special part of the stream.

754bool DumpRecords = O.has_value();

755if (BlockID ==bitc::BLOCKINFO_BLOCK_ID) {

756if (O && !O->DumpBlockinfo)

757 O->OS << Indent <<"<BLOCKINFO_BLOCK/>\n";

758 std::optional<BitstreamBlockInfo> NewBlockInfo;

759if (Error E = Stream.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true)

760 .moveInto(NewBlockInfo))

761return E;

762if (!NewBlockInfo)

763returnreportError("Malformed BlockInfoBlock");

764 BlockInfo = std::move(*NewBlockInfo);

765if (Error Err = Stream.JumpToBit(BlockBitStart))

766return Err;

767// It's not really interesting to dump the contents of the blockinfo

768// block, so only do it if the user explicitly requests it.

769 DumpRecords = O && O->DumpBlockinfo;

770 }

771

772unsigned NumWords = 0;

773if (Error Err = Stream.EnterSubBlock(BlockID, &NumWords))

774return Err;

775

776// Keep it for later, when we see a MODULE_HASH record

777uint64_t BlockEntryPos = Stream.getCurrentByteNo();

778

779 std::optional<const char *> BlockName;

780if (DumpRecords) {

781 O->OS << Indent <<"<";

782if ((BlockName =GetBlockName(BlockID, BlockInfo, CurStreamType)))

783 O->OS << *BlockName;

784else

785 O->OS <<"UnknownBlock" << BlockID;

786

787if (!O->Symbolic && BlockName)

788 O->OS <<" BlockID=" << BlockID;

789

790 O->OS <<" NumWords=" << NumWords

791 <<" BlockCodeSize=" << Stream.getAbbrevIDWidth() <<">\n";

792 }

793

794SmallVector<uint64_t, 64>Record;

795

796// Keep the offset to the metadata index if seen.

797uint64_t MetadataIndexOffset = 0;

798

799// Read all the records for this block.

800while (true) {

801if (Stream.AtEndOfStream())

802returnreportError("Premature end of bitstream");

803

804uint64_t RecordStartBit = Stream.GetCurrentBitNo();

805

806BitstreamEntry Entry;

807if (Error E = Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs)

808 .moveInto(Entry))

809return E;

810

811switch (Entry.Kind) {

812caseBitstreamEntry::Error:

813returnreportError("malformed bitcode file");

814caseBitstreamEntry::EndBlock: {

815uint64_t BlockBitEnd = Stream.GetCurrentBitNo();

816 BlockStats.NumBits += BlockBitEnd - BlockBitStart;

817if (DumpRecords) {

818O->OS << Indent <<"</";

819if (BlockName)

820O->OS << *BlockName <<">\n";

821else

822O->OS <<"UnknownBlock" << BlockID <<">\n";

823 }

824returnError::success();

825 }

826

827caseBitstreamEntry::SubBlock: {

828uint64_t SubBlockBitStart = Stream.GetCurrentBitNo();

829if (Error E = parseBlock(Entry.ID, IndentLevel + 1, O, CheckHash))

830return E;

831 ++BlockStats.NumSubBlocks;

832uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo();

833

834// Don't include subblock sizes in the size of this block.

835 BlockBitStart += SubBlockBitEnd - SubBlockBitStart;

836continue;

837 }

838caseBitstreamEntry::Record:

839// The interesting case.

840break;

841 }

842

843if (Entry.ID ==bitc::DEFINE_ABBREV) {

844if (Error Err = Stream.ReadAbbrevRecord())

845return Err;

846 ++BlockStats.NumAbbrevs;

847continue;

848 }

849

850Record.clear();

851

852 ++BlockStats.NumRecords;

853

854StringRef Blob;

855uint64_t CurrentRecordPos = Stream.GetCurrentBitNo();

856unsignedCode;

857if (Error E = Stream.readRecord(Entry.ID,Record, &Blob).moveInto(Code))

858return E;

859

860// Increment the # occurrences of this code.

861if (BlockStats.CodeFreq.size() <= Code)

862 BlockStats.CodeFreq.resize(Code + 1);

863 BlockStats.CodeFreq[Code].NumInstances++;

864 BlockStats.CodeFreq[Code].TotalBits +=

865 Stream.GetCurrentBitNo() - RecordStartBit;

866if (Entry.ID !=bitc::UNABBREV_RECORD) {

867 BlockStats.CodeFreq[Code].NumAbbrev++;

868 ++BlockStats.NumAbbreviatedRecords;

869 }

870

871if (DumpRecords) {

872O->OS << Indent <<" <";

873 std::optional<const char *> CodeName =

874GetCodeName(Code, BlockID, BlockInfo, CurStreamType);

875if (CodeName)

876O->OS << *CodeName;

877else

878O->OS <<"UnknownCode" <<Code;

879if (!O->Symbolic && CodeName)

880O->OS <<" codeid=" <<Code;

881constBitCodeAbbrev *Abbv =nullptr;

882if (Entry.ID !=bitc::UNABBREV_RECORD) {

883Expected<const BitCodeAbbrev *> MaybeAbbv = Stream.getAbbrev(Entry.ID);

884if (!MaybeAbbv)

885return MaybeAbbv.takeError();

886 Abbv = MaybeAbbv.get();

887O->OS <<" abbrevid=" <<Entry.ID;

888 }

889

890for (unsigned i = 0, e =Record.size(); i != e; ++i)

891O->OS <<" op" << i <<"=" << (int64_t)Record[i];

892

893// If we found a metadata index, let's verify that we had an offset

894// before and validate its forward reference offset was correct!

895if (BlockID ==bitc::METADATA_BLOCK_ID) {

896if (Code ==bitc::METADATA_INDEX_OFFSET) {

897if (Record.size() != 2)

898O->OS <<"(Invalid record)";

899else {

900autoOffset =Record[0] + (Record[1] << 32);

901 MetadataIndexOffset = Stream.GetCurrentBitNo() +Offset;

902 }

903 }

904if (Code ==bitc::METADATA_INDEX) {

905O->OS <<" (offset ";

906if (MetadataIndexOffset == RecordStartBit)

907O->OS <<"match)";

908else

909O->OS <<"mismatch: " << MetadataIndexOffset <<" vs "

910 << RecordStartBit <<")";

911 }

912 }

913

914// If we found a module hash, let's verify that it matches!

915if (BlockID ==bitc::MODULE_BLOCK_ID && Code ==bitc::MODULE_CODE_HASH &&

916 CheckHash) {

917if (Record.size() != 5)

918O->OS <<" (invalid)";

919else {

920// Recompute the hash and compare it to the one in the bitcode

921SHA1 Hasher;

922 std::array<uint8_t, 20> Hash;

923 Hasher.update(*CheckHash);

924 {

925intBlockSize = (CurrentRecordPos / 8) - BlockEntryPos;

926autoPtr = Stream.getPointerToByte(BlockEntryPos,BlockSize);

927 Hasher.update(ArrayRef<uint8_t>(Ptr,BlockSize));

928 Hash = Hasher.result();

929 }

930 std::array<uint8_t, 20> RecordedHash;

931int Pos = 0;

932for (auto &Val :Record) {

933assert(!(Val >> 32) &&"Unexpected high bits set");

934support::endian::write32be(&RecordedHash[Pos], Val);

935 Pos += 4;

936 }

937if (Hash == RecordedHash)

938O->OS <<" (match)";

939else

940O->OS <<" (!mismatch!)";

941 }

942 }

943

944O->OS <<"/>";

945

946if (Abbv) {

947for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) {

948constBitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);

949if (!Op.isEncoding() ||Op.getEncoding() !=BitCodeAbbrevOp::Array)

950continue;

951assert(i + 2 == e &&"Array op not second to last");

952 std::string Str;

953bool ArrayIsPrintable =true;

954for (unsigned j = i - 1, je =Record.size(); j != je; ++j) {

955if (!isPrint(static_cast<unsignedchar>(Record[j]))) {

956 ArrayIsPrintable =false;

957break;

958 }

959 Str += (char)Record[j];

960 }

961if (ArrayIsPrintable)

962O->OS <<" record string = '" << Str <<"'";

963break;

964 }

965 }

966

967if (Blob.data()) {

968if (canDecodeBlob(Code, BlockID)) {

969if (Error E = decodeMetadataStringsBlob(Indent,Record, Blob,O->OS))

970return E;

971 }else {

972O->OS <<" blob data = ";

973if (O->ShowBinaryBlobs) {

974O->OS <<"'";

975O->OS.write_escaped(Blob,/*hex=*/true) <<"'";

976 }else {

977bool BlobIsPrintable =true;

978for (charC : Blob)

979if (!isPrint(static_cast<unsignedchar>(C))) {

980 BlobIsPrintable =false;

981break;

982 }

983

984if (BlobIsPrintable)

985O->OS <<"'" << Blob <<"'";

986else

987O->OS <<"unprintable, " << Blob.size() <<" bytes.";

988 }

989 }

990 }

991

992O->OS <<"\n";

993 }

994

995// Make sure that we can skip the current record.

996if (Error Err = Stream.JumpToBit(CurrentRecordPos))

997return Err;

998if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))

999 ;// Do nothing.

1000else

1001return Skipped.takeError();

1002 }

1003}

1004

BitCodes.h

STRINGIFY_CODE

#define STRINGIFY_CODE(PREFIX, CODE)

canDecodeBlob

static bool canDecodeBlob(unsigned Code, unsigned BlockID)

Definition:BitcodeAnalyzer.cpp:523

GetBlockName

static std::optional< const char * > GetBlockName(unsigned BlockID, const BitstreamBlockInfo &BlockInfo, CurStreamTypeType CurStreamType)

Return a symbolic block name if known, otherwise return null.

Definition:BitcodeAnalyzer.cpp:26

ReadSignature

static Expected< CurStreamTypeType > ReadSignature(BitstreamCursor &Stream)

Definition:BitcodeAnalyzer.cpp:433

GetCodeName

static std::optional< const char * > GetCodeName(unsigned CodeID, unsigned BlockID, const BitstreamBlockInfo &BlockInfo, CurStreamTypeType CurStreamType)

Return a symbolic code name if known, otherwise return null.

Definition:BitcodeAnalyzer.cpp:89

printSize

static void printSize(raw_ostream &OS, double Bits)

Definition:BitcodeAnalyzer.cpp:425

analyzeHeader

static Expected< CurStreamTypeType > analyzeHeader(std::optional< BCDumpOptions > O, BitstreamCursor &Stream)

Definition:BitcodeAnalyzer.cpp:486

reportError

static Error reportError(StringRef Message)

Definition:BitcodeAnalyzer.cpp:20

Analysis containing CSE Info

Definition:CSEInfo.cpp:27

Size

uint64_t Size

Definition:ELFObjHandler.cpp:81

FUNCTION

#define FUNCTION(NAME, NARG, ROUND_MODE, INTRINSIC)

Format.h

NODE

#define NODE(NodeKind)

Definition:ItaniumDemangle.h:2633

LLVMBitCodes.h

KIND

#define KIND(ENUM, FIELD)

Definition:LVSupport.h:96

ENTRY

#define ENTRY(ASMNAME, ENUM)

Stats

block placement Basic Block Placement Stats

Definition:MachineBlockPlacement.cpp:3814

TOKEN

#define TOKEN(Name)

Definition:ResourceScriptToken.h:32

SHA1.h

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

raw_pwrite_stream & OS

Definition:SampleProfWriter.cpp:51

BlockSize

static const int BlockSize

Definition:TarWriter.cpp:33

Ptr

@ Ptr

Definition:TargetLibraryInfo.cpp:77

char

llvm::ArrayRef

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Definition:ArrayRef.h:41

llvm::ArrayRef::size

size_t size() const

size - Get the array size.

Definition:ArrayRef.h:168

llvm::ArrayRef::data

const T * data() const

Definition:ArrayRef.h:165

llvm::BitCodeAbbrevOp

BitCodeAbbrevOp - This describes one or more operands in an abbreviation.

Definition:BitCodes.h:33

llvm::BitCodeAbbrevOp::Array

@ Array

Definition:BitCodes.h:41

llvm::BitCodeAbbrev

BitCodeAbbrev - This class represents an abbreviation record.

Definition:BitCodes.h:103

llvm::BitCodeAbbrev::getNumOperandInfos

unsigned getNumOperandInfos() const

Definition:BitCodes.h:112

llvm::BitCodeAbbrev::getOperandInfo

const BitCodeAbbrevOp & getOperandInfo(unsigned N) const

Definition:BitCodes.h:115

llvm::BitcodeAnalyzer::BitcodeAnalyzer

BitcodeAnalyzer(StringRef Buffer, std::optional< StringRef > BlockInfoBuffer=std::nullopt)

Definition:BitcodeAnalyzer.cpp:565

llvm::BitcodeAnalyzer::analyze

Error analyze(std::optional< BCDumpOptions > O=std::nullopt, std::optional< StringRef > CheckHash=std::nullopt)

Analyze the bitcode file.

Definition:BitcodeAnalyzer.cpp:572

llvm::BitcodeAnalyzer::printStats

void printStats(BCDumpOptions O, std::optional< StringRef > Filename=std::nullopt)

Print stats about the bitcode file.

Definition:BitcodeAnalyzer.cpp:633

llvm::BitstreamBlockInfo

This class maintains the abbreviations read from a block info block.

Definition:BitstreamReader.h:37

llvm::BitstreamBlockInfo::getBlockInfo

const BlockInfo * getBlockInfo(unsigned BlockID) const

If there is block info for the specified ID, return it, otherwise return null.

Definition:BitstreamReader.h:54

llvm::BitstreamCursor

This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor.

Definition:BitstreamReader.h:357

llvm::BitstreamCursor::JumpToBit

Error JumpToBit(uint64_t BitNo)

Reset the stream to the specified bit number.

Definition:BitstreamReader.h:127

llvm::BitstreamCursor::AtEndOfStream

bool AtEndOfStream()

Definition:BitstreamReader.h:112

llvm::BitstreamCursor::ReadAbbrevRecord

Error ReadAbbrevRecord()

Definition:BitstreamReader.cpp:364

llvm::BitstreamCursor::GetCurrentBitNo

uint64_t GetCurrentBitNo() const

Return the bit # of the bit we are reading.

Definition:BitstreamReader.h:117

llvm::BitstreamCursor::ReadSubBlockID

Expected< unsigned > ReadSubBlockID()

Having read the ENTER_SUBBLOCK code, read the BlockID for the block.

Definition:BitstreamReader.h:479

llvm::BitstreamCursor::getBitcodeBytes

ArrayRef< uint8_t > getBitcodeBytes() const

Definition:BitstreamReader.h:124

llvm::BitstreamCursor::Read

Expected< word_t > Read(unsigned NumBits)

Definition:BitstreamReader.h:185

llvm::BitstreamCursor::advance

Expected< BitstreamEntry > advance(unsigned Flags=0)

Advance the current bitstream, returning the next entry in the stream.

Definition:BitstreamReader.h:417

llvm::BitstreamCursor::getAbbrev

Expected< const BitCodeAbbrev * > getAbbrev(unsigned AbbrevID)

Return the abbreviation for the specified AbbrevId.

Definition:BitstreamReader.h:542

llvm::BitstreamCursor::setBlockInfo

void setBlockInfo(BitstreamBlockInfo *BI)

Set the block info to be used by this BitstreamCursor to interpret abbreviated records.

Definition:BitstreamReader.h:572

llvm::BitstreamCursor::getPointerToByte

const uint8_t * getPointerToByte(uint64_t ByteNo, uint64_t NumBytes)

Get a pointer into the bitstream at the specified byte offset.

Definition:BitstreamReader.h:148

llvm::BitstreamCursor::readRecord

Expected< unsigned > readRecord(unsigned AbbrevID, SmallVectorImpl< uint64_t > &Vals, StringRef *Blob=nullptr)

Definition:BitstreamReader.cpp:214

llvm::BitstreamCursor::EnterSubBlock

Error EnterSubBlock(unsigned BlockID, unsigned *NumWordsP=nullptr)

Having read the ENTER_SUBBLOCK abbrevid, and enter the block.

Definition:BitstreamReader.cpp:26

llvm::BitstreamCursor::AF_DontAutoprocessAbbrevs

@ AF_DontAutoprocessAbbrevs

If this flag is used, abbrev entries are returned just like normal records.

Definition:BitstreamReader.h:413

llvm::BitstreamCursor::SkipBlock

Error SkipBlock()

Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body of this block.

Definition:BitstreamReader.h:483

llvm::BitstreamCursor::getCurrentByteNo

uint64_t getCurrentByteNo() const

Definition:BitstreamReader.h:122

llvm::BitstreamCursor::ReadCode

Expected< unsigned > ReadCode()

Definition:BitstreamReader.h:473

llvm::BitstreamCursor::ReadBlockInfoBlock

Expected< std::optional< BitstreamBlockInfo > > ReadBlockInfoBlock(bool ReadBlockInfoNames=false)

Read and return a block info block from the bitstream.

Definition:BitstreamReader.cpp:423

llvm::BitstreamCursor::getAbbrevIDWidth

unsigned getAbbrevIDWidth() const

Return the number of bits used to encode an abbrev #.

Definition:BitstreamReader.h:403

llvm::DWARFExpression::Operation

This class represents an Operation in the Expression.

Definition:DWARFExpression.h:32

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition:Error.h:160

llvm::Error::success

static ErrorSuccess success()

Create a success value.

Definition:Error.h:337

llvm::Expected

Tagged union holding either a T or a Error.

Definition:Error.h:481

llvm::Expected::takeError

Error takeError()

Take ownership of the stored error.

Definition:Error.h:608

llvm::Expected::get

reference get()

Returns a reference to the stored T value.

Definition:Error.h:578

llvm::Record

Definition:Record.h:1596

llvm::SHA1

A class that wrap the SHA1 algorithm.

Definition:SHA1.h:26

llvm::SHA1::update

void update(ArrayRef< uint8_t > Data)

Digest more data.

Definition:SHA1.cpp:208

llvm::SimpleBitstreamCursor

This represents a position within a bitstream.

Definition:BitstreamReader.h:79

llvm::SmallVector

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Definition:SmallVector.h:1196

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::StringRef::empty

constexpr bool empty() const

empty - Check if the string is empty.

Definition:StringRef.h:147

llvm::StringRef::drop_front

StringRef drop_front(size_t N=1) const

Return a StringRef equal to 'this' but with the first N elements dropped.

Definition:StringRef.h:609

llvm::StringRef::slice

StringRef slice(size_t Start, size_t End) const

Return a reference to the substring from [Start, End).

Definition:StringRef.h:684

llvm::StringRef::data

constexpr const char * data() const

data - Get a pointer to the start of the string (which may not be null terminated).

Definition:StringRef.h:144

llvm::raw_ostream

This class implements an extremely fast bulk output stream that can only output to a stream.

Definition:raw_ostream.h:52

llvm::raw_ostream::write_escaped

raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)

Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...

Definition:raw_ostream.cpp:168

uint32_t

uint64_t

llvm::COFF::Entry

@ Entry

Definition:COFF.h:844

llvm::CallingConv::C

@ C

The default llvm calling convention, compatible with C.

Definition:CallingConv.h:34

llvm::RISCVFenceField::R

@ R

Definition:RISCVBaseInfo.h:373

llvm::RISCVFenceField::O

@ O

Definition:RISCVBaseInfo.h:372

llvm::bitc::METADATA_STRINGS

@ METADATA_STRINGS

Definition:LLVMBitCodes.h:375

llvm::bitc::METADATA_INDEX

@ METADATA_INDEX

Definition:LLVMBitCodes.h:379

llvm::bitc::METADATA_INDEX_OFFSET

@ METADATA_INDEX_OFFSET

Definition:LLVMBitCodes.h:378

llvm::bitc::CST_CODE_BLOCKADDRESS

@ CST_CODE_BLOCKADDRESS

Definition:LLVMBitCodes.h:414

llvm::bitc::BLOCKINFO_CODE_BLOCKNAME

@ BLOCKINFO_CODE_BLOCKNAME

Definition:BitCodeEnums.h:82

llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME

@ BLOCKINFO_CODE_SETRECORDNAME

Definition:BitCodeEnums.h:83

llvm::bitc::BLOCKINFO_CODE_SETBID

@ BLOCKINFO_CODE_SETBID

Definition:BitCodeEnums.h:81

llvm::bitc::USELIST_CODE_BB

@ USELIST_CODE_BB

Definition:LLVMBitCodes.h:685

llvm::bitc::USELIST_CODE_DEFAULT

@ USELIST_CODE_DEFAULT

Definition:LLVMBitCodes.h:684

llvm::bitc::PARAMATTR_BLOCK_ID

@ PARAMATTR_BLOCK_ID

Definition:LLVMBitCodes.h:33

llvm::bitc::TYPE_BLOCK_ID_NEW

@ TYPE_BLOCK_ID_NEW

Definition:LLVMBitCodes.h:48

llvm::bitc::MODULE_BLOCK_ID

@ MODULE_BLOCK_ID

Definition:LLVMBitCodes.h:30

llvm::bitc::STRTAB_BLOCK_ID

@ STRTAB_BLOCK_ID

Definition:LLVMBitCodes.h:59

llvm::bitc::SYMTAB_BLOCK_ID

@ SYMTAB_BLOCK_ID

Definition:LLVMBitCodes.h:63

llvm::bitc::CONSTANTS_BLOCK_ID

@ CONSTANTS_BLOCK_ID

Definition:LLVMBitCodes.h:36

llvm::bitc::PARAMATTR_GROUP_BLOCK_ID

@ PARAMATTR_GROUP_BLOCK_ID

Definition:LLVMBitCodes.h:34

llvm::bitc::METADATA_KIND_BLOCK_ID

@ METADATA_KIND_BLOCK_ID

Definition:LLVMBitCodes.h:57

llvm::bitc::IDENTIFICATION_BLOCK_ID

@ IDENTIFICATION_BLOCK_ID

Definition:LLVMBitCodes.h:42

llvm::bitc::GLOBALVAL_SUMMARY_BLOCK_ID

@ GLOBALVAL_SUMMARY_BLOCK_ID

Definition:LLVMBitCodes.h:53

llvm::bitc::METADATA_ATTACHMENT_ID

@ METADATA_ATTACHMENT_ID

Definition:LLVMBitCodes.h:46

llvm::bitc::METADATA_BLOCK_ID

@ METADATA_BLOCK_ID

Definition:LLVMBitCodes.h:45

llvm::bitc::FUNCTION_BLOCK_ID

@ FUNCTION_BLOCK_ID

Definition:LLVMBitCodes.h:37

llvm::bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID

@ FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID

Definition:LLVMBitCodes.h:61

llvm::bitc::MODULE_STRTAB_BLOCK_ID

@ MODULE_STRTAB_BLOCK_ID

Definition:LLVMBitCodes.h:52

llvm::bitc::VALUE_SYMTAB_BLOCK_ID

@ VALUE_SYMTAB_BLOCK_ID

Definition:LLVMBitCodes.h:44

llvm::bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID

@ OPERAND_BUNDLE_TAGS_BLOCK_ID

Definition:LLVMBitCodes.h:55

llvm::bitc::USELIST_BLOCK_ID

@ USELIST_BLOCK_ID

Definition:LLVMBitCodes.h:50

llvm::bitc::BLOCKINFO_BLOCK_ID

@ BLOCKINFO_BLOCK_ID

BLOCKINFO_BLOCK is used to define metadata about blocks, for example, standard abbrevs that should be...

Definition:BitCodeEnums.h:69

llvm::bitc::FIRST_APPLICATION_BLOCKID

@ FIRST_APPLICATION_BLOCKID

Definition:BitCodeEnums.h:72

llvm::bitc::MODULE_CODE_HASH

@ MODULE_CODE_HASH

Definition:LLVMBitCodes.h:119

llvm::bitc::STRTAB_BLOB

@ STRTAB_BLOB

Definition:LLVMBitCodes.h:803

llvm::bitc::DEFINE_ABBREV

@ DEFINE_ABBREV

DEFINE_ABBREV - Defines an abbrev for the current block.

Definition:BitCodeEnums.h:53

llvm::bitc::UNABBREV_RECORD

@ UNABBREV_RECORD

Definition:BitCodeEnums.h:57

llvm::bitc::ENTER_SUBBLOCK

@ ENTER_SUBBLOCK

Definition:BitCodeEnums.h:46

llvm::bitc::OPERAND_BUNDLE_TAG

@ OPERAND_BUNDLE_TAG

Definition:LLVMBitCodes.h:183

llvm::bitc::PARAMATTR_CODE_ENTRY_OLD

@ PARAMATTR_CODE_ENTRY_OLD

Definition:LLVMBitCodes.h:128

llvm::bitc::PARAMATTR_GRP_CODE_ENTRY

@ PARAMATTR_GRP_CODE_ENTRY

Definition:LLVMBitCodes.h:131

llvm::bitc::PARAMATTR_CODE_ENTRY

@ PARAMATTR_CODE_ENTRY

Definition:LLVMBitCodes.h:130

llvm::bitc::SYMTAB_BLOB

@ SYMTAB_BLOB

Definition:LLVMBitCodes.h:807

llvm::rdf::Code

NodeAddr< CodeNode * > Code

Definition:RDFGraph.h:388

llvm::support::endian::write32be

void write32be(void *P, uint32_t V)

Definition:Endian.h:477

llvm::support::endian::read32le

uint32_t read32le(const void *P)

Definition:Endian.h:425

llvm::sys::locale::isPrint

bool isPrint(int c)

Definition:Locale.cpp:13

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::Offset

@ Offset

Definition:DWP.cpp:480

llvm::stable_sort

void stable_sort(R &&Range)

Definition:STLExtras.h:2037

llvm::size

auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)

Get the size of a range.

Definition:STLExtras.h:1697

llvm::BWH_OffsetField

@ BWH_OffsetField

Definition:BitCodeEnums.h:29

llvm::BWH_VersionField

@ BWH_VersionField

Definition:BitCodeEnums.h:28

llvm::BWH_MagicField

@ BWH_MagicField

Definition:BitCodeEnums.h:27

llvm::BWH_HeaderSize