Bug Summary

File:llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp
Warning:line 433, 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-store=region -analyzer-opt-analyze-nested-blocks -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-14~++20220116100644+5f782d25a742/build-llvm -resource-dir /usr/lib/llvm-14/lib/clang/14.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-14~++20220116100644+5f782d25a742/llvm/lib/Bitcode/Reader -I include -I /build/llvm-toolchain-snapshot-14~++20220116100644+5f782d25a742/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-14/lib/clang/14.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-14~++20220116100644+5f782d25a742/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220116100644+5f782d25a742/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220116100644+5f782d25a742/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220116100644+5f782d25a742/= -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 -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220116100644+5f782d25a742/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220116100644+5f782d25a742/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220116100644+5f782d25a742/= -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-01-16-232930-107970-1 -x c++ /build/llvm-toolchain-snapshot-14~++20220116100644+5f782d25a742/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 }
271 case bitc::VALUE_SYMTAB_BLOCK_ID:
272 switch (CodeID) {
273 default:
274 return None;
275 STRINGIFY_CODE(VST_CODE, ENTRY)
276 STRINGIFY_CODE(VST_CODE, BBENTRY)
277 STRINGIFY_CODE(VST_CODE, FNENTRY)
278 STRINGIFY_CODE(VST_CODE, COMBINED_ENTRY)
279 }
280 case bitc::MODULE_STRTAB_BLOCK_ID:
281 switch (CodeID) {
282 default:
283 return None;
284 STRINGIFY_CODE(MST_CODE, ENTRY)
285 STRINGIFY_CODE(MST_CODE, HASH)
286 }
287 case bitc::GLOBALVAL_SUMMARY_BLOCK_ID:
288 case bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID:
289 switch (CodeID) {
290 default:
291 return None;
292 STRINGIFY_CODE(FS, PERMODULE)
293 STRINGIFY_CODE(FS, PERMODULE_PROFILE)
294 STRINGIFY_CODE(FS, PERMODULE_RELBF)
295 STRINGIFY_CODE(FS, PERMODULE_GLOBALVAR_INIT_REFS)
296 STRINGIFY_CODE(FS, PERMODULE_VTABLE_GLOBALVAR_INIT_REFS)
297 STRINGIFY_CODE(FS, COMBINED)
298 STRINGIFY_CODE(FS, COMBINED_PROFILE)
299 STRINGIFY_CODE(FS, COMBINED_GLOBALVAR_INIT_REFS)
300 STRINGIFY_CODE(FS, ALIAS)
301 STRINGIFY_CODE(FS, COMBINED_ALIAS)
302 STRINGIFY_CODE(FS, COMBINED_ORIGINAL_NAME)
303 STRINGIFY_CODE(FS, VERSION)
304 STRINGIFY_CODE(FS, FLAGS)
305 STRINGIFY_CODE(FS, TYPE_TESTS)
306 STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_VCALLS)
307 STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_VCALLS)
308 STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_CONST_VCALL)
309 STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_CONST_VCALL)
310 STRINGIFY_CODE(FS, VALUE_GUID)
311 STRINGIFY_CODE(FS, CFI_FUNCTION_DEFS)
312 STRINGIFY_CODE(FS, CFI_FUNCTION_DECLS)
313 STRINGIFY_CODE(FS, TYPE_ID)
314 STRINGIFY_CODE(FS, TYPE_ID_METADATA)
315 STRINGIFY_CODE(FS, BLOCK_COUNT)
316 STRINGIFY_CODE(FS, PARAM_ACCESS)
317 }
318 case bitc::METADATA_ATTACHMENT_ID:
319 switch (CodeID) {
320 default:
321 return None;
322 STRINGIFY_CODE(METADATA, ATTACHMENT)
323 }
324 case bitc::METADATA_BLOCK_ID:
325 switch (CodeID) {
326 default:
327 return None;
328 STRINGIFY_CODE(METADATA, STRING_OLD)
329 STRINGIFY_CODE(METADATA, VALUE)
330 STRINGIFY_CODE(METADATA, NODE)
331 STRINGIFY_CODE(METADATA, NAME)
332 STRINGIFY_CODE(METADATA, DISTINCT_NODE)
333 STRINGIFY_CODE(METADATA, KIND) // Older bitcode has it in a MODULE_BLOCK
334 STRINGIFY_CODE(METADATA, LOCATION)
335 STRINGIFY_CODE(METADATA, OLD_NODE)
336 STRINGIFY_CODE(METADATA, OLD_FN_NODE)
337 STRINGIFY_CODE(METADATA, NAMED_NODE)
338 STRINGIFY_CODE(METADATA, GENERIC_DEBUG)
339 STRINGIFY_CODE(METADATA, SUBRANGE)
340 STRINGIFY_CODE(METADATA, ENUMERATOR)
341 STRINGIFY_CODE(METADATA, BASIC_TYPE)
342 STRINGIFY_CODE(METADATA, FILE)
343 STRINGIFY_CODE(METADATA, DERIVED_TYPE)
344 STRINGIFY_CODE(METADATA, COMPOSITE_TYPE)
345 STRINGIFY_CODE(METADATA, SUBROUTINE_TYPE)
346 STRINGIFY_CODE(METADATA, COMPILE_UNIT)
347 STRINGIFY_CODE(METADATA, SUBPROGRAM)
348 STRINGIFY_CODE(METADATA, LEXICAL_BLOCK)
349 STRINGIFY_CODE(METADATA, LEXICAL_BLOCK_FILE)
350 STRINGIFY_CODE(METADATA, NAMESPACE)
351 STRINGIFY_CODE(METADATA, TEMPLATE_TYPE)
352 STRINGIFY_CODE(METADATA, TEMPLATE_VALUE)
353 STRINGIFY_CODE(METADATA, GLOBAL_VAR)
354 STRINGIFY_CODE(METADATA, LOCAL_VAR)
355 STRINGIFY_CODE(METADATA, EXPRESSION)
356 STRINGIFY_CODE(METADATA, OBJC_PROPERTY)
357 STRINGIFY_CODE(METADATA, IMPORTED_ENTITY)
358 STRINGIFY_CODE(METADATA, MODULE)
359 STRINGIFY_CODE(METADATA, MACRO)
360 STRINGIFY_CODE(METADATA, MACRO_FILE)
361 STRINGIFY_CODE(METADATA, STRINGS)
362 STRINGIFY_CODE(METADATA, GLOBAL_DECL_ATTACHMENT)
363 STRINGIFY_CODE(METADATA, GLOBAL_VAR_EXPR)
364 STRINGIFY_CODE(METADATA, INDEX_OFFSET)
365 STRINGIFY_CODE(METADATA, INDEX)
366 STRINGIFY_CODE(METADATA, ARG_LIST)
367 }
368 case bitc::METADATA_KIND_BLOCK_ID:
369 switch (CodeID) {
370 default:
371 return None;
372 STRINGIFY_CODE(METADATA, KIND)
373 }
374 case bitc::USELIST_BLOCK_ID:
375 switch (CodeID) {
376 default:
377 return None;
378 case bitc::USELIST_CODE_DEFAULT:
379 return "USELIST_CODE_DEFAULT";
380 case bitc::USELIST_CODE_BB:
381 return "USELIST_CODE_BB";
382 }
383
384 case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID:
385 switch (CodeID) {
386 default:
387 return None;
388 case bitc::OPERAND_BUNDLE_TAG:
389 return "OPERAND_BUNDLE_TAG";
390 }
391 case bitc::STRTAB_BLOCK_ID:
392 switch (CodeID) {
393 default:
394 return None;
395 case bitc::STRTAB_BLOB:
396 return "BLOB";
397 }
398 case bitc::SYMTAB_BLOCK_ID:
399 switch (CodeID) {
400 default:
401 return None;
402 case bitc::SYMTAB_BLOB:
403 return "BLOB";
404 }
405 }
406#undef STRINGIFY_CODE
407}
408
409static void printSize(raw_ostream &OS, double Bits) {
410 OS << format("%.2f/%.2fB/%luW", Bits, Bits / 8, (unsigned long)(Bits / 32));
411}
412static void printSize(raw_ostream &OS, uint64_t Bits) {
413 OS << format("%lub/%.2fB/%luW", (unsigned long)Bits, (double)Bits / 8,
414 (unsigned long)(Bits / 32));
415}
416
417static Expected<CurStreamTypeType> ReadSignature(BitstreamCursor &Stream) {
418 auto tryRead = [&Stream](char &Dest, size_t size) -> Error {
419 if (Expected<SimpleBitstreamCursor::word_t> MaybeWord = Stream.Read(size))
5
Taking false branch
420 Dest = MaybeWord.get();
421 else
422 return MaybeWord.takeError();
6
Returning without writing to 'Dest'
423 return Error::success();
424 };
425
426 char Signature[6];
427 if (Error Err = tryRead(Signature[0], 8))
4
Calling 'operator()'
7
Returning from 'operator()'
8
Assuming the condition is false
9
Taking false branch
428 return std::move(Err);
429 if (Error Err = tryRead(Signature[1], 8))
10
Assuming the condition is false
11
Taking false branch
430 return std::move(Err);
431
432 // Autodetect the file contents, if it is one we know.
433 if (Signature[0] == 'C' && Signature[1] == 'P') {
12
The left operand of '==' is a garbage value
434 if (Error Err = tryRead(Signature[2], 8))
435 return std::move(Err);
436 if (Error Err = tryRead(Signature[3], 8))
437 return std::move(Err);
438 if (Signature[2] == 'C' && Signature[3] == 'H')
439 return ClangSerializedASTBitstream;
440 } else if (Signature[0] == 'D' && Signature[1] == 'I') {
441 if (Error Err = tryRead(Signature[2], 8))
442 return std::move(Err);
443 if (Error Err = tryRead(Signature[3], 8))
444 return std::move(Err);
445 if (Signature[2] == 'A' && Signature[3] == 'G')
446 return ClangSerializedDiagnosticsBitstream;
447 } else if (Signature[0] == 'R' && Signature[1] == 'M') {
448 if (Error Err = tryRead(Signature[2], 8))
449 return std::move(Err);
450 if (Error Err = tryRead(Signature[3], 8))
451 return std::move(Err);
452 if (Signature[2] == 'R' && Signature[3] == 'K')
453 return LLVMBitstreamRemarks;
454 } else {
455 if (Error Err = tryRead(Signature[2], 4))
456 return std::move(Err);
457 if (Error Err = tryRead(Signature[3], 4))
458 return std::move(Err);
459 if (Error Err = tryRead(Signature[4], 4))
460 return std::move(Err);
461 if (Error Err = tryRead(Signature[5], 4))
462 return std::move(Err);
463 if (Signature[0] == 'B' && Signature[1] == 'C' && Signature[2] == 0x0 &&
464 Signature[3] == 0xC && Signature[4] == 0xE && Signature[5] == 0xD)
465 return LLVMIRBitstream;
466 }
467 return UnknownBitstream;
468}
469
470static Expected<CurStreamTypeType> analyzeHeader(Optional<BCDumpOptions> O,
471 BitstreamCursor &Stream) {
472 ArrayRef<uint8_t> Bytes = Stream.getBitcodeBytes();
473 const unsigned char *BufPtr = (const unsigned char *)Bytes.data();
474 const unsigned char *EndBufPtr = BufPtr + Bytes.size();
475
476 // If we have a wrapper header, parse it and ignore the non-bc file
477 // contents. The magic number is 0x0B17C0DE stored in little endian.
478 if (isBitcodeWrapper(BufPtr, EndBufPtr)) {
2
Taking false branch
479 if (Bytes.size() < BWH_HeaderSize)
480 return reportError("Invalid bitcode wrapper header");
481
482 if (O) {
483 unsigned Magic = support::endian::read32le(&BufPtr[BWH_MagicField]);
484 unsigned Version = support::endian::read32le(&BufPtr[BWH_VersionField]);
485 unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]);
486 unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]);
487 unsigned CPUType = support::endian::read32le(&BufPtr[BWH_CPUTypeField]);
488
489 O->OS << "<BITCODE_WRAPPER_HEADER"
490 << " Magic=" << format_hex(Magic, 10)
491 << " Version=" << format_hex(Version, 10)
492 << " Offset=" << format_hex(Offset, 10)
493 << " Size=" << format_hex(Size, 10)
494 << " CPUType=" << format_hex(CPUType, 10) << "/>\n";
495 }
496
497 if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr, true))
498 return reportError("Invalid bitcode wrapper header");
499 }
500
501 // Use the cursor modified by skipping the wrapper header.
502 Stream = BitstreamCursor(ArrayRef<uint8_t>(BufPtr, EndBufPtr));
503
504 return ReadSignature(Stream);
3
Calling 'ReadSignature'
505}
506
507static bool canDecodeBlob(unsigned Code, unsigned BlockID) {
508 return BlockID == bitc::METADATA_BLOCK_ID && Code == bitc::METADATA_STRINGS;
509}
510
511Error BitcodeAnalyzer::decodeMetadataStringsBlob(StringRef Indent,
512 ArrayRef<uint64_t> Record,
513 StringRef Blob,
514 raw_ostream &OS) {
515 if (Blob.empty())
516 return reportError("Cannot decode empty blob.");
517
518 if (Record.size() != 2)
519 return reportError(
520 "Decoding metadata strings blob needs two record entries.");
521
522 unsigned NumStrings = Record[0];
523 unsigned StringsOffset = Record[1];
524 OS << " num-strings = " << NumStrings << " {\n";
525
526 StringRef Lengths = Blob.slice(0, StringsOffset);
527 SimpleBitstreamCursor R(Lengths);
528 StringRef Strings = Blob.drop_front(StringsOffset);
529 do {
530 if (R.AtEndOfStream())
531 return reportError("bad length");
532
533 uint32_t Size;
534 if (Error E = R.ReadVBR(6).moveInto(Size))
535 return E;
536 if (Strings.size() < Size)
537 return reportError("truncated chars");
538
539 OS << Indent << " '";
540 OS.write_escaped(Strings.slice(0, Size), /*hex=*/true);
541 OS << "'\n";
542 Strings = Strings.drop_front(Size);
543 } while (--NumStrings);
544
545 OS << Indent << " }";
546 return Error::success();
547}
548
549BitcodeAnalyzer::BitcodeAnalyzer(StringRef Buffer,
550 Optional<StringRef> BlockInfoBuffer)
551 : Stream(Buffer) {
552 if (BlockInfoBuffer)
553 BlockInfoStream.emplace(*BlockInfoBuffer);
554}
555
556Error BitcodeAnalyzer::analyze(Optional<BCDumpOptions> O,
557 Optional<StringRef> CheckHash) {
558 if (Error E = analyzeHeader(O, Stream).moveInto(CurStreamType))
1
Calling 'analyzeHeader'
559 return E;
560
561 Stream.setBlockInfo(&BlockInfo);
562
563 // Read block info from BlockInfoStream, if specified.
564 // The block info must be a top-level block.
565 if (BlockInfoStream) {
566 BitstreamCursor BlockInfoCursor(*BlockInfoStream);
567 if (Error E = analyzeHeader(O, BlockInfoCursor).takeError())
568 return E;
569
570 while (!BlockInfoCursor.AtEndOfStream()) {
571 Expected<unsigned> MaybeCode = BlockInfoCursor.ReadCode();
572 if (!MaybeCode)
573 return MaybeCode.takeError();
574 if (MaybeCode.get() != bitc::ENTER_SUBBLOCK)
575 return reportError("Invalid record at top-level in block info file");
576
577 Expected<unsigned> MaybeBlockID = BlockInfoCursor.ReadSubBlockID();
578 if (!MaybeBlockID)
579 return MaybeBlockID.takeError();
580 if (MaybeBlockID.get() == bitc::BLOCKINFO_BLOCK_ID) {
581 Optional<BitstreamBlockInfo> NewBlockInfo;
582 if (Error E =
583 BlockInfoCursor.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true)
584 .moveInto(NewBlockInfo))
585 return E;
586 if (!NewBlockInfo)
587 return reportError("Malformed BlockInfoBlock in block info file");
588 BlockInfo = std::move(*NewBlockInfo);
589 break;
590 }
591
592 if (Error Err = BlockInfoCursor.SkipBlock())
593 return Err;
594 }
595 }
596
597 // Parse the top-level structure. We only allow blocks at the top-level.
598 while (!Stream.AtEndOfStream()) {
599 Expected<unsigned> MaybeCode = Stream.ReadCode();
600 if (!MaybeCode)
601 return MaybeCode.takeError();
602 if (MaybeCode.get() != bitc::ENTER_SUBBLOCK)
603 return reportError("Invalid record at top-level");
604
605 Expected<unsigned> MaybeBlockID = Stream.ReadSubBlockID();
606 if (!MaybeBlockID)
607 return MaybeBlockID.takeError();
608
609 if (Error E = parseBlock(MaybeBlockID.get(), 0, O, CheckHash))
610 return E;
611 ++NumTopBlocks;
612 }
613
614 return Error::success();
615}
616
617void BitcodeAnalyzer::printStats(BCDumpOptions O,
618 Optional<StringRef> Filename) {
619 uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT8;
620 // Print a summary of the read file.
621 O.OS << "Summary ";
622 if (Filename)
623 O.OS << "of " << Filename->data() << ":\n";
624 O.OS << " Total size: ";
625 printSize(O.OS, BufferSizeBits);
626 O.OS << "\n";
627 O.OS << " Stream type: ";
628 switch (CurStreamType) {
629 case UnknownBitstream:
630 O.OS << "unknown\n";
631 break;
632 case LLVMIRBitstream:
633 O.OS << "LLVM IR\n";
634 break;
635 case ClangSerializedASTBitstream:
636 O.OS << "Clang Serialized AST\n";
637 break;
638 case ClangSerializedDiagnosticsBitstream:
639 O.OS << "Clang Serialized Diagnostics\n";
640 break;
641 case LLVMBitstreamRemarks:
642 O.OS << "LLVM Remarks\n";
643 break;
644 }
645 O.OS << " # Toplevel Blocks: " << NumTopBlocks << "\n";
646 O.OS << "\n";
647
648 // Emit per-block stats.
649 O.OS << "Per-block Summary:\n";
650 for (const auto &Stat : BlockIDStats) {
651 O.OS << " Block ID #" << Stat.first;
652 if (Optional<const char *> BlockName =
653 GetBlockName(Stat.first, BlockInfo, CurStreamType))
654 O.OS << " (" << *BlockName << ")";
655 O.OS << ":\n";
656
657 const PerBlockIDStats &Stats = Stat.second;
658 O.OS << " Num Instances: " << Stats.NumInstances << "\n";
659 O.OS << " Total Size: ";
660 printSize(O.OS, Stats.NumBits);
661 O.OS << "\n";
662 double pct = (Stats.NumBits * 100.0) / BufferSizeBits;
663 O.OS << " Percent of file: " << format("%2.4f%%", pct) << "\n";
664 if (Stats.NumInstances > 1) {
665 O.OS << " Average Size: ";
666 printSize(O.OS, Stats.NumBits / (double)Stats.NumInstances);
667 O.OS << "\n";
668 O.OS << " Tot/Avg SubBlocks: " << Stats.NumSubBlocks << "/"
669 << Stats.NumSubBlocks / (double)Stats.NumInstances << "\n";
670 O.OS << " Tot/Avg Abbrevs: " << Stats.NumAbbrevs << "/"
671 << Stats.NumAbbrevs / (double)Stats.NumInstances << "\n";
672 O.OS << " Tot/Avg Records: " << Stats.NumRecords << "/"
673 << Stats.NumRecords / (double)Stats.NumInstances << "\n";
674 } else {
675 O.OS << " Num SubBlocks: " << Stats.NumSubBlocks << "\n";
676 O.OS << " Num Abbrevs: " << Stats.NumAbbrevs << "\n";
677 O.OS << " Num Records: " << Stats.NumRecords << "\n";
678 }
679 if (Stats.NumRecords) {
680 double pct = (Stats.NumAbbreviatedRecords * 100.0) / Stats.NumRecords;
681 O.OS << " Percent Abbrevs: " << format("%2.4f%%", pct) << "\n";
682 }
683 O.OS << "\n";
684
685 // Print a histogram of the codes we see.
686 if (O.Histogram && !Stats.CodeFreq.empty()) {
687 std::vector<std::pair<unsigned, unsigned>> FreqPairs; // <freq,code>
688 for (unsigned i = 0, e = Stats.CodeFreq.size(); i != e; ++i)
689 if (unsigned Freq = Stats.CodeFreq[i].NumInstances)
690 FreqPairs.push_back(std::make_pair(Freq, i));
691 llvm::stable_sort(FreqPairs);
692 std::reverse(FreqPairs.begin(), FreqPairs.end());
693
694 O.OS << "\tRecord Histogram:\n";
695 O.OS << "\t\t Count # Bits b/Rec % Abv Record Kind\n";
696 for (const auto &FreqPair : FreqPairs) {
697 const PerRecordStats &RecStats = Stats.CodeFreq[FreqPair.second];
698
699 O.OS << format("\t\t%7d %9lu", RecStats.NumInstances,
700 (unsigned long)RecStats.TotalBits);
701
702 if (RecStats.NumInstances > 1)
703 O.OS << format(" %9.1f",
704 (double)RecStats.TotalBits / RecStats.NumInstances);
705 else
706 O.OS << " ";
707
708 if (RecStats.NumAbbrev)
709 O.OS << format(" %7.2f", (double)RecStats.NumAbbrev /
710 RecStats.NumInstances * 100);
711 else
712 O.OS << " ";
713
714 O.OS << " ";
715 if (Optional<const char *> CodeName = GetCodeName(
716 FreqPair.second, Stat.first, BlockInfo, CurStreamType))
717 O.OS << *CodeName << "\n";
718 else
719 O.OS << "UnknownCode" << FreqPair.second << "\n";
720 }
721 O.OS << "\n";
722 }
723 }
724}
725
726Error BitcodeAnalyzer::parseBlock(unsigned BlockID, unsigned IndentLevel,
727 Optional<BCDumpOptions> O,
728 Optional<StringRef> CheckHash) {
729 std::string Indent(IndentLevel * 2, ' ');
730 uint64_t BlockBitStart = Stream.GetCurrentBitNo();
731
732 // Get the statistics for this BlockID.
733 PerBlockIDStats &BlockStats = BlockIDStats[BlockID];
734
735 BlockStats.NumInstances++;
736
737 // BLOCKINFO is a special part of the stream.
738 bool DumpRecords = O.hasValue();
739 if (BlockID == bitc::BLOCKINFO_BLOCK_ID) {
740 if (O && !O->DumpBlockinfo)
741 O->OS << Indent << "<BLOCKINFO_BLOCK/>\n";
742 Optional<BitstreamBlockInfo> NewBlockInfo;
743 if (Error E = Stream.ReadBlockInfoBlock(/*ReadBlockInfoNames=*/true)
744 .moveInto(NewBlockInfo))
745 return E;
746 if (!NewBlockInfo)
747 return reportError("Malformed BlockInfoBlock");
748 BlockInfo = std::move(*NewBlockInfo);
749 if (Error Err = Stream.JumpToBit(BlockBitStart))
750 return Err;
751 // It's not really interesting to dump the contents of the blockinfo
752 // block, so only do it if the user explicitly requests it.
753 DumpRecords = O && O->DumpBlockinfo;
754 }
755
756 unsigned NumWords = 0;
757 if (Error Err = Stream.EnterSubBlock(BlockID, &NumWords))
758 return Err;
759
760 // Keep it for later, when we see a MODULE_HASH record
761 uint64_t BlockEntryPos = Stream.getCurrentByteNo();
762
763 Optional<const char *> BlockName = None;
764 if (DumpRecords) {
765 O->OS << Indent << "<";
766 if ((BlockName = GetBlockName(BlockID, BlockInfo, CurStreamType)))
767 O->OS << *BlockName;
768 else
769 O->OS << "UnknownBlock" << BlockID;
770
771 if (!O->Symbolic && BlockName)
772 O->OS << " BlockID=" << BlockID;
773
774 O->OS << " NumWords=" << NumWords
775 << " BlockCodeSize=" << Stream.getAbbrevIDWidth() << ">\n";
776 }
777
778 SmallVector<uint64_t, 64> Record;
779
780 // Keep the offset to the metadata index if seen.
781 uint64_t MetadataIndexOffset = 0;
782
783 // Read all the records for this block.
784 while (true) {
785 if (Stream.AtEndOfStream())
786 return reportError("Premature end of bitstream");
787
788 uint64_t RecordStartBit = Stream.GetCurrentBitNo();
789
790 BitstreamEntry Entry;
791 if (Error E = Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs)
792 .moveInto(Entry))
793 return E;
794
795 switch (Entry.Kind) {
796 case BitstreamEntry::Error:
797 return reportError("malformed bitcode file");
798 case BitstreamEntry::EndBlock: {
799 uint64_t BlockBitEnd = Stream.GetCurrentBitNo();
800 BlockStats.NumBits += BlockBitEnd - BlockBitStart;
801 if (DumpRecords) {
802 O->OS << Indent << "</";
803 if (BlockName)
804 O->OS << *BlockName << ">\n";
805 else
806 O->OS << "UnknownBlock" << BlockID << ">\n";
807 }
808 return Error::success();
809 }
810
811 case BitstreamEntry::SubBlock: {
812 uint64_t SubBlockBitStart = Stream.GetCurrentBitNo();
813 if (Error E = parseBlock(Entry.ID, IndentLevel + 1, O, CheckHash))
814 return E;
815 ++BlockStats.NumSubBlocks;
816 uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo();
817
818 // Don't include subblock sizes in the size of this block.
819 BlockBitStart += SubBlockBitEnd - SubBlockBitStart;
820 continue;
821 }
822 case BitstreamEntry::Record:
823 // The interesting case.
824 break;
825 }
826
827 if (Entry.ID == bitc::DEFINE_ABBREV) {
828 if (Error Err = Stream.ReadAbbrevRecord())
829 return Err;
830 ++BlockStats.NumAbbrevs;
831 continue;
832 }
833
834 Record.clear();
835
836 ++BlockStats.NumRecords;
837
838 StringRef Blob;
839 uint64_t CurrentRecordPos = Stream.GetCurrentBitNo();
840 unsigned Code;
841 if (Error E = Stream.readRecord(Entry.ID, Record, &Blob).moveInto(Code))
842 return E;
843
844 // Increment the # occurrences of this code.
845 if (BlockStats.CodeFreq.size() <= Code)
846 BlockStats.CodeFreq.resize(Code + 1);
847 BlockStats.CodeFreq[Code].NumInstances++;
848 BlockStats.CodeFreq[Code].TotalBits +=
849 Stream.GetCurrentBitNo() - RecordStartBit;
850 if (Entry.ID != bitc::UNABBREV_RECORD) {
851 BlockStats.CodeFreq[Code].NumAbbrev++;
852 ++BlockStats.NumAbbreviatedRecords;
853 }
854
855 if (DumpRecords) {
856 O->OS << Indent << " <";
857 Optional<const char *> CodeName =
858 GetCodeName(Code, BlockID, BlockInfo, CurStreamType);
859 if (CodeName)
860 O->OS << *CodeName;
861 else
862 O->OS << "UnknownCode" << Code;
863 if (!O->Symbolic && CodeName)
864 O->OS << " codeid=" << Code;
865 const BitCodeAbbrev *Abbv = nullptr;
866 if (Entry.ID != bitc::UNABBREV_RECORD) {
867 Abbv = Stream.getAbbrev(Entry.ID);
868 O->OS << " abbrevid=" << Entry.ID;
869 }
870
871 for (unsigned i = 0, e = Record.size(); i != e; ++i)
872 O->OS << " op" << i << "=" << (int64_t)Record[i];
873
874 // If we found a metadata index, let's verify that we had an offset
875 // before and validate its forward reference offset was correct!
876 if (BlockID == bitc::METADATA_BLOCK_ID) {
877 if (Code == bitc::METADATA_INDEX_OFFSET) {
878 if (Record.size() != 2)
879 O->OS << "(Invalid record)";
880 else {
881 auto Offset = Record[0] + (Record[1] << 32);
882 MetadataIndexOffset = Stream.GetCurrentBitNo() + Offset;
883 }
884 }
885 if (Code == bitc::METADATA_INDEX) {
886 O->OS << " (offset ";
887 if (MetadataIndexOffset == RecordStartBit)
888 O->OS << "match)";
889 else
890 O->OS << "mismatch: " << MetadataIndexOffset << " vs "
891 << RecordStartBit << ")";
892 }
893 }
894
895 // If we found a module hash, let's verify that it matches!
896 if (BlockID == bitc::MODULE_BLOCK_ID && Code == bitc::MODULE_CODE_HASH &&
897 CheckHash.hasValue()) {
898 if (Record.size() != 5)
899 O->OS << " (invalid)";
900 else {
901 // Recompute the hash and compare it to the one in the bitcode
902 SHA1 Hasher;
903 StringRef Hash;
904 Hasher.update(*CheckHash);
905 {
906 int BlockSize = (CurrentRecordPos / 8) - BlockEntryPos;
907 auto Ptr = Stream.getPointerToByte(BlockEntryPos, BlockSize);
908 Hasher.update(ArrayRef<uint8_t>(Ptr, BlockSize));
909 Hash = Hasher.result();
910 }
911 std::array<char, 20> RecordedHash;
912 int Pos = 0;
913 for (auto &Val : Record) {
914 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", 914, __extension__
__PRETTY_FUNCTION__))
;
915 support::endian::write32be(&RecordedHash[Pos], Val);
916 Pos += 4;
917 }
918 if (Hash == StringRef(RecordedHash.data(), RecordedHash.size()))
919 O->OS << " (match)";
920 else
921 O->OS << " (!mismatch!)";
922 }
923 }
924
925 O->OS << "/>";
926
927 if (Abbv) {
928 for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) {
929 const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
930 if (!Op.isEncoding() || Op.getEncoding() != BitCodeAbbrevOp::Array)
931 continue;
932 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", 932, __extension__
__PRETTY_FUNCTION__))
;
933 std::string Str;
934 bool ArrayIsPrintable = true;
935 for (unsigned j = i - 1, je = Record.size(); j != je; ++j) {
936 if (!isPrint(static_cast<unsigned char>(Record[j]))) {
937 ArrayIsPrintable = false;
938 break;
939 }
940 Str += (char)Record[j];
941 }
942 if (ArrayIsPrintable)
943 O->OS << " record string = '" << Str << "'";
944 break;
945 }
946 }
947
948 if (Blob.data()) {
949 if (canDecodeBlob(Code, BlockID)) {
950 if (Error E = decodeMetadataStringsBlob(Indent, Record, Blob, O->OS))
951 return E;
952 } else {
953 O->OS << " blob data = ";
954 if (O->ShowBinaryBlobs) {
955 O->OS << "'";
956 O->OS.write_escaped(Blob, /*hex=*/true) << "'";
957 } else {
958 bool BlobIsPrintable = true;
959 for (char C : Blob)
960 if (!isPrint(static_cast<unsigned char>(C))) {
961 BlobIsPrintable = false;
962 break;
963 }
964
965 if (BlobIsPrintable)
966 O->OS << "'" << Blob << "'";
967 else
968 O->OS << "unprintable, " << Blob.size() << " bytes.";
969 }
970 }
971 }
972
973 O->OS << "\n";
974 }
975
976 // Make sure that we can skip the current record.
977 if (Error Err = Stream.JumpToBit(CurrentRecordPos))
978 return Err;
979 if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))
980 ; // Do nothing.
981 else
982 return Skipped.takeError();
983 }
984}
985