File: | build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp |
Warning: | line 434, column 20 The left operand of '==' is a garbage value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
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 | //===----------------------------------------------------------------------===// | |||
8 | ||||
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 | ||||
17 | using namespace llvm; | |||
18 | ||||
19 | static Error reportError(StringRef Message) { | |||
20 | return createStringError(std::errc::illegal_byte_sequence, Message.data()); | |||
21 | } | |||
22 | ||||
23 | /// Return a symbolic block name if known, otherwise return null. | |||
24 | static Optional<const char *> GetBlockName(unsigned BlockID, | |||
25 | const BitstreamBlockInfo &BlockInfo, | |||
26 | CurStreamTypeType CurStreamType) { | |||
27 | // Standard blocks for all bitcode files. | |||
28 | if (BlockID < bitc::FIRST_APPLICATION_BLOCKID) { | |||
29 | if (BlockID == bitc::BLOCKINFO_BLOCK_ID) | |||
30 | return "BLOCKINFO_BLOCK"; | |||
31 | return None; | |||
32 | } | |||
33 | ||||
34 | // Check to see if we have a blockinfo record for this block, with a name. | |||
35 | if (const BitstreamBlockInfo::BlockInfo *Info = | |||
36 | BlockInfo.getBlockInfo(BlockID)) { | |||
37 | if (!Info->Name.empty()) | |||
38 | return Info->Name.c_str(); | |||
39 | } | |||
40 | ||||
41 | if (CurStreamType != LLVMIRBitstream) | |||
42 | return None; | |||
43 | ||||
44 | switch (BlockID) { | |||
45 | default: | |||
46 | return None; | |||
47 | case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID: | |||
48 | return "OPERAND_BUNDLE_TAGS_BLOCK"; | |||
49 | case bitc::MODULE_BLOCK_ID: | |||
50 | return "MODULE_BLOCK"; | |||
51 | case bitc::PARAMATTR_BLOCK_ID: | |||
52 | return "PARAMATTR_BLOCK"; | |||
53 | case bitc::PARAMATTR_GROUP_BLOCK_ID: | |||
54 | return "PARAMATTR_GROUP_BLOCK_ID"; | |||
55 | case bitc::TYPE_BLOCK_ID_NEW: | |||
56 | return "TYPE_BLOCK_ID"; | |||
57 | case bitc::CONSTANTS_BLOCK_ID: | |||
58 | return "CONSTANTS_BLOCK"; | |||
59 | case bitc::FUNCTION_BLOCK_ID: | |||
60 | return "FUNCTION_BLOCK"; | |||
61 | case bitc::IDENTIFICATION_BLOCK_ID: | |||
62 | return "IDENTIFICATION_BLOCK_ID"; | |||
63 | case bitc::VALUE_SYMTAB_BLOCK_ID: | |||
64 | return "VALUE_SYMTAB"; | |||
65 | case bitc::METADATA_BLOCK_ID: | |||
66 | return "METADATA_BLOCK"; | |||
67 | case bitc::METADATA_KIND_BLOCK_ID: | |||
68 | return "METADATA_KIND_BLOCK"; | |||
69 | case bitc::METADATA_ATTACHMENT_ID: | |||
70 | return "METADATA_ATTACHMENT_BLOCK"; | |||
71 | case bitc::USELIST_BLOCK_ID: | |||
72 | return "USELIST_BLOCK_ID"; | |||
73 | case bitc::GLOBALVAL_SUMMARY_BLOCK_ID: | |||
74 | return "GLOBALVAL_SUMMARY_BLOCK"; | |||
75 | case bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID: | |||
76 | return "FULL_LTO_GLOBALVAL_SUMMARY_BLOCK"; | |||
77 | case bitc::MODULE_STRTAB_BLOCK_ID: | |||
78 | return "MODULE_STRTAB_BLOCK"; | |||
79 | case bitc::STRTAB_BLOCK_ID: | |||
80 | return "STRTAB_BLOCK"; | |||
81 | case bitc::SYMTAB_BLOCK_ID: | |||
82 | return "SYMTAB_BLOCK"; | |||
83 | } | |||
84 | } | |||
85 | ||||
86 | /// Return a symbolic code name if known, otherwise return null. | |||
87 | static Optional<const char *> GetCodeName(unsigned CodeID, unsigned BlockID, | |||
88 | const BitstreamBlockInfo &BlockInfo, | |||
89 | CurStreamTypeType CurStreamType) { | |||
90 | // Standard blocks for all bitcode files. | |||
91 | if (BlockID < bitc::FIRST_APPLICATION_BLOCKID) { | |||
92 | if (BlockID == bitc::BLOCKINFO_BLOCK_ID) { | |||
93 | switch (CodeID) { | |||
94 | default: | |||
95 | return None; | |||
96 | case bitc::BLOCKINFO_CODE_SETBID: | |||
97 | return "SETBID"; | |||
98 | case bitc::BLOCKINFO_CODE_BLOCKNAME: | |||
99 | return "BLOCKNAME"; | |||
100 | case bitc::BLOCKINFO_CODE_SETRECORDNAME: | |||
101 | return "SETRECORDNAME"; | |||
102 | } | |||
103 | } | |||
104 | return None; | |||
105 | } | |||
106 | ||||
107 | // Check to see if we have a blockinfo record for this record, with a name. | |||
108 | if (const BitstreamBlockInfo::BlockInfo *Info = | |||
109 | BlockInfo.getBlockInfo(BlockID)) { | |||
110 | for (const std::pair<unsigned, std::string> &RN : Info->RecordNames) | |||
111 | if (RN.first == CodeID) | |||
112 | return RN.second.c_str(); | |||
113 | } | |||
114 | ||||
115 | if (CurStreamType != LLVMIRBitstream) | |||
116 | return None; | |||
117 | ||||
118 | #define STRINGIFY_CODE(PREFIX, CODE) \ | |||
119 | case bitc::PREFIX##_##CODE: \ | |||
120 | return #CODE; | |||
121 | switch (BlockID) { | |||
122 | default: | |||
123 | return None; | |||
124 | case bitc::MODULE_BLOCK_ID: | |||
125 | switch (CodeID) { | |||
126 | default: | |||
127 | return None; | |||
128 | STRINGIFY_CODE(MODULE_CODE, VERSION) | |||
129 | STRINGIFY_CODE(MODULE_CODE, TRIPLE) | |||
130 | STRINGIFY_CODE(MODULE_CODE, DATALAYOUT) | |||
131 | STRINGIFY_CODE(MODULE_CODE, ASM) | |||
132 | STRINGIFY_CODE(MODULE_CODE, SECTIONNAME) | |||
133 | STRINGIFY_CODE(MODULE_CODE, DEPLIB) // Deprecated, present in old bitcode | |||
134 | STRINGIFY_CODE(MODULE_CODE, GLOBALVAR) | |||
135 | STRINGIFY_CODE(MODULE_CODE, FUNCTION) | |||
136 | STRINGIFY_CODE(MODULE_CODE, ALIAS) | |||
137 | STRINGIFY_CODE(MODULE_CODE, GCNAME) | |||
138 | STRINGIFY_CODE(MODULE_CODE, COMDAT) | |||
139 | STRINGIFY_CODE(MODULE_CODE, VSTOFFSET) | |||
140 | STRINGIFY_CODE(MODULE_CODE, METADATA_VALUES_UNUSED) | |||
141 | STRINGIFY_CODE(MODULE_CODE, SOURCE_FILENAME) | |||
142 | STRINGIFY_CODE(MODULE_CODE, HASH) | |||
143 | } | |||
144 | case bitc::IDENTIFICATION_BLOCK_ID: | |||
145 | switch (CodeID) { | |||
146 | default: | |||
147 | return None; | |||
148 | STRINGIFY_CODE(IDENTIFICATION_CODE, STRING) | |||
149 | STRINGIFY_CODE(IDENTIFICATION_CODE, EPOCH) | |||
150 | } | |||
151 | case bitc::PARAMATTR_BLOCK_ID: | |||
152 | switch (CodeID) { | |||
153 | default: | |||
154 | return None; | |||
155 | // FIXME: Should these be different? | |||
156 | case bitc::PARAMATTR_CODE_ENTRY_OLD: | |||
157 | return "ENTRY"; | |||
158 | case bitc::PARAMATTR_CODE_ENTRY: | |||
159 | return "ENTRY"; | |||
160 | } | |||
161 | case bitc::PARAMATTR_GROUP_BLOCK_ID: | |||
162 | switch (CodeID) { | |||
163 | default: | |||
164 | return None; | |||
165 | case bitc::PARAMATTR_GRP_CODE_ENTRY: | |||
166 | return "ENTRY"; | |||
167 | } | |||
168 | case bitc::TYPE_BLOCK_ID_NEW: | |||
169 | switch (CodeID) { | |||
170 | default: | |||
171 | return None; | |||
172 | STRINGIFY_CODE(TYPE_CODE, NUMENTRY) | |||
173 | STRINGIFY_CODE(TYPE_CODE, VOID) | |||
174 | STRINGIFY_CODE(TYPE_CODE, FLOAT) | |||
175 | STRINGIFY_CODE(TYPE_CODE, DOUBLE) | |||
176 | STRINGIFY_CODE(TYPE_CODE, LABEL) | |||
177 | STRINGIFY_CODE(TYPE_CODE, OPAQUE) | |||
178 | STRINGIFY_CODE(TYPE_CODE, INTEGER) | |||
179 | STRINGIFY_CODE(TYPE_CODE, POINTER) | |||
180 | STRINGIFY_CODE(TYPE_CODE, HALF) | |||
181 | STRINGIFY_CODE(TYPE_CODE, ARRAY) | |||
182 | STRINGIFY_CODE(TYPE_CODE, VECTOR) | |||
183 | STRINGIFY_CODE(TYPE_CODE, X86_FP80) | |||
184 | STRINGIFY_CODE(TYPE_CODE, FP128) | |||
185 | STRINGIFY_CODE(TYPE_CODE, PPC_FP128) | |||
186 | STRINGIFY_CODE(TYPE_CODE, METADATA) | |||
187 | STRINGIFY_CODE(TYPE_CODE, X86_MMX) | |||
188 | STRINGIFY_CODE(TYPE_CODE, STRUCT_ANON) | |||
189 | STRINGIFY_CODE(TYPE_CODE, STRUCT_NAME) | |||
190 | STRINGIFY_CODE(TYPE_CODE, STRUCT_NAMED) | |||
191 | STRINGIFY_CODE(TYPE_CODE, FUNCTION) | |||
192 | STRINGIFY_CODE(TYPE_CODE, TOKEN) | |||
193 | STRINGIFY_CODE(TYPE_CODE, BFLOAT) | |||
194 | } | |||
195 | ||||
196 | case bitc::CONSTANTS_BLOCK_ID: | |||
197 | switch (CodeID) { | |||
198 | default: | |||
199 | return None; | |||
200 | STRINGIFY_CODE(CST_CODE, SETTYPE) | |||
201 | STRINGIFY_CODE(CST_CODE, NULL__null) | |||
202 | STRINGIFY_CODE(CST_CODE, UNDEF) | |||
203 | STRINGIFY_CODE(CST_CODE, INTEGER) | |||
204 | STRINGIFY_CODE(CST_CODE, WIDE_INTEGER) | |||
205 | STRINGIFY_CODE(CST_CODE, FLOAT) | |||
206 | STRINGIFY_CODE(CST_CODE, AGGREGATE) | |||
207 | STRINGIFY_CODE(CST_CODE, STRING) | |||
208 | STRINGIFY_CODE(CST_CODE, CSTRING) | |||
209 | STRINGIFY_CODE(CST_CODE, CE_BINOP) | |||
210 | STRINGIFY_CODE(CST_CODE, CE_CAST) | |||
211 | STRINGIFY_CODE(CST_CODE, CE_GEP) | |||
212 | STRINGIFY_CODE(CST_CODE, CE_INBOUNDS_GEP) | |||
213 | STRINGIFY_CODE(CST_CODE, CE_SELECT) | |||
214 | STRINGIFY_CODE(CST_CODE, CE_EXTRACTELT) | |||
215 | STRINGIFY_CODE(CST_CODE, CE_INSERTELT) | |||
216 | STRINGIFY_CODE(CST_CODE, CE_SHUFFLEVEC) | |||
217 | STRINGIFY_CODE(CST_CODE, CE_CMP) | |||
218 | STRINGIFY_CODE(CST_CODE, INLINEASM) | |||
219 | STRINGIFY_CODE(CST_CODE, CE_SHUFVEC_EX) | |||
220 | STRINGIFY_CODE(CST_CODE, CE_UNOP) | |||
221 | STRINGIFY_CODE(CST_CODE, DSO_LOCAL_EQUIVALENT) | |||
222 | STRINGIFY_CODE(CST_CODE, NO_CFI_VALUE) | |||
223 | case bitc::CST_CODE_BLOCKADDRESS: | |||
224 | return "CST_CODE_BLOCKADDRESS"; | |||
225 | STRINGIFY_CODE(CST_CODE, DATA) | |||
226 | } | |||
227 | case bitc::FUNCTION_BLOCK_ID: | |||
228 | switch (CodeID) { | |||
229 | default: | |||
230 | return None; | |||
231 | STRINGIFY_CODE(FUNC_CODE, DECLAREBLOCKS) | |||
232 | STRINGIFY_CODE(FUNC_CODE, INST_BINOP) | |||
233 | STRINGIFY_CODE(FUNC_CODE, INST_CAST) | |||
234 | STRINGIFY_CODE(FUNC_CODE, INST_GEP_OLD) | |||
235 | STRINGIFY_CODE(FUNC_CODE, INST_INBOUNDS_GEP_OLD) | |||
236 | STRINGIFY_CODE(FUNC_CODE, INST_SELECT) | |||
237 | STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTELT) | |||
238 | STRINGIFY_CODE(FUNC_CODE, INST_INSERTELT) | |||
239 | STRINGIFY_CODE(FUNC_CODE, INST_SHUFFLEVEC) | |||
240 | STRINGIFY_CODE(FUNC_CODE, INST_CMP) | |||
241 | STRINGIFY_CODE(FUNC_CODE, INST_RET) | |||
242 | STRINGIFY_CODE(FUNC_CODE, INST_BR) | |||
243 | STRINGIFY_CODE(FUNC_CODE, INST_SWITCH) | |||
244 | STRINGIFY_CODE(FUNC_CODE, INST_INVOKE) | |||
245 | STRINGIFY_CODE(FUNC_CODE, INST_UNOP) | |||
246 | STRINGIFY_CODE(FUNC_CODE, INST_UNREACHABLE) | |||
247 | STRINGIFY_CODE(FUNC_CODE, INST_CLEANUPRET) | |||
248 | STRINGIFY_CODE(FUNC_CODE, INST_CATCHRET) | |||
249 | STRINGIFY_CODE(FUNC_CODE, INST_CATCHPAD) | |||
250 | STRINGIFY_CODE(FUNC_CODE, INST_PHI) | |||
251 | STRINGIFY_CODE(FUNC_CODE, INST_ALLOCA) | |||
252 | STRINGIFY_CODE(FUNC_CODE, INST_LOAD) | |||
253 | STRINGIFY_CODE(FUNC_CODE, INST_VAARG) | |||
254 | STRINGIFY_CODE(FUNC_CODE, INST_STORE) | |||
255 | STRINGIFY_CODE(FUNC_CODE, INST_EXTRACTVAL) | |||
256 | STRINGIFY_CODE(FUNC_CODE, INST_INSERTVAL) | |||
257 | STRINGIFY_CODE(FUNC_CODE, INST_CMP2) | |||
258 | STRINGIFY_CODE(FUNC_CODE, INST_VSELECT) | |||
259 | STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC_AGAIN) | |||
260 | STRINGIFY_CODE(FUNC_CODE, INST_CALL) | |||
261 | STRINGIFY_CODE(FUNC_CODE, DEBUG_LOC) | |||
262 | STRINGIFY_CODE(FUNC_CODE, INST_GEP) | |||
263 | STRINGIFY_CODE(FUNC_CODE, OPERAND_BUNDLE) | |||
264 | STRINGIFY_CODE(FUNC_CODE, INST_FENCE) | |||
265 | STRINGIFY_CODE(FUNC_CODE, INST_ATOMICRMW) | |||
266 | STRINGIFY_CODE(FUNC_CODE, INST_LOADATOMIC) | |||
267 | STRINGIFY_CODE(FUNC_CODE, INST_STOREATOMIC) | |||
268 | STRINGIFY_CODE(FUNC_CODE, INST_CMPXCHG) | |||
269 | STRINGIFY_CODE(FUNC_CODE, INST_CALLBR) | |||
270 | STRINGIFY_CODE(FUNC_CODE, BLOCKADDR_USERS) | |||
271 | } | |||
272 | case bitc::VALUE_SYMTAB_BLOCK_ID: | |||
273 | switch (CodeID) { | |||
274 | default: | |||
275 | return None; | |||
276 | STRINGIFY_CODE(VST_CODE, ENTRY) | |||
277 | STRINGIFY_CODE(VST_CODE, BBENTRY) | |||
278 | STRINGIFY_CODE(VST_CODE, FNENTRY) | |||
279 | STRINGIFY_CODE(VST_CODE, COMBINED_ENTRY) | |||
280 | } | |||
281 | case bitc::MODULE_STRTAB_BLOCK_ID: | |||
282 | switch (CodeID) { | |||
283 | default: | |||
284 | return None; | |||
285 | STRINGIFY_CODE(MST_CODE, ENTRY) | |||
286 | STRINGIFY_CODE(MST_CODE, HASH) | |||
287 | } | |||
288 | case bitc::GLOBALVAL_SUMMARY_BLOCK_ID: | |||
289 | case bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID: | |||
290 | switch (CodeID) { | |||
291 | default: | |||
292 | return None; | |||
293 | STRINGIFY_CODE(FS, PERMODULE) | |||
294 | STRINGIFY_CODE(FS, PERMODULE_PROFILE) | |||
295 | STRINGIFY_CODE(FS, PERMODULE_RELBF) | |||
296 | STRINGIFY_CODE(FS, PERMODULE_GLOBALVAR_INIT_REFS) | |||
297 | STRINGIFY_CODE(FS, PERMODULE_VTABLE_GLOBALVAR_INIT_REFS) | |||
298 | STRINGIFY_CODE(FS, COMBINED) | |||
299 | STRINGIFY_CODE(FS, COMBINED_PROFILE) | |||
300 | STRINGIFY_CODE(FS, COMBINED_GLOBALVAR_INIT_REFS) | |||
301 | STRINGIFY_CODE(FS, ALIAS) | |||
302 | STRINGIFY_CODE(FS, COMBINED_ALIAS) | |||
303 | STRINGIFY_CODE(FS, COMBINED_ORIGINAL_NAME) | |||
304 | STRINGIFY_CODE(FS, VERSION) | |||
305 | STRINGIFY_CODE(FS, FLAGS) | |||
306 | STRINGIFY_CODE(FS, TYPE_TESTS) | |||
307 | STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_VCALLS) | |||
308 | STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_VCALLS) | |||
309 | STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_CONST_VCALL) | |||
310 | STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_CONST_VCALL) | |||
311 | STRINGIFY_CODE(FS, VALUE_GUID) | |||
312 | STRINGIFY_CODE(FS, CFI_FUNCTION_DEFS) | |||
313 | STRINGIFY_CODE(FS, CFI_FUNCTION_DECLS) | |||
314 | STRINGIFY_CODE(FS, TYPE_ID) | |||
315 | STRINGIFY_CODE(FS, TYPE_ID_METADATA) | |||
316 | STRINGIFY_CODE(FS, BLOCK_COUNT) | |||
317 | STRINGIFY_CODE(FS, PARAM_ACCESS) | |||
318 | } | |||
319 | case bitc::METADATA_ATTACHMENT_ID: | |||
320 | switch (CodeID) { | |||
321 | default: | |||
322 | return None; | |||
323 | STRINGIFY_CODE(METADATA, ATTACHMENT) | |||
324 | } | |||
325 | case bitc::METADATA_BLOCK_ID: | |||
326 | switch (CodeID) { | |||
327 | default: | |||
328 | return None; | |||
329 | STRINGIFY_CODE(METADATA, STRING_OLD) | |||
330 | STRINGIFY_CODE(METADATA, VALUE) | |||
331 | STRINGIFY_CODE(METADATA, NODE) | |||
332 | STRINGIFY_CODE(METADATA, NAME) | |||
333 | STRINGIFY_CODE(METADATA, DISTINCT_NODE) | |||
334 | STRINGIFY_CODE(METADATA, KIND) // Older bitcode has it in a MODULE_BLOCK | |||
335 | STRINGIFY_CODE(METADATA, LOCATION) | |||
336 | STRINGIFY_CODE(METADATA, OLD_NODE) | |||
337 | STRINGIFY_CODE(METADATA, OLD_FN_NODE) | |||
338 | STRINGIFY_CODE(METADATA, NAMED_NODE) | |||
339 | STRINGIFY_CODE(METADATA, GENERIC_DEBUG) | |||
340 | STRINGIFY_CODE(METADATA, SUBRANGE) | |||
341 | STRINGIFY_CODE(METADATA, ENUMERATOR) | |||
342 | STRINGIFY_CODE(METADATA, BASIC_TYPE) | |||
343 | STRINGIFY_CODE(METADATA, FILE) | |||
344 | STRINGIFY_CODE(METADATA, DERIVED_TYPE) | |||
345 | STRINGIFY_CODE(METADATA, COMPOSITE_TYPE) | |||
346 | STRINGIFY_CODE(METADATA, SUBROUTINE_TYPE) | |||
347 | STRINGIFY_CODE(METADATA, COMPILE_UNIT) | |||
348 | STRINGIFY_CODE(METADATA, SUBPROGRAM) | |||
349 | STRINGIFY_CODE(METADATA, LEXICAL_BLOCK) | |||
350 | STRINGIFY_CODE(METADATA, LEXICAL_BLOCK_FILE) | |||
351 | STRINGIFY_CODE(METADATA, NAMESPACE) | |||
352 | STRINGIFY_CODE(METADATA, TEMPLATE_TYPE) | |||
353 | STRINGIFY_CODE(METADATA, TEMPLATE_VALUE) | |||
354 | STRINGIFY_CODE(METADATA, GLOBAL_VAR) | |||
355 | STRINGIFY_CODE(METADATA, LOCAL_VAR) | |||
356 | STRINGIFY_CODE(METADATA, EXPRESSION) | |||
357 | STRINGIFY_CODE(METADATA, OBJC_PROPERTY) | |||
358 | STRINGIFY_CODE(METADATA, IMPORTED_ENTITY) | |||
359 | STRINGIFY_CODE(METADATA, MODULE) | |||
360 | STRINGIFY_CODE(METADATA, MACRO) | |||
361 | STRINGIFY_CODE(METADATA, MACRO_FILE) | |||
362 | STRINGIFY_CODE(METADATA, STRINGS) | |||
363 | STRINGIFY_CODE(METADATA, GLOBAL_DECL_ATTACHMENT) | |||
364 | STRINGIFY_CODE(METADATA, GLOBAL_VAR_EXPR) | |||
365 | STRINGIFY_CODE(METADATA, INDEX_OFFSET) | |||
366 | STRINGIFY_CODE(METADATA, INDEX) | |||
367 | STRINGIFY_CODE(METADATA, ARG_LIST) | |||
368 | } | |||
369 | case bitc::METADATA_KIND_BLOCK_ID: | |||
370 | switch (CodeID) { | |||
371 | default: | |||
372 | return None; | |||
373 | STRINGIFY_CODE(METADATA, KIND) | |||
374 | } | |||
375 | case bitc::USELIST_BLOCK_ID: | |||
376 | switch (CodeID) { | |||
377 | default: | |||
378 | return None; | |||
379 | case bitc::USELIST_CODE_DEFAULT: | |||
380 | return "USELIST_CODE_DEFAULT"; | |||
381 | case bitc::USELIST_CODE_BB: | |||
382 | return "USELIST_CODE_BB"; | |||
383 | } | |||
384 | ||||
385 | case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID: | |||
386 | switch (CodeID) { | |||
387 | default: | |||
388 | return None; | |||
389 | case bitc::OPERAND_BUNDLE_TAG: | |||
390 | return "OPERAND_BUNDLE_TAG"; | |||
391 | } | |||
392 | case bitc::STRTAB_BLOCK_ID: | |||
393 | switch (CodeID) { | |||
394 | default: | |||
395 | return None; | |||
396 | case bitc::STRTAB_BLOB: | |||
397 | return "BLOB"; | |||
398 | } | |||
399 | case bitc::SYMTAB_BLOCK_ID: | |||
400 | switch (CodeID) { | |||
401 | default: | |||
402 | return None; | |||
403 | case bitc::SYMTAB_BLOB: | |||
404 | return "BLOB"; | |||
405 | } | |||
406 | } | |||
407 | #undef STRINGIFY_CODE | |||
408 | } | |||
409 | ||||
410 | static void printSize(raw_ostream &OS, double Bits) { | |||
411 | OS << format("%.2f/%.2fB/%luW", Bits, Bits / 8, (unsigned long)(Bits / 32)); | |||
412 | } | |||
413 | static void printSize(raw_ostream &OS, uint64_t Bits) { | |||
414 | OS << format("%lub/%.2fB/%luW", (unsigned long)Bits, (double)Bits / 8, | |||
415 | (unsigned long)(Bits / 32)); | |||
416 | } | |||
417 | ||||
418 | static Expected<CurStreamTypeType> ReadSignature(BitstreamCursor &Stream) { | |||
419 | auto tryRead = [&Stream](char &Dest, size_t size) -> Error { | |||
420 | if (Expected<SimpleBitstreamCursor::word_t> MaybeWord = Stream.Read(size)) | |||
421 | Dest = MaybeWord.get(); | |||
422 | else | |||
423 | return MaybeWord.takeError(); | |||
424 | return Error::success(); | |||
425 | }; | |||
426 | ||||
427 | char Signature[6]; | |||
428 | if (Error Err = tryRead(Signature[0], 8)) | |||
429 | return std::move(Err); | |||
430 | if (Error Err = tryRead(Signature[1], 8)) | |||
431 | return std::move(Err); | |||
432 | ||||
433 | // Autodetect the file contents, if it is one we know. | |||
434 | if (Signature[0] == 'C' && Signature[1] == 'P') { | |||
| ||||
435 | if (Error Err = tryRead(Signature[2], 8)) | |||
436 | return std::move(Err); | |||
437 | if (Error Err = tryRead(Signature[3], 8)) | |||
438 | return std::move(Err); | |||
439 | if (Signature[2] == 'C' && Signature[3] == 'H') | |||
440 | return ClangSerializedASTBitstream; | |||
441 | } else if (Signature[0] == 'D' && Signature[1] == 'I') { | |||
442 | if (Error Err = tryRead(Signature[2], 8)) | |||
443 | return std::move(Err); | |||
444 | if (Error Err = tryRead(Signature[3], 8)) | |||
445 | return std::move(Err); | |||
446 | if (Signature[2] == 'A' && Signature[3] == 'G') | |||
447 | return ClangSerializedDiagnosticsBitstream; | |||
448 | } else if (Signature[0] == 'R' && Signature[1] == 'M') { | |||
449 | if (Error Err = tryRead(Signature[2], 8)) | |||
450 | return std::move(Err); | |||
451 | if (Error Err = tryRead(Signature[3], 8)) | |||
452 | return std::move(Err); | |||
453 | if (Signature[2] == 'R' && Signature[3] == 'K') | |||
454 | return LLVMBitstreamRemarks; | |||
455 | } else { | |||
456 | if (Error Err = tryRead(Signature[2], 4)) | |||
457 | return std::move(Err); | |||
458 | if (Error Err = tryRead(Signature[3], 4)) | |||
459 | return std::move(Err); | |||
460 | if (Error Err = tryRead(Signature[4], 4)) | |||
461 | return std::move(Err); | |||
462 | if (Error Err = tryRead(Signature[5], 4)) | |||
463 | return std::move(Err); | |||
464 | if (Signature[0] == 'B' && Signature[1] == 'C' && Signature[2] == 0x0 && | |||
465 | Signature[3] == 0xC && Signature[4] == 0xE && Signature[5] == 0xD) | |||
466 | return LLVMIRBitstream; | |||
467 | } | |||
468 | return UnknownBitstream; | |||
469 | } | |||
470 | ||||
471 | static Expected<CurStreamTypeType> analyzeHeader(Optional<BCDumpOptions> O, | |||
472 | BitstreamCursor &Stream) { | |||
473 | ArrayRef<uint8_t> Bytes = Stream.getBitcodeBytes(); | |||
474 | const unsigned char *BufPtr = (const unsigned char *)Bytes.data(); | |||
475 | const unsigned char *EndBufPtr = BufPtr + Bytes.size(); | |||
476 | ||||
477 | // If we have a wrapper header, parse it and ignore the non-bc file | |||
478 | // contents. The magic number is 0x0B17C0DE stored in little endian. | |||
479 | if (isBitcodeWrapper(BufPtr, EndBufPtr)) { | |||
480 | if (Bytes.size() < BWH_HeaderSize) | |||
481 | return reportError("Invalid bitcode wrapper header"); | |||
482 | ||||
483 | if (O) { | |||
484 | unsigned Magic = support::endian::read32le(&BufPtr[BWH_MagicField]); | |||
485 | unsigned Version = support::endian::read32le(&BufPtr[BWH_VersionField]); | |||
486 | unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]); | |||
487 | unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]); | |||
488 | unsigned CPUType = support::endian::read32le(&BufPtr[BWH_CPUTypeField]); | |||
489 | ||||
490 | O->OS << "<BITCODE_WRAPPER_HEADER" | |||
491 | << " Magic=" << format_hex(Magic, 10) | |||
492 | << " Version=" << format_hex(Version, 10) | |||
493 | << " Offset=" << format_hex(Offset, 10) | |||
494 | << " Size=" << format_hex(Size, 10) | |||
495 | << " CPUType=" << format_hex(CPUType, 10) << "/>\n"; | |||
496 | } | |||
497 | ||||
498 | if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr, true)) | |||
499 | return reportError("Invalid bitcode wrapper header"); | |||
500 | } | |||
501 | ||||
502 | // Use the cursor modified by skipping the wrapper header. | |||
503 | Stream = BitstreamCursor(ArrayRef<uint8_t>(BufPtr, EndBufPtr)); | |||
504 | ||||
505 | return ReadSignature(Stream); | |||
506 | } | |||
507 | ||||
508 | static bool canDecodeBlob(unsigned Code, unsigned BlockID) { | |||
509 | return BlockID == bitc::METADATA_BLOCK_ID && Code == bitc::METADATA_STRINGS; | |||
510 | } | |||
511 | ||||
512 | Error BitcodeAnalyzer::decodeMetadataStringsBlob(StringRef Indent, | |||
513 | ArrayRef<uint64_t> Record, | |||
514 | StringRef Blob, | |||
515 | raw_ostream &OS) { | |||
516 | if (Blob.empty()) | |||
517 | return reportError("Cannot decode empty blob."); | |||
518 | ||||
519 | if (Record.size() != 2) | |||
520 | return reportError( | |||
521 | "Decoding metadata strings blob needs two record entries."); | |||
522 | ||||
523 | unsigned NumStrings = Record[0]; | |||
524 | unsigned StringsOffset = Record[1]; | |||
525 | OS << " num-strings = " << NumStrings << " {\n"; | |||
526 | ||||
527 | StringRef Lengths = Blob.slice(0, StringsOffset); | |||
528 | SimpleBitstreamCursor R(Lengths); | |||
529 | StringRef Strings = Blob.drop_front(StringsOffset); | |||
530 | do { | |||
531 | if (R.AtEndOfStream()) | |||
532 | return reportError("bad length"); | |||
533 | ||||
534 | uint32_t Size; | |||
535 | if (Error E = R.ReadVBR(6).moveInto(Size)) | |||
536 | return E; | |||
537 | if (Strings.size() < Size) | |||
538 | return reportError("truncated chars"); | |||
539 | ||||
540 | OS << Indent << " '"; | |||
541 | OS.write_escaped(Strings.slice(0, Size), /*hex=*/true); | |||
542 | OS << "'\n"; | |||
543 | Strings = Strings.drop_front(Size); | |||
544 | } while (--NumStrings); | |||
545 | ||||
546 | OS << Indent << " }"; | |||
547 | return Error::success(); | |||
548 | } | |||
549 | ||||
550 | BitcodeAnalyzer::BitcodeAnalyzer(StringRef Buffer, | |||
551 | Optional<StringRef> BlockInfoBuffer) | |||
552 | : Stream(Buffer) { | |||
553 | if (BlockInfoBuffer) | |||
554 | BlockInfoStream.emplace(*BlockInfoBuffer); | |||
555 | } | |||
556 | ||||
557 | Error BitcodeAnalyzer::analyze(Optional<BCDumpOptions> O, | |||
558 | Optional<StringRef> CheckHash) { | |||
559 | if (Error E = analyzeHeader(O, Stream).moveInto(CurStreamType)) | |||
| ||||
560 | return E; | |||
561 | ||||
562 | Stream.setBlockInfo(&BlockInfo); | |||
563 | ||||
564 | // Read block info from BlockInfoStream, if specified. | |||
565 | // The block info must be a top-level block. | |||
566 | if (BlockInfoStream) { | |||
567 | BitstreamCursor BlockInfoCursor(*BlockInfoStream); | |||
568 | if (Error E = analyzeHeader(O, BlockInfoCursor).takeError()) | |||
569 | return E; | |||
570 | ||||
571 | while (!BlockInfoCursor.AtEndOfStream()) { | |||
572 | Expected<unsigned> MaybeCode = BlockInfoCursor.ReadCode(); | |||
573 | if (!MaybeCode) | |||
574 | return MaybeCode.takeError(); | |||
575 | if (MaybeCode.get() != bitc::ENTER_SUBBLOCK) | |||
576 | return reportError("Invalid record at top-level in block info file"); | |||
577 | ||||
578 | Expected<unsigned> MaybeBlockID = BlockInfoCursor.ReadSubBlockID(); | |||
579 | if (!MaybeBlockID) | |||
580 | return MaybeBlockID.takeError(); | |||
581 | if (MaybeBlockID.get() == bitc::BLOCKINFO_BLOCK_ID) { | |||
582 | Optional<BitstreamBlockInfo> NewBlockInfo; | |||
583 | if (Error E = | |||
584 | BlockInfoCursor.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true) | |||
585 | .moveInto(NewBlockInfo)) | |||
586 | return E; | |||
587 | if (!NewBlockInfo) | |||
588 | return reportError("Malformed BlockInfoBlock in block info file"); | |||
589 | BlockInfo = std::move(*NewBlockInfo); | |||
590 | break; | |||
591 | } | |||
592 | ||||
593 | if (Error Err = BlockInfoCursor.SkipBlock()) | |||
594 | return Err; | |||
595 | } | |||
596 | } | |||
597 | ||||
598 | // Parse the top-level structure. We only allow blocks at the top-level. | |||
599 | while (!Stream.AtEndOfStream()) { | |||
600 | Expected<unsigned> MaybeCode = Stream.ReadCode(); | |||
601 | if (!MaybeCode) | |||
602 | return MaybeCode.takeError(); | |||
603 | if (MaybeCode.get() != bitc::ENTER_SUBBLOCK) | |||
604 | return reportError("Invalid record at top-level"); | |||
605 | ||||
606 | Expected<unsigned> MaybeBlockID = Stream.ReadSubBlockID(); | |||
607 | if (!MaybeBlockID) | |||
608 | return MaybeBlockID.takeError(); | |||
609 | ||||
610 | if (Error E = parseBlock(MaybeBlockID.get(), 0, O, CheckHash)) | |||
611 | return E; | |||
612 | ++NumTopBlocks; | |||
613 | } | |||
614 | ||||
615 | return Error::success(); | |||
616 | } | |||
617 | ||||
618 | void BitcodeAnalyzer::printStats(BCDumpOptions O, | |||
619 | Optional<StringRef> Filename) { | |||
620 | uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT8; | |||
621 | // Print a summary of the read file. | |||
622 | O.OS << "Summary "; | |||
623 | if (Filename) | |||
624 | O.OS << "of " << Filename->data() << ":\n"; | |||
625 | O.OS << " Total size: "; | |||
626 | printSize(O.OS, BufferSizeBits); | |||
627 | O.OS << "\n"; | |||
628 | O.OS << " Stream type: "; | |||
629 | switch (CurStreamType) { | |||
630 | case UnknownBitstream: | |||
631 | O.OS << "unknown\n"; | |||
632 | break; | |||
633 | case LLVMIRBitstream: | |||
634 | O.OS << "LLVM IR\n"; | |||
635 | break; | |||
636 | case ClangSerializedASTBitstream: | |||
637 | O.OS << "Clang Serialized AST\n"; | |||
638 | break; | |||
639 | case ClangSerializedDiagnosticsBitstream: | |||
640 | O.OS << "Clang Serialized Diagnostics\n"; | |||
641 | break; | |||
642 | case LLVMBitstreamRemarks: | |||
643 | O.OS << "LLVM Remarks\n"; | |||
644 | break; | |||
645 | } | |||
646 | O.OS << " # Toplevel Blocks: " << NumTopBlocks << "\n"; | |||
647 | O.OS << "\n"; | |||
648 | ||||
649 | // Emit per-block stats. | |||
650 | O.OS << "Per-block Summary:\n"; | |||
651 | for (const auto &Stat : BlockIDStats) { | |||
652 | O.OS << " Block ID #" << Stat.first; | |||
653 | if (Optional<const char *> BlockName = | |||
654 | GetBlockName(Stat.first, BlockInfo, CurStreamType)) | |||
655 | O.OS << " (" << *BlockName << ")"; | |||
656 | O.OS << ":\n"; | |||
657 | ||||
658 | const PerBlockIDStats &Stats = Stat.second; | |||
659 | O.OS << " Num Instances: " << Stats.NumInstances << "\n"; | |||
660 | O.OS << " Total Size: "; | |||
661 | printSize(O.OS, Stats.NumBits); | |||
662 | O.OS << "\n"; | |||
663 | double pct = (Stats.NumBits * 100.0) / BufferSizeBits; | |||
664 | O.OS << " Percent of file: " << format("%2.4f%%", pct) << "\n"; | |||
665 | if (Stats.NumInstances > 1) { | |||
666 | O.OS << " Average Size: "; | |||
667 | printSize(O.OS, Stats.NumBits / (double)Stats.NumInstances); | |||
668 | O.OS << "\n"; | |||
669 | O.OS << " Tot/Avg SubBlocks: " << Stats.NumSubBlocks << "/" | |||
670 | << Stats.NumSubBlocks / (double)Stats.NumInstances << "\n"; | |||
671 | O.OS << " Tot/Avg Abbrevs: " << Stats.NumAbbrevs << "/" | |||
672 | << Stats.NumAbbrevs / (double)Stats.NumInstances << "\n"; | |||
673 | O.OS << " Tot/Avg Records: " << Stats.NumRecords << "/" | |||
674 | << Stats.NumRecords / (double)Stats.NumInstances << "\n"; | |||
675 | } else { | |||
676 | O.OS << " Num SubBlocks: " << Stats.NumSubBlocks << "\n"; | |||
677 | O.OS << " Num Abbrevs: " << Stats.NumAbbrevs << "\n"; | |||
678 | O.OS << " Num Records: " << Stats.NumRecords << "\n"; | |||
679 | } | |||
680 | if (Stats.NumRecords) { | |||
681 | double pct = (Stats.NumAbbreviatedRecords * 100.0) / Stats.NumRecords; | |||
682 | O.OS << " Percent Abbrevs: " << format("%2.4f%%", pct) << "\n"; | |||
683 | } | |||
684 | O.OS << "\n"; | |||
685 | ||||
686 | // Print a histogram of the codes we see. | |||
687 | if (O.Histogram && !Stats.CodeFreq.empty()) { | |||
688 | std::vector<std::pair<unsigned, unsigned>> FreqPairs; // <freq,code> | |||
689 | for (unsigned i = 0, e = Stats.CodeFreq.size(); i != e; ++i) | |||
690 | if (unsigned Freq = Stats.CodeFreq[i].NumInstances) | |||
691 | FreqPairs.push_back(std::make_pair(Freq, i)); | |||
692 | llvm::stable_sort(FreqPairs); | |||
693 | std::reverse(FreqPairs.begin(), FreqPairs.end()); | |||
694 | ||||
695 | O.OS << "\tRecord Histogram:\n"; | |||
696 | O.OS << "\t\t Count # Bits b/Rec % Abv Record Kind\n"; | |||
697 | for (const auto &FreqPair : FreqPairs) { | |||
698 | const PerRecordStats &RecStats = Stats.CodeFreq[FreqPair.second]; | |||
699 | ||||
700 | O.OS << format("\t\t%7d %9lu", RecStats.NumInstances, | |||
701 | (unsigned long)RecStats.TotalBits); | |||
702 | ||||
703 | if (RecStats.NumInstances > 1) | |||
704 | O.OS << format(" %9.1f", | |||
705 | (double)RecStats.TotalBits / RecStats.NumInstances); | |||
706 | else | |||
707 | O.OS << " "; | |||
708 | ||||
709 | if (RecStats.NumAbbrev) | |||
710 | O.OS << format(" %7.2f", (double)RecStats.NumAbbrev / | |||
711 | RecStats.NumInstances * 100); | |||
712 | else | |||
713 | O.OS << " "; | |||
714 | ||||
715 | O.OS << " "; | |||
716 | if (Optional<const char *> CodeName = GetCodeName( | |||
717 | FreqPair.second, Stat.first, BlockInfo, CurStreamType)) | |||
718 | O.OS << *CodeName << "\n"; | |||
719 | else | |||
720 | O.OS << "UnknownCode" << FreqPair.second << "\n"; | |||
721 | } | |||
722 | O.OS << "\n"; | |||
723 | } | |||
724 | } | |||
725 | } | |||
726 | ||||
727 | Error BitcodeAnalyzer::parseBlock(unsigned BlockID, unsigned IndentLevel, | |||
728 | Optional<BCDumpOptions> O, | |||
729 | Optional<StringRef> CheckHash) { | |||
730 | std::string Indent(IndentLevel * 2, ' '); | |||
731 | uint64_t BlockBitStart = Stream.GetCurrentBitNo(); | |||
732 | ||||
733 | // Get the statistics for this BlockID. | |||
734 | PerBlockIDStats &BlockStats = BlockIDStats[BlockID]; | |||
735 | ||||
736 | BlockStats.NumInstances++; | |||
737 | ||||
738 | // BLOCKINFO is a special part of the stream. | |||
739 | bool DumpRecords = O.hasValue(); | |||
740 | if (BlockID == bitc::BLOCKINFO_BLOCK_ID) { | |||
741 | if (O && !O->DumpBlockinfo) | |||
742 | O->OS << Indent << "<BLOCKINFO_BLOCK/>\n"; | |||
743 | Optional<BitstreamBlockInfo> NewBlockInfo; | |||
744 | if (Error E = Stream.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true) | |||
745 | .moveInto(NewBlockInfo)) | |||
746 | return E; | |||
747 | if (!NewBlockInfo) | |||
748 | return reportError("Malformed BlockInfoBlock"); | |||
749 | BlockInfo = std::move(*NewBlockInfo); | |||
750 | if (Error Err = Stream.JumpToBit(BlockBitStart)) | |||
751 | return Err; | |||
752 | // It's not really interesting to dump the contents of the blockinfo | |||
753 | // block, so only do it if the user explicitly requests it. | |||
754 | DumpRecords = O && O->DumpBlockinfo; | |||
755 | } | |||
756 | ||||
757 | unsigned NumWords = 0; | |||
758 | if (Error Err = Stream.EnterSubBlock(BlockID, &NumWords)) | |||
759 | return Err; | |||
760 | ||||
761 | // Keep it for later, when we see a MODULE_HASH record | |||
762 | uint64_t BlockEntryPos = Stream.getCurrentByteNo(); | |||
763 | ||||
764 | Optional<const char *> BlockName = None; | |||
765 | if (DumpRecords) { | |||
766 | O->OS << Indent << "<"; | |||
767 | if ((BlockName = GetBlockName(BlockID, BlockInfo, CurStreamType))) | |||
768 | O->OS << *BlockName; | |||
769 | else | |||
770 | O->OS << "UnknownBlock" << BlockID; | |||
771 | ||||
772 | if (!O->Symbolic && BlockName) | |||
773 | O->OS << " BlockID=" << BlockID; | |||
774 | ||||
775 | O->OS << " NumWords=" << NumWords | |||
776 | << " BlockCodeSize=" << Stream.getAbbrevIDWidth() << ">\n"; | |||
777 | } | |||
778 | ||||
779 | SmallVector<uint64_t, 64> Record; | |||
780 | ||||
781 | // Keep the offset to the metadata index if seen. | |||
782 | uint64_t MetadataIndexOffset = 0; | |||
783 | ||||
784 | // Read all the records for this block. | |||
785 | while (true) { | |||
786 | if (Stream.AtEndOfStream()) | |||
787 | return reportError("Premature end of bitstream"); | |||
788 | ||||
789 | uint64_t RecordStartBit = Stream.GetCurrentBitNo(); | |||
790 | ||||
791 | BitstreamEntry Entry; | |||
792 | if (Error E = Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs) | |||
793 | .moveInto(Entry)) | |||
794 | return E; | |||
795 | ||||
796 | switch (Entry.Kind) { | |||
797 | case BitstreamEntry::Error: | |||
798 | return reportError("malformed bitcode file"); | |||
799 | case BitstreamEntry::EndBlock: { | |||
800 | uint64_t BlockBitEnd = Stream.GetCurrentBitNo(); | |||
801 | BlockStats.NumBits += BlockBitEnd - BlockBitStart; | |||
802 | if (DumpRecords) { | |||
803 | O->OS << Indent << "</"; | |||
804 | if (BlockName) | |||
805 | O->OS << *BlockName << ">\n"; | |||
806 | else | |||
807 | O->OS << "UnknownBlock" << BlockID << ">\n"; | |||
808 | } | |||
809 | return Error::success(); | |||
810 | } | |||
811 | ||||
812 | case BitstreamEntry::SubBlock: { | |||
813 | uint64_t SubBlockBitStart = Stream.GetCurrentBitNo(); | |||
814 | if (Error E = parseBlock(Entry.ID, IndentLevel + 1, O, CheckHash)) | |||
815 | return E; | |||
816 | ++BlockStats.NumSubBlocks; | |||
817 | uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo(); | |||
818 | ||||
819 | // Don't include subblock sizes in the size of this block. | |||
820 | BlockBitStart += SubBlockBitEnd - SubBlockBitStart; | |||
821 | continue; | |||
822 | } | |||
823 | case BitstreamEntry::Record: | |||
824 | // The interesting case. | |||
825 | break; | |||
826 | } | |||
827 | ||||
828 | if (Entry.ID == bitc::DEFINE_ABBREV) { | |||
829 | if (Error Err = Stream.ReadAbbrevRecord()) | |||
830 | return Err; | |||
831 | ++BlockStats.NumAbbrevs; | |||
832 | continue; | |||
833 | } | |||
834 | ||||
835 | Record.clear(); | |||
836 | ||||
837 | ++BlockStats.NumRecords; | |||
838 | ||||
839 | StringRef Blob; | |||
840 | uint64_t CurrentRecordPos = Stream.GetCurrentBitNo(); | |||
841 | unsigned Code; | |||
842 | if (Error E = Stream.readRecord(Entry.ID, Record, &Blob).moveInto(Code)) | |||
843 | return E; | |||
844 | ||||
845 | // Increment the # occurrences of this code. | |||
846 | if (BlockStats.CodeFreq.size() <= Code) | |||
847 | BlockStats.CodeFreq.resize(Code + 1); | |||
848 | BlockStats.CodeFreq[Code].NumInstances++; | |||
849 | BlockStats.CodeFreq[Code].TotalBits += | |||
850 | Stream.GetCurrentBitNo() - RecordStartBit; | |||
851 | if (Entry.ID != bitc::UNABBREV_RECORD) { | |||
852 | BlockStats.CodeFreq[Code].NumAbbrev++; | |||
853 | ++BlockStats.NumAbbreviatedRecords; | |||
854 | } | |||
855 | ||||
856 | if (DumpRecords) { | |||
857 | O->OS << Indent << " <"; | |||
858 | Optional<const char *> CodeName = | |||
859 | GetCodeName(Code, BlockID, BlockInfo, CurStreamType); | |||
860 | if (CodeName) | |||
861 | O->OS << *CodeName; | |||
862 | else | |||
863 | O->OS << "UnknownCode" << Code; | |||
864 | if (!O->Symbolic && CodeName) | |||
865 | O->OS << " codeid=" << Code; | |||
866 | const BitCodeAbbrev *Abbv = nullptr; | |||
867 | if (Entry.ID != bitc::UNABBREV_RECORD) { | |||
868 | Expected<const BitCodeAbbrev *> MaybeAbbv = Stream.getAbbrev(Entry.ID); | |||
869 | if (!MaybeAbbv) | |||
870 | return MaybeAbbv.takeError(); | |||
871 | Abbv = MaybeAbbv.get(); | |||
872 | O->OS << " abbrevid=" << Entry.ID; | |||
873 | } | |||
874 | ||||
875 | for (unsigned i = 0, e = Record.size(); i != e; ++i) | |||
876 | O->OS << " op" << i << "=" << (int64_t)Record[i]; | |||
877 | ||||
878 | // If we found a metadata index, let's verify that we had an offset | |||
879 | // before and validate its forward reference offset was correct! | |||
880 | if (BlockID == bitc::METADATA_BLOCK_ID) { | |||
881 | if (Code == bitc::METADATA_INDEX_OFFSET) { | |||
882 | if (Record.size() != 2) | |||
883 | O->OS << "(Invalid record)"; | |||
884 | else { | |||
885 | auto Offset = Record[0] + (Record[1] << 32); | |||
886 | MetadataIndexOffset = Stream.GetCurrentBitNo() + Offset; | |||
887 | } | |||
888 | } | |||
889 | if (Code == bitc::METADATA_INDEX) { | |||
890 | O->OS << " (offset "; | |||
891 | if (MetadataIndexOffset == RecordStartBit) | |||
892 | O->OS << "match)"; | |||
893 | else | |||
894 | O->OS << "mismatch: " << MetadataIndexOffset << " vs " | |||
895 | << RecordStartBit << ")"; | |||
896 | } | |||
897 | } | |||
898 | ||||
899 | // If we found a module hash, let's verify that it matches! | |||
900 | if (BlockID == bitc::MODULE_BLOCK_ID && Code == bitc::MODULE_CODE_HASH && | |||
901 | CheckHash.hasValue()) { | |||
902 | if (Record.size() != 5) | |||
903 | O->OS << " (invalid)"; | |||
904 | else { | |||
905 | // Recompute the hash and compare it to the one in the bitcode | |||
906 | SHA1 Hasher; | |||
907 | std::array<uint8_t, 20> Hash; | |||
908 | Hasher.update(*CheckHash); | |||
909 | { | |||
910 | int BlockSize = (CurrentRecordPos / 8) - BlockEntryPos; | |||
911 | auto Ptr = Stream.getPointerToByte(BlockEntryPos, BlockSize); | |||
912 | Hasher.update(ArrayRef<uint8_t>(Ptr, BlockSize)); | |||
913 | Hash = Hasher.result(); | |||
914 | } | |||
915 | std::array<uint8_t, 20> RecordedHash; | |||
916 | int Pos = 0; | |||
917 | for (auto &Val : Record) { | |||
918 | assert(!(Val >> 32) && "Unexpected high bits set")(static_cast <bool> (!(Val >> 32) && "Unexpected high bits set" ) ? void (0) : __assert_fail ("!(Val >> 32) && \"Unexpected high bits set\"" , "llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp", 918, __extension__ __PRETTY_FUNCTION__)); | |||
919 | support::endian::write32be(&RecordedHash[Pos], Val); | |||
920 | Pos += 4; | |||
921 | } | |||
922 | if (Hash == RecordedHash) | |||
923 | O->OS << " (match)"; | |||
924 | else | |||
925 | O->OS << " (!mismatch!)"; | |||
926 | } | |||
927 | } | |||
928 | ||||
929 | O->OS << "/>"; | |||
930 | ||||
931 | if (Abbv) { | |||
932 | for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) { | |||
933 | const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); | |||
934 | if (!Op.isEncoding() || Op.getEncoding() != BitCodeAbbrevOp::Array) | |||
935 | continue; | |||
936 | assert(i + 2 == e && "Array op not second to last")(static_cast <bool> (i + 2 == e && "Array op not second to last" ) ? void (0) : __assert_fail ("i + 2 == e && \"Array op not second to last\"" , "llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp", 936, __extension__ __PRETTY_FUNCTION__)); | |||
937 | std::string Str; | |||
938 | bool ArrayIsPrintable = true; | |||
939 | for (unsigned j = i - 1, je = Record.size(); j != je; ++j) { | |||
940 | if (!isPrint(static_cast<unsigned char>(Record[j]))) { | |||
941 | ArrayIsPrintable = false; | |||
942 | break; | |||
943 | } | |||
944 | Str += (char)Record[j]; | |||
945 | } | |||
946 | if (ArrayIsPrintable) | |||
947 | O->OS << " record string = '" << Str << "'"; | |||
948 | break; | |||
949 | } | |||
950 | } | |||
951 | ||||
952 | if (Blob.data()) { | |||
953 | if (canDecodeBlob(Code, BlockID)) { | |||
954 | if (Error E = decodeMetadataStringsBlob(Indent, Record, Blob, O->OS)) | |||
955 | return E; | |||
956 | } else { | |||
957 | O->OS << " blob data = "; | |||
958 | if (O->ShowBinaryBlobs) { | |||
959 | O->OS << "'"; | |||
960 | O->OS.write_escaped(Blob, /*hex=*/true) << "'"; | |||
961 | } else { | |||
962 | bool BlobIsPrintable = true; | |||
963 | for (char C : Blob) | |||
964 | if (!isPrint(static_cast<unsigned char>(C))) { | |||
965 | BlobIsPrintable = false; | |||
966 | break; | |||
967 | } | |||
968 | ||||
969 | if (BlobIsPrintable) | |||
970 | O->OS << "'" << Blob << "'"; | |||
971 | else | |||
972 | O->OS << "unprintable, " << Blob.size() << " bytes."; | |||
973 | } | |||
974 | } | |||
975 | } | |||
976 | ||||
977 | O->OS << "\n"; | |||
978 | } | |||
979 | ||||
980 | // Make sure that we can skip the current record. | |||
981 | if (Error Err = Stream.JumpToBit(CurrentRecordPos)) | |||
982 | return Err; | |||
983 | if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID)) | |||
984 | ; // Do nothing. | |||
985 | else | |||
986 | return Skipped.takeError(); | |||
987 | } | |||
988 | } | |||
989 |