Bug Summary

File:build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp
Warning:line 434, column 20
The left operand of '==' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name BitcodeAnalyzer.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm -resource-dir /usr/lib/llvm-16/lib/clang/16.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I lib/Bitcode/Reader -I /build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/llvm/lib/Bitcode/Reader -I include -I /build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-09-04-125545-48738-1 -x c++ /build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp
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
17using namespace llvm;
18
19static 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.
24static 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.
87static 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
410static void printSize(raw_ostream &OS, double Bits) {
411 OS << format("%.2f/%.2fB/%luW", Bits, Bits / 8, (unsigned long)(Bits / 32));
412}
413static 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
418static 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))
5
Taking false branch
421 Dest = MaybeWord.get();
422 else
423 return MaybeWord.takeError();
6
Returning without writing to 'Dest'
424 return Error::success();
425 };
426
427 char Signature[6];
428 if (Error Err = tryRead(Signature[0], 8))
4
Calling 'operator()'
7
Returning from 'operator()'
8
Assuming the condition is false
9
Taking false branch
429 return std::move(Err);
430 if (Error Err = tryRead(Signature[1], 8))
10
Assuming the condition is false
11
Taking false branch
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') {
12
The left operand of '==' is a garbage value
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
471static 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)) {
2
Taking false branch
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);
3
Calling 'ReadSignature'
506}
507
508static bool canDecodeBlob(unsigned Code, unsigned BlockID) {
509 return BlockID == bitc::METADATA_BLOCK_ID && Code == bitc::METADATA_STRINGS;
510}
511
512Error 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
550BitcodeAnalyzer::BitcodeAnalyzer(StringRef Buffer,
551 Optional<StringRef> BlockInfoBuffer)
552 : Stream(Buffer) {
553 if (BlockInfoBuffer)
554 BlockInfoStream.emplace(*BlockInfoBuffer);
555}
556
557Error BitcodeAnalyzer::analyze(Optional<BCDumpOptions> O,
558 Optional<StringRef> CheckHash) {
559 if (Error E = analyzeHeader(O, Stream).moveInto(CurStreamType))
1
Calling 'analyzeHeader'
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
618void 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
727Error 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.has_value();
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;
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) {
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