Bug Summary

File:lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
Warning:line 248, column 5
Value stored to 'ref_addr_size' is never read

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 DWARFFormValue.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~++20220125101009+ceec4383681c/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -isystem /usr/include/libxml2 -D HAVE_ROUND -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/lldb/source/Plugins/SymbolFile/DWARF -I /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/lldb/source/Plugins/SymbolFile/DWARF -I /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/lldb/include -I tools/lldb/include -I include -I /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/llvm/include -I /usr/include/python3.9 -I /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/clang/include -I tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/lldb/source -I tools/lldb/source -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~++20220125101009+ceec4383681c/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/= -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-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/= -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-25-232935-20746-1 -x c++ /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
1//===-- DWARFFormValue.cpp ------------------------------------------------===//
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 <cassert>
10
11#include "lldb/Core/Module.h"
12#include "lldb/Core/dwarf.h"
13#include "lldb/Symbol/ObjectFile.h"
14#include "lldb/Utility/Stream.h"
15
16#include "DWARFDebugInfo.h"
17#include "DWARFFormValue.h"
18#include "DWARFUnit.h"
19
20class DWARFUnit;
21
22using namespace lldb_private;
23
24void DWARFFormValue::Clear() {
25 m_unit = nullptr;
26 m_form = 0;
27 m_value = ValueTypeTag();
28}
29
30bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
31 lldb::offset_t *offset_ptr) {
32 if (m_form == DW_FORM_implicit_const)
33 return true;
34
35 bool indirect = false;
36 bool is_block = false;
37 m_value.data = nullptr;
38 uint8_t ref_addr_size;
39 // Read the value for the form into value and follow and DW_FORM_indirect
40 // instances we run into
41 do {
42 indirect = false;
43 switch (m_form) {
44 case DW_FORM_addr:
45 assert(m_unit)(static_cast <bool> (m_unit) ? void (0) : __assert_fail
("m_unit", "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp"
, 45, __extension__ __PRETTY_FUNCTION__))
;
46 m_value.value.uval =
47 data.GetMaxU64(offset_ptr, DWARFUnit::GetAddressByteSize(m_unit));
48 break;
49 case DW_FORM_block1:
50 m_value.value.uval = data.GetU8(offset_ptr);
51 is_block = true;
52 break;
53 case DW_FORM_block2:
54 m_value.value.uval = data.GetU16(offset_ptr);
55 is_block = true;
56 break;
57 case DW_FORM_block4:
58 m_value.value.uval = data.GetU32(offset_ptr);
59 is_block = true;
60 break;
61 case DW_FORM_data16:
62 m_value.value.uval = 16;
63 is_block = true;
64 break;
65 case DW_FORM_exprloc:
66 case DW_FORM_block:
67 m_value.value.uval = data.GetULEB128(offset_ptr);
68 is_block = true;
69 break;
70 case DW_FORM_string:
71 m_value.value.cstr = data.GetCStr(offset_ptr);
72 break;
73 case DW_FORM_sdata:
74 m_value.value.sval = data.GetSLEB128(offset_ptr);
75 break;
76 case DW_FORM_strp:
77 case DW_FORM_line_strp:
78 case DW_FORM_sec_offset:
79 m_value.value.uval = data.GetMaxU64(offset_ptr, 4);
80 break;
81 case DW_FORM_addrx1:
82 case DW_FORM_strx1:
83 case DW_FORM_ref1:
84 case DW_FORM_data1:
85 case DW_FORM_flag:
86 m_value.value.uval = data.GetU8(offset_ptr);
87 break;
88 case DW_FORM_addrx2:
89 case DW_FORM_strx2:
90 case DW_FORM_ref2:
91 case DW_FORM_data2:
92 m_value.value.uval = data.GetU16(offset_ptr);
93 break;
94 case DW_FORM_addrx3:
95 case DW_FORM_strx3:
96 m_value.value.uval = data.GetMaxU64(offset_ptr, 3);
97 break;
98 case DW_FORM_addrx4:
99 case DW_FORM_strx4:
100 case DW_FORM_ref4:
101 case DW_FORM_data4:
102 m_value.value.uval = data.GetU32(offset_ptr);
103 break;
104 case DW_FORM_data8:
105 case DW_FORM_ref8:
106 case DW_FORM_ref_sig8:
107 m_value.value.uval = data.GetU64(offset_ptr);
108 break;
109 case DW_FORM_addrx:
110 case DW_FORM_loclistx:
111 case DW_FORM_rnglistx:
112 case DW_FORM_strx:
113 case DW_FORM_udata:
114 case DW_FORM_ref_udata:
115 case DW_FORM_GNU_str_index:
116 case DW_FORM_GNU_addr_index:
117 m_value.value.uval = data.GetULEB128(offset_ptr);
118 break;
119 case DW_FORM_ref_addr:
120 assert(m_unit)(static_cast <bool> (m_unit) ? void (0) : __assert_fail
("m_unit", "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp"
, 120, __extension__ __PRETTY_FUNCTION__))
;
121 if (m_unit->GetVersion() <= 2)
122 ref_addr_size = m_unit->GetAddressByteSize();
123 else
124 ref_addr_size = 4;
125 m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);
126 break;
127 case DW_FORM_indirect:
128 m_form = data.GetULEB128(offset_ptr);
129 indirect = true;
130 break;
131 case DW_FORM_flag_present:
132 m_value.value.uval = 1;
133 break;
134 default:
135 return false;
136 }
137 } while (indirect);
138
139 if (is_block) {
140 m_value.data = data.PeekData(*offset_ptr, m_value.value.uval);
141 if (m_value.data != nullptr) {
142 *offset_ptr += m_value.value.uval;
143 }
144 }
145
146 return true;
147}
148
149struct FormSize {
150 uint8_t valid:1, size:7;
151};
152static FormSize g_form_sizes[] = {
153 {0, 0}, // 0x00 unused
154 {0, 0}, // 0x01 DW_FORM_addr
155 {0, 0}, // 0x02 unused
156 {0, 0}, // 0x03 DW_FORM_block2
157 {0, 0}, // 0x04 DW_FORM_block4
158 {1, 2}, // 0x05 DW_FORM_data2
159 {1, 4}, // 0x06 DW_FORM_data4
160 {1, 8}, // 0x07 DW_FORM_data8
161 {0, 0}, // 0x08 DW_FORM_string
162 {0, 0}, // 0x09 DW_FORM_block
163 {0, 0}, // 0x0a DW_FORM_block1
164 {1, 1}, // 0x0b DW_FORM_data1
165 {1, 1}, // 0x0c DW_FORM_flag
166 {0, 0}, // 0x0d DW_FORM_sdata
167 {1, 4}, // 0x0e DW_FORM_strp
168 {0, 0}, // 0x0f DW_FORM_udata
169 {0, 0}, // 0x10 DW_FORM_ref_addr (addr size for DWARF2 and earlier, 4 bytes
170 // for DWARF32, 8 bytes for DWARF32 in DWARF 3 and later
171 {1, 1}, // 0x11 DW_FORM_ref1
172 {1, 2}, // 0x12 DW_FORM_ref2
173 {1, 4}, // 0x13 DW_FORM_ref4
174 {1, 8}, // 0x14 DW_FORM_ref8
175 {0, 0}, // 0x15 DW_FORM_ref_udata
176 {0, 0}, // 0x16 DW_FORM_indirect
177 {1, 4}, // 0x17 DW_FORM_sec_offset
178 {0, 0}, // 0x18 DW_FORM_exprloc
179 {1, 0}, // 0x19 DW_FORM_flag_present
180 {0, 0}, // 0x1a DW_FORM_strx (ULEB128)
181 {0, 0}, // 0x1b DW_FORM_addrx (ULEB128)
182 {1, 4}, // 0x1c DW_FORM_ref_sup4
183 {0, 0}, // 0x1d DW_FORM_strp_sup (4 bytes for DWARF32, 8 bytes for DWARF64)
184 {1, 16}, // 0x1e DW_FORM_data16
185 {1, 4}, // 0x1f DW_FORM_line_strp
186 {1, 8}, // 0x20 DW_FORM_ref_sig8
187};
188
189llvm::Optional<uint8_t>
190DWARFFormValue::GetFixedSize(dw_form_t form, const DWARFUnit *u) {
191 if (form <= DW_FORM_ref_sig8 && g_form_sizes[form].valid)
192 return g_form_sizes[form].size;
193 if (form == DW_FORM_addr && u)
194 return u->GetAddressByteSize();
195 return llvm::None;
196}
197
198llvm::Optional<uint8_t> DWARFFormValue::GetFixedSize() const {
199 return GetFixedSize(m_form, m_unit);
200}
201
202bool DWARFFormValue::SkipValue(const DWARFDataExtractor &debug_info_data,
203 lldb::offset_t *offset_ptr) const {
204 return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, m_unit);
205}
206
207bool DWARFFormValue::SkipValue(dw_form_t form,
208 const DWARFDataExtractor &debug_info_data,
209 lldb::offset_t *offset_ptr,
210 const DWARFUnit *unit) {
211 uint8_t ref_addr_size;
212 switch (form) {
213 // Blocks if inlined data that have a length field and the data bytes inlined
214 // in the .debug_info
215 case DW_FORM_exprloc:
216 case DW_FORM_block: {
217 dw_uleb128_t size = debug_info_data.GetULEB128(offset_ptr);
218 *offset_ptr += size;
219 }
220 return true;
221 case DW_FORM_block1: {
222 dw_uleb128_t size = debug_info_data.GetU8(offset_ptr);
223 *offset_ptr += size;
224 }
225 return true;
226 case DW_FORM_block2: {
227 dw_uleb128_t size = debug_info_data.GetU16(offset_ptr);
228 *offset_ptr += size;
229 }
230 return true;
231 case DW_FORM_block4: {
232 dw_uleb128_t size = debug_info_data.GetU32(offset_ptr);
233 *offset_ptr += size;
234 }
235 return true;
236
237 // Inlined NULL terminated C-strings
238 case DW_FORM_string:
239 debug_info_data.GetCStr(offset_ptr);
240 return true;
241
242 // Compile unit address sized values
243 case DW_FORM_addr:
244 *offset_ptr += DWARFUnit::GetAddressByteSize(unit);
245 return true;
246
247 case DW_FORM_ref_addr:
248 ref_addr_size = 4;
Value stored to 'ref_addr_size' is never read
249 assert(unit)(static_cast <bool> (unit) ? void (0) : __assert_fail (
"unit", "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp"
, 249, __extension__ __PRETTY_FUNCTION__))
; // Unit must be valid for DW_FORM_ref_addr objects or we will
250 // get this wrong
251 if (unit->GetVersion() <= 2)
252 ref_addr_size = unit->GetAddressByteSize();
253 else
254 ref_addr_size = 4;
255 *offset_ptr += ref_addr_size;
256 return true;
257
258 // 0 bytes values (implied from DW_FORM)
259 case DW_FORM_flag_present:
260 case DW_FORM_implicit_const:
261 return true;
262
263 // 1 byte values
264 case DW_FORM_addrx1:
265 case DW_FORM_data1:
266 case DW_FORM_flag:
267 case DW_FORM_ref1:
268 case DW_FORM_strx1:
269 *offset_ptr += 1;
270 return true;
271
272 // 2 byte values
273 case DW_FORM_addrx2:
274 case DW_FORM_data2:
275 case DW_FORM_ref2:
276 case DW_FORM_strx2:
277 *offset_ptr += 2;
278 return true;
279
280 // 3 byte values
281 case DW_FORM_addrx3:
282 case DW_FORM_strx3:
283 *offset_ptr += 3;
284 return true;
285
286 // 32 bit for DWARF 32, 64 for DWARF 64
287 case DW_FORM_sec_offset:
288 case DW_FORM_strp:
289 case DW_FORM_line_strp:
290 *offset_ptr += 4;
291 return true;
292
293 // 4 byte values
294 case DW_FORM_addrx4:
295 case DW_FORM_data4:
296 case DW_FORM_ref4:
297 case DW_FORM_strx4:
298 *offset_ptr += 4;
299 return true;
300
301 // 8 byte values
302 case DW_FORM_data8:
303 case DW_FORM_ref8:
304 case DW_FORM_ref_sig8:
305 *offset_ptr += 8;
306 return true;
307
308 // signed or unsigned LEB 128 values
309 case DW_FORM_addrx:
310 case DW_FORM_loclistx:
311 case DW_FORM_rnglistx:
312 case DW_FORM_sdata:
313 case DW_FORM_udata:
314 case DW_FORM_ref_udata:
315 case DW_FORM_GNU_addr_index:
316 case DW_FORM_GNU_str_index:
317 case DW_FORM_strx:
318 debug_info_data.Skip_LEB128(offset_ptr);
319 return true;
320
321 case DW_FORM_indirect: {
322 dw_form_t indirect_form = debug_info_data.GetULEB128(offset_ptr);
323 return DWARFFormValue::SkipValue(indirect_form, debug_info_data, offset_ptr,
324 unit);
325 }
326
327 default:
328 break;
329 }
330 return false;
331}
332
333void DWARFFormValue::Dump(Stream &s) const {
334 uint64_t uvalue = Unsigned();
335 bool unit_relative_offset = false;
336
337 switch (m_form) {
338 case DW_FORM_addr:
339 DumpAddress(s.AsRawOstream(), uvalue, sizeof(uint64_t));
340 break;
341 case DW_FORM_flag:
342 case DW_FORM_data1:
343 s.PutHex8(uvalue);
344 break;
345 case DW_FORM_data2:
346 s.PutHex16(uvalue);
347 break;
348 case DW_FORM_sec_offset:
349 case DW_FORM_data4:
350 s.PutHex32(uvalue);
351 break;
352 case DW_FORM_ref_sig8:
353 case DW_FORM_data8:
354 s.PutHex64(uvalue);
355 break;
356 case DW_FORM_string:
357 s.QuotedCString(AsCString());
358 break;
359 case DW_FORM_exprloc:
360 case DW_FORM_block:
361 case DW_FORM_block1:
362 case DW_FORM_block2:
363 case DW_FORM_block4:
364 if (uvalue > 0) {
365 switch (m_form) {
366 case DW_FORM_exprloc:
367 case DW_FORM_block:
368 s.Printf("<0x%" PRIx64"l" "x" "> ", uvalue);
369 break;
370 case DW_FORM_block1:
371 s.Printf("<0x%2.2x> ", (uint8_t)uvalue);
372 break;
373 case DW_FORM_block2:
374 s.Printf("<0x%4.4x> ", (uint16_t)uvalue);
375 break;
376 case DW_FORM_block4:
377 s.Printf("<0x%8.8x> ", (uint32_t)uvalue);
378 break;
379 default:
380 break;
381 }
382
383 const uint8_t *data_ptr = m_value.data;
384 if (data_ptr) {
385 const uint8_t *end_data_ptr =
386 data_ptr + uvalue; // uvalue contains size of block
387 while (data_ptr < end_data_ptr) {
388 s.Printf("%2.2x ", *data_ptr);
389 ++data_ptr;
390 }
391 } else
392 s.PutCString("NULL");
393 }
394 break;
395
396 case DW_FORM_sdata:
397 s.PutSLEB128(uvalue);
398 break;
399 case DW_FORM_udata:
400 s.PutULEB128(uvalue);
401 break;
402 case DW_FORM_strp:
403 case DW_FORM_line_strp: {
404 const char *dbg_str = AsCString();
405 if (dbg_str) {
406 s.QuotedCString(dbg_str);
407 } else {
408 s.PutHex32(uvalue);
409 }
410 } break;
411
412 case DW_FORM_ref_addr: {
413 assert(m_unit)(static_cast <bool> (m_unit) ? void (0) : __assert_fail
("m_unit", "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp"
, 413, __extension__ __PRETTY_FUNCTION__))
; // Unit must be valid for DW_FORM_ref_addr objects or we
414 // will get this wrong
415 if (m_unit->GetVersion() <= 2)
416 DumpAddress(s.AsRawOstream(), uvalue, sizeof(uint64_t) * 2);
417 else
418 DumpAddress(s.AsRawOstream(), uvalue,
419 4 * 2); // 4 for DWARF32, 8 for DWARF64, but we don't
420 // support DWARF64 yet
421 break;
422 }
423 case DW_FORM_ref1:
424 unit_relative_offset = true;
425 break;
426 case DW_FORM_ref2:
427 unit_relative_offset = true;
428 break;
429 case DW_FORM_ref4:
430 unit_relative_offset = true;
431 break;
432 case DW_FORM_ref8:
433 unit_relative_offset = true;
434 break;
435 case DW_FORM_ref_udata:
436 unit_relative_offset = true;
437 break;
438
439 // All DW_FORM_indirect attributes should be resolved prior to calling this
440 // function
441 case DW_FORM_indirect:
442 s.PutCString("DW_FORM_indirect");
443 break;
444 case DW_FORM_flag_present:
445 break;
446 default:
447 s.Printf("DW_FORM(0x%4.4x)", m_form);
448 break;
449 }
450
451 if (unit_relative_offset) {
452 assert(m_unit)(static_cast <bool> (m_unit) ? void (0) : __assert_fail
("m_unit", "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp"
, 452, __extension__ __PRETTY_FUNCTION__))
; // Unit must be valid for DW_FORM_ref forms that are compile
453 // unit relative or we will get this wrong
454 s.Printf("{0x%8.8" PRIx64"l" "x" "}", uvalue + m_unit->GetOffset());
455 }
456}
457
458const char *DWARFFormValue::AsCString() const {
459 DWARFContext &context = m_unit->GetSymbolFileDWARF().GetDWARFContext();
460
461 if (m_form == DW_FORM_string)
462 return m_value.value.cstr;
463 if (m_form == DW_FORM_strp)
464 return context.getOrLoadStrData().PeekCStr(m_value.value.uval);
465
466 if (m_form == DW_FORM_GNU_str_index || m_form == DW_FORM_strx ||
467 m_form == DW_FORM_strx1 || m_form == DW_FORM_strx2 ||
468 m_form == DW_FORM_strx3 || m_form == DW_FORM_strx4) {
469
470 llvm::Optional<uint64_t> offset =
471 m_unit->GetStringOffsetSectionItem(m_value.value.uval);
472 if (!offset)
473 return nullptr;
474 return context.getOrLoadStrData().PeekCStr(*offset);
475 }
476
477 if (m_form == DW_FORM_line_strp)
478 return context.getOrLoadLineStrData().PeekCStr(m_value.value.uval);
479
480 return nullptr;
481}
482
483dw_addr_t DWARFFormValue::Address() const {
484 SymbolFileDWARF &symbol_file = m_unit->GetSymbolFileDWARF();
485
486 if (m_form == DW_FORM_addr)
487 return Unsigned();
488
489 assert(m_unit)(static_cast <bool> (m_unit) ? void (0) : __assert_fail
("m_unit", "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp"
, 489, __extension__ __PRETTY_FUNCTION__))
;
490 assert(m_form == DW_FORM_GNU_addr_index || m_form == DW_FORM_addrx ||(static_cast <bool> (m_form == DW_FORM_GNU_addr_index ||
m_form == DW_FORM_addrx || m_form == DW_FORM_addrx1 || m_form
== DW_FORM_addrx2 || m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4
) ? void (0) : __assert_fail ("m_form == DW_FORM_GNU_addr_index || m_form == DW_FORM_addrx || m_form == DW_FORM_addrx1 || m_form == DW_FORM_addrx2 || m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4"
, "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp", 492
, __extension__ __PRETTY_FUNCTION__))
491 m_form == DW_FORM_addrx1 || m_form == DW_FORM_addrx2 ||(static_cast <bool> (m_form == DW_FORM_GNU_addr_index ||
m_form == DW_FORM_addrx || m_form == DW_FORM_addrx1 || m_form
== DW_FORM_addrx2 || m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4
) ? void (0) : __assert_fail ("m_form == DW_FORM_GNU_addr_index || m_form == DW_FORM_addrx || m_form == DW_FORM_addrx1 || m_form == DW_FORM_addrx2 || m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4"
, "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp", 492
, __extension__ __PRETTY_FUNCTION__))
492 m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4)(static_cast <bool> (m_form == DW_FORM_GNU_addr_index ||
m_form == DW_FORM_addrx || m_form == DW_FORM_addrx1 || m_form
== DW_FORM_addrx2 || m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4
) ? void (0) : __assert_fail ("m_form == DW_FORM_GNU_addr_index || m_form == DW_FORM_addrx || m_form == DW_FORM_addrx1 || m_form == DW_FORM_addrx2 || m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4"
, "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp", 492
, __extension__ __PRETTY_FUNCTION__))
;
493
494 uint32_t index_size = m_unit->GetAddressByteSize();
495 dw_offset_t addr_base = m_unit->GetAddrBase();
496 lldb::offset_t offset = addr_base + m_value.value.uval * index_size;
497 return symbol_file.GetDWARFContext().getOrLoadAddrData().GetMaxU64(
498 &offset, index_size);
499}
500
501DWARFDIE DWARFFormValue::Reference() const {
502 uint64_t value = m_value.value.uval;
503 switch (m_form) {
504 case DW_FORM_ref1:
505 case DW_FORM_ref2:
506 case DW_FORM_ref4:
507 case DW_FORM_ref8:
508 case DW_FORM_ref_udata:
509 assert(m_unit)(static_cast <bool> (m_unit) ? void (0) : __assert_fail
("m_unit", "lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp"
, 509, __extension__ __PRETTY_FUNCTION__))
; // Unit must be valid for DW_FORM_ref forms that are compile
510 // unit relative or we will get this wrong
511 value += m_unit->GetOffset();
512 if (!m_unit->ContainsDIEOffset(value)) {
513 m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
514 "DW_FORM_ref* DIE reference 0x%" PRIx64"l" "x" " is outside of its CU",
515 value);
516 return {};
517 }
518 return const_cast<DWARFUnit *>(m_unit)->GetDIE(value);
519
520 case DW_FORM_ref_addr: {
521 DWARFUnit *ref_cu =
522 m_unit->GetSymbolFileDWARF().DebugInfo().GetUnitContainingDIEOffset(
523 DIERef::Section::DebugInfo, value);
524 if (!ref_cu) {
525 m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
526 "DW_FORM_ref_addr DIE reference 0x%" PRIx64"l" "x" " has no matching CU",
527 value);
528 return {};
529 }
530 return ref_cu->GetDIE(value);
531 }
532
533 case DW_FORM_ref_sig8: {
534 DWARFTypeUnit *tu =
535 m_unit->GetSymbolFileDWARF().DebugInfo().GetTypeUnitForHash(value);
536 if (!tu)
537 return {};
538 return tu->GetDIE(tu->GetTypeOffset());
539 }
540
541 default:
542 return {};
543 }
544}
545
546uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const {
547 uint64_t value = m_value.value.uval;
548 switch (m_form) {
549 case DW_FORM_ref1:
550 case DW_FORM_ref2:
551 case DW_FORM_ref4:
552 case DW_FORM_ref8:
553 case DW_FORM_ref_udata:
554 return value + base_offset;
555
556 case DW_FORM_ref_addr:
557 case DW_FORM_ref_sig8:
558 case DW_FORM_GNU_ref_alt:
559 return value;
560
561 default:
562 return DW_INVALID_OFFSET(~(dw_offset_t)0);
563 }
564}
565
566const uint8_t *DWARFFormValue::BlockData() const { return m_value.data; }
567
568bool DWARFFormValue::IsBlockForm(const dw_form_t form) {
569 switch (form) {
570 case DW_FORM_exprloc:
571 case DW_FORM_block:
572 case DW_FORM_block1:
573 case DW_FORM_block2:
574 case DW_FORM_block4:
575 return true;
576 }
577 return false;
578}
579
580bool DWARFFormValue::IsDataForm(const dw_form_t form) {
581 switch (form) {
582 case DW_FORM_sdata:
583 case DW_FORM_udata:
584 case DW_FORM_data1:
585 case DW_FORM_data2:
586 case DW_FORM_data4:
587 case DW_FORM_data8:
588 return true;
589 }
590 return false;
591}
592
593bool DWARFFormValue::FormIsSupported(dw_form_t form) {
594 switch (form) {
595 case DW_FORM_addr:
596 case DW_FORM_addrx:
597 case DW_FORM_loclistx:
598 case DW_FORM_rnglistx:
599 case DW_FORM_block2:
600 case DW_FORM_block4:
601 case DW_FORM_data2:
602 case DW_FORM_data4:
603 case DW_FORM_data8:
604 case DW_FORM_string:
605 case DW_FORM_block:
606 case DW_FORM_block1:
607 case DW_FORM_data1:
608 case DW_FORM_flag:
609 case DW_FORM_sdata:
610 case DW_FORM_strp:
611 case DW_FORM_line_strp:
612 case DW_FORM_strx:
613 case DW_FORM_strx1:
614 case DW_FORM_strx2:
615 case DW_FORM_strx3:
616 case DW_FORM_strx4:
617 case DW_FORM_udata:
618 case DW_FORM_ref_addr:
619 case DW_FORM_ref1:
620 case DW_FORM_ref2:
621 case DW_FORM_ref4:
622 case DW_FORM_ref8:
623 case DW_FORM_ref_udata:
624 case DW_FORM_indirect:
625 case DW_FORM_sec_offset:
626 case DW_FORM_exprloc:
627 case DW_FORM_flag_present:
628 case DW_FORM_ref_sig8:
629 case DW_FORM_GNU_str_index:
630 case DW_FORM_GNU_addr_index:
631 case DW_FORM_implicit_const:
632 return true;
633 default:
634 break;
635 }
636 return false;
637}