VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/dbg/dbgmoddwarf.cpp@ 49082

Last change on this file since 49082 was 49082, checked in by vboxsync, 11 years ago

IPRT: darwin debugging fixes.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 176.4 KB
Line 
1/* $Id: dbgmoddwarf.cpp 49082 2013-10-14 03:31:06Z vboxsync $ */
2/** @file
3 * IPRT - Debug Info Reader For DWARF.
4 */
5
6/*
7 * Copyright (C) 2011-2013 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*******************************************************************************
29* Header Files *
30*******************************************************************************/
31#define LOG_GROUP RTLOGGROUP_DBG_DWARF
32#include <iprt/dbg.h>
33#include "internal/iprt.h"
34
35#include <iprt/asm.h>
36#include <iprt/ctype.h>
37#include <iprt/err.h>
38#include <iprt/list.h>
39#include <iprt/log.h>
40#include <iprt/mem.h>
41#define RTDBGMODDWARF_WITH_MEM_CACHE
42#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
43# include <iprt/memcache.h>
44#endif
45#include <iprt/path.h>
46#include <iprt/string.h>
47#include <iprt/strcache.h>
48#include "internal/dbgmod.h"
49
50
51/*******************************************************************************
52* Defined Constants And Macros *
53*******************************************************************************/
54/** @name Standard DWARF Line Number Opcodes
55 * @{ */
56#define DW_LNS_extended UINT8_C(0x00)
57#define DW_LNS_copy UINT8_C(0x01)
58#define DW_LNS_advance_pc UINT8_C(0x02)
59#define DW_LNS_advance_line UINT8_C(0x03)
60#define DW_LNS_set_file UINT8_C(0x04)
61#define DW_LNS_set_column UINT8_C(0x05)
62#define DW_LNS_negate_stmt UINT8_C(0x06)
63#define DW_LNS_set_basic_block UINT8_C(0x07)
64#define DW_LNS_const_add_pc UINT8_C(0x08)
65#define DW_LNS_fixed_advance_pc UINT8_C(0x09)
66#define DW_LNS_set_prologue_end UINT8_C(0x0a)
67#define DW_LNS_set_epilogue_begin UINT8_C(0x0b)
68#define DW_LNS_set_isa UINT8_C(0x0c)
69#define DW_LNS_what_question_mark UINT8_C(0x0d)
70/** @} */
71
72
73/** @name Extended DWARF Line Number Opcodes
74 * @{ */
75#define DW_LNE_end_sequence UINT8_C(1)
76#define DW_LNE_set_address UINT8_C(2)
77#define DW_LNE_define_file UINT8_C(3)
78#define DW_LNE_set_descriminator UINT8_C(4)
79/** @} */
80
81/** @name DIE Tags.
82 * @{ */
83#define DW_TAG_array_type UINT16_C(0x0001)
84#define DW_TAG_class_type UINT16_C(0x0002)
85#define DW_TAG_entry_point UINT16_C(0x0003)
86#define DW_TAG_enumeration_type UINT16_C(0x0004)
87#define DW_TAG_formal_parameter UINT16_C(0x0005)
88#define DW_TAG_imported_declaration UINT16_C(0x0008)
89#define DW_TAG_label UINT16_C(0x000a)
90#define DW_TAG_lexical_block UINT16_C(0x000b)
91#define DW_TAG_member UINT16_C(0x000d)
92#define DW_TAG_pointer_type UINT16_C(0x000f)
93#define DW_TAG_reference_type UINT16_C(0x0010)
94#define DW_TAG_compile_unit UINT16_C(0x0011)
95#define DW_TAG_string_type UINT16_C(0x0012)
96#define DW_TAG_structure_type UINT16_C(0x0013)
97#define DW_TAG_subroutine_type UINT16_C(0x0015)
98#define DW_TAG_typedef UINT16_C(0x0016)
99#define DW_TAG_union_type UINT16_C(0x0017)
100#define DW_TAG_unspecified_parameters UINT16_C(0x0018)
101#define DW_TAG_variant UINT16_C(0x0019)
102#define DW_TAG_common_block UINT16_C(0x001a)
103#define DW_TAG_common_inclusion UINT16_C(0x001b)
104#define DW_TAG_inheritance UINT16_C(0x001c)
105#define DW_TAG_inlined_subroutine UINT16_C(0x001d)
106#define DW_TAG_module UINT16_C(0x001e)
107#define DW_TAG_ptr_to_member_type UINT16_C(0x001f)
108#define DW_TAG_set_type UINT16_C(0x0020)
109#define DW_TAG_subrange_type UINT16_C(0x0021)
110#define DW_TAG_with_stmt UINT16_C(0x0022)
111#define DW_TAG_access_declaration UINT16_C(0x0023)
112#define DW_TAG_base_type UINT16_C(0x0024)
113#define DW_TAG_catch_block UINT16_C(0x0025)
114#define DW_TAG_const_type UINT16_C(0x0026)
115#define DW_TAG_constant UINT16_C(0x0027)
116#define DW_TAG_enumerator UINT16_C(0x0028)
117#define DW_TAG_file_type UINT16_C(0x0029)
118#define DW_TAG_friend UINT16_C(0x002a)
119#define DW_TAG_namelist UINT16_C(0x002b)
120#define DW_TAG_namelist_item UINT16_C(0x002c)
121#define DW_TAG_packed_type UINT16_C(0x002d)
122#define DW_TAG_subprogram UINT16_C(0x002e)
123#define DW_TAG_template_type_parameter UINT16_C(0x002f)
124#define DW_TAG_template_value_parameter UINT16_C(0x0030)
125#define DW_TAG_thrown_type UINT16_C(0x0031)
126#define DW_TAG_try_block UINT16_C(0x0032)
127#define DW_TAG_variant_part UINT16_C(0x0033)
128#define DW_TAG_variable UINT16_C(0x0034)
129#define DW_TAG_volatile_type UINT16_C(0x0035)
130#define DW_TAG_dwarf_procedure UINT16_C(0x0036)
131#define DW_TAG_restrict_type UINT16_C(0x0037)
132#define DW_TAG_interface_type UINT16_C(0x0038)
133#define DW_TAG_namespace UINT16_C(0x0039)
134#define DW_TAG_imported_module UINT16_C(0x003a)
135#define DW_TAG_unspecified_type UINT16_C(0x003b)
136#define DW_TAG_partial_unit UINT16_C(0x003c)
137#define DW_TAG_imported_unit UINT16_C(0x003d)
138#define DW_TAG_condition UINT16_C(0x003f)
139#define DW_TAG_shared_type UINT16_C(0x0040)
140#define DW_TAG_type_unit UINT16_C(0x0041)
141#define DW_TAG_rvalue_reference_type UINT16_C(0x0042)
142#define DW_TAG_template_alias UINT16_C(0x0043)
143#define DW_TAG_lo_user UINT16_C(0x4080)
144#define DW_TAG_GNU_call_site UINT16_C(0x4109)
145#define DW_TAG_GNU_call_site_parameter UINT16_C(0x410a)
146#define DW_TAG_hi_user UINT16_C(0xffff)
147/** @} */
148
149
150/** @name DIE Attributes.
151 * @{ */
152#define DW_AT_sibling UINT16_C(0x0001)
153#define DW_AT_location UINT16_C(0x0002)
154#define DW_AT_name UINT16_C(0x0003)
155#define DW_AT_ordering UINT16_C(0x0009)
156#define DW_AT_byte_size UINT16_C(0x000b)
157#define DW_AT_bit_offset UINT16_C(0x000c)
158#define DW_AT_bit_size UINT16_C(0x000d)
159#define DW_AT_stmt_list UINT16_C(0x0010)
160#define DW_AT_low_pc UINT16_C(0x0011)
161#define DW_AT_high_pc UINT16_C(0x0012)
162#define DW_AT_language UINT16_C(0x0013)
163#define DW_AT_discr UINT16_C(0x0015)
164#define DW_AT_discr_value UINT16_C(0x0016)
165#define DW_AT_visibility UINT16_C(0x0017)
166#define DW_AT_import UINT16_C(0x0018)
167#define DW_AT_string_length UINT16_C(0x0019)
168#define DW_AT_common_reference UINT16_C(0x001a)
169#define DW_AT_comp_dir UINT16_C(0x001b)
170#define DW_AT_const_value UINT16_C(0x001c)
171#define DW_AT_containing_type UINT16_C(0x001d)
172#define DW_AT_default_value UINT16_C(0x001e)
173#define DW_AT_inline UINT16_C(0x0020)
174#define DW_AT_is_optional UINT16_C(0x0021)
175#define DW_AT_lower_bound UINT16_C(0x0022)
176#define DW_AT_producer UINT16_C(0x0025)
177#define DW_AT_prototyped UINT16_C(0x0027)
178#define DW_AT_return_addr UINT16_C(0x002a)
179#define DW_AT_start_scope UINT16_C(0x002c)
180#define DW_AT_bit_stride UINT16_C(0x002e)
181#define DW_AT_upper_bound UINT16_C(0x002f)
182#define DW_AT_abstract_origin UINT16_C(0x0031)
183#define DW_AT_accessibility UINT16_C(0x0032)
184#define DW_AT_address_class UINT16_C(0x0033)
185#define DW_AT_artificial UINT16_C(0x0034)
186#define DW_AT_base_types UINT16_C(0x0035)
187#define DW_AT_calling_convention UINT16_C(0x0036)
188#define DW_AT_count UINT16_C(0x0037)
189#define DW_AT_data_member_location UINT16_C(0x0038)
190#define DW_AT_decl_column UINT16_C(0x0039)
191#define DW_AT_decl_file UINT16_C(0x003a)
192#define DW_AT_decl_line UINT16_C(0x003b)
193#define DW_AT_declaration UINT16_C(0x003c)
194#define DW_AT_discr_list UINT16_C(0x003d)
195#define DW_AT_encoding UINT16_C(0x003e)
196#define DW_AT_external UINT16_C(0x003f)
197#define DW_AT_frame_base UINT16_C(0x0040)
198#define DW_AT_friend UINT16_C(0x0041)
199#define DW_AT_identifier_case UINT16_C(0x0042)
200#define DW_AT_macro_info UINT16_C(0x0043)
201#define DW_AT_namelist_item UINT16_C(0x0044)
202#define DW_AT_priority UINT16_C(0x0045)
203#define DW_AT_segment UINT16_C(0x0046)
204#define DW_AT_specification UINT16_C(0x0047)
205#define DW_AT_static_link UINT16_C(0x0048)
206#define DW_AT_type UINT16_C(0x0049)
207#define DW_AT_use_location UINT16_C(0x004a)
208#define DW_AT_variable_parameter UINT16_C(0x004b)
209#define DW_AT_virtuality UINT16_C(0x004c)
210#define DW_AT_vtable_elem_location UINT16_C(0x004d)
211#define DW_AT_allocated UINT16_C(0x004e)
212#define DW_AT_associated UINT16_C(0x004f)
213#define DW_AT_data_location UINT16_C(0x0050)
214#define DW_AT_byte_stride UINT16_C(0x0051)
215#define DW_AT_entry_pc UINT16_C(0x0052)
216#define DW_AT_use_UTF8 UINT16_C(0x0053)
217#define DW_AT_extension UINT16_C(0x0054)
218#define DW_AT_ranges UINT16_C(0x0055)
219#define DW_AT_trampoline UINT16_C(0x0056)
220#define DW_AT_call_column UINT16_C(0x0057)
221#define DW_AT_call_file UINT16_C(0x0058)
222#define DW_AT_call_line UINT16_C(0x0059)
223#define DW_AT_description UINT16_C(0x005a)
224#define DW_AT_binary_scale UINT16_C(0x005b)
225#define DW_AT_decimal_scale UINT16_C(0x005c)
226#define DW_AT_small UINT16_C(0x005d)
227#define DW_AT_decimal_sign UINT16_C(0x005e)
228#define DW_AT_digit_count UINT16_C(0x005f)
229#define DW_AT_picture_string UINT16_C(0x0060)
230#define DW_AT_mutable UINT16_C(0x0061)
231#define DW_AT_threads_scaled UINT16_C(0x0062)
232#define DW_AT_explicit UINT16_C(0x0063)
233#define DW_AT_object_pointer UINT16_C(0x0064)
234#define DW_AT_endianity UINT16_C(0x0065)
235#define DW_AT_elemental UINT16_C(0x0066)
236#define DW_AT_pure UINT16_C(0x0067)
237#define DW_AT_recursive UINT16_C(0x0068)
238#define DW_AT_signature UINT16_C(0x0069)
239#define DW_AT_main_subprogram UINT16_C(0x006a)
240#define DW_AT_data_bit_offset UINT16_C(0x006b)
241#define DW_AT_const_expr UINT16_C(0x006c)
242#define DW_AT_enum_class UINT16_C(0x006d)
243#define DW_AT_linkage_name UINT16_C(0x006e)
244#define DW_AT_lo_user UINT16_C(0x2000)
245/** Used by GCC and others, same as DW_AT_linkage_name. See http://wiki.dwarfstd.org/index.php?title=DW_AT_linkage_name*/
246#define DW_AT_MIPS_linkage_name UINT16_C(0x2007)
247#define DW_AT_hi_user UINT16_C(0x3fff)
248/** @} */
249
250/** @name DIE Forms.
251 * @{ */
252#define DW_FORM_addr UINT16_C(0x01)
253/* What was 0x02? */
254#define DW_FORM_block2 UINT16_C(0x03)
255#define DW_FORM_block4 UINT16_C(0x04)
256#define DW_FORM_data2 UINT16_C(0x05)
257#define DW_FORM_data4 UINT16_C(0x06)
258#define DW_FORM_data8 UINT16_C(0x07)
259#define DW_FORM_string UINT16_C(0x08)
260#define DW_FORM_block UINT16_C(0x09)
261#define DW_FORM_block1 UINT16_C(0x0a)
262#define DW_FORM_data1 UINT16_C(0x0b)
263#define DW_FORM_flag UINT16_C(0x0c)
264#define DW_FORM_sdata UINT16_C(0x0d)
265#define DW_FORM_strp UINT16_C(0x0e)
266#define DW_FORM_udata UINT16_C(0x0f)
267#define DW_FORM_ref_addr UINT16_C(0x10)
268#define DW_FORM_ref1 UINT16_C(0x11)
269#define DW_FORM_ref2 UINT16_C(0x12)
270#define DW_FORM_ref4 UINT16_C(0x13)
271#define DW_FORM_ref8 UINT16_C(0x14)
272#define DW_FORM_ref_udata UINT16_C(0x15)
273#define DW_FORM_indirect UINT16_C(0x16)
274#define DW_FORM_sec_offset UINT16_C(0x17)
275#define DW_FORM_exprloc UINT16_C(0x18)
276#define DW_FORM_flag_present UINT16_C(0x19)
277#define DW_FORM_ref_sig8 UINT16_C(0x20)
278/** @} */
279
280/** @name Address classes.
281 * @{ */
282#define DW_ADDR_none UINT8_C(0)
283#define DW_ADDR_i386_near16 UINT8_C(1)
284#define DW_ADDR_i386_far16 UINT8_C(2)
285#define DW_ADDR_i386_huge16 UINT8_C(3)
286#define DW_ADDR_i386_near32 UINT8_C(4)
287#define DW_ADDR_i386_far32 UINT8_C(5)
288/** @} */
289
290
291/** @name Location Expression Opcodes
292 * @{ */
293#define DW_OP_addr UINT8_C(0x03) /**< 1 operand, a constant address (size target specific). */
294#define DW_OP_deref UINT8_C(0x06) /**< 0 operands. */
295#define DW_OP_const1u UINT8_C(0x08) /**< 1 operand, a 1-byte constant. */
296#define DW_OP_const1s UINT8_C(0x09) /**< 1 operand, a 1-byte constant. */
297#define DW_OP_const2u UINT8_C(0x0a) /**< 1 operand, a 2-byte constant. */
298#define DW_OP_const2s UINT8_C(0x0b) /**< 1 operand, a 2-byte constant. */
299#define DW_OP_const4u UINT8_C(0x0c) /**< 1 operand, a 4-byte constant. */
300#define DW_OP_const4s UINT8_C(0x0d) /**< 1 operand, a 4-byte constant. */
301#define DW_OP_const8u UINT8_C(0x0e) /**< 1 operand, a 8-byte constant. */
302#define DW_OP_const8s UINT8_C(0x0f) /**< 1 operand, a 8-byte constant. */
303#define DW_OP_constu UINT8_C(0x10) /**< 1 operand, a ULEB128 constant. */
304#define DW_OP_consts UINT8_C(0x11) /**< 1 operand, a SLEB128 constant. */
305#define DW_OP_dup UINT8_C(0x12) /**< 0 operands. */
306#define DW_OP_drop UINT8_C(0x13) /**< 0 operands. */
307#define DW_OP_over UINT8_C(0x14) /**< 0 operands. */
308#define DW_OP_pick UINT8_C(0x15) /**< 1 operands, a 1-byte stack index. */
309#define DW_OP_swap UINT8_C(0x16) /**< 0 operands. */
310#define DW_OP_rot UINT8_C(0x17) /**< 0 operands. */
311#define DW_OP_xderef UINT8_C(0x18) /**< 0 operands. */
312#define DW_OP_abs UINT8_C(0x19) /**< 0 operands. */
313#define DW_OP_and UINT8_C(0x1a) /**< 0 operands. */
314#define DW_OP_div UINT8_C(0x1b) /**< 0 operands. */
315#define DW_OP_minus UINT8_C(0x1c) /**< 0 operands. */
316#define DW_OP_mod UINT8_C(0x1d) /**< 0 operands. */
317#define DW_OP_mul UINT8_C(0x1e) /**< 0 operands. */
318#define DW_OP_neg UINT8_C(0x1f) /**< 0 operands. */
319#define DW_OP_not UINT8_C(0x20) /**< 0 operands. */
320#define DW_OP_or UINT8_C(0x21) /**< 0 operands. */
321#define DW_OP_plus UINT8_C(0x22) /**< 0 operands. */
322#define DW_OP_plus_uconst UINT8_C(0x23) /**< 1 operands, a ULEB128 addend. */
323#define DW_OP_shl UINT8_C(0x24) /**< 0 operands. */
324#define DW_OP_shr UINT8_C(0x25) /**< 0 operands. */
325#define DW_OP_shra UINT8_C(0x26) /**< 0 operands. */
326#define DW_OP_xor UINT8_C(0x27) /**< 0 operands. */
327#define DW_OP_skip UINT8_C(0x2f) /**< 1 signed 2-byte constant. */
328#define DW_OP_bra UINT8_C(0x28) /**< 1 signed 2-byte constant. */
329#define DW_OP_eq UINT8_C(0x29) /**< 0 operands. */
330#define DW_OP_ge UINT8_C(0x2a) /**< 0 operands. */
331#define DW_OP_gt UINT8_C(0x2b) /**< 0 operands. */
332#define DW_OP_le UINT8_C(0x2c) /**< 0 operands. */
333#define DW_OP_lt UINT8_C(0x2d) /**< 0 operands. */
334#define DW_OP_ne UINT8_C(0x2e) /**< 0 operands. */
335#define DW_OP_lit0 UINT8_C(0x30) /**< 0 operands - literals 0..31 */
336#define DW_OP_lit31 UINT8_C(0x4f) /**< last litteral. */
337#define DW_OP_reg0 UINT8_C(0x50) /**< 0 operands - reg 0..31. */
338#define DW_OP_reg31 UINT8_C(0x6f) /**< last register. */
339#define DW_OP_breg0 UINT8_C(0x70) /**< 1 operand, a SLEB128 offset. */
340#define DW_OP_breg31 UINT8_C(0x8f) /**< last branch register. */
341#define DW_OP_regx UINT8_C(0x90) /**< 1 operand, a ULEB128 register. */
342#define DW_OP_fbreg UINT8_C(0x91) /**< 1 operand, a SLEB128 offset. */
343#define DW_OP_bregx UINT8_C(0x92) /**< 2 operands, a ULEB128 register followed by a SLEB128 offset. */
344#define DW_OP_piece UINT8_C(0x93) /**< 1 operand, a ULEB128 size of piece addressed. */
345#define DW_OP_deref_size UINT8_C(0x94) /**< 1 operand, a 1-byte size of data retrieved. */
346#define DW_OP_xderef_size UINT8_C(0x95) /**< 1 operand, a 1-byte size of data retrieved. */
347#define DW_OP_nop UINT8_C(0x96) /**< 0 operands. */
348#define DW_OP_lo_user UINT8_C(0xe0) /**< First user opcode */
349#define DW_OP_hi_user UINT8_C(0xff) /**< Last user opcode. */
350/** @} */
351
352
353/*******************************************************************************
354* Structures and Typedefs *
355*******************************************************************************/
356/** Pointer to a DWARF section reader. */
357typedef struct RTDWARFCURSOR *PRTDWARFCURSOR;
358/** Pointer to an attribute descriptor. */
359typedef struct RTDWARFATTRDESC const *PCRTDWARFATTRDESC;
360/** Pointer to a DIE. */
361typedef struct RTDWARFDIE *PRTDWARFDIE;
362/** Pointer to a const DIE. */
363typedef struct RTDWARFDIE const *PCRTDWARFDIE;
364
365/**
366 * DWARF sections.
367 */
368typedef enum krtDbgModDwarfSect
369{
370 krtDbgModDwarfSect_abbrev = 0,
371 krtDbgModDwarfSect_aranges,
372 krtDbgModDwarfSect_frame,
373 krtDbgModDwarfSect_info,
374 krtDbgModDwarfSect_inlined,
375 krtDbgModDwarfSect_line,
376 krtDbgModDwarfSect_loc,
377 krtDbgModDwarfSect_macinfo,
378 krtDbgModDwarfSect_pubnames,
379 krtDbgModDwarfSect_pubtypes,
380 krtDbgModDwarfSect_ranges,
381 krtDbgModDwarfSect_str,
382 krtDbgModDwarfSect_types,
383 /** End of valid parts (exclusive). */
384 krtDbgModDwarfSect_End
385} krtDbgModDwarfSect;
386
387/**
388 * Abbreviation cache entry.
389 */
390typedef struct RTDWARFABBREV
391{
392 /** Whether there are children or not. */
393 bool fChildren;
394 /** The tag. */
395 uint16_t uTag;
396 /** Offset into the abbrev section of the specification pairs. */
397 uint32_t offSpec;
398 /** The abbreviation table offset this is entry is valid for.
399 * UINT32_MAX if not valid. */
400 uint32_t offAbbrev;
401} RTDWARFABBREV;
402/** Pointer to an abbreviation cache entry. */
403typedef RTDWARFABBREV *PRTDWARFABBREV;
404/** Pointer to a const abbreviation cache entry. */
405typedef RTDWARFABBREV const *PCRTDWARFABBREV;
406
407/**
408 * Structure for gathering segment info.
409 */
410typedef struct RTDBGDWARFSEG
411{
412 /** The highest offset in the segment. */
413 uint64_t offHighest;
414 /** Calculated base address. */
415 uint64_t uBaseAddr;
416 /** Estimated The segment size. */
417 uint64_t cbSegment;
418 /** Segment number (RTLDRSEG::Sel16bit). */
419 RTSEL uSegment;
420} RTDBGDWARFSEG;
421/** Pointer to segment info. */
422typedef RTDBGDWARFSEG *PRTDBGDWARFSEG;
423
424
425/**
426 * The instance data of the DWARF reader.
427 */
428typedef struct RTDBGMODDWARF
429{
430 /** The debug container containing doing the real work. */
431 RTDBGMOD hCnt;
432 /** The image module (no reference). */
433 PRTDBGMODINT pImgMod;
434 /** The debug info module (no reference). */
435 PRTDBGMODINT pDbgInfoMod;
436 /** Nested image module (with reference ofc). */
437 PRTDBGMODINT pNestedMod;
438
439 /** DWARF debug info sections. */
440 struct
441 {
442 /** The file offset of the part. */
443 RTFOFF offFile;
444 /** The size of the part. */
445 size_t cb;
446 /** The memory mapping of the part. */
447 void const *pv;
448 /** Set if present. */
449 bool fPresent;
450 /** The debug info ordinal number in the image file. */
451 uint32_t iDbgInfo;
452 } aSections[krtDbgModDwarfSect_End];
453
454 /** The offset into the abbreviation section of the current cache. */
455 uint32_t offCachedAbbrev;
456 /** The number of cached abbreviations we've allocated space for. */
457 uint32_t cCachedAbbrevsAlloced;
458 /** Array of cached abbreviations, indexed by code. */
459 PRTDWARFABBREV paCachedAbbrevs;
460 /** Used by rtDwarfAbbrev_Lookup when the result is uncachable. */
461 RTDWARFABBREV LookupAbbrev;
462
463 /** The list of compilation units (RTDWARFDIE). */
464 RTLISTANCHOR CompileUnitList;
465
466 /** Set if we have to use link addresses because the module does not have
467 * fixups (mach_kernel). */
468 bool fUseLinkAddress;
469 /** This is set to -1 if we're doing everything in one pass.
470 * Otherwise it's 1 or 2:
471 * - In pass 1, we collect segment info.
472 * - In pass 2, we add debug info to the container.
473 * The two pass parsing is necessary for watcom generated symbol files as
474 * these contains no information about the code and data segments in the
475 * image. So we have to figure out some approximate stuff based on the
476 * segments and offsets we encounter in the debug info. */
477 int8_t iWatcomPass;
478 /** Segment index hint. */
479 uint16_t iSegHint;
480 /** The number of segments in paSegs.
481 * (During segment copying, this is abused to count useful segments.) */
482 uint32_t cSegs;
483 /** Pointer to segments if iWatcomPass isn't -1. */
484 PRTDBGDWARFSEG paSegs;
485#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
486 /** DIE allocators. */
487 struct
488 {
489 RTMEMCACHE hMemCache;
490 uint32_t cbMax;
491 } aDieAllocators[2];
492#endif
493} RTDBGMODDWARF;
494/** Pointer to instance data of the DWARF reader. */
495typedef RTDBGMODDWARF *PRTDBGMODDWARF;
496
497/**
498 * DWARF cursor for reading byte data.
499 */
500typedef struct RTDWARFCURSOR
501{
502 /** The current position. */
503 uint8_t const *pb;
504 /** The number of bytes left to read. */
505 size_t cbLeft;
506 /** The number of bytes left to read in the current unit. */
507 size_t cbUnitLeft;
508 /** The DWARF debug info reader instance. */
509 PRTDBGMODDWARF pDwarfMod;
510 /** Set if this is 64-bit DWARF, clear if 32-bit. */
511 bool f64bitDwarf;
512 /** Set if the format endian is native, clear if endian needs to be
513 * inverted. */
514 bool fNativEndian;
515 /** The size of a native address. */
516 uint8_t cbNativeAddr;
517 /** The cursor status code. This is VINF_SUCCESS until some error
518 * occurs. */
519 int rc;
520 /** The start of the area covered by the cursor.
521 * Used for repositioning the cursor relative to the start of a section. */
522 uint8_t const *pbStart;
523 /** The section. */
524 krtDbgModDwarfSect enmSect;
525} RTDWARFCURSOR;
526
527
528/**
529 * DWARF line number program state.
530 */
531typedef struct RTDWARFLINESTATE
532{
533 /** Virtual Line Number Machine Registers. */
534 struct
535 {
536 uint64_t uAddress;
537 uint64_t idxOp;
538 uint32_t iFile;
539 uint32_t uLine;
540 uint32_t uColumn;
541 bool fIsStatement;
542 bool fBasicBlock;
543 bool fEndSequence;
544 bool fPrologueEnd;
545 bool fEpilogueBegin;
546 uint32_t uIsa;
547 uint32_t uDiscriminator;
548 RTSEL uSegment;
549 } Regs;
550 /** @} */
551
552 /** Header. */
553 struct
554 {
555 uint32_t uVer;
556 uint64_t offFirstOpcode;
557 uint8_t cbMinInstr;
558 uint8_t cMaxOpsPerInstr;
559 uint8_t u8DefIsStmt;
560 int8_t s8LineBase;
561 uint8_t u8LineRange;
562 uint8_t u8OpcodeBase;
563 uint8_t const *pacStdOperands;
564 } Hdr;
565
566 /** @name Include Path Table (0-based)
567 * @{ */
568 const char **papszIncPaths;
569 uint32_t cIncPaths;
570 /** @} */
571
572 /** @name File Name Table (0-based, dummy zero entry)
573 * @{ */
574 char **papszFileNames;
575 uint32_t cFileNames;
576 /** @} */
577
578 /** The DWARF debug info reader instance. */
579 PRTDBGMODDWARF pDwarfMod;
580} RTDWARFLINESTATE;
581/** Pointer to a DWARF line number program state. */
582typedef RTDWARFLINESTATE *PRTDWARFLINESTATE;
583
584
585/**
586 * Decodes an attribute and stores it in the specified DIE member field.
587 *
588 * @returns IPRT status code.
589 * @param pDie Pointer to the DIE structure.
590 * @param pbMember Pointer to the first byte in the member.
591 * @param pDesc The attribute descriptor.
592 * @param uForm The data form.
593 * @param pDataCursor The cursor to read data from.
594 */
595typedef DECLCALLBACK(int) FNRTDWARFATTRDECODER(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
596 uint32_t uForm, PRTDWARFCURSOR pCursor);
597/** Pointer to an attribute decoder callback. */
598typedef FNRTDWARFATTRDECODER *PFNRTDWARFATTRDECODER;
599
600/**
601 * Attribute descriptor.
602 */
603typedef struct RTDWARFATTRDESC
604{
605 /** The attribute. */
606 uint16_t uAttr;
607 /** The data member offset. */
608 uint16_t off;
609 /** The data member size and initialization method. */
610 uint8_t cbInit;
611 uint8_t bPadding[3]; /**< Alignment padding. */
612 /** The decoder function. */
613 PFNRTDWARFATTRDECODER pfnDecoder;
614} RTDWARFATTRDESC;
615
616/** Define a attribute entry. */
617#define ATTR_ENTRY(a_uAttr, a_Struct, a_Member, a_Init, a_pfnDecoder) \
618 { \
619 a_uAttr, \
620 (uint16_t)RT_OFFSETOF(a_Struct, a_Member), \
621 a_Init | ((uint8_t)RT_SIZEOFMEMB(a_Struct, a_Member) & ATTR_SIZE_MASK), \
622 { 0, 0, 0 }, \
623 a_pfnDecoder\
624 }
625
626/** @name Attribute size and init methods.
627 * @{ */
628#define ATTR_INIT_ZERO UINT8_C(0x00)
629#define ATTR_INIT_FFFS UINT8_C(0x80)
630#define ATTR_INIT_MASK UINT8_C(0x80)
631#define ATTR_SIZE_MASK UINT8_C(0x3f)
632#define ATTR_GET_SIZE(a_pAttrDesc) ((a_pAttrDesc)->cbInit & ATTR_SIZE_MASK)
633/** @} */
634
635
636/**
637 * DIE descriptor.
638 */
639typedef struct RTDWARFDIEDESC
640{
641 /** The size of the DIE. */
642 size_t cbDie;
643 /** The number of attributes. */
644 size_t cAttributes;
645 /** The */
646 PCRTDWARFATTRDESC paAttributes;
647} RTDWARFDIEDESC;
648typedef struct RTDWARFDIEDESC const *PCRTDWARFDIEDESC;
649/** DIE descriptor initializer. */
650#define DIE_DESC_INIT(a_Type, a_aAttrs) { sizeof(a_Type), RT_ELEMENTS(a_aAttrs), &a_aAttrs[0] }
651
652
653/**
654 * DIE core structure, all inherits (starts with) this.
655 */
656typedef struct RTDWARFDIE
657{
658 /** Pointer to the parent node. NULL if root unit. */
659 struct RTDWARFDIE *pParent;
660 /** Our node in the sibling list. */
661 RTLISTNODE SiblingNode;
662 /** List of children. */
663 RTLISTNODE ChildList;
664 /** The number of attributes successfully decoded. */
665 uint8_t cDecodedAttrs;
666 /** The number of unknown or otherwise unhandled attributes. */
667 uint8_t cUnhandledAttrs;
668#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
669 /** The allocator index. */
670 uint8_t iAllocator;
671#endif
672 /** The die tag, indicating which union structure to use. */
673 uint16_t uTag;
674 /** Offset of the abbreviation specification (within debug_abbrev). */
675 uint32_t offSpec;
676} RTDWARFDIE;
677
678
679/**
680 * DWARF address structure.
681 */
682typedef struct RTDWARFADDR
683{
684 /** The address. */
685 uint64_t uAddress;
686} RTDWARFADDR;
687typedef RTDWARFADDR *PRTDWARFADDR;
688typedef RTDWARFADDR const *PCRTDWARFADDR;
689
690
691/**
692 * DWARF address range.
693 */
694typedef struct RTDWARFADDRRANGE
695{
696 uint64_t uLowAddress;
697 uint64_t uHighAddress;
698 uint8_t const *pbRanges; /* ?? */
699 uint8_t cAttrs : 2;
700 uint8_t fHaveLowAddress : 1;
701 uint8_t fHaveHighAddress : 1;
702 uint8_t fHaveHighIsAddress : 1;
703 uint8_t fHaveRanges : 1;
704} RTDWARFADDRRANGE;
705typedef RTDWARFADDRRANGE *PRTDWARFADDRRANGE;
706typedef RTDWARFADDRRANGE const *PCRTDWARFADDRRANGE;
707
708/** What a RTDWARFREF is relative to. */
709typedef enum krtDwarfRef
710{
711 krtDwarfRef_NotSet,
712 krtDwarfRef_LineSection,
713 krtDwarfRef_LocSection,
714 krtDwarfRef_RangesSection,
715 krtDwarfRef_InfoSection,
716 krtDwarfRef_SameUnit,
717 krtDwarfRef_TypeId64
718} krtDwarfRef;
719
720/**
721 * DWARF reference.
722 */
723typedef struct RTDWARFREF
724{
725 /** The offset. */
726 uint64_t off;
727 /** What the offset is relative to. */
728 krtDwarfRef enmWrt;
729} RTDWARFREF;
730typedef RTDWARFREF *PRTDWARFREF;
731typedef RTDWARFREF const *PCRTDWARFREF;
732
733
734/**
735 * DWARF Location state.
736 */
737typedef struct RTDWARFLOCST
738{
739 /** The input cursor. */
740 RTDWARFCURSOR Cursor;
741 /** Points to the current top of the stack. Initial value -1. */
742 int32_t iTop;
743 /** The value stack. */
744 uint64_t auStack[64];
745} RTDWARFLOCST;
746/** Pointer to location state. */
747typedef RTDWARFLOCST *PRTDWARFLOCST;
748
749
750
751/*******************************************************************************
752* Internal Functions *
753*******************************************************************************/
754static FNRTDWARFATTRDECODER rtDwarfDecode_Address;
755static FNRTDWARFATTRDECODER rtDwarfDecode_Bool;
756static FNRTDWARFATTRDECODER rtDwarfDecode_LowHighPc;
757static FNRTDWARFATTRDECODER rtDwarfDecode_Ranges;
758static FNRTDWARFATTRDECODER rtDwarfDecode_Reference;
759static FNRTDWARFATTRDECODER rtDwarfDecode_SectOff;
760static FNRTDWARFATTRDECODER rtDwarfDecode_String;
761static FNRTDWARFATTRDECODER rtDwarfDecode_UnsignedInt;
762static FNRTDWARFATTRDECODER rtDwarfDecode_SegmentLoc;
763
764
765/*******************************************************************************
766* Global Variables *
767*******************************************************************************/
768/** RTDWARFDIE description. */
769static const RTDWARFDIEDESC g_CoreDieDesc = { sizeof(RTDWARFDIE), 0, NULL };
770
771
772/**
773 * DW_TAG_compile_unit & DW_TAG_partial_unit.
774 */
775typedef struct RTDWARFDIECOMPILEUNIT
776{
777 /** The DIE core structure. */
778 RTDWARFDIE Core;
779 /** The unit name. */
780 const char *pszName;
781 /** The address range of the code belonging to this unit. */
782 RTDWARFADDRRANGE PcRange;
783 /** The language name. */
784 uint16_t uLanguage;
785 /** The identifier case. */
786 uint8_t uIdentifierCase;
787 /** String are UTF-8 encoded. If not set, the encoding is
788 * unknown. */
789 bool fUseUtf8;
790 /** The unit contains main() or equivalent. */
791 bool fMainFunction;
792 /** The line numbers for this unit. */
793 RTDWARFREF StmtListRef;
794 /** The macro information for this unit. */
795 RTDWARFREF MacroInfoRef;
796 /** Reference to the base types. */
797 RTDWARFREF BaseTypesRef;
798 /** Working directory for the unit. */
799 const char *pszCurDir;
800 /** The name of the compiler or whatever that produced this unit. */
801 const char *pszProducer;
802
803 /** @name From the unit header.
804 * @{ */
805 /** The offset into debug_info of this unit (for references). */
806 uint64_t offUnit;
807 /** The length of this unit. */
808 uint64_t cbUnit;
809 /** The offset into debug_abbrev of the abbreviation for this unit. */
810 uint64_t offAbbrev;
811 /** The native address size. */
812 uint8_t cbNativeAddr;
813 /** The DWARF version. */
814 uint8_t uDwarfVer;
815 /** @} */
816} RTDWARFDIECOMPILEUNIT;
817typedef RTDWARFDIECOMPILEUNIT *PRTDWARFDIECOMPILEUNIT;
818
819
820/** RTDWARFDIECOMPILEUNIT attributes. */
821static const RTDWARFATTRDESC g_aCompileUnitAttrs[] =
822{
823 ATTR_ENTRY(DW_AT_name, RTDWARFDIECOMPILEUNIT, pszName, ATTR_INIT_ZERO, rtDwarfDecode_String),
824 ATTR_ENTRY(DW_AT_low_pc, RTDWARFDIECOMPILEUNIT, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_LowHighPc),
825 ATTR_ENTRY(DW_AT_high_pc, RTDWARFDIECOMPILEUNIT, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_LowHighPc),
826 ATTR_ENTRY(DW_AT_ranges, RTDWARFDIECOMPILEUNIT, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_Ranges),
827 ATTR_ENTRY(DW_AT_language, RTDWARFDIECOMPILEUNIT, uLanguage, ATTR_INIT_ZERO, rtDwarfDecode_UnsignedInt),
828 ATTR_ENTRY(DW_AT_macro_info, RTDWARFDIECOMPILEUNIT, MacroInfoRef, ATTR_INIT_ZERO, rtDwarfDecode_SectOff),
829 ATTR_ENTRY(DW_AT_stmt_list, RTDWARFDIECOMPILEUNIT, StmtListRef, ATTR_INIT_ZERO, rtDwarfDecode_SectOff),
830 ATTR_ENTRY(DW_AT_comp_dir, RTDWARFDIECOMPILEUNIT, pszCurDir, ATTR_INIT_ZERO, rtDwarfDecode_String),
831 ATTR_ENTRY(DW_AT_producer, RTDWARFDIECOMPILEUNIT, pszProducer, ATTR_INIT_ZERO, rtDwarfDecode_String),
832 ATTR_ENTRY(DW_AT_identifier_case, RTDWARFDIECOMPILEUNIT, uIdentifierCase,ATTR_INIT_ZERO, rtDwarfDecode_UnsignedInt),
833 ATTR_ENTRY(DW_AT_base_types, RTDWARFDIECOMPILEUNIT, BaseTypesRef, ATTR_INIT_ZERO, rtDwarfDecode_Reference),
834 ATTR_ENTRY(DW_AT_use_UTF8, RTDWARFDIECOMPILEUNIT, fUseUtf8, ATTR_INIT_ZERO, rtDwarfDecode_Bool),
835 ATTR_ENTRY(DW_AT_main_subprogram, RTDWARFDIECOMPILEUNIT, fMainFunction, ATTR_INIT_ZERO, rtDwarfDecode_Bool)
836};
837
838/** RTDWARFDIECOMPILEUNIT description. */
839static const RTDWARFDIEDESC g_CompileUnitDesc = DIE_DESC_INIT(RTDWARFDIECOMPILEUNIT, g_aCompileUnitAttrs);
840
841
842/**
843 * DW_TAG_subprogram.
844 */
845typedef struct RTDWARFDIESUBPROGRAM
846{
847 /** The DIE core structure. */
848 RTDWARFDIE Core;
849 /** The name. */
850 const char *pszName;
851 /** The linkage name. */
852 const char *pszLinkageName;
853 /** The address range of the code belonging to this unit. */
854 RTDWARFADDRRANGE PcRange;
855 /** The first instruction in the function. */
856 RTDWARFADDR EntryPc;
857 /** Segment number (watcom). */
858 RTSEL uSegment;
859 /** Reference to the specification. */
860 RTDWARFREF SpecRef;
861} RTDWARFDIESUBPROGRAM;
862/** Pointer to a DW_TAG_subprogram DIE. */
863typedef RTDWARFDIESUBPROGRAM *PRTDWARFDIESUBPROGRAM;
864/** Pointer to a const DW_TAG_subprogram DIE. */
865typedef RTDWARFDIESUBPROGRAM const *PCRTDWARFDIESUBPROGRAM;
866
867
868/** RTDWARFDIESUBPROGRAM attributes. */
869static const RTDWARFATTRDESC g_aSubProgramAttrs[] =
870{
871 ATTR_ENTRY(DW_AT_name, RTDWARFDIESUBPROGRAM, pszName, ATTR_INIT_ZERO, rtDwarfDecode_String),
872 ATTR_ENTRY(DW_AT_linkage_name, RTDWARFDIESUBPROGRAM, pszLinkageName, ATTR_INIT_ZERO, rtDwarfDecode_String),
873 ATTR_ENTRY(DW_AT_MIPS_linkage_name, RTDWARFDIESUBPROGRAM, pszLinkageName, ATTR_INIT_ZERO, rtDwarfDecode_String),
874 ATTR_ENTRY(DW_AT_low_pc, RTDWARFDIESUBPROGRAM, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_LowHighPc),
875 ATTR_ENTRY(DW_AT_high_pc, RTDWARFDIESUBPROGRAM, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_LowHighPc),
876 ATTR_ENTRY(DW_AT_ranges, RTDWARFDIESUBPROGRAM, PcRange, ATTR_INIT_ZERO, rtDwarfDecode_Ranges),
877 ATTR_ENTRY(DW_AT_entry_pc, RTDWARFDIESUBPROGRAM, EntryPc, ATTR_INIT_ZERO, rtDwarfDecode_Address),
878 ATTR_ENTRY(DW_AT_segment, RTDWARFDIESUBPROGRAM, uSegment, ATTR_INIT_ZERO, rtDwarfDecode_SegmentLoc),
879 ATTR_ENTRY(DW_AT_specification, RTDWARFDIESUBPROGRAM, SpecRef, ATTR_INIT_ZERO, rtDwarfDecode_Reference)
880};
881
882/** RTDWARFDIESUBPROGRAM description. */
883static const RTDWARFDIEDESC g_SubProgramDesc = DIE_DESC_INIT(RTDWARFDIESUBPROGRAM, g_aSubProgramAttrs);
884
885
886/** RTDWARFDIESUBPROGRAM attributes for the specification hack. */
887static const RTDWARFATTRDESC g_aSubProgramSpecHackAttrs[] =
888{
889 ATTR_ENTRY(DW_AT_name, RTDWARFDIESUBPROGRAM, pszName, ATTR_INIT_ZERO, rtDwarfDecode_String),
890 ATTR_ENTRY(DW_AT_linkage_name, RTDWARFDIESUBPROGRAM, pszLinkageName, ATTR_INIT_ZERO, rtDwarfDecode_String),
891 ATTR_ENTRY(DW_AT_MIPS_linkage_name, RTDWARFDIESUBPROGRAM, pszLinkageName, ATTR_INIT_ZERO, rtDwarfDecode_String),
892};
893
894/** RTDWARFDIESUBPROGRAM description for the specification hack. */
895static const RTDWARFDIEDESC g_SubProgramSpecHackDesc = DIE_DESC_INIT(RTDWARFDIESUBPROGRAM, g_aSubProgramSpecHackAttrs);
896
897
898/**
899 * DW_TAG_label.
900 */
901typedef struct RTDWARFDIELABEL
902{
903 /** The DIE core structure. */
904 RTDWARFDIE Core;
905 /** The name. */
906 const char *pszName;
907 /** The address of the first instruction. */
908 RTDWARFADDR Address;
909 /** Segment number (watcom). */
910 RTSEL uSegment;
911 /** Externally visible? */
912 bool fExternal;
913} RTDWARFDIELABEL;
914/** Pointer to a DW_TAG_label DIE. */
915typedef RTDWARFDIELABEL *PRTDWARFDIELABEL;
916/** Pointer to a const DW_TAG_label DIE. */
917typedef RTDWARFDIELABEL const *PCRTDWARFDIELABEL;
918
919
920/** RTDWARFDIESUBPROGRAM attributes. */
921static const RTDWARFATTRDESC g_aLabelAttrs[] =
922{
923 ATTR_ENTRY(DW_AT_name, RTDWARFDIELABEL, pszName, ATTR_INIT_ZERO, rtDwarfDecode_String),
924 ATTR_ENTRY(DW_AT_low_pc, RTDWARFDIELABEL, Address, ATTR_INIT_ZERO, rtDwarfDecode_Address),
925 ATTR_ENTRY(DW_AT_segment, RTDWARFDIELABEL, uSegment, ATTR_INIT_ZERO, rtDwarfDecode_SegmentLoc),
926 ATTR_ENTRY(DW_AT_external, RTDWARFDIELABEL, fExternal, ATTR_INIT_ZERO, rtDwarfDecode_Bool)
927};
928
929/** RTDWARFDIESUBPROGRAM description. */
930static const RTDWARFDIEDESC g_LabelDesc = DIE_DESC_INIT(RTDWARFDIELABEL, g_aLabelAttrs);
931
932
933/**
934 * Tag names and descriptors.
935 */
936static const struct RTDWARFTAGDESC
937{
938 /** The tag value. */
939 uint16_t uTag;
940 /** The tag name as string. */
941 const char *pszName;
942 /** The DIE descriptor to use. */
943 PCRTDWARFDIEDESC pDesc;
944} g_aTagDescs[] =
945{
946#define TAGDESC(a_Name, a_pDesc) { DW_ ## a_Name, #a_Name, a_pDesc }
947#define TAGDESC_EMPTY() { 0, NULL, NULL }
948#define TAGDESC_CORE(a_Name) TAGDESC(a_Name, &g_CoreDieDesc)
949 TAGDESC_EMPTY(), /* 0x00 */
950 TAGDESC_CORE(TAG_array_type),
951 TAGDESC_CORE(TAG_class_type),
952 TAGDESC_CORE(TAG_entry_point),
953 TAGDESC_CORE(TAG_enumeration_type), /* 0x04 */
954 TAGDESC_CORE(TAG_formal_parameter),
955 TAGDESC_EMPTY(),
956 TAGDESC_EMPTY(),
957 TAGDESC_CORE(TAG_imported_declaration), /* 0x08 */
958 TAGDESC_EMPTY(),
959 TAGDESC(TAG_label, &g_LabelDesc),
960 TAGDESC_CORE(TAG_lexical_block),
961 TAGDESC_EMPTY(), /* 0x0c */
962 TAGDESC_CORE(TAG_member),
963 TAGDESC_EMPTY(),
964 TAGDESC_CORE(TAG_pointer_type),
965 TAGDESC_CORE(TAG_reference_type), /* 0x10 */
966 TAGDESC_CORE(TAG_compile_unit),
967 TAGDESC_CORE(TAG_string_type),
968 TAGDESC_CORE(TAG_structure_type),
969 TAGDESC_EMPTY(), /* 0x14 */
970 TAGDESC_CORE(TAG_subroutine_type),
971 TAGDESC_CORE(TAG_typedef),
972 TAGDESC_CORE(TAG_union_type),
973 TAGDESC_CORE(TAG_unspecified_parameters), /* 0x18 */
974 TAGDESC_CORE(TAG_variant),
975 TAGDESC_CORE(TAG_common_block),
976 TAGDESC_CORE(TAG_common_inclusion),
977 TAGDESC_CORE(TAG_inheritance), /* 0x1c */
978 TAGDESC_CORE(TAG_inlined_subroutine),
979 TAGDESC_CORE(TAG_module),
980 TAGDESC_CORE(TAG_ptr_to_member_type),
981 TAGDESC_CORE(TAG_set_type), /* 0x20 */
982 TAGDESC_CORE(TAG_subrange_type),
983 TAGDESC_CORE(TAG_with_stmt),
984 TAGDESC_CORE(TAG_access_declaration),
985 TAGDESC_CORE(TAG_base_type), /* 0x24 */
986 TAGDESC_CORE(TAG_catch_block),
987 TAGDESC_CORE(TAG_const_type),
988 TAGDESC_CORE(TAG_constant),
989 TAGDESC_CORE(TAG_enumerator), /* 0x28 */
990 TAGDESC_CORE(TAG_file_type),
991 TAGDESC_CORE(TAG_friend),
992 TAGDESC_CORE(TAG_namelist),
993 TAGDESC_CORE(TAG_namelist_item), /* 0x2c */
994 TAGDESC_CORE(TAG_packed_type),
995 TAGDESC(TAG_subprogram, &g_SubProgramDesc),
996 TAGDESC_CORE(TAG_template_type_parameter),
997 TAGDESC_CORE(TAG_template_value_parameter), /* 0x30 */
998 TAGDESC_CORE(TAG_thrown_type),
999 TAGDESC_CORE(TAG_try_block),
1000 TAGDESC_CORE(TAG_variant_part),
1001 TAGDESC_CORE(TAG_variable), /* 0x34 */
1002 TAGDESC_CORE(TAG_volatile_type),
1003 TAGDESC_CORE(TAG_dwarf_procedure),
1004 TAGDESC_CORE(TAG_restrict_type),
1005 TAGDESC_CORE(TAG_interface_type), /* 0x38 */
1006 TAGDESC_CORE(TAG_namespace),
1007 TAGDESC_CORE(TAG_imported_module),
1008 TAGDESC_CORE(TAG_unspecified_type),
1009 TAGDESC_CORE(TAG_partial_unit), /* 0x3c */
1010 TAGDESC_CORE(TAG_imported_unit),
1011 TAGDESC_EMPTY(),
1012 TAGDESC_CORE(TAG_condition),
1013 TAGDESC_CORE(TAG_shared_type), /* 0x40 */
1014 TAGDESC_CORE(TAG_type_unit),
1015 TAGDESC_CORE(TAG_rvalue_reference_type),
1016 TAGDESC_CORE(TAG_template_alias)
1017#undef TAGDESC
1018#undef TAGDESC_EMPTY
1019#undef TAGDESC_CORE
1020};
1021
1022
1023/*******************************************************************************
1024* Internal Functions *
1025*******************************************************************************/
1026static int rtDwarfInfo_ParseDie(PRTDBGMODDWARF pThis, PRTDWARFDIE pDie, PCRTDWARFDIEDESC pDieDesc,
1027 PRTDWARFCURSOR pCursor, PCRTDWARFABBREV pAbbrev, bool fInitDie);
1028
1029
1030
1031#if defined(LOG_ENABLED) || defined(RT_STRICT)
1032
1033/**
1034 * Turns a tag value into a string for logging purposes.
1035 *
1036 * @returns String name.
1037 * @param uTag The tag.
1038 */
1039static const char *rtDwarfLog_GetTagName(uint32_t uTag)
1040{
1041 if (uTag < RT_ELEMENTS(g_aTagDescs))
1042 {
1043 const char *pszTag = g_aTagDescs[uTag].pszName;
1044 if (pszTag)
1045 return pszTag;
1046 }
1047
1048 static char s_szStatic[32];
1049 RTStrPrintf(s_szStatic, sizeof(s_szStatic),"DW_TAG_%#x", uTag);
1050 return s_szStatic;
1051}
1052
1053
1054/**
1055 * Turns an attributevalue into a string for logging purposes.
1056 *
1057 * @returns String name.
1058 * @param uAttr The attribute.
1059 */
1060static const char *rtDwarfLog_AttrName(uint32_t uAttr)
1061{
1062 switch (uAttr)
1063 {
1064 RT_CASE_RET_STR(DW_AT_sibling);
1065 RT_CASE_RET_STR(DW_AT_location);
1066 RT_CASE_RET_STR(DW_AT_name);
1067 RT_CASE_RET_STR(DW_AT_ordering);
1068 RT_CASE_RET_STR(DW_AT_byte_size);
1069 RT_CASE_RET_STR(DW_AT_bit_offset);
1070 RT_CASE_RET_STR(DW_AT_bit_size);
1071 RT_CASE_RET_STR(DW_AT_stmt_list);
1072 RT_CASE_RET_STR(DW_AT_low_pc);
1073 RT_CASE_RET_STR(DW_AT_high_pc);
1074 RT_CASE_RET_STR(DW_AT_language);
1075 RT_CASE_RET_STR(DW_AT_discr);
1076 RT_CASE_RET_STR(DW_AT_discr_value);
1077 RT_CASE_RET_STR(DW_AT_visibility);
1078 RT_CASE_RET_STR(DW_AT_import);
1079 RT_CASE_RET_STR(DW_AT_string_length);
1080 RT_CASE_RET_STR(DW_AT_common_reference);
1081 RT_CASE_RET_STR(DW_AT_comp_dir);
1082 RT_CASE_RET_STR(DW_AT_const_value);
1083 RT_CASE_RET_STR(DW_AT_containing_type);
1084 RT_CASE_RET_STR(DW_AT_default_value);
1085 RT_CASE_RET_STR(DW_AT_inline);
1086 RT_CASE_RET_STR(DW_AT_is_optional);
1087 RT_CASE_RET_STR(DW_AT_lower_bound);
1088 RT_CASE_RET_STR(DW_AT_producer);
1089 RT_CASE_RET_STR(DW_AT_prototyped);
1090 RT_CASE_RET_STR(DW_AT_return_addr);
1091 RT_CASE_RET_STR(DW_AT_start_scope);
1092 RT_CASE_RET_STR(DW_AT_bit_stride);
1093 RT_CASE_RET_STR(DW_AT_upper_bound);
1094 RT_CASE_RET_STR(DW_AT_abstract_origin);
1095 RT_CASE_RET_STR(DW_AT_accessibility);
1096 RT_CASE_RET_STR(DW_AT_address_class);
1097 RT_CASE_RET_STR(DW_AT_artificial);
1098 RT_CASE_RET_STR(DW_AT_base_types);
1099 RT_CASE_RET_STR(DW_AT_calling_convention);
1100 RT_CASE_RET_STR(DW_AT_count);
1101 RT_CASE_RET_STR(DW_AT_data_member_location);
1102 RT_CASE_RET_STR(DW_AT_decl_column);
1103 RT_CASE_RET_STR(DW_AT_decl_file);
1104 RT_CASE_RET_STR(DW_AT_decl_line);
1105 RT_CASE_RET_STR(DW_AT_declaration);
1106 RT_CASE_RET_STR(DW_AT_discr_list);
1107 RT_CASE_RET_STR(DW_AT_encoding);
1108 RT_CASE_RET_STR(DW_AT_external);
1109 RT_CASE_RET_STR(DW_AT_frame_base);
1110 RT_CASE_RET_STR(DW_AT_friend);
1111 RT_CASE_RET_STR(DW_AT_identifier_case);
1112 RT_CASE_RET_STR(DW_AT_macro_info);
1113 RT_CASE_RET_STR(DW_AT_namelist_item);
1114 RT_CASE_RET_STR(DW_AT_priority);
1115 RT_CASE_RET_STR(DW_AT_segment);
1116 RT_CASE_RET_STR(DW_AT_specification);
1117 RT_CASE_RET_STR(DW_AT_static_link);
1118 RT_CASE_RET_STR(DW_AT_type);
1119 RT_CASE_RET_STR(DW_AT_use_location);
1120 RT_CASE_RET_STR(DW_AT_variable_parameter);
1121 RT_CASE_RET_STR(DW_AT_virtuality);
1122 RT_CASE_RET_STR(DW_AT_vtable_elem_location);
1123 RT_CASE_RET_STR(DW_AT_allocated);
1124 RT_CASE_RET_STR(DW_AT_associated);
1125 RT_CASE_RET_STR(DW_AT_data_location);
1126 RT_CASE_RET_STR(DW_AT_byte_stride);
1127 RT_CASE_RET_STR(DW_AT_entry_pc);
1128 RT_CASE_RET_STR(DW_AT_use_UTF8);
1129 RT_CASE_RET_STR(DW_AT_extension);
1130 RT_CASE_RET_STR(DW_AT_ranges);
1131 RT_CASE_RET_STR(DW_AT_trampoline);
1132 RT_CASE_RET_STR(DW_AT_call_column);
1133 RT_CASE_RET_STR(DW_AT_call_file);
1134 RT_CASE_RET_STR(DW_AT_call_line);
1135 RT_CASE_RET_STR(DW_AT_description);
1136 RT_CASE_RET_STR(DW_AT_binary_scale);
1137 RT_CASE_RET_STR(DW_AT_decimal_scale);
1138 RT_CASE_RET_STR(DW_AT_small);
1139 RT_CASE_RET_STR(DW_AT_decimal_sign);
1140 RT_CASE_RET_STR(DW_AT_digit_count);
1141 RT_CASE_RET_STR(DW_AT_picture_string);
1142 RT_CASE_RET_STR(DW_AT_mutable);
1143 RT_CASE_RET_STR(DW_AT_threads_scaled);
1144 RT_CASE_RET_STR(DW_AT_explicit);
1145 RT_CASE_RET_STR(DW_AT_object_pointer);
1146 RT_CASE_RET_STR(DW_AT_endianity);
1147 RT_CASE_RET_STR(DW_AT_elemental);
1148 RT_CASE_RET_STR(DW_AT_pure);
1149 RT_CASE_RET_STR(DW_AT_recursive);
1150 RT_CASE_RET_STR(DW_AT_signature);
1151 RT_CASE_RET_STR(DW_AT_main_subprogram);
1152 RT_CASE_RET_STR(DW_AT_data_bit_offset);
1153 RT_CASE_RET_STR(DW_AT_const_expr);
1154 RT_CASE_RET_STR(DW_AT_enum_class);
1155 RT_CASE_RET_STR(DW_AT_linkage_name);
1156 RT_CASE_RET_STR(DW_AT_MIPS_linkage_name);
1157 }
1158 static char s_szStatic[32];
1159 RTStrPrintf(s_szStatic, sizeof(s_szStatic),"DW_AT_%#x", uAttr);
1160 return s_szStatic;
1161}
1162
1163
1164/**
1165 * Turns a form value into a string for logging purposes.
1166 *
1167 * @returns String name.
1168 * @param uForm The form.
1169 */
1170static const char *rtDwarfLog_FormName(uint32_t uForm)
1171{
1172 switch (uForm)
1173 {
1174 RT_CASE_RET_STR(DW_FORM_addr);
1175 RT_CASE_RET_STR(DW_FORM_block2);
1176 RT_CASE_RET_STR(DW_FORM_block4);
1177 RT_CASE_RET_STR(DW_FORM_data2);
1178 RT_CASE_RET_STR(DW_FORM_data4);
1179 RT_CASE_RET_STR(DW_FORM_data8);
1180 RT_CASE_RET_STR(DW_FORM_string);
1181 RT_CASE_RET_STR(DW_FORM_block);
1182 RT_CASE_RET_STR(DW_FORM_block1);
1183 RT_CASE_RET_STR(DW_FORM_data1);
1184 RT_CASE_RET_STR(DW_FORM_flag);
1185 RT_CASE_RET_STR(DW_FORM_sdata);
1186 RT_CASE_RET_STR(DW_FORM_strp);
1187 RT_CASE_RET_STR(DW_FORM_udata);
1188 RT_CASE_RET_STR(DW_FORM_ref_addr);
1189 RT_CASE_RET_STR(DW_FORM_ref1);
1190 RT_CASE_RET_STR(DW_FORM_ref2);
1191 RT_CASE_RET_STR(DW_FORM_ref4);
1192 RT_CASE_RET_STR(DW_FORM_ref8);
1193 RT_CASE_RET_STR(DW_FORM_ref_udata);
1194 RT_CASE_RET_STR(DW_FORM_indirect);
1195 RT_CASE_RET_STR(DW_FORM_sec_offset);
1196 RT_CASE_RET_STR(DW_FORM_exprloc);
1197 RT_CASE_RET_STR(DW_FORM_flag_present);
1198 RT_CASE_RET_STR(DW_FORM_ref_sig8);
1199 }
1200 static char s_szStatic[32];
1201 RTStrPrintf(s_szStatic, sizeof(s_szStatic),"DW_FORM_%#x", uForm);
1202 return s_szStatic;
1203}
1204
1205#endif /* LOG_ENABLED || RT_STRICT */
1206
1207
1208
1209/** @callback_method_impl{FNRTLDRENUMSEGS} */
1210static DECLCALLBACK(int) rtDbgModDwarfScanSegmentsCallback(RTLDRMOD hLdrMod, PCRTLDRSEG pSeg, void *pvUser)
1211{
1212 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pvUser;
1213 Log(("Segment %.*s: LinkAddress=%#llx RVA=%#llx cb=%#llx\n",
1214 pSeg->cchName, pSeg->pszName, (uint64_t)pSeg->LinkAddress, (uint64_t)pSeg->RVA, pSeg->cb));
1215 NOREF(hLdrMod);
1216
1217 /* Count relevant segments. */
1218 if (pSeg->RVA != NIL_RTLDRADDR)
1219 pThis->cSegs++;
1220
1221 return VINF_SUCCESS;
1222}
1223
1224
1225/** @callback_method_impl{FNRTLDRENUMSEGS} */
1226static DECLCALLBACK(int) rtDbgModDwarfAddSegmentsCallback(RTLDRMOD hLdrMod, PCRTLDRSEG pSeg, void *pvUser)
1227{
1228 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pvUser;
1229 Log(("Segment %.*s: LinkAddress=%#llx RVA=%#llx cb=%#llx cbMapped=%#llx\n",
1230 pSeg->cchName, pSeg->pszName, (uint64_t)pSeg->LinkAddress, (uint64_t)pSeg->RVA, pSeg->cb, pSeg->cbMapped));
1231 NOREF(hLdrMod);
1232 Assert(pSeg->cchName > 0);
1233 Assert(!pSeg->pszName[pSeg->cchName]);
1234
1235 /* If the segment doesn't have a mapping, just add a dummy so the indexing
1236 works out correctly (same as for the image). */
1237 if (pSeg->RVA == NIL_RTLDRADDR)
1238 return RTDbgModSegmentAdd(pThis->hCnt, 0, 0, pSeg->pszName, 0 /*fFlags*/, NULL);
1239
1240 /* The link address is 0 for all segments in a relocatable ELF image. */
1241 RTLDRADDR cb = RT_MAX(pSeg->cb, pSeg->cbMapped);
1242 return RTDbgModSegmentAdd(pThis->hCnt, pSeg->RVA, cb, pSeg->pszName, 0 /*fFlags*/, NULL);
1243}
1244
1245
1246/**
1247 * Calls pfnSegmentAdd for each segment in the executable image.
1248 *
1249 * @returns IPRT status code.
1250 * @param pThis The DWARF instance.
1251 */
1252static int rtDbgModDwarfAddSegmentsFromImage(PRTDBGMODDWARF pThis)
1253{
1254 AssertReturn(pThis->pImgMod && pThis->pImgMod->pImgVt, VERR_INTERNAL_ERROR_2);
1255 Assert(!pThis->cSegs);
1256 int rc = pThis->pImgMod->pImgVt->pfnEnumSegments(pThis->pImgMod, rtDbgModDwarfScanSegmentsCallback, pThis);
1257 if (RT_SUCCESS(rc))
1258 {
1259 if (pThis->cSegs == 0)
1260 pThis->iWatcomPass = 1;
1261 else
1262 {
1263 pThis->cSegs = 0;
1264 pThis->iWatcomPass = -1;
1265 rc = pThis->pImgMod->pImgVt->pfnEnumSegments(pThis->pImgMod, rtDbgModDwarfAddSegmentsCallback, pThis);
1266 }
1267 }
1268
1269 return rc;
1270}
1271
1272
1273/**
1274 * Looks up a segment.
1275 *
1276 * @returns Pointer to the segment on success, NULL if not found.
1277 * @param pThis The DWARF instance.
1278 * @param uSeg The segment number / selector.
1279 */
1280static PRTDBGDWARFSEG rtDbgModDwarfFindSegment(PRTDBGMODDWARF pThis, RTSEL uSeg)
1281{
1282 uint32_t cSegs = pThis->cSegs;
1283 uint32_t iSeg = pThis->iSegHint;
1284 PRTDBGDWARFSEG paSegs = pThis->paSegs;
1285 if ( iSeg < cSegs
1286 && paSegs[iSeg].uSegment == uSeg)
1287 return &paSegs[iSeg];
1288
1289 for (iSeg = 0; iSeg < cSegs; iSeg++)
1290 if (uSeg == paSegs[iSeg].uSegment)
1291 {
1292 pThis->iSegHint = iSeg;
1293 return &paSegs[iSeg];
1294 }
1295
1296 AssertFailed();
1297 return NULL;
1298}
1299
1300
1301/**
1302 * Record a segment:offset during pass 1.
1303 *
1304 * @returns IPRT status code.
1305 * @param pThis The DWARF instance.
1306 * @param uSeg The segment number / selector.
1307 * @param offSeg The segment offset.
1308 */
1309static int rtDbgModDwarfRecordSegOffset(PRTDBGMODDWARF pThis, RTSEL uSeg, uint64_t offSeg)
1310{
1311 /* Look up the segment. */
1312 uint32_t cSegs = pThis->cSegs;
1313 uint32_t iSeg = pThis->iSegHint;
1314 PRTDBGDWARFSEG paSegs = pThis->paSegs;
1315 if ( iSeg >= cSegs
1316 || paSegs[iSeg].uSegment != uSeg)
1317 {
1318 for (iSeg = 0; iSeg < cSegs; iSeg++)
1319 if (uSeg <= paSegs[iSeg].uSegment)
1320 break;
1321 if ( iSeg >= cSegs
1322 || paSegs[iSeg].uSegment != uSeg)
1323 {
1324 /* Add */
1325 void *pvNew = RTMemRealloc(paSegs, (pThis->cSegs + 1) * sizeof(paSegs[0]));
1326 if (!pvNew)
1327 return VERR_NO_MEMORY;
1328 pThis->paSegs = paSegs = (PRTDBGDWARFSEG)pvNew;
1329 if (iSeg != cSegs)
1330 memmove(&paSegs[iSeg + 1], &paSegs[iSeg], (cSegs - iSeg) * sizeof(paSegs[0]));
1331 paSegs[iSeg].offHighest = offSeg;
1332 paSegs[iSeg].uBaseAddr = 0;
1333 paSegs[iSeg].cbSegment = 0;
1334 paSegs[iSeg].uSegment = uSeg;
1335 pThis->cSegs++;
1336 }
1337
1338 pThis->iSegHint = iSeg;
1339 }
1340
1341 /* Increase it's range? */
1342 if (paSegs[iSeg].offHighest < offSeg)
1343 {
1344 Log3(("rtDbgModDwarfRecordSegOffset: iSeg=%d uSeg=%#06x offSeg=%#llx\n", iSeg, uSeg, offSeg));
1345 paSegs[iSeg].offHighest = offSeg;
1346 }
1347
1348 return VINF_SUCCESS;
1349}
1350
1351
1352/**
1353 * Calls pfnSegmentAdd for each segment in the executable image.
1354 *
1355 * @returns IPRT status code.
1356 * @param pThis The DWARF instance.
1357 */
1358static int rtDbgModDwarfAddSegmentsFromPass1(PRTDBGMODDWARF pThis)
1359{
1360 AssertReturn(pThis->cSegs, VERR_DWARF_BAD_INFO);
1361 uint32_t const cSegs = pThis->cSegs;
1362 PRTDBGDWARFSEG paSegs = pThis->paSegs;
1363
1364 /*
1365 * Are the segments assigned more or less in numerical order?
1366 */
1367 if ( paSegs[0].uSegment < 16U
1368 && paSegs[cSegs - 1].uSegment - paSegs[0].uSegment + 1U <= cSegs + 16U)
1369 {
1370 /** @todo heuristics, plase. */
1371 AssertFailedReturn(VERR_DWARF_TODO);
1372
1373 }
1374 /*
1375 * Assume DOS segmentation.
1376 */
1377 else
1378 {
1379 for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
1380 paSegs[iSeg].uBaseAddr = (uint32_t)paSegs[iSeg].uSegment << 16;
1381 for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
1382 paSegs[iSeg].cbSegment = paSegs[iSeg].offHighest;
1383 }
1384
1385 /*
1386 * Add them.
1387 */
1388 for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
1389 {
1390 Log3(("rtDbgModDwarfAddSegmentsFromPass1: Seg#%u: %#010llx LB %#llx uSegment=%#x\n",
1391 iSeg, paSegs[iSeg].uBaseAddr, paSegs[iSeg].cbSegment, paSegs[iSeg].uSegment));
1392 char szName[32];
1393 RTStrPrintf(szName, sizeof(szName), "seg-%#04xh", paSegs[iSeg].uSegment);
1394 int rc = RTDbgModSegmentAdd(pThis->hCnt, paSegs[iSeg].uBaseAddr, paSegs[iSeg].cbSegment,
1395 szName, 0 /*fFlags*/, NULL);
1396 if (RT_FAILURE(rc))
1397 return rc;
1398 }
1399
1400 return VINF_SUCCESS;
1401}
1402
1403
1404/**
1405 * Loads a DWARF section from the image file.
1406 *
1407 * @returns IPRT status code.
1408 * @param pThis The DWARF instance.
1409 * @param enmSect The section to load.
1410 */
1411static int rtDbgModDwarfLoadSection(PRTDBGMODDWARF pThis, krtDbgModDwarfSect enmSect)
1412{
1413 /*
1414 * Don't load stuff twice.
1415 */
1416 if (pThis->aSections[enmSect].pv)
1417 return VINF_SUCCESS;
1418
1419 /*
1420 * Sections that are not present cannot be loaded, treat them like they
1421 * are empty
1422 */
1423 if (!pThis->aSections[enmSect].fPresent)
1424 {
1425 Assert(pThis->aSections[enmSect].cb);
1426 return VINF_SUCCESS;
1427 }
1428 if (!pThis->aSections[enmSect].cb)
1429 return VINF_SUCCESS;
1430
1431 /*
1432 * Sections must be readable with the current image interface.
1433 */
1434 if (pThis->aSections[enmSect].offFile < 0)
1435 return VERR_OUT_OF_RANGE;
1436
1437 /*
1438 * Do the job.
1439 */
1440 return pThis->pDbgInfoMod->pImgVt->pfnMapPart(pThis->pDbgInfoMod,
1441 pThis->aSections[enmSect].iDbgInfo,
1442 pThis->aSections[enmSect].offFile,
1443 pThis->aSections[enmSect].cb,
1444 &pThis->aSections[enmSect].pv);
1445}
1446
1447
1448#ifdef SOME_UNUSED_FUNCTION
1449/**
1450 * Unloads a DWARF section previously mapped by rtDbgModDwarfLoadSection.
1451 *
1452 * @returns IPRT status code.
1453 * @param pThis The DWARF instance.
1454 * @param enmSect The section to unload.
1455 */
1456static int rtDbgModDwarfUnloadSection(PRTDBGMODDWARF pThis, krtDbgModDwarfSect enmSect)
1457{
1458 if (!pThis->aSections[enmSect].pv)
1459 return VINF_SUCCESS;
1460
1461 int rc = pThis->pDbgInfoMod->pImgVt->pfnUnmapPart(pThis->pDbgInfoMod, pThis->aSections[enmSect].cb, &pThis->aSections[enmSect].pv);
1462 AssertRC(rc);
1463 return rc;
1464}
1465#endif
1466
1467
1468/**
1469 * Converts to UTF-8 or otherwise makes sure it's valid UTF-8.
1470 *
1471 * @returns IPRT status code.
1472 * @param pThis The DWARF instance.
1473 * @param ppsz Pointer to the string pointer. May be
1474 * reallocated (RTStr*).
1475 */
1476static int rtDbgModDwarfStringToUtf8(PRTDBGMODDWARF pThis, char **ppsz)
1477{
1478 /** @todo DWARF & UTF-8. */
1479 NOREF(pThis);
1480 RTStrPurgeEncoding(*ppsz);
1481 return VINF_SUCCESS;
1482}
1483
1484
1485/**
1486 * Convers a link address into a segment+offset or RVA.
1487 *
1488 * @returns IPRT status code.
1489 * @param pThis The DWARF instance.
1490 * @param uSegment The segment, 0 if not applicable.
1491 * @param LinkAddress The address to convert..
1492 * @param piSeg The segment index.
1493 * @param poffSeg Where to return the segment offset.
1494 */
1495static int rtDbgModDwarfLinkAddressToSegOffset(PRTDBGMODDWARF pThis, RTSEL uSegment, uint64_t LinkAddress,
1496 PRTDBGSEGIDX piSeg, PRTLDRADDR poffSeg)
1497{
1498 if (pThis->paSegs)
1499 {
1500 PRTDBGDWARFSEG pSeg = rtDbgModDwarfFindSegment(pThis, uSegment);
1501 if (pSeg)
1502 {
1503 *piSeg = pSeg - pThis->paSegs;
1504 *poffSeg = LinkAddress;
1505 return VINF_SUCCESS;
1506 }
1507 }
1508
1509 if (pThis->fUseLinkAddress)
1510 return pThis->pImgMod->pImgVt->pfnLinkAddressToSegOffset(pThis->pImgMod, LinkAddress, piSeg, poffSeg);
1511 return pThis->pImgMod->pImgVt->pfnRvaToSegOffset(pThis->pImgMod, LinkAddress, piSeg, poffSeg);
1512}
1513
1514
1515/*
1516 *
1517 * DWARF Cursor.
1518 * DWARF Cursor.
1519 * DWARF Cursor.
1520 *
1521 */
1522
1523
1524/**
1525 * Reads a 8-bit unsigned integer and advances the cursor.
1526 *
1527 * @returns 8-bit unsigned integer. On error RTDWARFCURSOR::rc is set and @a
1528 * uErrValue is returned.
1529 * @param pCursor The cursor.
1530 * @param uErrValue What to return on read error.
1531 */
1532static uint8_t rtDwarfCursor_GetU8(PRTDWARFCURSOR pCursor, uint8_t uErrValue)
1533{
1534 if (pCursor->cbUnitLeft < 1)
1535 {
1536 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1537 return uErrValue;
1538 }
1539
1540 uint8_t u8 = pCursor->pb[0];
1541 pCursor->pb += 1;
1542 pCursor->cbUnitLeft -= 1;
1543 pCursor->cbLeft -= 1;
1544 return u8;
1545}
1546
1547
1548/**
1549 * Reads a 16-bit unsigned integer and advances the cursor.
1550 *
1551 * @returns 16-bit unsigned integer. On error RTDWARFCURSOR::rc is set and @a
1552 * uErrValue is returned.
1553 * @param pCursor The cursor.
1554 * @param uErrValue What to return on read error.
1555 */
1556static uint16_t rtDwarfCursor_GetU16(PRTDWARFCURSOR pCursor, uint16_t uErrValue)
1557{
1558 if (pCursor->cbUnitLeft < 2)
1559 {
1560 pCursor->pb += pCursor->cbUnitLeft;
1561 pCursor->cbLeft -= pCursor->cbUnitLeft;
1562 pCursor->cbUnitLeft = 0;
1563 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1564 return uErrValue;
1565 }
1566
1567 uint16_t u16 = RT_MAKE_U16(pCursor->pb[0], pCursor->pb[1]);
1568 pCursor->pb += 2;
1569 pCursor->cbUnitLeft -= 2;
1570 pCursor->cbLeft -= 2;
1571 if (!pCursor->fNativEndian)
1572 u16 = RT_BSWAP_U16(u16);
1573 return u16;
1574}
1575
1576
1577/**
1578 * Reads a 32-bit unsigned integer and advances the cursor.
1579 *
1580 * @returns 32-bit unsigned integer. On error RTDWARFCURSOR::rc is set and @a
1581 * uErrValue is returned.
1582 * @param pCursor The cursor.
1583 * @param uErrValue What to return on read error.
1584 */
1585static uint32_t rtDwarfCursor_GetU32(PRTDWARFCURSOR pCursor, uint32_t uErrValue)
1586{
1587 if (pCursor->cbUnitLeft < 4)
1588 {
1589 pCursor->pb += pCursor->cbUnitLeft;
1590 pCursor->cbLeft -= pCursor->cbUnitLeft;
1591 pCursor->cbUnitLeft = 0;
1592 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1593 return uErrValue;
1594 }
1595
1596 uint32_t u32 = RT_MAKE_U32_FROM_U8(pCursor->pb[0], pCursor->pb[1], pCursor->pb[2], pCursor->pb[3]);
1597 pCursor->pb += 4;
1598 pCursor->cbUnitLeft -= 4;
1599 pCursor->cbLeft -= 4;
1600 if (!pCursor->fNativEndian)
1601 u32 = RT_BSWAP_U32(u32);
1602 return u32;
1603}
1604
1605
1606/**
1607 * Reads a 64-bit unsigned integer and advances the cursor.
1608 *
1609 * @returns 64-bit unsigned integer. On error RTDWARFCURSOR::rc is set and @a
1610 * uErrValue is returned.
1611 * @param pCursor The cursor.
1612 * @param uErrValue What to return on read error.
1613 */
1614static uint64_t rtDwarfCursor_GetU64(PRTDWARFCURSOR pCursor, uint64_t uErrValue)
1615{
1616 if (pCursor->cbUnitLeft < 8)
1617 {
1618 pCursor->pb += pCursor->cbUnitLeft;
1619 pCursor->cbLeft -= pCursor->cbUnitLeft;
1620 pCursor->cbUnitLeft = 0;
1621 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1622 return uErrValue;
1623 }
1624
1625 uint64_t u64 = RT_MAKE_U64_FROM_U8(pCursor->pb[0], pCursor->pb[1], pCursor->pb[2], pCursor->pb[3],
1626 pCursor->pb[4], pCursor->pb[5], pCursor->pb[6], pCursor->pb[7]);
1627 pCursor->pb += 8;
1628 pCursor->cbUnitLeft -= 8;
1629 pCursor->cbLeft -= 8;
1630 if (!pCursor->fNativEndian)
1631 u64 = RT_BSWAP_U64(u64);
1632 return u64;
1633}
1634
1635
1636/**
1637 * Reads an unsigned LEB128 encoded number.
1638 *
1639 * @returns unsigned 64-bit number. On error RTDWARFCURSOR::rc is set and @a
1640 * uErrValue is returned.
1641 * @param pCursor The cursor.
1642 * @param uErrValue The value to return on error.
1643 */
1644static uint64_t rtDwarfCursor_GetULeb128(PRTDWARFCURSOR pCursor, uint64_t uErrValue)
1645{
1646 if (pCursor->cbUnitLeft < 1)
1647 {
1648 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1649 return uErrValue;
1650 }
1651
1652 /*
1653 * Special case - single byte.
1654 */
1655 uint8_t b = pCursor->pb[0];
1656 if (!(b & 0x80))
1657 {
1658 pCursor->pb += 1;
1659 pCursor->cbUnitLeft -= 1;
1660 pCursor->cbLeft -= 1;
1661 return b;
1662 }
1663
1664 /*
1665 * Generic case.
1666 */
1667 /* Decode. */
1668 uint32_t off = 1;
1669 uint64_t u64Ret = b & 0x7f;
1670 do
1671 {
1672 if (off == pCursor->cbUnitLeft)
1673 {
1674 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1675 u64Ret = uErrValue;
1676 break;
1677 }
1678 b = pCursor->pb[off];
1679 u64Ret |= (b & 0x7f) << off * 7;
1680 off++;
1681 } while (b & 0x80);
1682
1683 /* Update the cursor. */
1684 pCursor->pb += off;
1685 pCursor->cbUnitLeft -= off;
1686 pCursor->cbLeft -= off;
1687
1688 /* Check the range. */
1689 uint32_t cBits = off * 7;
1690 if (cBits > 64)
1691 {
1692 pCursor->rc = VERR_DWARF_LEB_OVERFLOW;
1693 u64Ret = uErrValue;
1694 }
1695
1696 return u64Ret;
1697}
1698
1699
1700/**
1701 * Reads a signed LEB128 encoded number.
1702 *
1703 * @returns signed 64-bit number. On error RTDWARFCURSOR::rc is set and @a
1704 * uErrValue is returned.
1705 * @param pCursor The cursor.
1706 * @param sErrValue The value to return on error.
1707 */
1708static int64_t rtDwarfCursor_GetSLeb128(PRTDWARFCURSOR pCursor, int64_t sErrValue)
1709{
1710 if (pCursor->cbUnitLeft < 1)
1711 {
1712 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1713 return sErrValue;
1714 }
1715
1716 /*
1717 * Special case - single byte.
1718 */
1719 uint8_t b = pCursor->pb[0];
1720 if (!(b & 0x80))
1721 {
1722 pCursor->pb += 1;
1723 pCursor->cbUnitLeft -= 1;
1724 pCursor->cbLeft -= 1;
1725 if (b & 0x40)
1726 b |= 0x80;
1727 return (int8_t)b;
1728 }
1729
1730 /*
1731 * Generic case.
1732 */
1733 /* Decode it. */
1734 uint32_t off = 1;
1735 uint64_t u64Ret = b & 0x7f;
1736 do
1737 {
1738 if (off == pCursor->cbUnitLeft)
1739 {
1740 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1741 u64Ret = (uint64_t)sErrValue;
1742 break;
1743 }
1744 b = pCursor->pb[off];
1745 u64Ret |= (b & 0x7f) << off * 7;
1746 off++;
1747 } while (b & 0x80);
1748
1749 /* Update cursor. */
1750 pCursor->pb += off;
1751 pCursor->cbUnitLeft -= off;
1752 pCursor->cbLeft -= off;
1753
1754 /* Check the range. */
1755 uint32_t cBits = off * 7;
1756 if (cBits > 64)
1757 {
1758 pCursor->rc = VERR_DWARF_LEB_OVERFLOW;
1759 u64Ret = (uint64_t)sErrValue;
1760 }
1761 /* Sign extend the value. */
1762 else if (u64Ret & RT_BIT_64(cBits - 1))
1763 u64Ret |= ~(RT_BIT_64(cBits - 1) - 1);
1764
1765 return (int64_t)u64Ret;
1766}
1767
1768
1769/**
1770 * Reads an unsigned LEB128 encoded number, max 32-bit width.
1771 *
1772 * @returns unsigned 32-bit number. On error RTDWARFCURSOR::rc is set and @a
1773 * uErrValue is returned.
1774 * @param pCursor The cursor.
1775 * @param uErrValue The value to return on error.
1776 */
1777static uint32_t rtDwarfCursor_GetULeb128AsU32(PRTDWARFCURSOR pCursor, uint32_t uErrValue)
1778{
1779 uint64_t u64 = rtDwarfCursor_GetULeb128(pCursor, uErrValue);
1780 if (u64 > UINT32_MAX)
1781 {
1782 pCursor->rc = VERR_DWARF_LEB_OVERFLOW;
1783 return uErrValue;
1784 }
1785 return (uint32_t)u64;
1786}
1787
1788
1789/**
1790 * Reads a signed LEB128 encoded number, max 32-bit width.
1791 *
1792 * @returns signed 32-bit number. On error RTDWARFCURSOR::rc is set and @a
1793 * uErrValue is returned.
1794 * @param pCursor The cursor.
1795 * @param sErrValue The value to return on error.
1796 */
1797static int32_t rtDwarfCursor_GetSLeb128AsS32(PRTDWARFCURSOR pCursor, int32_t sErrValue)
1798{
1799 int64_t s64 = rtDwarfCursor_GetSLeb128(pCursor, sErrValue);
1800 if (s64 > INT32_MAX || s64 < INT32_MIN)
1801 {
1802 pCursor->rc = VERR_DWARF_LEB_OVERFLOW;
1803 return sErrValue;
1804 }
1805 return (int32_t)s64;
1806}
1807
1808
1809/**
1810 * Skips a LEB128 encoded number.
1811 *
1812 * @returns IPRT status code.
1813 * @param pCursor The cursor.
1814 */
1815static int rtDwarfCursor_SkipLeb128(PRTDWARFCURSOR pCursor)
1816{
1817 if (RT_FAILURE(pCursor->rc))
1818 return pCursor->rc;
1819
1820 if (pCursor->cbUnitLeft < 1)
1821 return pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1822
1823 uint32_t offSkip = 1;
1824 if (pCursor->pb[0] & 0x80)
1825 do
1826 {
1827 if (offSkip == pCursor->cbUnitLeft)
1828 {
1829 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1830 break;
1831 }
1832 } while (pCursor->pb[offSkip++] & 0x80);
1833
1834 pCursor->pb += offSkip;
1835 pCursor->cbUnitLeft -= offSkip;
1836 pCursor->cbLeft -= offSkip;
1837 return pCursor->rc;
1838}
1839
1840
1841/**
1842 * Advances the cursor a given number of bytes.
1843 *
1844 * @returns IPRT status code.
1845 * @param pCursor The cursor.
1846 * @param offSkip The number of bytes to advance.
1847 */
1848static int rtDwarfCursor_SkipBytes(PRTDWARFCURSOR pCursor, uint64_t offSkip)
1849{
1850 if (RT_FAILURE(pCursor->rc))
1851 return pCursor->rc;
1852 if (pCursor->cbUnitLeft < offSkip)
1853 return pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1854
1855 size_t const offSkipSizeT = (size_t)offSkip;
1856 pCursor->cbUnitLeft -= offSkipSizeT;
1857 pCursor->cbLeft -= offSkipSizeT;
1858 pCursor->pb += offSkipSizeT;
1859
1860 return VINF_SUCCESS;
1861}
1862
1863
1864/**
1865 * Reads a zero terminated string, advancing the cursor beyond the terminator.
1866 *
1867 * @returns Pointer to the string.
1868 * @param pCursor The cursor.
1869 * @param pszErrValue What to return if the string isn't terminated
1870 * before the end of the unit.
1871 */
1872static const char *rtDwarfCursor_GetSZ(PRTDWARFCURSOR pCursor, const char *pszErrValue)
1873{
1874 const char *pszRet = (const char *)pCursor->pb;
1875 for (;;)
1876 {
1877 if (!pCursor->cbUnitLeft)
1878 {
1879 pCursor->rc = VERR_DWARF_BAD_STRING;
1880 return pszErrValue;
1881 }
1882 pCursor->cbUnitLeft--;
1883 pCursor->cbLeft--;
1884 if (!*pCursor->pb++)
1885 break;
1886 }
1887 return pszRet;
1888}
1889
1890
1891/**
1892 * Reads a 1, 2, 4 or 8 byte unsgined value.
1893 *
1894 * @returns 64-bit unsigned value.
1895 * @param pCursor The cursor.
1896 * @param cbValue The value size.
1897 * @param uErrValue The error value.
1898 */
1899static uint64_t rtDwarfCursor_GetVarSizedU(PRTDWARFCURSOR pCursor, size_t cbValue, uint64_t uErrValue)
1900{
1901 uint64_t u64Ret;
1902 switch (cbValue)
1903 {
1904 case 1: u64Ret = rtDwarfCursor_GetU8( pCursor, UINT8_MAX); break;
1905 case 2: u64Ret = rtDwarfCursor_GetU16(pCursor, UINT16_MAX); break;
1906 case 4: u64Ret = rtDwarfCursor_GetU32(pCursor, UINT32_MAX); break;
1907 case 8: u64Ret = rtDwarfCursor_GetU64(pCursor, UINT64_MAX); break;
1908 default:
1909 pCursor->rc = VERR_DWARF_BAD_INFO;
1910 return uErrValue;
1911 }
1912 if (RT_FAILURE(pCursor->rc))
1913 return uErrValue;
1914 return u64Ret;
1915}
1916
1917
1918#if 0 /* unused */
1919/**
1920 * Gets the pointer to a variable size block and advances the cursor.
1921 *
1922 * @returns Pointer to the block at the current cursor location. On error
1923 * RTDWARFCURSOR::rc is set and NULL returned.
1924 * @param pCursor The cursor.
1925 * @param cbBlock The block size.
1926 */
1927static const uint8_t *rtDwarfCursor_GetBlock(PRTDWARFCURSOR pCursor, uint32_t cbBlock)
1928{
1929 if (cbBlock > pCursor->cbUnitLeft)
1930 {
1931 pCursor->rc = VERR_DWARF_UNEXPECTED_END;
1932 return NULL;
1933 }
1934
1935 uint8_t const *pb = &pCursor->pb[0];
1936 pCursor->pb += cbBlock;
1937 pCursor->cbUnitLeft -= cbBlock;
1938 pCursor->cbLeft -= cbBlock;
1939 return pb;
1940}
1941#endif
1942
1943
1944/**
1945 * Reads an unsigned DWARF half number.
1946 *
1947 * @returns The number. On error RTDWARFCURSOR::rc is set and @a
1948 * uErrValue is returned.
1949 * @param pCursor The cursor.
1950 * @param uErrValue What to return on error.
1951 */
1952static uint16_t rtDwarfCursor_GetUHalf(PRTDWARFCURSOR pCursor, uint16_t uErrValue)
1953{
1954 return rtDwarfCursor_GetU16(pCursor, uErrValue);
1955}
1956
1957
1958/**
1959 * Reads an unsigned DWARF byte number.
1960 *
1961 * @returns The number. On error RTDWARFCURSOR::rc is set and @a
1962 * uErrValue is returned.
1963 * @param pCursor The cursor.
1964 * @param uErrValue What to return on error.
1965 */
1966static uint8_t rtDwarfCursor_GetUByte(PRTDWARFCURSOR pCursor, uint8_t uErrValue)
1967{
1968 return rtDwarfCursor_GetU8(pCursor, uErrValue);
1969}
1970
1971
1972/**
1973 * Reads a signed DWARF byte number.
1974 *
1975 * @returns The number. On error RTDWARFCURSOR::rc is set and @a
1976 * uErrValue is returned.
1977 * @param pCursor The cursor.
1978 * @param uErrValue What to return on error.
1979 */
1980static int8_t rtDwarfCursor_GetSByte(PRTDWARFCURSOR pCursor, int8_t iErrValue)
1981{
1982 return (int8_t)rtDwarfCursor_GetU8(pCursor, (uint8_t)iErrValue);
1983}
1984
1985
1986/**
1987 * Reads a unsigned DWARF offset value.
1988 *
1989 * @returns The value. On error RTDWARFCURSOR::rc is set and @a
1990 * uErrValue is returned.
1991 * @param pCursor The cursor.
1992 * @param uErrValue What to return on error.
1993 */
1994static uint64_t rtDwarfCursor_GetUOff(PRTDWARFCURSOR pCursor, uint64_t uErrValue)
1995{
1996 if (pCursor->f64bitDwarf)
1997 return rtDwarfCursor_GetU64(pCursor, uErrValue);
1998 return rtDwarfCursor_GetU32(pCursor, (uint32_t)uErrValue);
1999}
2000
2001
2002/**
2003 * Reads a unsigned DWARF native offset value.
2004 *
2005 * @returns The value. On error RTDWARFCURSOR::rc is set and @a
2006 * uErrValue is returned.
2007 * @param pCursor The cursor.
2008 * @param uErrValue What to return on error.
2009 */
2010static uint64_t rtDwarfCursor_GetNativeUOff(PRTDWARFCURSOR pCursor, uint64_t uErrValue)
2011{
2012 switch (pCursor->cbNativeAddr)
2013 {
2014 case 1: return rtDwarfCursor_GetU8(pCursor, (uint8_t )uErrValue);
2015 case 2: return rtDwarfCursor_GetU16(pCursor, (uint16_t)uErrValue);
2016 case 4: return rtDwarfCursor_GetU32(pCursor, (uint32_t)uErrValue);
2017 case 8: return rtDwarfCursor_GetU64(pCursor, uErrValue);
2018 default:
2019 pCursor->rc = VERR_INTERNAL_ERROR_2;
2020 return uErrValue;
2021 }
2022}
2023
2024
2025/**
2026 * Gets the unit length, updating the unit length member and DWARF bitness
2027 * members of the cursor.
2028 *
2029 * @returns The unit length.
2030 * @param pCursor The cursor.
2031 */
2032static uint64_t rtDwarfCursor_GetInitalLength(PRTDWARFCURSOR pCursor)
2033{
2034 /*
2035 * Read the initial length.
2036 */
2037 pCursor->cbUnitLeft = pCursor->cbLeft;
2038 uint64_t cbUnit = rtDwarfCursor_GetU32(pCursor, 0);
2039 if (cbUnit != UINT32_C(0xffffffff))
2040 pCursor->f64bitDwarf = false;
2041 else
2042 {
2043 pCursor->f64bitDwarf = true;
2044 cbUnit = rtDwarfCursor_GetU64(pCursor, 0);
2045 }
2046
2047
2048 /*
2049 * Set the unit length, quitely fixing bad lengths.
2050 */
2051 pCursor->cbUnitLeft = (size_t)cbUnit;
2052 if ( pCursor->cbUnitLeft > pCursor->cbLeft
2053 || pCursor->cbUnitLeft != cbUnit)
2054 pCursor->cbUnitLeft = pCursor->cbLeft;
2055
2056 return cbUnit;
2057}
2058
2059
2060/**
2061 * Calculates the section offset corresponding to the current cursor position.
2062 *
2063 * @returns 32-bit section offset. If out of range, RTDWARFCURSOR::rc will be
2064 * set and UINT32_MAX returned.
2065 * @param pCursor The cursor.
2066 */
2067static uint32_t rtDwarfCursor_CalcSectOffsetU32(PRTDWARFCURSOR pCursor)
2068{
2069 size_t off = pCursor->pb - (uint8_t const *)pCursor->pDwarfMod->aSections[pCursor->enmSect].pv;
2070 uint32_t offRet = (uint32_t)off;
2071 if (offRet != off)
2072 {
2073 AssertFailed();
2074 pCursor->rc = VERR_OUT_OF_RANGE;
2075 offRet = UINT32_MAX;
2076 }
2077 return offRet;
2078}
2079
2080
2081/**
2082 * Calculates an absolute cursor position from one relative to the current
2083 * cursor position.
2084 *
2085 * @returns The absolute cursor position.
2086 * @param pCursor The cursor.
2087 * @param offRelative The relative position. Must be a positive
2088 * offset.
2089 */
2090static uint8_t const *rtDwarfCursor_CalcPos(PRTDWARFCURSOR pCursor, size_t offRelative)
2091{
2092 if (offRelative > pCursor->cbUnitLeft)
2093 {
2094 Log(("rtDwarfCursor_CalcPos: bad position %#zx, cbUnitLeft=%#zu\n", offRelative, pCursor->cbUnitLeft));
2095 pCursor->rc = VERR_DWARF_BAD_POS;
2096 return NULL;
2097 }
2098 return pCursor->pb + offRelative;
2099}
2100
2101
2102/**
2103 * Advances the cursor to the given position.
2104 *
2105 * @returns IPRT status code.
2106 * @param pCursor The cursor.
2107 * @param pbNewPos The new position - returned by
2108 * rtDwarfCursor_CalcPos().
2109 */
2110static int rtDwarfCursor_AdvanceToPos(PRTDWARFCURSOR pCursor, uint8_t const *pbNewPos)
2111{
2112 if (RT_FAILURE(pCursor->rc))
2113 return pCursor->rc;
2114 AssertPtr(pbNewPos);
2115 if ((uintptr_t)pbNewPos < (uintptr_t)pCursor->pb)
2116 {
2117 Log(("rtDwarfCursor_AdvanceToPos: bad position %p, current %p\n", pbNewPos, pCursor->pb));
2118 return pCursor->rc = VERR_DWARF_BAD_POS;
2119 }
2120
2121 uintptr_t cbAdj = (uintptr_t)pbNewPos - (uintptr_t)pCursor->pb;
2122 if (RT_UNLIKELY(cbAdj > pCursor->cbUnitLeft))
2123 {
2124 AssertFailed();
2125 pCursor->rc = VERR_DWARF_BAD_POS;
2126 cbAdj = pCursor->cbUnitLeft;
2127 }
2128
2129 pCursor->cbUnitLeft -= cbAdj;
2130 pCursor->cbLeft -= cbAdj;
2131 pCursor->pb += cbAdj;
2132 return pCursor->rc;
2133}
2134
2135
2136/**
2137 * Check if the cursor is at the end of the current DWARF unit.
2138 *
2139 * @retval @c true if at the end or a cursor error is pending.
2140 * @retval @c false if not.
2141 * @param pCursor The cursor.
2142 */
2143static bool rtDwarfCursor_IsAtEndOfUnit(PRTDWARFCURSOR pCursor)
2144{
2145 return !pCursor->cbUnitLeft || RT_FAILURE(pCursor->rc);
2146}
2147
2148
2149/**
2150 * Skips to the end of the current unit.
2151 *
2152 * @returns IPRT status code.
2153 * @param pCursor The cursor.
2154 */
2155static int rtDwarfCursor_SkipUnit(PRTDWARFCURSOR pCursor)
2156{
2157 pCursor->pb += pCursor->cbUnitLeft;
2158 pCursor->cbLeft -= pCursor->cbUnitLeft;
2159 pCursor->cbUnitLeft = 0;
2160 return pCursor->rc;
2161}
2162
2163
2164/**
2165 * Check if the cursor is at the end of the section (or whatever the cursor is
2166 * processing).
2167 *
2168 * @retval @c true if at the end or a cursor error is pending.
2169 * @retval @c false if not.
2170 * @param pCursor The cursor.
2171 */
2172static bool rtDwarfCursor_IsAtEnd(PRTDWARFCURSOR pCursor)
2173{
2174 return !pCursor->cbLeft || RT_FAILURE(pCursor->rc);
2175}
2176
2177
2178/**
2179 * Initialize a section reader cursor.
2180 *
2181 * @returns IPRT status code.
2182 * @param pCursor The cursor.
2183 * @param pThis The dwarf module.
2184 * @param enmSect The name of the section to read.
2185 */
2186static int rtDwarfCursor_Init(PRTDWARFCURSOR pCursor, PRTDBGMODDWARF pThis, krtDbgModDwarfSect enmSect)
2187{
2188 int rc = rtDbgModDwarfLoadSection(pThis, enmSect);
2189 if (RT_FAILURE(rc))
2190 return rc;
2191
2192 pCursor->enmSect = enmSect;
2193 pCursor->pbStart = (uint8_t const *)pThis->aSections[enmSect].pv;
2194 pCursor->pb = pCursor->pbStart;
2195 pCursor->cbLeft = pThis->aSections[enmSect].cb;
2196 pCursor->cbUnitLeft = pCursor->cbLeft;
2197 pCursor->pDwarfMod = pThis;
2198 pCursor->f64bitDwarf = false;
2199 /** @todo ask the image about the endian used as well as the address
2200 * width. */
2201 pCursor->fNativEndian = true;
2202 pCursor->cbNativeAddr = 4;
2203 pCursor->rc = VINF_SUCCESS;
2204
2205 return VINF_SUCCESS;
2206}
2207
2208
2209/**
2210 * Initialize a section reader cursor with an offset.
2211 *
2212 * @returns IPRT status code.
2213 * @param pCursor The cursor.
2214 * @param pThis The dwarf module.
2215 * @param enmSect The name of the section to read.
2216 * @param offSect The offset into the section.
2217 */
2218static int rtDwarfCursor_InitWithOffset(PRTDWARFCURSOR pCursor, PRTDBGMODDWARF pThis,
2219 krtDbgModDwarfSect enmSect, uint32_t offSect)
2220{
2221 if (offSect > pThis->aSections[enmSect].cb)
2222 {
2223 Log(("rtDwarfCursor_InitWithOffset: offSect=%#x cb=%#x enmSect=%d\n", offSect, pThis->aSections[enmSect].cb, enmSect));
2224 return VERR_DWARF_BAD_POS;
2225 }
2226
2227 int rc = rtDwarfCursor_Init(pCursor, pThis, enmSect);
2228 if (RT_SUCCESS(rc))
2229 {
2230 pCursor->pbStart += offSect;
2231 pCursor->pb += offSect;
2232 pCursor->cbLeft -= offSect;
2233 pCursor->cbUnitLeft -= offSect;
2234 }
2235
2236 return rc;
2237}
2238
2239
2240/**
2241 * Initialize a cursor for a block (subsection) retrieved from the given cursor.
2242 *
2243 * The parent cursor will be advanced past the block.
2244 *
2245 * @returns IPRT status code.
2246 * @param pCursor The cursor.
2247 * @param pParent The parent cursor. Will be moved by @a cbBlock.
2248 * @param cbBlock The size of the block the new cursor should
2249 * cover.
2250 */
2251static int rtDwarfCursor_InitForBlock(PRTDWARFCURSOR pCursor, PRTDWARFCURSOR pParent, uint32_t cbBlock)
2252{
2253 if (RT_FAILURE(pParent->rc))
2254 return pParent->rc;
2255 if (pParent->cbUnitLeft < cbBlock)
2256 {
2257 Log(("rtDwarfCursor_InitForBlock: cbUnitLeft=%#x < cbBlock=%#x \n", pParent->cbUnitLeft, cbBlock));
2258 return VERR_DWARF_BAD_POS;
2259 }
2260
2261 *pCursor = *pParent;
2262 pCursor->cbLeft = cbBlock;
2263 pCursor->cbUnitLeft = cbBlock;
2264
2265 pParent->pb += cbBlock;
2266 pParent->cbLeft -= cbBlock;
2267 pParent->cbUnitLeft -= cbBlock;
2268
2269 return VINF_SUCCESS;
2270}
2271
2272
2273/**
2274 * Deletes a section reader initialized by rtDwarfCursor_Init.
2275 *
2276 * @returns @a rcOther or RTDWARCURSOR::rc.
2277 * @param pCursor The section reader.
2278 * @param rcOther Other error code to be returned if it indicates
2279 * error or if the cursor status is OK.
2280 */
2281static int rtDwarfCursor_Delete(PRTDWARFCURSOR pCursor, int rcOther)
2282{
2283 /* ... and a drop of poison. */
2284 pCursor->pb = NULL;
2285 pCursor->cbLeft = ~(size_t)0;
2286 pCursor->cbUnitLeft = ~(size_t)0;
2287 pCursor->pDwarfMod = NULL;
2288 if (RT_FAILURE(pCursor->rc) && RT_SUCCESS(rcOther))
2289 rcOther = pCursor->rc;
2290 pCursor->rc = VERR_INTERNAL_ERROR_4;
2291 return rcOther;
2292}
2293
2294
2295/*
2296 *
2297 * DWARF Line Numbers.
2298 * DWARF Line Numbers.
2299 * DWARF Line Numbers.
2300 *
2301 */
2302
2303
2304/**
2305 * Defines a file name.
2306 *
2307 * @returns IPRT status code.
2308 * @param pLnState The line number program state.
2309 * @param pszFilename The name of the file.
2310 * @param idxInc The include path index.
2311 */
2312static int rtDwarfLine_DefineFileName(PRTDWARFLINESTATE pLnState, const char *pszFilename, uint64_t idxInc)
2313{
2314 /*
2315 * Resize the array if necessary.
2316 */
2317 uint32_t iFileName = pLnState->cFileNames;
2318 if ((iFileName % 2) == 0)
2319 {
2320 void *pv = RTMemRealloc(pLnState->papszFileNames, sizeof(pLnState->papszFileNames[0]) * (iFileName + 2));
2321 if (!pv)
2322 return VERR_NO_MEMORY;
2323 pLnState->papszFileNames = (char **)pv;
2324 }
2325
2326 /*
2327 * Add the file name.
2328 */
2329 if ( pszFilename[0] == '/'
2330 || pszFilename[0] == '\\'
2331 || (RT_C_IS_ALPHA(pszFilename[0]) && pszFilename[1] == ':') )
2332 pLnState->papszFileNames[iFileName] = RTStrDup(pszFilename);
2333 else if (idxInc < pLnState->cIncPaths)
2334 pLnState->papszFileNames[iFileName] = RTPathJoinA(pLnState->papszIncPaths[idxInc], pszFilename);
2335 else
2336 return VERR_DWARF_BAD_LINE_NUMBER_HEADER;
2337 if (!pLnState->papszFileNames[iFileName])
2338 return VERR_NO_STR_MEMORY;
2339 pLnState->cFileNames = iFileName + 1;
2340
2341 /*
2342 * Sanitize the name.
2343 */
2344 int rc = rtDbgModDwarfStringToUtf8(pLnState->pDwarfMod, &pLnState->papszFileNames[iFileName]);
2345 Log((" File #%02u = '%s'\n", iFileName, pLnState->papszFileNames[iFileName]));
2346 return rc;
2347}
2348
2349
2350/**
2351 * Adds a line to the table and resets parts of the state (DW_LNS_copy).
2352 *
2353 * @returns IPRT status code
2354 * @param pLnState The line number program state.
2355 * @param offOpCode The opcode offset (for logging
2356 * purposes).
2357 */
2358static int rtDwarfLine_AddLine(PRTDWARFLINESTATE pLnState, uint32_t offOpCode)
2359{
2360 PRTDBGMODDWARF pThis = pLnState->pDwarfMod;
2361 int rc;
2362 if (pThis->iWatcomPass == 1)
2363 rc = rtDbgModDwarfRecordSegOffset(pThis, pLnState->Regs.uSegment, pLnState->Regs.uAddress + 1);
2364 else
2365 {
2366 const char *pszFile = pLnState->Regs.iFile < pLnState->cFileNames
2367 ? pLnState->papszFileNames[pLnState->Regs.iFile]
2368 : "<bad file name index>";
2369 NOREF(offOpCode);
2370
2371 RTDBGSEGIDX iSeg;
2372 RTUINTPTR offSeg;
2373 rc = rtDbgModDwarfLinkAddressToSegOffset(pLnState->pDwarfMod, pLnState->Regs.uSegment, pLnState->Regs.uAddress,
2374 &iSeg, &offSeg); /*AssertRC(rc);*/
2375 if (RT_SUCCESS(rc))
2376 {
2377 Log2(("rtDwarfLine_AddLine: %x:%08llx (%#llx) %s(%d) [offOpCode=%08x]\n", iSeg, offSeg, pLnState->Regs.uAddress, pszFile, pLnState->Regs.uLine, offOpCode));
2378 rc = RTDbgModLineAdd(pLnState->pDwarfMod->hCnt, pszFile, pLnState->Regs.uLine, iSeg, offSeg, NULL);
2379
2380 /* Ignore address conflicts for now. */
2381 if (rc == VERR_DBG_ADDRESS_CONFLICT)
2382 rc = VINF_SUCCESS;
2383 }
2384 else
2385 rc = VINF_SUCCESS; /* ignore failure */
2386 }
2387
2388 pLnState->Regs.fBasicBlock = false;
2389 pLnState->Regs.fPrologueEnd = false;
2390 pLnState->Regs.fEpilogueBegin = false;
2391 pLnState->Regs.uDiscriminator = 0;
2392 return rc;
2393}
2394
2395
2396/**
2397 * Reset the program to the start-of-sequence state.
2398 *
2399 * @param pLnState The line number program state.
2400 */
2401static void rtDwarfLine_ResetState(PRTDWARFLINESTATE pLnState)
2402{
2403 pLnState->Regs.uAddress = 0;
2404 pLnState->Regs.idxOp = 0;
2405 pLnState->Regs.iFile = 1;
2406 pLnState->Regs.uLine = 1;
2407 pLnState->Regs.uColumn = 0;
2408 pLnState->Regs.fIsStatement = RT_BOOL(pLnState->Hdr.u8DefIsStmt);
2409 pLnState->Regs.fBasicBlock = false;
2410 pLnState->Regs.fEndSequence = false;
2411 pLnState->Regs.fPrologueEnd = false;
2412 pLnState->Regs.fEpilogueBegin = false;
2413 pLnState->Regs.uIsa = 0;
2414 pLnState->Regs.uDiscriminator = 0;
2415 pLnState->Regs.uSegment = 0;
2416}
2417
2418
2419/**
2420 * Runs the line number program.
2421 *
2422 * @returns IPRT status code.
2423 * @param pLnState The line number program state.
2424 * @param pCursor The cursor.
2425 */
2426static int rtDwarfLine_RunProgram(PRTDWARFLINESTATE pLnState, PRTDWARFCURSOR pCursor)
2427{
2428 LogFlow(("rtDwarfLine_RunProgram: cbUnitLeft=%zu\n", pCursor->cbUnitLeft));
2429
2430 int rc = VINF_SUCCESS;
2431 rtDwarfLine_ResetState(pLnState);
2432
2433 while (!rtDwarfCursor_IsAtEndOfUnit(pCursor))
2434 {
2435#ifdef LOG_ENABLED
2436 uint32_t const offOpCode = rtDwarfCursor_CalcSectOffsetU32(pCursor);
2437#else
2438 uint32_t const offOpCode = 0;
2439#endif
2440 uint8_t bOpCode = rtDwarfCursor_GetUByte(pCursor, DW_LNS_extended);
2441 if (bOpCode >= pLnState->Hdr.u8OpcodeBase)
2442 {
2443 /*
2444 * Special opcode.
2445 */
2446 uint8_t const bLogOpCode = bOpCode; NOREF(bLogOpCode);
2447 bOpCode -= pLnState->Hdr.u8OpcodeBase;
2448
2449 int32_t const cLineDelta = bOpCode % pLnState->Hdr.u8LineRange + (int32_t)pLnState->Hdr.s8LineBase;
2450 bOpCode /= pLnState->Hdr.u8LineRange;
2451
2452 uint64_t uTmp = bOpCode + pLnState->Regs.idxOp;
2453 uint64_t const cAddressDelta = uTmp / pLnState->Hdr.cMaxOpsPerInstr * pLnState->Hdr.cbMinInstr;
2454 uint64_t const cOpIndexDelta = uTmp % pLnState->Hdr.cMaxOpsPerInstr;
2455
2456 pLnState->Regs.uLine += cLineDelta;
2457 pLnState->Regs.uAddress += cAddressDelta;
2458 pLnState->Regs.idxOp += cOpIndexDelta;
2459 Log2(("%08x: DW Special Opcode %#04x: uLine + %d => %u; uAddress + %#llx => %#llx; idxOp + %#llx => %#llx\n",
2460 offOpCode, bLogOpCode, cLineDelta, pLnState->Regs.uLine, cAddressDelta, pLnState->Regs.uAddress,
2461 cOpIndexDelta, pLnState->Regs.idxOp));
2462
2463 rc = rtDwarfLine_AddLine(pLnState, offOpCode);
2464 }
2465 else
2466 {
2467 switch (bOpCode)
2468 {
2469 /*
2470 * Standard opcode.
2471 */
2472 case DW_LNS_copy:
2473 Log2(("%08x: DW_LNS_copy\n", offOpCode));
2474 rc = rtDwarfLine_AddLine(pLnState, offOpCode);
2475 break;
2476
2477 case DW_LNS_advance_pc:
2478 {
2479 uint64_t u64Adv = rtDwarfCursor_GetULeb128(pCursor, 0);
2480 pLnState->Regs.uAddress += (pLnState->Regs.idxOp + u64Adv) / pLnState->Hdr.cMaxOpsPerInstr
2481 * pLnState->Hdr.cbMinInstr;
2482 pLnState->Regs.idxOp += (pLnState->Regs.idxOp + u64Adv) % pLnState->Hdr.cMaxOpsPerInstr;
2483 Log2(("%08x: DW_LNS_advance_pc: u64Adv=%#llx (%lld) )\n", offOpCode, u64Adv, u64Adv));
2484 break;
2485 }
2486
2487 case DW_LNS_advance_line:
2488 {
2489 int32_t cLineDelta = rtDwarfCursor_GetSLeb128AsS32(pCursor, 0);
2490 pLnState->Regs.uLine += cLineDelta;
2491 Log2(("%08x: DW_LNS_advance_line: uLine + %d => %u\n", offOpCode, cLineDelta, pLnState->Regs.uLine));
2492 break;
2493 }
2494
2495 case DW_LNS_set_file:
2496 pLnState->Regs.iFile = rtDwarfCursor_GetULeb128AsU32(pCursor, 0);
2497 Log2(("%08x: DW_LNS_set_file: iFile=%u\n", offOpCode, pLnState->Regs.iFile));
2498 break;
2499
2500 case DW_LNS_set_column:
2501 pLnState->Regs.uColumn = rtDwarfCursor_GetULeb128AsU32(pCursor, 0);
2502 Log2(("%08x: DW_LNS_set_column\n", offOpCode));
2503 break;
2504
2505 case DW_LNS_negate_stmt:
2506 pLnState->Regs.fIsStatement = !pLnState->Regs.fIsStatement;
2507 Log2(("%08x: DW_LNS_negate_stmt\n", offOpCode));
2508 break;
2509
2510 case DW_LNS_set_basic_block:
2511 pLnState->Regs.fBasicBlock = true;
2512 Log2(("%08x: DW_LNS_set_basic_block\n", offOpCode));
2513 break;
2514
2515 case DW_LNS_const_add_pc:
2516 pLnState->Regs.uAddress += (pLnState->Regs.idxOp + 255) / pLnState->Hdr.cMaxOpsPerInstr
2517 * pLnState->Hdr.cbMinInstr;
2518 pLnState->Regs.idxOp += (pLnState->Regs.idxOp + 255) % pLnState->Hdr.cMaxOpsPerInstr;
2519 Log2(("%08x: DW_LNS_const_add_pc\n", offOpCode));
2520 break;
2521
2522 case DW_LNS_fixed_advance_pc:
2523 pLnState->Regs.uAddress += rtDwarfCursor_GetUHalf(pCursor, 0);
2524 pLnState->Regs.idxOp = 0;
2525 Log2(("%08x: DW_LNS_fixed_advance_pc\n", offOpCode));
2526 break;
2527
2528 case DW_LNS_set_prologue_end:
2529 pLnState->Regs.fPrologueEnd = true;
2530 Log2(("%08x: DW_LNS_set_prologue_end\n", offOpCode));
2531 break;
2532
2533 case DW_LNS_set_epilogue_begin:
2534 pLnState->Regs.fEpilogueBegin = true;
2535 Log2(("%08x: DW_LNS_set_epilogue_begin\n", offOpCode));
2536 break;
2537
2538 case DW_LNS_set_isa:
2539 pLnState->Regs.uIsa = rtDwarfCursor_GetULeb128AsU32(pCursor, 0);
2540 Log2(("%08x: DW_LNS_set_isa %#x\n", offOpCode, pLnState->Regs.uIsa));
2541 break;
2542
2543 default:
2544 {
2545 unsigned cOpsToSkip = pLnState->Hdr.pacStdOperands[bOpCode - 1];
2546 Log(("rtDwarfLine_RunProgram: Unknown standard opcode %#x, %#x operands, at %08x.\n", bOpCode, cOpsToSkip, offOpCode));
2547 while (cOpsToSkip-- > 0)
2548 rc = rtDwarfCursor_SkipLeb128(pCursor);
2549 break;
2550 }
2551
2552 /*
2553 * Extended opcode.
2554 */
2555 case DW_LNS_extended:
2556 {
2557 /* The instruction has a length prefix. */
2558 uint64_t cbInstr = rtDwarfCursor_GetULeb128(pCursor, UINT64_MAX);
2559 if (RT_FAILURE(pCursor->rc))
2560 return pCursor->rc;
2561 if (cbInstr > pCursor->cbUnitLeft)
2562 return VERR_DWARF_BAD_LNE;
2563 uint8_t const * const pbEndOfInstr = rtDwarfCursor_CalcPos(pCursor, cbInstr);
2564
2565 /* Get the opcode and deal with it if we know it. */
2566 bOpCode = rtDwarfCursor_GetUByte(pCursor, 0);
2567 switch (bOpCode)
2568 {
2569 case DW_LNE_end_sequence:
2570#if 0 /* No need for this, I think. */
2571 pLnState->Regs.fEndSequence = true;
2572 rc = rtDwarfLine_AddLine(pLnState, offOpCode);
2573#endif
2574 rtDwarfLine_ResetState(pLnState);
2575 Log2(("%08x: DW_LNE_end_sequence\n", offOpCode));
2576 break;
2577
2578 case DW_LNE_set_address:
2579 pLnState->Regs.uAddress = rtDwarfCursor_GetVarSizedU(pCursor, cbInstr - 1, UINT64_MAX);
2580 pLnState->Regs.idxOp = 0;
2581 Log2(("%08x: DW_LNE_set_address: %#llx\n", offOpCode, pLnState->Regs.uAddress));
2582 break;
2583
2584 case DW_LNE_define_file:
2585 {
2586 const char *pszFilename = rtDwarfCursor_GetSZ(pCursor, NULL);
2587 uint32_t idxInc = rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX);
2588 rtDwarfCursor_SkipLeb128(pCursor); /* st_mtime */
2589 rtDwarfCursor_SkipLeb128(pCursor); /* st_size */
2590 Log2(("%08x: DW_LNE_define_file: {%d}/%s\n", offOpCode, idxInc, pszFilename));
2591
2592 rc = rtDwarfCursor_AdvanceToPos(pCursor, pbEndOfInstr);
2593 if (RT_SUCCESS(rc))
2594 rc = rtDwarfLine_DefineFileName(pLnState, pszFilename, idxInc);
2595 break;
2596 }
2597
2598 /*
2599 * Note! Was defined in DWARF 4. But... Watcom used it
2600 * for setting the segment in DWARF 2, creating
2601 * an incompatibility with the newer standard.
2602 */
2603 case DW_LNE_set_descriminator:
2604 if (pLnState->Hdr.uVer != 2)
2605 {
2606 Assert(pLnState->Hdr.uVer >= 4);
2607 pLnState->Regs.uDiscriminator = rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX);
2608 Log2(("%08x: DW_LNE_set_descriminator: %u\n", offOpCode, pLnState->Regs.uDiscriminator));
2609 }
2610 else
2611 {
2612 uint64_t uSeg = rtDwarfCursor_GetVarSizedU(pCursor, cbInstr - 1, UINT64_MAX);
2613 Log2(("%08x: DW_LNE_set_segment: %#llx, cbInstr=%#x - Watcom Extension\n", offOpCode, uSeg, cbInstr));
2614 pLnState->Regs.uSegment = (RTSEL)uSeg;
2615 AssertStmt(pLnState->Regs.uSegment == uSeg, rc = VERR_DWARF_BAD_INFO);
2616 }
2617 break;
2618
2619 default:
2620 Log(("rtDwarfLine_RunProgram: Unknown extended opcode %#x, length %#x at %08x\n", bOpCode, cbInstr, offOpCode));
2621 break;
2622 }
2623
2624 /* Advance the cursor to the end of the instruction . */
2625 rtDwarfCursor_AdvanceToPos(pCursor, pbEndOfInstr);
2626 break;
2627 }
2628 }
2629 }
2630
2631 /*
2632 * Check the status before looping.
2633 */
2634 if (RT_FAILURE(rc))
2635 return rc;
2636 if (RT_FAILURE(pCursor->rc))
2637 return pCursor->rc;
2638 }
2639 return rc;
2640}
2641
2642
2643/**
2644 * Reads the include directories for a line number unit.
2645 *
2646 * @returns IPRT status code
2647 * @param pLnState The line number program state.
2648 * @param pCursor The cursor.
2649 */
2650static int rtDwarfLine_ReadFileNames(PRTDWARFLINESTATE pLnState, PRTDWARFCURSOR pCursor)
2651{
2652 int rc = rtDwarfLine_DefineFileName(pLnState, "/<bad-zero-file-name-entry>", 0);
2653 if (RT_FAILURE(rc))
2654 return rc;
2655
2656 for (;;)
2657 {
2658 const char *psz = rtDwarfCursor_GetSZ(pCursor, NULL);
2659 if (!*psz)
2660 break;
2661
2662 uint64_t idxInc = rtDwarfCursor_GetULeb128(pCursor, UINT64_MAX);
2663 rtDwarfCursor_SkipLeb128(pCursor); /* st_mtime */
2664 rtDwarfCursor_SkipLeb128(pCursor); /* st_size */
2665
2666 rc = rtDwarfLine_DefineFileName(pLnState, psz, idxInc);
2667 if (RT_FAILURE(rc))
2668 return rc;
2669 }
2670 return pCursor->rc;
2671}
2672
2673
2674/**
2675 * Reads the include directories for a line number unit.
2676 *
2677 * @returns IPRT status code
2678 * @param pLnState The line number program state.
2679 * @param pCursor The cursor.
2680 */
2681static int rtDwarfLine_ReadIncludePaths(PRTDWARFLINESTATE pLnState, PRTDWARFCURSOR pCursor)
2682{
2683 const char *psz = ""; /* The zeroth is the unit dir. */
2684 for (;;)
2685 {
2686 if ((pLnState->cIncPaths % 2) == 0)
2687 {
2688 void *pv = RTMemRealloc(pLnState->papszIncPaths, sizeof(pLnState->papszIncPaths[0]) * (pLnState->cIncPaths + 2));
2689 if (!pv)
2690 return VERR_NO_MEMORY;
2691 pLnState->papszIncPaths = (const char **)pv;
2692 }
2693 Log((" Path #%02u = '%s'\n", pLnState->cIncPaths, psz));
2694 pLnState->papszIncPaths[pLnState->cIncPaths] = psz;
2695 pLnState->cIncPaths++;
2696
2697 psz = rtDwarfCursor_GetSZ(pCursor, NULL);
2698 if (!*psz)
2699 break;
2700 }
2701
2702 return pCursor->rc;
2703}
2704
2705
2706/**
2707 * Explodes the line number table for a compilation unit.
2708 *
2709 * @returns IPRT status code
2710 * @param pThis The DWARF instance.
2711 * @param pCursor The cursor to read the line number information
2712 * via.
2713 */
2714static int rtDwarfLine_ExplodeUnit(PRTDBGMODDWARF pThis, PRTDWARFCURSOR pCursor)
2715{
2716 RTDWARFLINESTATE LnState;
2717 RT_ZERO(LnState);
2718 LnState.pDwarfMod = pThis;
2719
2720 /*
2721 * Parse the header.
2722 */
2723 rtDwarfCursor_GetInitalLength(pCursor);
2724 LnState.Hdr.uVer = rtDwarfCursor_GetUHalf(pCursor, 0);
2725 if ( LnState.Hdr.uVer < 2
2726 || LnState.Hdr.uVer > 4)
2727 return rtDwarfCursor_SkipUnit(pCursor);
2728
2729 LnState.Hdr.offFirstOpcode = rtDwarfCursor_GetUOff(pCursor, 0);
2730 uint8_t const * const pbFirstOpcode = rtDwarfCursor_CalcPos(pCursor, LnState.Hdr.offFirstOpcode);
2731
2732 LnState.Hdr.cbMinInstr = rtDwarfCursor_GetUByte(pCursor, 0);
2733 if (LnState.Hdr.uVer >= 4)
2734 LnState.Hdr.cMaxOpsPerInstr = rtDwarfCursor_GetUByte(pCursor, 0);
2735 else
2736 LnState.Hdr.cMaxOpsPerInstr = 1;
2737 LnState.Hdr.u8DefIsStmt = rtDwarfCursor_GetUByte(pCursor, 0);
2738 LnState.Hdr.s8LineBase = rtDwarfCursor_GetSByte(pCursor, 0);
2739 LnState.Hdr.u8LineRange = rtDwarfCursor_GetUByte(pCursor, 0);
2740 LnState.Hdr.u8OpcodeBase = rtDwarfCursor_GetUByte(pCursor, 0);
2741
2742 if ( !LnState.Hdr.u8OpcodeBase
2743 || !LnState.Hdr.cMaxOpsPerInstr
2744 || !LnState.Hdr.u8LineRange
2745 || LnState.Hdr.u8DefIsStmt > 1)
2746 return VERR_DWARF_BAD_LINE_NUMBER_HEADER;
2747 Log2(("DWARF Line number header:\n"
2748 " uVer %d\n"
2749 " offFirstOpcode %#llx\n"
2750 " cbMinInstr %u\n"
2751 " cMaxOpsPerInstr %u\n"
2752 " u8DefIsStmt %u\n"
2753 " s8LineBase %d\n"
2754 " u8LineRange %u\n"
2755 " u8OpcodeBase %u\n",
2756 LnState.Hdr.uVer, LnState.Hdr.offFirstOpcode, LnState.Hdr.cbMinInstr, LnState.Hdr.cMaxOpsPerInstr,
2757 LnState.Hdr.u8DefIsStmt, LnState.Hdr.s8LineBase, LnState.Hdr.u8LineRange, LnState.Hdr.u8OpcodeBase));
2758
2759 LnState.Hdr.pacStdOperands = pCursor->pb;
2760 for (uint8_t iStdOpcode = 1; iStdOpcode < LnState.Hdr.u8OpcodeBase; iStdOpcode++)
2761 rtDwarfCursor_GetUByte(pCursor, 0);
2762
2763 int rc = pCursor->rc;
2764 if (RT_SUCCESS(rc))
2765 rc = rtDwarfLine_ReadIncludePaths(&LnState, pCursor);
2766 if (RT_SUCCESS(rc))
2767 rc = rtDwarfLine_ReadFileNames(&LnState, pCursor);
2768
2769 /*
2770 * Run the program....
2771 */
2772 if (RT_SUCCESS(rc))
2773 rc = rtDwarfCursor_AdvanceToPos(pCursor, pbFirstOpcode);
2774 if (RT_SUCCESS(rc))
2775 rc = rtDwarfLine_RunProgram(&LnState, pCursor);
2776
2777 /*
2778 * Clean up.
2779 */
2780 size_t i = LnState.cFileNames;
2781 while (i-- > 0)
2782 RTStrFree(LnState.papszFileNames[i]);
2783 RTMemFree(LnState.papszFileNames);
2784 RTMemFree(LnState.papszIncPaths);
2785
2786 Assert(rtDwarfCursor_IsAtEndOfUnit(pCursor) || RT_FAILURE(rc));
2787 return rc;
2788}
2789
2790
2791/**
2792 * Explodes the line number table.
2793 *
2794 * The line numbers are insered into the debug info container.
2795 *
2796 * @returns IPRT status code
2797 * @param pThis The DWARF instance.
2798 */
2799static int rtDwarfLine_ExplodeAll(PRTDBGMODDWARF pThis)
2800{
2801 if (!pThis->aSections[krtDbgModDwarfSect_line].fPresent)
2802 return VINF_SUCCESS;
2803
2804 RTDWARFCURSOR Cursor;
2805 int rc = rtDwarfCursor_Init(&Cursor, pThis, krtDbgModDwarfSect_line);
2806 if (RT_FAILURE(rc))
2807 return rc;
2808
2809 while ( !rtDwarfCursor_IsAtEnd(&Cursor)
2810 && RT_SUCCESS(rc))
2811 rc = rtDwarfLine_ExplodeUnit(pThis, &Cursor);
2812
2813 return rtDwarfCursor_Delete(&Cursor, rc);
2814}
2815
2816
2817/*
2818 *
2819 * DWARF Abbreviations.
2820 * DWARF Abbreviations.
2821 * DWARF Abbreviations.
2822 *
2823 */
2824
2825/**
2826 * Deals with a cache miss in rtDwarfAbbrev_Lookup.
2827 *
2828 * @returns Pointer to abbreviation cache entry (read only). May be rendered
2829 * invalid by subsequent calls to this function.
2830 * @param pThis The DWARF instance.
2831 * @param uCode The abbreviation code to lookup.
2832 */
2833static PCRTDWARFABBREV rtDwarfAbbrev_LookupMiss(PRTDBGMODDWARF pThis, uint32_t uCode)
2834{
2835 /*
2836 * There is no entry with code zero.
2837 */
2838 if (!uCode)
2839 return NULL;
2840
2841 /*
2842 * Resize the cache array if the code is considered cachable.
2843 */
2844 bool fFillCache = true;
2845 if (pThis->cCachedAbbrevsAlloced < uCode)
2846 {
2847 if (uCode >= _64K)
2848 fFillCache = false;
2849 else
2850 {
2851 uint32_t cNew = RT_ALIGN(uCode, 64);
2852 void *pv = RTMemRealloc(pThis->paCachedAbbrevs, sizeof(pThis->paCachedAbbrevs[0]) * cNew);
2853 if (!pv)
2854 fFillCache = false;
2855 else
2856 {
2857 Log(("rtDwarfAbbrev_LookupMiss: Growing from %u to %u...\n", pThis->cCachedAbbrevsAlloced, cNew));
2858 pThis->paCachedAbbrevs = (PRTDWARFABBREV)pv;
2859 for (uint32_t i = pThis->cCachedAbbrevsAlloced; i < cNew; i++)
2860 pThis->paCachedAbbrevs[i].offAbbrev = UINT32_MAX;
2861 pThis->cCachedAbbrevsAlloced = cNew;
2862 }
2863 }
2864 }
2865
2866 /*
2867 * Walk the abbreviations till we find the desired code.
2868 */
2869 RTDWARFCURSOR Cursor;
2870 int rc = rtDwarfCursor_InitWithOffset(&Cursor, pThis, krtDbgModDwarfSect_abbrev, pThis->offCachedAbbrev);
2871 if (RT_FAILURE(rc))
2872 return NULL;
2873
2874 PRTDWARFABBREV pRet = NULL;
2875 if (fFillCache)
2876 {
2877 /*
2878 * Search for the entry and fill the cache while doing so.
2879 * We assume that abbreviation codes for a unit will stop when we see
2880 * zero code or when the code value drops.
2881 */
2882 uint32_t uPrevCode = 0;
2883 for (;;)
2884 {
2885 /* Read the 'header'. Skipping zero code bytes. */
2886 uint32_t const uCurCode = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
2887 if (pRet && (uCurCode == 0 || uCurCode < uPrevCode))
2888 break; /* probably end of unit. */
2889 if (uCurCode != 0)
2890 {
2891 uint32_t const uCurTag = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
2892 uint8_t const uChildren = rtDwarfCursor_GetU8(&Cursor, 0);
2893 if (RT_FAILURE(Cursor.rc))
2894 break;
2895 if ( uCurTag > 0xffff
2896 || uChildren > 1)
2897 {
2898 Cursor.rc = VERR_DWARF_BAD_ABBREV;
2899 break;
2900 }
2901
2902 /* Cache it? */
2903 if (uCurCode <= pThis->cCachedAbbrevsAlloced)
2904 {
2905 PRTDWARFABBREV pEntry = &pThis->paCachedAbbrevs[uCurCode - 1];
2906 if (pEntry->offAbbrev != pThis->offCachedAbbrev)
2907 {
2908 pEntry->offAbbrev = pThis->offCachedAbbrev;
2909 pEntry->fChildren = RT_BOOL(uChildren);
2910 pEntry->uTag = uCurTag;
2911 pEntry->offSpec = rtDwarfCursor_CalcSectOffsetU32(&Cursor);
2912
2913 if (uCurCode == uCode)
2914 {
2915 Assert(!pRet);
2916 pRet = pEntry;
2917 if (uCurCode == pThis->cCachedAbbrevsAlloced)
2918 break;
2919 }
2920 }
2921 else if (pRet)
2922 break; /* Next unit, don't cache more. */
2923 /* else: We're growing the cache and re-reading old data. */
2924 }
2925
2926 /* Skip the specification. */
2927 uint32_t uAttr, uForm;
2928 do
2929 {
2930 uAttr = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
2931 uForm = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
2932 } while (uAttr != 0);
2933 }
2934 if (RT_FAILURE(Cursor.rc))
2935 break;
2936
2937 /* Done? (Maximize cache filling.) */
2938 if ( pRet != NULL
2939 && uCurCode >= pThis->cCachedAbbrevsAlloced)
2940 break;
2941 }
2942 }
2943 else
2944 {
2945 /*
2946 * Search for the entry with the desired code, no cache filling.
2947 */
2948 for (;;)
2949 {
2950 /* Read the 'header'. */
2951 uint32_t const uCurCode = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
2952 uint32_t const uCurTag = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
2953 uint8_t const uChildren = rtDwarfCursor_GetU8(&Cursor, 0);
2954 if (RT_FAILURE(Cursor.rc))
2955 break;
2956 if ( uCurTag > 0xffff
2957 || uChildren > 1)
2958 {
2959 Cursor.rc = VERR_DWARF_BAD_ABBREV;
2960 break;
2961 }
2962
2963 /* Do we have a match? */
2964 if (uCurCode == uCode)
2965 {
2966 pRet = &pThis->LookupAbbrev;
2967 pRet->fChildren = RT_BOOL(uChildren);
2968 pRet->uTag = uCurTag;
2969 pRet->offSpec = rtDwarfCursor_CalcSectOffsetU32(&Cursor);
2970 pRet->offAbbrev = pThis->offCachedAbbrev;
2971 break;
2972 }
2973
2974 /* Skip the specification. */
2975 uint32_t uAttr, uForm;
2976 do
2977 {
2978 uAttr = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
2979 uForm = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
2980 } while (uAttr != 0);
2981 if (RT_FAILURE(Cursor.rc))
2982 break;
2983 }
2984 }
2985
2986 rtDwarfCursor_Delete(&Cursor, VINF_SUCCESS);
2987 return pRet;
2988}
2989
2990
2991/**
2992 * Looks up an abbreviation.
2993 *
2994 * @returns Pointer to abbreviation cache entry (read only). May be rendered
2995 * invalid by subsequent calls to this function.
2996 * @param pThis The DWARF instance.
2997 * @param uCode The abbreviation code to lookup.
2998 */
2999static PCRTDWARFABBREV rtDwarfAbbrev_Lookup(PRTDBGMODDWARF pThis, uint32_t uCode)
3000{
3001 if ( uCode - 1 >= pThis->cCachedAbbrevsAlloced
3002 || pThis->paCachedAbbrevs[uCode - 1].offAbbrev != pThis->offCachedAbbrev)
3003 return rtDwarfAbbrev_LookupMiss(pThis, uCode);
3004 return &pThis->paCachedAbbrevs[uCode - 1];
3005}
3006
3007
3008/**
3009 * Sets the abbreviation offset of the current unit.
3010 *
3011 * @param pThis The DWARF instance.
3012 * @param offAbbrev The offset into the abbreviation section.
3013 */
3014static void rtDwarfAbbrev_SetUnitOffset(PRTDBGMODDWARF pThis, uint32_t offAbbrev)
3015{
3016 pThis->offCachedAbbrev = offAbbrev;
3017}
3018
3019
3020
3021/*
3022 *
3023 * DIE Attribute Parsers.
3024 * DIE Attribute Parsers.
3025 * DIE Attribute Parsers.
3026 *
3027 */
3028
3029/**
3030 * Gets the compilation unit a DIE belongs to.
3031 *
3032 * @returns The compilation unit DIE.
3033 * @param pDie Some DIE in the unit.
3034 */
3035static PRTDWARFDIECOMPILEUNIT rtDwarfDie_GetCompileUnit(PRTDWARFDIE pDie)
3036{
3037 while (pDie->pParent)
3038 pDie = pDie->pParent;
3039 AssertReturn( pDie->uTag == DW_TAG_compile_unit
3040 || pDie->uTag == DW_TAG_partial_unit,
3041 NULL);
3042 return (PRTDWARFDIECOMPILEUNIT)pDie;
3043}
3044
3045
3046/**
3047 * Resolves a string section (debug_str) reference.
3048 *
3049 * @returns Pointer to the string (inside the string section).
3050 * @param pThis The DWARF instance.
3051 * @param pCursor The cursor.
3052 * @param pszErrValue What to return on failure (@a
3053 * pCursor->rc is set).
3054 */
3055static const char *rtDwarfDecodeHlp_GetStrp(PRTDBGMODDWARF pThis, PRTDWARFCURSOR pCursor, const char *pszErrValue)
3056{
3057 uint64_t offDebugStr = rtDwarfCursor_GetUOff(pCursor, UINT64_MAX);
3058 if (RT_FAILURE(pCursor->rc))
3059 return pszErrValue;
3060
3061 if (offDebugStr >= pThis->aSections[krtDbgModDwarfSect_str].cb)
3062 {
3063 /* Ugly: Exploit the cursor status field for reporting errors. */
3064 pCursor->rc = VERR_DWARF_BAD_INFO;
3065 return pszErrValue;
3066 }
3067
3068 if (!pThis->aSections[krtDbgModDwarfSect_str].pv)
3069 {
3070 int rc = rtDbgModDwarfLoadSection(pThis, krtDbgModDwarfSect_str);
3071 if (RT_FAILURE(rc))
3072 {
3073 /* Ugly: Exploit the cursor status field for reporting errors. */
3074 pCursor->rc = rc;
3075 return pszErrValue;
3076 }
3077 }
3078
3079 return (const char *)pThis->aSections[krtDbgModDwarfSect_str].pv + (size_t)offDebugStr;
3080}
3081
3082
3083/** @callback_method_impl{FNRTDWARFATTRDECODER} */
3084static DECLCALLBACK(int) rtDwarfDecode_Address(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
3085 uint32_t uForm, PRTDWARFCURSOR pCursor)
3086{
3087 AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFADDR), VERR_INTERNAL_ERROR_3);
3088 NOREF(pDie);
3089
3090 uint64_t uAddr;
3091 switch (uForm)
3092 {
3093 case DW_FORM_addr: uAddr = rtDwarfCursor_GetNativeUOff(pCursor, 0); break;
3094 case DW_FORM_data1: uAddr = rtDwarfCursor_GetU8(pCursor, 0); break;
3095 case DW_FORM_data2: uAddr = rtDwarfCursor_GetU16(pCursor, 0); break;
3096 case DW_FORM_data4: uAddr = rtDwarfCursor_GetU32(pCursor, 0); break;
3097 case DW_FORM_data8: uAddr = rtDwarfCursor_GetU64(pCursor, 0); break;
3098 case DW_FORM_udata: uAddr = rtDwarfCursor_GetULeb128(pCursor, 0); break;
3099 default:
3100 AssertMsgFailedReturn(("%#x (%s)\n", uForm, rtDwarfLog_FormName(uForm)), VERR_DWARF_UNEXPECTED_FORM);
3101 }
3102 if (RT_FAILURE(pCursor->rc))
3103 return pCursor->rc;
3104
3105 PRTDWARFADDR pAddr = (PRTDWARFADDR)pbMember;
3106 pAddr->uAddress = uAddr;
3107
3108 Log4((" %-20s %#010llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), uAddr, rtDwarfLog_FormName(uForm)));
3109 return VINF_SUCCESS;
3110}
3111
3112
3113/** @callback_method_impl{FNRTDWARFATTRDECODER} */
3114static DECLCALLBACK(int) rtDwarfDecode_Bool(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
3115 uint32_t uForm, PRTDWARFCURSOR pCursor)
3116{
3117 AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(bool), VERR_INTERNAL_ERROR_3);
3118 NOREF(pDie);
3119
3120 bool *pfMember = (bool *)pbMember;
3121 switch (uForm)
3122 {
3123 case DW_FORM_flag:
3124 {
3125 uint8_t b = rtDwarfCursor_GetU8(pCursor, UINT8_MAX);
3126 if (b > 1)
3127 {
3128 Log(("Unexpected boolean value %#x\n", b));
3129 return RT_FAILURE(pCursor->rc) ? pCursor->rc : pCursor->rc = VERR_DWARF_BAD_INFO;
3130 }
3131 *pfMember = RT_BOOL(b);
3132 break;
3133 }
3134
3135 case DW_FORM_flag_present:
3136 *pfMember = true;
3137 break;
3138
3139 default:
3140 AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
3141 }
3142
3143 Log4((" %-20s %RTbool [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), *pfMember, rtDwarfLog_FormName(uForm)));
3144 return VINF_SUCCESS;
3145}
3146
3147
3148/** @callback_method_impl{FNRTDWARFATTRDECODER} */
3149static DECLCALLBACK(int) rtDwarfDecode_LowHighPc(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
3150 uint32_t uForm, PRTDWARFCURSOR pCursor)
3151{
3152 AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFADDRRANGE), VERR_INTERNAL_ERROR_3);
3153 AssertReturn(pDesc->uAttr == DW_AT_low_pc || pDesc->uAttr == DW_AT_high_pc, VERR_INTERNAL_ERROR_3);
3154 NOREF(pDie);
3155
3156 uint64_t uAddr;
3157 switch (uForm)
3158 {
3159 case DW_FORM_addr: uAddr = rtDwarfCursor_GetNativeUOff(pCursor, 0); break;
3160 case DW_FORM_data1: uAddr = rtDwarfCursor_GetU8(pCursor, 0); break;
3161 case DW_FORM_data2: uAddr = rtDwarfCursor_GetU16(pCursor, 0); break;
3162 case DW_FORM_data4: uAddr = rtDwarfCursor_GetU32(pCursor, 0); break;
3163 case DW_FORM_data8: uAddr = rtDwarfCursor_GetU64(pCursor, 0); break;
3164 case DW_FORM_udata: uAddr = rtDwarfCursor_GetULeb128(pCursor, 0); break;
3165 default:
3166 AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
3167 }
3168 if (RT_FAILURE(pCursor->rc))
3169 return pCursor->rc;
3170
3171 PRTDWARFADDRRANGE pRange = (PRTDWARFADDRRANGE)pbMember;
3172 if (pDesc->uAttr == DW_AT_low_pc)
3173 {
3174 if (pRange->fHaveLowAddress)
3175 {
3176 Log(("rtDwarfDecode_LowHighPc: Duplicate DW_AT_low_pc\n"));
3177 return pCursor->rc = VERR_DWARF_BAD_INFO;
3178 }
3179 pRange->fHaveLowAddress = true;
3180 pRange->uLowAddress = uAddr;
3181 }
3182 else
3183 {
3184 if (pRange->fHaveHighAddress)
3185 {
3186 Log(("rtDwarfDecode_LowHighPc: Duplicate DW_AT_high_pc\n"));
3187 return pCursor->rc = VERR_DWARF_BAD_INFO;
3188 }
3189 pRange->fHaveHighAddress = true;
3190 pRange->fHaveHighIsAddress = uForm == DW_FORM_addr;
3191 if (!pRange->fHaveHighIsAddress && pRange->fHaveLowAddress)
3192 {
3193 pRange->fHaveHighIsAddress = true;
3194 pRange->uHighAddress = uAddr + pRange->uLowAddress;
3195 }
3196 else
3197 pRange->uHighAddress = uAddr;
3198
3199 }
3200 pRange->cAttrs++;
3201
3202 Log4((" %-20s %#010llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), uAddr, rtDwarfLog_FormName(uForm)));
3203 return VINF_SUCCESS;
3204}
3205
3206
3207/** @callback_method_impl{FNRTDWARFATTRDECODER} */
3208static DECLCALLBACK(int) rtDwarfDecode_Ranges(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
3209 uint32_t uForm, PRTDWARFCURSOR pCursor)
3210{
3211 AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFADDRRANGE), VERR_INTERNAL_ERROR_3);
3212 AssertReturn(pDesc->uAttr == DW_AT_ranges, VERR_INTERNAL_ERROR_3);
3213 NOREF(pDie);
3214
3215 /* Decode it. */
3216 uint64_t off;
3217 switch (uForm)
3218 {
3219 case DW_FORM_addr: off = rtDwarfCursor_GetNativeUOff(pCursor, 0); break;
3220 case DW_FORM_data4: off = rtDwarfCursor_GetU32(pCursor, 0); break;
3221 case DW_FORM_data8: off = rtDwarfCursor_GetU64(pCursor, 0); break;
3222 case DW_FORM_sec_offset: off = rtDwarfCursor_GetUOff(pCursor, 0); break;
3223 default:
3224 AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
3225 }
3226 if (RT_FAILURE(pCursor->rc))
3227 return pCursor->rc;
3228
3229 /* Validate the offset and load the ranges. */
3230 PRTDBGMODDWARF pThis = pCursor->pDwarfMod;
3231 if (off >= pThis->aSections[krtDbgModDwarfSect_ranges].cb)
3232 {
3233 Log(("rtDwarfDecode_Ranges: bad ranges off=%#llx\n", off));
3234 return pCursor->rc = VERR_DWARF_BAD_POS;
3235 }
3236
3237 if (!pThis->aSections[krtDbgModDwarfSect_ranges].pv)
3238 {
3239 int rc = rtDbgModDwarfLoadSection(pThis, krtDbgModDwarfSect_ranges);
3240 if (RT_FAILURE(rc))
3241 return pCursor->rc = rc;
3242 }
3243
3244 /* Store the result. */
3245 PRTDWARFADDRRANGE pRange = (PRTDWARFADDRRANGE)pbMember;
3246 if (pRange->fHaveRanges)
3247 {
3248 Log(("rtDwarfDecode_Ranges: Duplicate DW_AT_ranges\n"));
3249 return pCursor->rc = VERR_DWARF_BAD_INFO;
3250 }
3251 pRange->fHaveRanges = true;
3252 pRange->cAttrs++;
3253 pRange->pbRanges = (uint8_t const *)pThis->aSections[krtDbgModDwarfSect_ranges].pv + (size_t)off;
3254
3255 Log4((" %-20s TODO [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), rtDwarfLog_FormName(uForm)));
3256 return VINF_SUCCESS;
3257}
3258
3259
3260/** @callback_method_impl{FNRTDWARFATTRDECODER} */
3261static DECLCALLBACK(int) rtDwarfDecode_Reference(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
3262 uint32_t uForm, PRTDWARFCURSOR pCursor)
3263{
3264 AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFREF), VERR_INTERNAL_ERROR_3);
3265
3266 /* Decode it. */
3267 uint64_t off;
3268 krtDwarfRef enmWrt = krtDwarfRef_SameUnit;
3269 switch (uForm)
3270 {
3271 case DW_FORM_ref1: off = rtDwarfCursor_GetU8(pCursor, 0); break;
3272 case DW_FORM_ref2: off = rtDwarfCursor_GetU16(pCursor, 0); break;
3273 case DW_FORM_ref4: off = rtDwarfCursor_GetU32(pCursor, 0); break;
3274 case DW_FORM_ref8: off = rtDwarfCursor_GetU64(pCursor, 0); break;
3275 case DW_FORM_ref_udata: off = rtDwarfCursor_GetULeb128(pCursor, 0); break;
3276
3277 case DW_FORM_ref_addr:
3278 enmWrt = krtDwarfRef_InfoSection;
3279 off = rtDwarfCursor_GetUOff(pCursor, 0);
3280 break;
3281
3282 case DW_FORM_ref_sig8:
3283 enmWrt = krtDwarfRef_TypeId64;
3284 off = rtDwarfCursor_GetU64(pCursor, 0);
3285 break;
3286
3287 default:
3288 AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
3289 }
3290 if (RT_FAILURE(pCursor->rc))
3291 return pCursor->rc;
3292
3293 /* Validate the offset and convert to debug_info relative offsets. */
3294 if (enmWrt == krtDwarfRef_InfoSection)
3295 {
3296 if (off >= pCursor->pDwarfMod->aSections[krtDbgModDwarfSect_info].cb)
3297 {
3298 Log(("rtDwarfDecode_Reference: bad info off=%#llx\n", off));
3299 return pCursor->rc = VERR_DWARF_BAD_POS;
3300 }
3301 }
3302 else if (enmWrt == krtDwarfRef_SameUnit)
3303 {
3304 PRTDWARFDIECOMPILEUNIT pUnit = rtDwarfDie_GetCompileUnit(pDie);
3305 if (off >= pUnit->cbUnit)
3306 {
3307 Log(("rtDwarfDecode_Reference: bad unit off=%#llx\n", off));
3308 return pCursor->rc = VERR_DWARF_BAD_POS;
3309 }
3310 off += pUnit->offUnit;
3311 enmWrt = krtDwarfRef_InfoSection;
3312 }
3313 /* else: not bother verifying/resolving the indirect type reference yet. */
3314
3315 /* Store it */
3316 PRTDWARFREF pRef = (PRTDWARFREF)pbMember;
3317 pRef->enmWrt = enmWrt;
3318 pRef->off = off;
3319
3320 Log4((" %-20s %d:%#010llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), enmWrt, off, rtDwarfLog_FormName(uForm)));
3321 return VINF_SUCCESS;
3322}
3323
3324
3325/** @callback_method_impl{FNRTDWARFATTRDECODER} */
3326static DECLCALLBACK(int) rtDwarfDecode_SectOff(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
3327 uint32_t uForm, PRTDWARFCURSOR pCursor)
3328{
3329 AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFREF), VERR_INTERNAL_ERROR_3);
3330 NOREF(pDie);
3331
3332 uint64_t off;
3333 switch (uForm)
3334 {
3335 case DW_FORM_data4: off = rtDwarfCursor_GetU32(pCursor, 0); break;
3336 case DW_FORM_data8: off = rtDwarfCursor_GetU64(pCursor, 0); break;
3337 case DW_FORM_sec_offset: off = rtDwarfCursor_GetUOff(pCursor, 0); break;
3338 default:
3339 AssertMsgFailedReturn(("%#x (%s)\n", uForm, rtDwarfLog_FormName(uForm)), VERR_DWARF_UNEXPECTED_FORM);
3340 }
3341 if (RT_FAILURE(pCursor->rc))
3342 return pCursor->rc;
3343
3344 krtDbgModDwarfSect enmSect;
3345 krtDwarfRef enmWrt;
3346 switch (pDesc->uAttr)
3347 {
3348 case DW_AT_stmt_list: enmSect = krtDbgModDwarfSect_line; enmWrt = krtDwarfRef_LineSection; break;
3349 case DW_AT_macro_info: enmSect = krtDbgModDwarfSect_loc; enmWrt = krtDwarfRef_LocSection; break;
3350 case DW_AT_ranges: enmSect = krtDbgModDwarfSect_ranges; enmWrt = krtDwarfRef_RangesSection; break;
3351 default:
3352 AssertMsgFailedReturn(("%u (%s)\n", pDesc->uAttr, rtDwarfLog_AttrName(pDesc->uAttr)), VERR_INTERNAL_ERROR_4);
3353 }
3354 size_t cbSect = pCursor->pDwarfMod->aSections[enmSect].cb;
3355 if (off >= cbSect)
3356 {
3357 /* Watcom generates offset past the end of the section, increasing the
3358 offset by one for each compile unit. So, just fudge it. */
3359 Log(("rtDwarfDecode_SectOff: bad off=%#llx, attr %#x (%s), enmSect=%d cb=%#llx; Assuming watcom/gcc.\n", off,
3360 pDesc->uAttr, rtDwarfLog_AttrName(pDesc->uAttr), enmSect, cbSect));
3361 off = cbSect;
3362 }
3363
3364 PRTDWARFREF pRef = (PRTDWARFREF)pbMember;
3365 pRef->enmWrt = enmWrt;
3366 pRef->off = off;
3367
3368 Log4((" %-20s %d:%#010llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), enmWrt, off, rtDwarfLog_FormName(uForm)));
3369 return VINF_SUCCESS;
3370}
3371
3372
3373/** @callback_method_impl{FNRTDWARFATTRDECODER} */
3374static DECLCALLBACK(int) rtDwarfDecode_String(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
3375 uint32_t uForm, PRTDWARFCURSOR pCursor)
3376{
3377 AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(const char *), VERR_INTERNAL_ERROR_3);
3378 NOREF(pDie);
3379
3380 const char *psz;
3381 switch (uForm)
3382 {
3383 case DW_FORM_string:
3384 psz = rtDwarfCursor_GetSZ(pCursor, NULL);
3385 break;
3386
3387 case DW_FORM_strp:
3388 psz = rtDwarfDecodeHlp_GetStrp(pCursor->pDwarfMod, pCursor, NULL);
3389 break;
3390
3391 default:
3392 AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
3393 }
3394
3395 *(const char **)pbMember = psz;
3396 Log4((" %-20s '%s' [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr), psz, rtDwarfLog_FormName(uForm)));
3397 return pCursor->rc;
3398}
3399
3400
3401/** @callback_method_impl{FNRTDWARFATTRDECODER} */
3402static DECLCALLBACK(int) rtDwarfDecode_UnsignedInt(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
3403 uint32_t uForm, PRTDWARFCURSOR pCursor)
3404{
3405 NOREF(pDie);
3406 uint64_t u64Val;
3407 switch (uForm)
3408 {
3409 case DW_FORM_udata: u64Val = rtDwarfCursor_GetULeb128(pCursor, 0); break;
3410 case DW_FORM_data1: u64Val = rtDwarfCursor_GetU8(pCursor, 0); break;
3411 case DW_FORM_data2: u64Val = rtDwarfCursor_GetU16(pCursor, 0); break;
3412 case DW_FORM_data4: u64Val = rtDwarfCursor_GetU32(pCursor, 0); break;
3413 case DW_FORM_data8: u64Val = rtDwarfCursor_GetU64(pCursor, 0); break;
3414 default:
3415 AssertMsgFailedReturn(("%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
3416 }
3417 if (RT_FAILURE(pCursor->rc))
3418 return pCursor->rc;
3419
3420 switch (ATTR_GET_SIZE(pDesc))
3421 {
3422 case 1:
3423 *pbMember = (uint8_t)u64Val;
3424 if (*pbMember != u64Val)
3425 {
3426 AssertFailed();
3427 return VERR_OUT_OF_RANGE;
3428 }
3429 break;
3430
3431 case 2:
3432 *(uint16_t *)pbMember = (uint16_t)u64Val;
3433 if (*(uint16_t *)pbMember != u64Val)
3434 {
3435 AssertFailed();
3436 return VERR_OUT_OF_RANGE;
3437 }
3438 break;
3439
3440 case 4:
3441 *(uint32_t *)pbMember = (uint32_t)u64Val;
3442 if (*(uint32_t *)pbMember != u64Val)
3443 {
3444 AssertFailed();
3445 return VERR_OUT_OF_RANGE;
3446 }
3447 break;
3448
3449 case 8:
3450 *(uint64_t *)pbMember = (uint64_t)u64Val;
3451 if (*(uint64_t *)pbMember != u64Val)
3452 {
3453 AssertFailed();
3454 return VERR_OUT_OF_RANGE;
3455 }
3456 break;
3457
3458 default:
3459 AssertMsgFailedReturn(("%#x\n", ATTR_GET_SIZE(pDesc)), VERR_INTERNAL_ERROR_2);
3460 }
3461 return VINF_SUCCESS;
3462}
3463
3464
3465/**
3466 * Initialize location interpreter state from cursor & form.
3467 *
3468 * @returns IPRT status code.
3469 * @retval VERR_NOT_FOUND if no location information (i.e. there is source but
3470 * it resulted in no byte code).
3471 * @param pLoc The location state structure to initialize.
3472 * @param pCursor The cursor to read from.
3473 * @param uForm The attribute form.
3474 */
3475static int rtDwarfLoc_Init(PRTDWARFLOCST pLoc, PRTDWARFCURSOR pCursor, uint32_t uForm)
3476{
3477 uint32_t cbBlock;
3478 switch (uForm)
3479 {
3480 case DW_FORM_block1:
3481 cbBlock = rtDwarfCursor_GetU8(pCursor, 0);
3482 break;
3483
3484 case DW_FORM_block2:
3485 cbBlock = rtDwarfCursor_GetU16(pCursor, 0);
3486 break;
3487
3488 case DW_FORM_block4:
3489 cbBlock = rtDwarfCursor_GetU32(pCursor, 0);
3490 break;
3491
3492 case DW_FORM_block:
3493 cbBlock = rtDwarfCursor_GetULeb128(pCursor, 0);
3494 break;
3495
3496 default:
3497 AssertMsgFailedReturn(("uForm=%#x\n", uForm), VERR_DWARF_UNEXPECTED_FORM);
3498 }
3499 if (!cbBlock)
3500 return VERR_NOT_FOUND;
3501
3502 int rc = rtDwarfCursor_InitForBlock(&pLoc->Cursor, pCursor, cbBlock);
3503 if (RT_FAILURE(rc))
3504 return rc;
3505 pLoc->iTop = -1;
3506 return VINF_SUCCESS;
3507}
3508
3509
3510/**
3511 * Pushes a value onto the stack.
3512 *
3513 * @returns VINF_SUCCESS or VERR_DWARF_STACK_OVERFLOW.
3514 * @param pLoc The state.
3515 * @param uValue The value to push.
3516 */
3517static int rtDwarfLoc_Push(PRTDWARFLOCST pLoc, uint64_t uValue)
3518{
3519 int iTop = pLoc->iTop + 1;
3520 AssertReturn((unsigned)iTop < RT_ELEMENTS(pLoc->auStack), VERR_DWARF_STACK_OVERFLOW);
3521 pLoc->auStack[iTop] = uValue;
3522 pLoc->iTop = iTop;
3523 return VINF_SUCCESS;
3524}
3525
3526
3527static int rtDwarfLoc_Evaluate(PRTDWARFLOCST pLoc, void *pvLater, void *pvUser)
3528{
3529 while (!rtDwarfCursor_IsAtEndOfUnit(&pLoc->Cursor))
3530 {
3531 /* Read the next opcode.*/
3532 uint8_t const bOpcode = rtDwarfCursor_GetU8(&pLoc->Cursor, 0);
3533
3534 /* Get its operands. */
3535 uint64_t uOperand1 = 0;
3536 uint64_t uOperand2 = 0;
3537 switch (bOpcode)
3538 {
3539 case DW_OP_addr:
3540 uOperand1 = rtDwarfCursor_GetNativeUOff(&pLoc->Cursor, 0);
3541 break;
3542 case DW_OP_pick:
3543 case DW_OP_const1u:
3544 case DW_OP_deref_size:
3545 case DW_OP_xderef_size:
3546 uOperand1 = rtDwarfCursor_GetU8(&pLoc->Cursor, 0);
3547 break;
3548 case DW_OP_const1s:
3549 uOperand1 = (int8_t)rtDwarfCursor_GetU8(&pLoc->Cursor, 0);
3550 break;
3551 case DW_OP_const2u:
3552 uOperand1 = rtDwarfCursor_GetU16(&pLoc->Cursor, 0);
3553 break;
3554 case DW_OP_skip:
3555 case DW_OP_bra:
3556 case DW_OP_const2s:
3557 uOperand1 = (int16_t)rtDwarfCursor_GetU16(&pLoc->Cursor, 0);
3558 break;
3559 case DW_OP_const4u:
3560 uOperand1 = rtDwarfCursor_GetU32(&pLoc->Cursor, 0);
3561 break;
3562 case DW_OP_const4s:
3563 uOperand1 = (int32_t)rtDwarfCursor_GetU32(&pLoc->Cursor, 0);
3564 break;
3565 case DW_OP_const8u:
3566 uOperand1 = rtDwarfCursor_GetU64(&pLoc->Cursor, 0);
3567 break;
3568 case DW_OP_const8s:
3569 uOperand1 = rtDwarfCursor_GetU64(&pLoc->Cursor, 0);
3570 break;
3571 case DW_OP_regx:
3572 case DW_OP_piece:
3573 case DW_OP_plus_uconst:
3574 case DW_OP_constu:
3575 uOperand1 = rtDwarfCursor_GetULeb128(&pLoc->Cursor, 0);
3576 break;
3577 case DW_OP_consts:
3578 case DW_OP_fbreg:
3579 case DW_OP_breg0+0: case DW_OP_breg0+1: case DW_OP_breg0+2: case DW_OP_breg0+3:
3580 case DW_OP_breg0+4: case DW_OP_breg0+5: case DW_OP_breg0+6: case DW_OP_breg0+7:
3581 case DW_OP_breg0+8: case DW_OP_breg0+9: case DW_OP_breg0+10: case DW_OP_breg0+11:
3582 case DW_OP_breg0+12: case DW_OP_breg0+13: case DW_OP_breg0+14: case DW_OP_breg0+15:
3583 case DW_OP_breg0+16: case DW_OP_breg0+17: case DW_OP_breg0+18: case DW_OP_breg0+19:
3584 case DW_OP_breg0+20: case DW_OP_breg0+21: case DW_OP_breg0+22: case DW_OP_breg0+23:
3585 case DW_OP_breg0+24: case DW_OP_breg0+25: case DW_OP_breg0+26: case DW_OP_breg0+27:
3586 case DW_OP_breg0+28: case DW_OP_breg0+29: case DW_OP_breg0+30: case DW_OP_breg0+31:
3587 uOperand1 = rtDwarfCursor_GetSLeb128(&pLoc->Cursor, 0);
3588 break;
3589 case DW_OP_bregx:
3590 uOperand1 = rtDwarfCursor_GetULeb128(&pLoc->Cursor, 0);
3591 uOperand2 = rtDwarfCursor_GetSLeb128(&pLoc->Cursor, 0);
3592 break;
3593 }
3594 if (RT_FAILURE(pLoc->Cursor.rc))
3595 break;
3596
3597 /* Interpret the opcode. */
3598 int rc;
3599 switch (bOpcode)
3600 {
3601 case DW_OP_const1u:
3602 case DW_OP_const1s:
3603 case DW_OP_const2u:
3604 case DW_OP_const2s:
3605 case DW_OP_const4u:
3606 case DW_OP_const4s:
3607 case DW_OP_const8u:
3608 case DW_OP_const8s:
3609 case DW_OP_constu:
3610 case DW_OP_consts:
3611 case DW_OP_addr:
3612 rc = rtDwarfLoc_Push(pLoc, uOperand1);
3613 break;
3614 case DW_OP_lit0 + 0: case DW_OP_lit0 + 1: case DW_OP_lit0 + 2: case DW_OP_lit0 + 3:
3615 case DW_OP_lit0 + 4: case DW_OP_lit0 + 5: case DW_OP_lit0 + 6: case DW_OP_lit0 + 7:
3616 case DW_OP_lit0 + 8: case DW_OP_lit0 + 9: case DW_OP_lit0 + 10: case DW_OP_lit0 + 11:
3617 case DW_OP_lit0 + 12: case DW_OP_lit0 + 13: case DW_OP_lit0 + 14: case DW_OP_lit0 + 15:
3618 case DW_OP_lit0 + 16: case DW_OP_lit0 + 17: case DW_OP_lit0 + 18: case DW_OP_lit0 + 19:
3619 case DW_OP_lit0 + 20: case DW_OP_lit0 + 21: case DW_OP_lit0 + 22: case DW_OP_lit0 + 23:
3620 case DW_OP_lit0 + 24: case DW_OP_lit0 + 25: case DW_OP_lit0 + 26: case DW_OP_lit0 + 27:
3621 case DW_OP_lit0 + 28: case DW_OP_lit0 + 29: case DW_OP_lit0 + 30: case DW_OP_lit0 + 31:
3622 rc = rtDwarfLoc_Push(pLoc, bOpcode - DW_OP_lit0);
3623 break;
3624 case DW_OP_nop:
3625 break;
3626 case DW_OP_dup: /** @todo 0 operands. */
3627 case DW_OP_drop: /** @todo 0 operands. */
3628 case DW_OP_over: /** @todo 0 operands. */
3629 case DW_OP_pick: /** @todo 1 operands, a 1-byte stack index. */
3630 case DW_OP_swap: /** @todo 0 operands. */
3631 case DW_OP_rot: /** @todo 0 operands. */
3632 case DW_OP_abs: /** @todo 0 operands. */
3633 case DW_OP_and: /** @todo 0 operands. */
3634 case DW_OP_div: /** @todo 0 operands. */
3635 case DW_OP_minus: /** @todo 0 operands. */
3636 case DW_OP_mod: /** @todo 0 operands. */
3637 case DW_OP_mul: /** @todo 0 operands. */
3638 case DW_OP_neg: /** @todo 0 operands. */
3639 case DW_OP_not: /** @todo 0 operands. */
3640 case DW_OP_or: /** @todo 0 operands. */
3641 case DW_OP_plus: /** @todo 0 operands. */
3642 case DW_OP_plus_uconst: /** @todo 1 operands, a ULEB128 addend. */
3643 case DW_OP_shl: /** @todo 0 operands. */
3644 case DW_OP_shr: /** @todo 0 operands. */
3645 case DW_OP_shra: /** @todo 0 operands. */
3646 case DW_OP_xor: /** @todo 0 operands. */
3647 case DW_OP_skip: /** @todo 1 signed 2-byte constant. */
3648 case DW_OP_bra: /** @todo 1 signed 2-byte constant. */
3649 case DW_OP_eq: /** @todo 0 operands. */
3650 case DW_OP_ge: /** @todo 0 operands. */
3651 case DW_OP_gt: /** @todo 0 operands. */
3652 case DW_OP_le: /** @todo 0 operands. */
3653 case DW_OP_lt: /** @todo 0 operands. */
3654 case DW_OP_ne: /** @todo 0 operands. */
3655 case DW_OP_reg0 + 0: case DW_OP_reg0 + 1: case DW_OP_reg0 + 2: case DW_OP_reg0 + 3: /** @todo 0 operands - reg 0..31. */
3656 case DW_OP_reg0 + 4: case DW_OP_reg0 + 5: case DW_OP_reg0 + 6: case DW_OP_reg0 + 7:
3657 case DW_OP_reg0 + 8: case DW_OP_reg0 + 9: case DW_OP_reg0 + 10: case DW_OP_reg0 + 11:
3658 case DW_OP_reg0 + 12: case DW_OP_reg0 + 13: case DW_OP_reg0 + 14: case DW_OP_reg0 + 15:
3659 case DW_OP_reg0 + 16: case DW_OP_reg0 + 17: case DW_OP_reg0 + 18: case DW_OP_reg0 + 19:
3660 case DW_OP_reg0 + 20: case DW_OP_reg0 + 21: case DW_OP_reg0 + 22: case DW_OP_reg0 + 23:
3661 case DW_OP_reg0 + 24: case DW_OP_reg0 + 25: case DW_OP_reg0 + 26: case DW_OP_reg0 + 27:
3662 case DW_OP_reg0 + 28: case DW_OP_reg0 + 29: case DW_OP_reg0 + 30: case DW_OP_reg0 + 31:
3663 case DW_OP_breg0+ 0: case DW_OP_breg0+ 1: case DW_OP_breg0+ 2: case DW_OP_breg0+ 3: /** @todo 1 operand, a SLEB128 offset. */
3664 case DW_OP_breg0+ 4: case DW_OP_breg0+ 5: case DW_OP_breg0+ 6: case DW_OP_breg0+ 7:
3665 case DW_OP_breg0+ 8: case DW_OP_breg0+ 9: case DW_OP_breg0+ 10: case DW_OP_breg0+ 11:
3666 case DW_OP_breg0+ 12: case DW_OP_breg0+ 13: case DW_OP_breg0+ 14: case DW_OP_breg0+ 15:
3667 case DW_OP_breg0+ 16: case DW_OP_breg0+ 17: case DW_OP_breg0+ 18: case DW_OP_breg0+ 19:
3668 case DW_OP_breg0+ 20: case DW_OP_breg0+ 21: case DW_OP_breg0+ 22: case DW_OP_breg0+ 23:
3669 case DW_OP_breg0+ 24: case DW_OP_breg0+ 25: case DW_OP_breg0+ 26: case DW_OP_breg0+ 27:
3670 case DW_OP_breg0+ 28: case DW_OP_breg0+ 29: case DW_OP_breg0+ 30: case DW_OP_breg0+ 31:
3671 case DW_OP_piece: /** @todo 1 operand, a ULEB128 size of piece addressed. */
3672 case DW_OP_regx: /** @todo 1 operand, a ULEB128 register. */
3673 case DW_OP_fbreg: /** @todo 1 operand, a SLEB128 offset. */
3674 case DW_OP_bregx: /** @todo 2 operands, a ULEB128 register followed by a SLEB128 offset. */
3675 case DW_OP_deref: /** @todo 0 operands. */
3676 case DW_OP_deref_size: /** @todo 1 operand, a 1-byte size of data retrieved. */
3677 case DW_OP_xderef: /** @todo 0 operands. */
3678 case DW_OP_xderef_size: /** @todo 1 operand, a 1-byte size of data retrieved. */
3679 AssertMsgFailedReturn(("bOpcode=%#x\n", bOpcode), VERR_DWARF_TODO);
3680 default:
3681 AssertMsgFailedReturn(("bOpcode=%#x\n", bOpcode), VERR_DWARF_UNKNOWN_LOC_OPCODE);
3682 }
3683 }
3684
3685 return pLoc->Cursor.rc;
3686}
3687
3688
3689/** @callback_method_impl{FNRTDWARFATTRDECODER} */
3690static DECLCALLBACK(int) rtDwarfDecode_SegmentLoc(PRTDWARFDIE pDie, uint8_t *pbMember, PCRTDWARFATTRDESC pDesc,
3691 uint32_t uForm, PRTDWARFCURSOR pCursor)
3692{
3693 NOREF(pDie);
3694 AssertReturn(ATTR_GET_SIZE(pDesc) == 2, VERR_DWARF_IPE);
3695
3696 RTDWARFLOCST LocSt;
3697 int rc = rtDwarfLoc_Init(&LocSt, pCursor, uForm);
3698 if (RT_SUCCESS(rc))
3699 {
3700 rc = rtDwarfLoc_Evaluate(&LocSt, NULL, NULL);
3701 if (RT_SUCCESS(rc))
3702 {
3703 if (LocSt.iTop >= 0)
3704 {
3705 *(uint16_t *)pbMember = LocSt.auStack[LocSt.iTop];
3706 Log4((" %-20s %#06llx [%s]\n", rtDwarfLog_AttrName(pDesc->uAttr),
3707 LocSt.auStack[LocSt.iTop], rtDwarfLog_FormName(uForm)));
3708 return VINF_SUCCESS;
3709 }
3710 rc = VERR_DWARF_STACK_UNDERFLOW;
3711 }
3712 }
3713 return rc;
3714}
3715
3716/*
3717 *
3718 * DWARF debug_info parser
3719 * DWARF debug_info parser
3720 * DWARF debug_info parser
3721 *
3722 */
3723
3724
3725/**
3726 * Special hack to get the name and/or linkage name for a subprogram via a
3727 * specification reference.
3728 *
3729 * Since this is a hack, we ignore failure.
3730 *
3731 * If we want to really make use of DWARF info, we'll have to create some kind
3732 * of lookup tree for handling this. But currently we don't, so a hack will
3733 * suffice.
3734 *
3735 * @param pThis The DWARF instance.
3736 * @param pSubProgram The subprogram which is short on names.
3737 */
3738static void rtDwarfInfo_TryGetSubProgramNameFromSpecRef(PRTDBGMODDWARF pThis, PRTDWARFDIESUBPROGRAM pSubProgram)
3739{
3740 /*
3741 * Must have a spec ref, and it must be in the info section.
3742 */
3743 if (pSubProgram->SpecRef.enmWrt != krtDwarfRef_InfoSection)
3744 return;
3745
3746 /*
3747 * Create a cursor for reading the info and then the abbrivation code
3748 * starting the off the DIE.
3749 */
3750 RTDWARFCURSOR InfoCursor;
3751 int rc = rtDwarfCursor_InitWithOffset(&InfoCursor, pThis, krtDbgModDwarfSect_info, pSubProgram->SpecRef.off);
3752 if (RT_FAILURE(rc))
3753 return;
3754
3755 uint32_t uAbbrCode = rtDwarfCursor_GetULeb128AsU32(&InfoCursor, UINT32_MAX);
3756 if (uAbbrCode)
3757 {
3758 /* Only references to subprogram tags are interesting here. */
3759 PCRTDWARFABBREV pAbbrev = rtDwarfAbbrev_Lookup(pThis, uAbbrCode);
3760 if ( pAbbrev
3761 && pAbbrev->uTag == DW_TAG_subprogram)
3762 {
3763 /*
3764 * Use rtDwarfInfo_ParseDie to do the parsing, but with a different
3765 * attribute spec than usual.
3766 */
3767 rtDwarfInfo_ParseDie(pThis, &pSubProgram->Core, &g_SubProgramSpecHackDesc, &InfoCursor,
3768 pAbbrev, false /*fInitDie*/);
3769 }
3770 }
3771
3772 rtDwarfCursor_Delete(&InfoCursor, VINF_SUCCESS);
3773}
3774
3775
3776/**
3777 * Select which name to use.
3778 *
3779 * @returns One of the names.
3780 * @param pszName The DWARF name, may exclude namespace and class.
3781 * Can also be NULL.
3782 * @param pszLinkageName The linkage name. Can be NULL.
3783 */
3784static const char *rtDwarfInfo_SelectName(const char *pszName, const char *pszLinkageName)
3785{
3786 if (!pszName || !pszLinkageName)
3787 return pszName ? pszName : pszLinkageName;
3788
3789 /*
3790 * Some heuristics for selecting the link name if the normal name is missing
3791 * namespace or class prefixes.
3792 */
3793 size_t cchName = strlen(pszName);
3794 size_t cchLinkageName = strlen(pszLinkageName);
3795 if (cchLinkageName <= cchName + 1)
3796 return pszName;
3797
3798 const char *psz = strstr(pszLinkageName, pszName);
3799 if (!psz || psz - pszLinkageName < 4)
3800 return pszName;
3801
3802 return pszLinkageName;
3803}
3804
3805
3806/**
3807 * Parse the attributes of a DIE.
3808 *
3809 * @returns IPRT status code.
3810 * @param pThis The DWARF instance.
3811 * @param pDie The internal DIE structure to fill.
3812 */
3813static int rtDwarfInfo_SnoopSymbols(PRTDBGMODDWARF pThis, PRTDWARFDIE pDie)
3814{
3815 int rc = VINF_SUCCESS;
3816 switch (pDie->uTag)
3817 {
3818 case DW_TAG_subprogram:
3819 {
3820 PRTDWARFDIESUBPROGRAM pSubProgram = (PRTDWARFDIESUBPROGRAM)pDie;
3821
3822 /* Obtain referenced specification there is only partial info. */
3823 if ( pSubProgram->PcRange.cAttrs
3824 && !pSubProgram->pszName)
3825 rtDwarfInfo_TryGetSubProgramNameFromSpecRef(pThis, pSubProgram);
3826
3827 if (pSubProgram->PcRange.cAttrs)
3828 {
3829 if (pSubProgram->PcRange.fHaveRanges)
3830 Log5(("subprogram %s (%s) <implement ranges>\n", pSubProgram->pszName, pSubProgram->pszLinkageName));
3831 else
3832 {
3833 Log5(("subprogram %s (%s) %#llx-%#llx%s\n", pSubProgram->pszName, pSubProgram->pszLinkageName,
3834 pSubProgram->PcRange.uLowAddress, pSubProgram->PcRange.uHighAddress,
3835 pSubProgram->PcRange.cAttrs == 2 ? "" : " !bad!"));
3836 if ( ( pSubProgram->pszName || pSubProgram->pszLinkageName)
3837 && pSubProgram->PcRange.cAttrs == 2)
3838 {
3839 if (pThis->iWatcomPass == 1)
3840 rc = rtDbgModDwarfRecordSegOffset(pThis, pSubProgram->uSegment, pSubProgram->PcRange.uHighAddress);
3841 else
3842 {
3843 RTDBGSEGIDX iSeg;
3844 RTUINTPTR offSeg;
3845 rc = rtDbgModDwarfLinkAddressToSegOffset(pThis, pSubProgram->uSegment,
3846 pSubProgram->PcRange.uLowAddress,
3847 &iSeg, &offSeg);
3848 if (RT_SUCCESS(rc))
3849 {
3850 uint64_t cb;
3851 if (pSubProgram->PcRange.uHighAddress >= pSubProgram->PcRange.uLowAddress)
3852 cb = pSubProgram->PcRange.uHighAddress - pSubProgram->PcRange.uLowAddress;
3853 else
3854 cb = 1;
3855 rc = RTDbgModSymbolAdd(pThis->hCnt,
3856 rtDwarfInfo_SelectName(pSubProgram->pszName, pSubProgram->pszLinkageName),
3857 iSeg, offSeg, cb, 0 /*fFlags*/, NULL /*piOrdinal*/);
3858 if (RT_FAILURE(rc))
3859 {
3860 if ( rc == VERR_DBG_DUPLICATE_SYMBOL
3861 || rc == VERR_DBG_ADDRESS_CONFLICT /** @todo figure why this happens with 10.6.8 mach_kernel, 32-bit. */
3862 )
3863 rc = VINF_SUCCESS;
3864 else
3865 AssertMsgFailed(("%Rrc\n", rc));
3866 }
3867 }
3868 else if ( pSubProgram->PcRange.uLowAddress == 0 /* see with vmlinux */
3869 && pSubProgram->PcRange.uHighAddress == 0)
3870 {
3871 Log5(("rtDbgModDwarfLinkAddressToSegOffset: Ignoring empty range.\n"));
3872 rc = VINF_SUCCESS; /* ignore */
3873 }
3874 else
3875 {
3876 AssertRC(rc);
3877 Log5(("rtDbgModDwarfLinkAddressToSegOffset failed: %Rrc\n", rc));
3878 }
3879 }
3880 }
3881 }
3882 }
3883 else
3884 Log5(("subprogram %s (%s) external\n", pSubProgram->pszName, pSubProgram->pszLinkageName));
3885 break;
3886 }
3887
3888 case DW_TAG_label:
3889 {
3890 PCRTDWARFDIELABEL pLabel = (PCRTDWARFDIELABEL)pDie;
3891 if (pLabel->fExternal)
3892 {
3893 Log5(("label %s %#x:%#llx\n", pLabel->pszName, pLabel->uSegment, pLabel->Address.uAddress));
3894 if (pThis->iWatcomPass == 1)
3895 rc = rtDbgModDwarfRecordSegOffset(pThis, pLabel->uSegment, pLabel->Address.uAddress);
3896 else
3897 {
3898 RTDBGSEGIDX iSeg;
3899 RTUINTPTR offSeg;
3900 rc = rtDbgModDwarfLinkAddressToSegOffset(pThis, pLabel->uSegment, pLabel->Address.uAddress,
3901 &iSeg, &offSeg);
3902 AssertRC(rc);
3903 if (RT_SUCCESS(rc))
3904 {
3905 rc = RTDbgModSymbolAdd(pThis->hCnt, pLabel->pszName, iSeg, offSeg, 0 /*cb*/,
3906 0 /*fFlags*/, NULL /*piOrdinal*/);
3907 AssertRC(rc);
3908 }
3909 else
3910 Log5(("rtDbgModDwarfLinkAddressToSegOffset failed: %Rrc\n", rc));
3911 }
3912
3913 }
3914 break;
3915 }
3916
3917 }
3918 return rc;
3919}
3920
3921
3922/**
3923 * Initializes the non-core fields of an internal DIE structure.
3924 *
3925 * @param pDie The DIE structure.
3926 * @param pDieDesc The DIE descriptor.
3927 */
3928static void rtDwarfInfo_InitDie(PRTDWARFDIE pDie, PCRTDWARFDIEDESC pDieDesc)
3929{
3930 size_t i = pDieDesc->cAttributes;
3931 while (i-- > 0)
3932 {
3933 switch (pDieDesc->paAttributes[i].cbInit & ATTR_INIT_MASK)
3934 {
3935 case ATTR_INIT_ZERO:
3936 /* Nothing to do (RTMemAllocZ). */
3937 break;
3938
3939 case ATTR_INIT_FFFS:
3940 switch (pDieDesc->paAttributes[i].cbInit & ATTR_SIZE_MASK)
3941 {
3942 case 1:
3943 *(uint8_t *)((uintptr_t)pDie + pDieDesc->paAttributes[i].off) = UINT8_MAX;
3944 break;
3945 case 2:
3946 *(uint16_t *)((uintptr_t)pDie + pDieDesc->paAttributes[i].off) = UINT16_MAX;
3947 break;
3948 case 4:
3949 *(uint32_t *)((uintptr_t)pDie + pDieDesc->paAttributes[i].off) = UINT32_MAX;
3950 break;
3951 case 8:
3952 *(uint64_t *)((uintptr_t)pDie + pDieDesc->paAttributes[i].off) = UINT64_MAX;
3953 break;
3954 default:
3955 AssertFailed();
3956 memset((uint8_t *)pDie + pDieDesc->paAttributes[i].off, 0xff,
3957 pDieDesc->paAttributes[i].cbInit & ATTR_SIZE_MASK);
3958 break;
3959 }
3960 break;
3961
3962 default:
3963 AssertFailed();
3964 }
3965 }
3966}
3967
3968
3969/**
3970 * Creates a new internal DIE structure and links it up.
3971 *
3972 * @returns Pointer to the new DIE structure.
3973 * @param pThis The DWARF instance.
3974 * @param pDieDesc The DIE descriptor (for size and init).
3975 * @param pAbbrev The abbreviation cache entry.
3976 * @param pParent The parent DIE (NULL if unit).
3977 */
3978static PRTDWARFDIE rtDwarfInfo_NewDie(PRTDBGMODDWARF pThis, PCRTDWARFDIEDESC pDieDesc,
3979 PCRTDWARFABBREV pAbbrev, PRTDWARFDIE pParent)
3980{
3981 NOREF(pThis);
3982 Assert(pDieDesc->cbDie >= sizeof(RTDWARFDIE));
3983#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
3984 uint32_t iAllocator = pDieDesc->cbDie > pThis->aDieAllocators[0].cbMax;
3985 Assert(pDieDesc->cbDie <= pThis->aDieAllocators[iAllocator].cbMax);
3986 PRTDWARFDIE pDie = (PRTDWARFDIE)RTMemCacheAlloc(pThis->aDieAllocators[iAllocator].hMemCache);
3987#else
3988 PRTDWARFDIE pDie = (PRTDWARFDIE)RTMemAllocZ(pDieDesc->cbDie);
3989#endif
3990 if (pDie)
3991 {
3992#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
3993 RT_BZERO(pDie, pDieDesc->cbDie);
3994 pDie->iAllocator = iAllocator;
3995#endif
3996 rtDwarfInfo_InitDie(pDie, pDieDesc);
3997
3998 pDie->uTag = pAbbrev->uTag;
3999 pDie->offSpec = pAbbrev->offSpec;
4000 pDie->pParent = pParent;
4001 if (pParent)
4002 RTListAppend(&pParent->ChildList, &pDie->SiblingNode);
4003 else
4004 RTListInit(&pDie->SiblingNode);
4005 RTListInit(&pDie->ChildList);
4006
4007 }
4008 return pDie;
4009}
4010
4011
4012/**
4013 * Free all children of a DIE.
4014 *
4015 * @param pThis The DWARF instance.
4016 * @param pParent The parent DIE.
4017 */
4018static void rtDwarfInfo_FreeChildren(PRTDBGMODDWARF pThis, PRTDWARFDIE pParentDie)
4019{
4020 PRTDWARFDIE pChild, pNextChild;
4021 RTListForEachSafe(&pParentDie->ChildList, pChild, pNextChild, RTDWARFDIE, SiblingNode)
4022 {
4023 if (!RTListIsEmpty(&pChild->ChildList))
4024 rtDwarfInfo_FreeChildren(pThis, pChild);
4025 RTListNodeRemove(&pChild->SiblingNode);
4026#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
4027 RTMemCacheFree(pThis->aDieAllocators[pChild->iAllocator].hMemCache, pChild);
4028#else
4029 RTMemFree(pChild);
4030#endif
4031 }
4032}
4033
4034
4035/**
4036 * Free a DIE an all its children.
4037 *
4038 * @param pThis The DWARF instance.
4039 * @param pDie The DIE to free.
4040 */
4041static void rtDwarfInfo_FreeDie(PRTDBGMODDWARF pThis, PRTDWARFDIE pDie)
4042{
4043 rtDwarfInfo_FreeChildren(pThis, pDie);
4044 RTListNodeRemove(&pDie->SiblingNode);
4045#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
4046 RTMemCacheFree(pThis->aDieAllocators[pDie->iAllocator].hMemCache, pDie);
4047#else
4048 RTMemFree(pChild);
4049#endif
4050}
4051
4052
4053/**
4054 * Skips a form.
4055 * @returns IPRT status code
4056 * @param pCursor The cursor.
4057 * @param uForm The form to skip.
4058 */
4059static int rtDwarfInfo_SkipForm(PRTDWARFCURSOR pCursor, uint32_t uForm)
4060{
4061 switch (uForm)
4062 {
4063 case DW_FORM_addr:
4064 return rtDwarfCursor_SkipBytes(pCursor, pCursor->cbNativeAddr);
4065
4066 case DW_FORM_block:
4067 case DW_FORM_exprloc:
4068 return rtDwarfCursor_SkipBytes(pCursor, rtDwarfCursor_GetULeb128(pCursor, 0));
4069
4070 case DW_FORM_block1:
4071 return rtDwarfCursor_SkipBytes(pCursor, rtDwarfCursor_GetU8(pCursor, 0));
4072
4073 case DW_FORM_block2:
4074 return rtDwarfCursor_SkipBytes(pCursor, rtDwarfCursor_GetU16(pCursor, 0));
4075
4076 case DW_FORM_block4:
4077 return rtDwarfCursor_SkipBytes(pCursor, rtDwarfCursor_GetU32(pCursor, 0));
4078
4079 case DW_FORM_data1:
4080 case DW_FORM_ref1:
4081 case DW_FORM_flag:
4082 return rtDwarfCursor_SkipBytes(pCursor, 1);
4083
4084 case DW_FORM_data2:
4085 case DW_FORM_ref2:
4086 return rtDwarfCursor_SkipBytes(pCursor, 2);
4087
4088 case DW_FORM_data4:
4089 case DW_FORM_ref4:
4090 return rtDwarfCursor_SkipBytes(pCursor, 4);
4091
4092 case DW_FORM_data8:
4093 case DW_FORM_ref8:
4094 case DW_FORM_ref_sig8:
4095 return rtDwarfCursor_SkipBytes(pCursor, 8);
4096
4097 case DW_FORM_udata:
4098 case DW_FORM_sdata:
4099 case DW_FORM_ref_udata:
4100 return rtDwarfCursor_SkipLeb128(pCursor);
4101
4102 case DW_FORM_string:
4103 rtDwarfCursor_GetSZ(pCursor, NULL);
4104 return pCursor->rc;
4105
4106 case DW_FORM_indirect:
4107 return rtDwarfInfo_SkipForm(pCursor, rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX));
4108
4109 case DW_FORM_strp:
4110 case DW_FORM_ref_addr:
4111 case DW_FORM_sec_offset:
4112 return rtDwarfCursor_SkipBytes(pCursor, pCursor->f64bitDwarf ? 8 : 4);
4113
4114 case DW_FORM_flag_present:
4115 return pCursor->rc; /* no data */
4116
4117 default:
4118 return VERR_DWARF_UNKNOWN_FORM;
4119 }
4120}
4121
4122
4123
4124#ifdef SOME_UNUSED_FUNCTION
4125/**
4126 * Skips a DIE.
4127 *
4128 * @returns IPRT status code.
4129 * @param pCursor The cursor.
4130 * @param pAbbrevCursor The abbreviation cursor.
4131 */
4132static int rtDwarfInfo_SkipDie(PRTDWARFCURSOR pCursor, PRTDWARFCURSOR pAbbrevCursor)
4133{
4134 for (;;)
4135 {
4136 uint32_t uAttr = rtDwarfCursor_GetULeb128AsU32(pAbbrevCursor, 0);
4137 uint32_t uForm = rtDwarfCursor_GetULeb128AsU32(pAbbrevCursor, 0);
4138 if (uAttr == 0 && uForm == 0)
4139 break;
4140
4141 int rc = rtDwarfInfo_SkipForm(pCursor, uForm);
4142 if (RT_FAILURE(rc))
4143 return rc;
4144 }
4145 return RT_FAILURE(pCursor->rc) ? pCursor->rc : pAbbrevCursor->rc;
4146}
4147#endif
4148
4149
4150/**
4151 * Parse the attributes of a DIE.
4152 *
4153 * @returns IPRT status code.
4154 * @param pThis The DWARF instance.
4155 * @param pDie The internal DIE structure to fill.
4156 * @param pDieDesc The DIE descriptor.
4157 * @param pCursor The debug_info cursor.
4158 * @param pAbbrev The abbreviation cache entry.
4159 * @param fInitDie Whether to initialize the DIE first. If not (@c
4160 * false) it's safe to assume we're following a
4161 * DW_AT_specification or DW_AT_abstract_origin,
4162 * and that we shouldn't be snooping any symbols.
4163 */
4164static int rtDwarfInfo_ParseDie(PRTDBGMODDWARF pThis, PRTDWARFDIE pDie, PCRTDWARFDIEDESC pDieDesc,
4165 PRTDWARFCURSOR pCursor, PCRTDWARFABBREV pAbbrev, bool fInitDie)
4166{
4167 RTDWARFCURSOR AbbrevCursor;
4168 int rc = rtDwarfCursor_InitWithOffset(&AbbrevCursor, pThis, krtDbgModDwarfSect_abbrev, pAbbrev->offSpec);
4169 if (RT_FAILURE(rc))
4170 return rc;
4171
4172 if (fInitDie)
4173 rtDwarfInfo_InitDie(pDie, pDieDesc);
4174 for (;;)
4175 {
4176 uint32_t uAttr = rtDwarfCursor_GetULeb128AsU32(&AbbrevCursor, 0);
4177 uint32_t uForm = rtDwarfCursor_GetULeb128AsU32(&AbbrevCursor, 0);
4178 if (uAttr == 0)
4179 break;
4180 if (uForm == DW_FORM_indirect)
4181 uForm = rtDwarfCursor_GetULeb128AsU32(pCursor, 0);
4182
4183 /* Look up the attribute in the descriptor and invoke the decoder. */
4184 PCRTDWARFATTRDESC pAttr = NULL;
4185 size_t i = pDieDesc->cAttributes;
4186 while (i-- > 0)
4187 if (pDieDesc->paAttributes[i].uAttr == uAttr)
4188 {
4189 pAttr = &pDieDesc->paAttributes[i];
4190 rc = pAttr->pfnDecoder(pDie, (uint8_t *)pDie + pAttr->off, pAttr, uForm, pCursor);
4191 break;
4192 }
4193
4194 /* Some house keeping. */
4195 if (pAttr)
4196 pDie->cDecodedAttrs++;
4197 else
4198 {
4199 pDie->cUnhandledAttrs++;
4200 rc = rtDwarfInfo_SkipForm(pCursor, uForm);
4201 Log4((" %-20s [%s]\n", rtDwarfLog_AttrName(uAttr), rtDwarfLog_FormName(uForm)));
4202 }
4203 if (RT_FAILURE(rc))
4204 break;
4205 }
4206
4207 rc = rtDwarfCursor_Delete(&AbbrevCursor, rc);
4208 if (RT_SUCCESS(rc))
4209 rc = pCursor->rc;
4210
4211 /*
4212 * Snoop up symbols on the way out.
4213 */
4214 if (RT_SUCCESS(rc) && fInitDie)
4215 {
4216 rc = rtDwarfInfo_SnoopSymbols(pThis, pDie);
4217 /* Ignore duplicates, get work done instead. */
4218 /** @todo clean up global/static symbol mess. */
4219 if (rc == VERR_DBG_DUPLICATE_SYMBOL)
4220 rc = VINF_SUCCESS;
4221 }
4222
4223 return rc;
4224}
4225
4226
4227/**
4228 * Load the debug information of a unit.
4229 *
4230 * @returns IPRT status code.
4231 * @param pThis The DWARF instance.
4232 * @param pCursor The debug_info cursor.
4233 * @param fKeepDies Whether to keep the DIEs or discard them as soon
4234 * as possible.
4235 */
4236static int rtDwarfInfo_LoadUnit(PRTDBGMODDWARF pThis, PRTDWARFCURSOR pCursor, bool fKeepDies)
4237{
4238 Log(("rtDwarfInfo_LoadUnit: %#x\n", rtDwarfCursor_CalcSectOffsetU32(pCursor)));
4239
4240 /*
4241 * Read the compilation unit header.
4242 */
4243 uint64_t offUnit = rtDwarfCursor_CalcSectOffsetU32(pCursor);
4244 uint64_t cbUnit = rtDwarfCursor_GetInitalLength(pCursor);
4245 cbUnit += rtDwarfCursor_CalcSectOffsetU32(pCursor) - offUnit;
4246 uint16_t const uVer = rtDwarfCursor_GetUHalf(pCursor, 0);
4247 if ( uVer < 2
4248 || uVer > 4)
4249 return rtDwarfCursor_SkipUnit(pCursor);
4250 uint64_t const offAbbrev = rtDwarfCursor_GetUOff(pCursor, UINT64_MAX);
4251 uint8_t const cbNativeAddr = rtDwarfCursor_GetU8(pCursor, UINT8_MAX);
4252 if (RT_FAILURE(pCursor->rc))
4253 return pCursor->rc;
4254 Log((" uVer=%d offAbbrev=%#llx cbNativeAddr=%d\n", uVer, offAbbrev, cbNativeAddr));
4255
4256 /*
4257 * Set up the abbreviation cache and store the native address size in the cursor.
4258 */
4259 if (offAbbrev > UINT32_MAX)
4260 {
4261 Log(("Unexpected abbrviation code offset of %#llx\n", offAbbrev));
4262 return VERR_DWARF_BAD_INFO;
4263 }
4264 rtDwarfAbbrev_SetUnitOffset(pThis, (uint32_t)offAbbrev);
4265 pCursor->cbNativeAddr = cbNativeAddr;
4266
4267 /*
4268 * The first DIE is a compile or partial unit, parse it here.
4269 */
4270 uint32_t uAbbrCode = rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX);
4271 if (!uAbbrCode)
4272 {
4273 Log(("Unexpected abbrviation code of zero\n"));
4274 return VERR_DWARF_BAD_INFO;
4275 }
4276 PCRTDWARFABBREV pAbbrev = rtDwarfAbbrev_Lookup(pThis, uAbbrCode);
4277 if (!pAbbrev)
4278 return VERR_DWARF_ABBREV_NOT_FOUND;
4279 if ( pAbbrev->uTag != DW_TAG_compile_unit
4280 && pAbbrev->uTag != DW_TAG_partial_unit)
4281 {
4282 Log(("Unexpected compile/partial unit tag %#x\n", pAbbrev->uTag));
4283 return VERR_DWARF_BAD_INFO;
4284 }
4285
4286 PRTDWARFDIECOMPILEUNIT pUnit;
4287 pUnit = (PRTDWARFDIECOMPILEUNIT)rtDwarfInfo_NewDie(pThis, &g_CompileUnitDesc, pAbbrev, NULL /*pParent*/);
4288 if (!pUnit)
4289 return VERR_NO_MEMORY;
4290 pUnit->offUnit = offUnit;
4291 pUnit->cbUnit = cbUnit;
4292 pUnit->offAbbrev = offAbbrev;
4293 pUnit->cbNativeAddr = cbNativeAddr;
4294 pUnit->uDwarfVer = (uint8_t)uVer;
4295 RTListAppend(&pThis->CompileUnitList, &pUnit->Core.SiblingNode);
4296
4297 int rc = rtDwarfInfo_ParseDie(pThis, &pUnit->Core, &g_CompileUnitDesc, pCursor, pAbbrev, true /*fInitDie*/);
4298 if (RT_FAILURE(rc))
4299 return rc;
4300
4301 /*
4302 * Parse DIEs.
4303 */
4304 uint32_t cDepth = 0;
4305 PRTDWARFDIE pParentDie = &pUnit->Core;
4306 while (!rtDwarfCursor_IsAtEndOfUnit(pCursor))
4307 {
4308#ifdef LOG_ENABLED
4309 uint32_t offLog = rtDwarfCursor_CalcSectOffsetU32(pCursor);
4310#endif
4311 uAbbrCode = rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX);
4312 if (!uAbbrCode)
4313 {
4314 /* End of siblings, up one level. (Is this correct?) */
4315 if (pParentDie->pParent)
4316 {
4317 pParentDie = pParentDie->pParent;
4318 cDepth--;
4319 if (!fKeepDies && pParentDie->pParent)
4320 rtDwarfInfo_FreeChildren(pThis, pParentDie);
4321 }
4322 }
4323 else
4324 {
4325 /*
4326 * Look up the abbreviation and match the tag up with a descriptor.
4327 */
4328 pAbbrev = rtDwarfAbbrev_Lookup(pThis, uAbbrCode);
4329 if (!pAbbrev)
4330 return VERR_DWARF_ABBREV_NOT_FOUND;
4331
4332 PCRTDWARFDIEDESC pDieDesc;
4333 const char *pszName;
4334 if (pAbbrev->uTag < RT_ELEMENTS(g_aTagDescs))
4335 {
4336 Assert(g_aTagDescs[pAbbrev->uTag].uTag == pAbbrev->uTag || g_aTagDescs[pAbbrev->uTag].uTag == 0);
4337 pszName = g_aTagDescs[pAbbrev->uTag].pszName;
4338 pDieDesc = g_aTagDescs[pAbbrev->uTag].pDesc;
4339 }
4340 else
4341 {
4342 pszName = "<unknown>";
4343 pDieDesc = &g_CoreDieDesc;
4344 }
4345 Log4(("%08x: %*stag=%s (%#x, abbrev %u)%s\n", offLog, cDepth * 2, "", pszName,
4346 pAbbrev->uTag, uAbbrCode, pAbbrev->fChildren ? " has children" : ""));
4347
4348 /*
4349 * Create a new internal DIE structure and parse the
4350 * attributes.
4351 */
4352 PRTDWARFDIE pNewDie = rtDwarfInfo_NewDie(pThis, pDieDesc, pAbbrev, pParentDie);
4353 if (!pNewDie)
4354 return VERR_NO_MEMORY;
4355
4356 if (pAbbrev->fChildren)
4357 {
4358 pParentDie = pNewDie;
4359 cDepth++;
4360 }
4361
4362 rc = rtDwarfInfo_ParseDie(pThis, pNewDie, pDieDesc, pCursor, pAbbrev, true /*fInitDie*/);
4363 if (RT_FAILURE(rc))
4364 return rc;
4365
4366 if (!fKeepDies && !pAbbrev->fChildren)
4367 rtDwarfInfo_FreeDie(pThis, pNewDie);
4368 }
4369 } /* while more DIEs */
4370
4371
4372 /* Unlink and free child DIEs if told to do so. */
4373 if (!fKeepDies)
4374 rtDwarfInfo_FreeChildren(pThis, &pUnit->Core);
4375
4376 return RT_SUCCESS(rc) ? pCursor->rc : rc;
4377}
4378
4379
4380/**
4381 * Extracts the symbols.
4382 *
4383 * The symbols are insered into the debug info container.
4384 *
4385 * @returns IPRT status code
4386 * @param pThis The DWARF instance.
4387 */
4388static int rtDwarfInfo_LoadAll(PRTDBGMODDWARF pThis)
4389{
4390 RTDWARFCURSOR Cursor;
4391 int rc = rtDwarfCursor_Init(&Cursor, pThis, krtDbgModDwarfSect_info);
4392 if (RT_SUCCESS(rc))
4393 {
4394 while ( !rtDwarfCursor_IsAtEnd(&Cursor)
4395 && RT_SUCCESS(rc))
4396 rc = rtDwarfInfo_LoadUnit(pThis, &Cursor, false /* fKeepDies */);
4397
4398 rc = rtDwarfCursor_Delete(&Cursor, rc);
4399 }
4400 return rc;
4401}
4402
4403
4404
4405/*
4406 *
4407 * Public and image level symbol handling.
4408 * Public and image level symbol handling.
4409 * Public and image level symbol handling.
4410 * Public and image level symbol handling.
4411 *
4412 *
4413 */
4414
4415#define RTDBGDWARF_SYM_ENUM_BASE_ADDRESS UINT32_C(0x200000)
4416
4417/** @callback_method_impl{FNRTLDRENUMSYMS,
4418 * Adds missing symbols from the image symbol table.} */
4419static DECLCALLBACK(int) rtDwarfSyms_EnumSymbolsCallback(RTLDRMOD hLdrMod, const char *pszSymbol, unsigned uSymbol,
4420 RTLDRADDR Value, void *pvUser)
4421{
4422 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pvUser;
4423 NOREF(hLdrMod);
4424 Assert(pThis->iWatcomPass != 1);
4425
4426 RTLDRADDR uRva = Value - RTDBGDWARF_SYM_ENUM_BASE_ADDRESS;
4427 if ( Value >= RTDBGDWARF_SYM_ENUM_BASE_ADDRESS
4428 && uRva < _1G)
4429 {
4430 RTDBGSYMBOL SymInfo;
4431 RTINTPTR offDisp;
4432 int rc = RTDbgModSymbolByAddr(pThis->hCnt, RTDBGSEGIDX_RVA, uRva, RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL, &offDisp, &SymInfo);
4433 if ( RT_FAILURE(rc)
4434 || offDisp != 0)
4435 {
4436 rc = RTDbgModSymbolAdd(pThis->hCnt, pszSymbol, RTDBGSEGIDX_RVA, uRva, 1, 0 /*fFlags*/, NULL /*piOrdinal*/);
4437 Log6(("Dwarf: Symbol #%05u %#018x %s [%Rrc]\n", uSymbol, Value, pszSymbol, rc)); NOREF(rc);
4438 }
4439 }
4440 else
4441 Log6(("Dwarf: Symbol #%05u %#018x %s [SKIPPED - INVALID ADDRESS]\n", uSymbol, Value, pszSymbol));
4442 return VINF_SUCCESS;
4443}
4444
4445
4446
4447/**
4448 * Loads additional symbols from the pubnames section and the executable image.
4449 *
4450 * The symbols are insered into the debug info container.
4451 *
4452 * @returns IPRT status code
4453 * @param pThis The DWARF instance.
4454 */
4455static int rtDwarfSyms_LoadAll(PRTDBGMODDWARF pThis)
4456{
4457 /*
4458 * pubnames.
4459 */
4460 int rc = VINF_SUCCESS;
4461 if (pThis->aSections[krtDbgModDwarfSect_pubnames].fPresent)
4462 {
4463// RTDWARFCURSOR Cursor;
4464// int rc = rtDwarfCursor_Init(&Cursor, pThis, krtDbgModDwarfSect_info);
4465// if (RT_SUCCESS(rc))
4466// {
4467// while ( !rtDwarfCursor_IsAtEnd(&Cursor)
4468// && RT_SUCCESS(rc))
4469// rc = rtDwarfInfo_LoadUnit(pThis, &Cursor, false /* fKeepDies */);
4470//
4471// rc = rtDwarfCursor_Delete(&Cursor, rc);
4472// }
4473// return rc;
4474 }
4475
4476 /*
4477 * The executable image.
4478 */
4479 if ( pThis->pImgMod
4480 && pThis->pImgMod->pImgVt->pfnEnumSymbols
4481 && pThis->iWatcomPass != 1
4482 && RT_SUCCESS(rc))
4483 {
4484 rc = pThis->pImgMod->pImgVt->pfnEnumSymbols(pThis->pImgMod,
4485 RTLDR_ENUM_SYMBOL_FLAGS_ALL | RTLDR_ENUM_SYMBOL_FLAGS_NO_FWD,
4486 RTDBGDWARF_SYM_ENUM_BASE_ADDRESS,
4487 rtDwarfSyms_EnumSymbolsCallback,
4488 pThis);
4489 }
4490
4491 return rc;
4492}
4493
4494
4495
4496
4497/*
4498 *
4499 * DWARF Debug module implementation.
4500 * DWARF Debug module implementation.
4501 * DWARF Debug module implementation.
4502 *
4503 */
4504
4505
4506/** @interface_method_impl{RTDBGMODVTDBG,pfnLineByAddr} */
4507static DECLCALLBACK(int) rtDbgModDwarf_LineByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off,
4508 PRTINTPTR poffDisp, PRTDBGLINE pLineInfo)
4509{
4510 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4511 return RTDbgModLineByAddr(pThis->hCnt, iSeg, off, poffDisp, pLineInfo);
4512}
4513
4514
4515/** @interface_method_impl{RTDBGMODVTDBG,pfnLineByOrdinal} */
4516static DECLCALLBACK(int) rtDbgModDwarf_LineByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGLINE pLineInfo)
4517{
4518 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4519 return RTDbgModLineByOrdinal(pThis->hCnt, iOrdinal, pLineInfo);
4520}
4521
4522
4523/** @interface_method_impl{RTDBGMODVTDBG,pfnLineCount} */
4524static DECLCALLBACK(uint32_t) rtDbgModDwarf_LineCount(PRTDBGMODINT pMod)
4525{
4526 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4527 return RTDbgModLineCount(pThis->hCnt);
4528}
4529
4530
4531/** @interface_method_impl{RTDBGMODVTDBG,pfnLineAdd} */
4532static DECLCALLBACK(int) rtDbgModDwarf_LineAdd(PRTDBGMODINT pMod, const char *pszFile, size_t cchFile, uint32_t uLineNo,
4533 uint32_t iSeg, RTUINTPTR off, uint32_t *piOrdinal)
4534{
4535 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4536 Assert(!pszFile[cchFile]); NOREF(cchFile);
4537 return RTDbgModLineAdd(pThis->hCnt, pszFile, uLineNo, iSeg, off, piOrdinal);
4538}
4539
4540
4541/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByAddr} */
4542static DECLCALLBACK(int) rtDbgModDwarf_SymbolByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t fFlags,
4543 PRTINTPTR poffDisp, PRTDBGSYMBOL pSymInfo)
4544{
4545 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4546 return RTDbgModSymbolByAddr(pThis->hCnt, iSeg, off, fFlags, poffDisp, pSymInfo);
4547}
4548
4549
4550/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByName} */
4551static DECLCALLBACK(int) rtDbgModDwarf_SymbolByName(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
4552 PRTDBGSYMBOL pSymInfo)
4553{
4554 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4555 Assert(!pszSymbol[cchSymbol]);
4556 return RTDbgModSymbolByName(pThis->hCnt, pszSymbol/*, cchSymbol*/, pSymInfo);
4557}
4558
4559
4560/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByOrdinal} */
4561static DECLCALLBACK(int) rtDbgModDwarf_SymbolByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGSYMBOL pSymInfo)
4562{
4563 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4564 return RTDbgModSymbolByOrdinal(pThis->hCnt, iOrdinal, pSymInfo);
4565}
4566
4567
4568/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolCount} */
4569static DECLCALLBACK(uint32_t) rtDbgModDwarf_SymbolCount(PRTDBGMODINT pMod)
4570{
4571 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4572 return RTDbgModSymbolCount(pThis->hCnt);
4573}
4574
4575
4576/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolAdd} */
4577static DECLCALLBACK(int) rtDbgModDwarf_SymbolAdd(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
4578 RTDBGSEGIDX iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags,
4579 uint32_t *piOrdinal)
4580{
4581 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4582 Assert(!pszSymbol[cchSymbol]); NOREF(cchSymbol);
4583 return RTDbgModSymbolAdd(pThis->hCnt, pszSymbol, iSeg, off, cb, fFlags, piOrdinal);
4584}
4585
4586
4587/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentByIndex} */
4588static DECLCALLBACK(int) rtDbgModDwarf_SegmentByIndex(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, PRTDBGSEGMENT pSegInfo)
4589{
4590 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4591 return RTDbgModSegmentByIndex(pThis->hCnt, iSeg, pSegInfo);
4592}
4593
4594
4595/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentCount} */
4596static DECLCALLBACK(RTDBGSEGIDX) rtDbgModDwarf_SegmentCount(PRTDBGMODINT pMod)
4597{
4598 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4599 return RTDbgModSegmentCount(pThis->hCnt);
4600}
4601
4602
4603/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentAdd} */
4604static DECLCALLBACK(int) rtDbgModDwarf_SegmentAdd(PRTDBGMODINT pMod, RTUINTPTR uRva, RTUINTPTR cb, const char *pszName, size_t cchName,
4605 uint32_t fFlags, PRTDBGSEGIDX piSeg)
4606{
4607 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4608 Assert(!pszName[cchName]); NOREF(cchName);
4609 return RTDbgModSegmentAdd(pThis->hCnt, uRva, cb, pszName, fFlags, piSeg);
4610}
4611
4612
4613/** @interface_method_impl{RTDBGMODVTDBG,pfnImageSize} */
4614static DECLCALLBACK(RTUINTPTR) rtDbgModDwarf_ImageSize(PRTDBGMODINT pMod)
4615{
4616 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4617 RTUINTPTR cb1 = RTDbgModImageSize(pThis->hCnt);
4618 RTUINTPTR cb2 = pThis->pImgMod->pImgVt->pfnImageSize(pMod);
4619 return RT_MAX(cb1, cb2);
4620}
4621
4622
4623/** @interface_method_impl{RTDBGMODVTDBG,pfnRvaToSegOff} */
4624static DECLCALLBACK(RTDBGSEGIDX) rtDbgModDwarf_RvaToSegOff(PRTDBGMODINT pMod, RTUINTPTR uRva, PRTUINTPTR poffSeg)
4625{
4626 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4627 return RTDbgModRvaToSegOff(pThis->hCnt, uRva, poffSeg);
4628}
4629
4630
4631/** @interface_method_impl{RTDBGMODVTDBG,pfnClose} */
4632static DECLCALLBACK(int) rtDbgModDwarf_Close(PRTDBGMODINT pMod)
4633{
4634 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
4635
4636 for (unsigned iSect = 0; iSect < RT_ELEMENTS(pThis->aSections); iSect++)
4637 if (pThis->aSections[iSect].pv)
4638 pThis->pDbgInfoMod->pImgVt->pfnUnmapPart(pThis->pDbgInfoMod, pThis->aSections[iSect].cb, &pThis->aSections[iSect].pv);
4639
4640 RTDbgModRelease(pThis->hCnt);
4641 RTMemFree(pThis->paCachedAbbrevs);
4642 if (pThis->pNestedMod)
4643 {
4644 pThis->pNestedMod->pImgVt->pfnClose(pThis->pNestedMod);
4645 RTStrCacheRelease(g_hDbgModStrCache, pThis->pNestedMod->pszName);
4646 RTStrCacheRelease(g_hDbgModStrCache, pThis->pNestedMod->pszDbgFile);
4647 RTMemFree(pThis->pNestedMod);
4648 pThis->pNestedMod = NULL;
4649 }
4650
4651#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
4652 uint32_t i = RT_ELEMENTS(pThis->aDieAllocators);
4653 while (i-- > 0)
4654 {
4655 RTMemCacheDestroy(pThis->aDieAllocators[i].hMemCache);
4656 pThis->aDieAllocators[i].hMemCache = NIL_RTMEMCACHE;
4657 }
4658#endif
4659
4660 RTMemFree(pThis);
4661
4662 return VINF_SUCCESS;
4663}
4664
4665
4666/** @callback_method_impl{FNRTLDRENUMDBG} */
4667static DECLCALLBACK(int) rtDbgModDwarfEnumCallback(RTLDRMOD hLdrMod, PCRTLDRDBGINFO pDbgInfo, void *pvUser)
4668{
4669 /*
4670 * Skip stuff we can't handle.
4671 */
4672 if (pDbgInfo->enmType != RTLDRDBGINFOTYPE_DWARF)
4673 return VINF_SUCCESS;
4674 const char *pszSection = pDbgInfo->u.Dwarf.pszSection;
4675 if (!pszSection || !*pszSection)
4676 return VINF_SUCCESS;
4677 Assert(!pDbgInfo->pszExtFile);
4678
4679 /*
4680 * Must have a part name starting with debug_ and possibly prefixed by dots
4681 * or underscores.
4682 */
4683 if (!strncmp(pszSection, RT_STR_TUPLE(".debug_"))) /* ELF */
4684 pszSection += sizeof(".debug_") - 1;
4685 else if (!strncmp(pszSection, RT_STR_TUPLE("__debug_"))) /* Mach-O */
4686 pszSection += sizeof("__debug_") - 1;
4687 else if (!strcmp(pszSection, ".WATCOM_references"))
4688 return VINF_SUCCESS; /* Ignore special watcom section for now.*/
4689 else if ( !strcmp(pszSection, "__apple_types")
4690 || !strcmp(pszSection, "__apple_namespac")
4691 || !strcmp(pszSection, "__apple_objc")
4692 || !strcmp(pszSection, "__apple_names"))
4693 return VINF_SUCCESS; /* Ignore special apple sections for now. */
4694 else
4695 AssertMsgFailedReturn(("%s\n", pszSection), VINF_SUCCESS /*ignore*/);
4696
4697 /*
4698 * Figure out which part we're talking about.
4699 */
4700 krtDbgModDwarfSect enmSect;
4701 if (0) { /* dummy */ }
4702#define ELSE_IF_STRCMP_SET(a_Name) else if (!strcmp(pszSection, #a_Name)) enmSect = krtDbgModDwarfSect_ ## a_Name
4703 ELSE_IF_STRCMP_SET(abbrev);
4704 ELSE_IF_STRCMP_SET(aranges);
4705 ELSE_IF_STRCMP_SET(frame);
4706 ELSE_IF_STRCMP_SET(info);
4707 ELSE_IF_STRCMP_SET(inlined);
4708 ELSE_IF_STRCMP_SET(line);
4709 ELSE_IF_STRCMP_SET(loc);
4710 ELSE_IF_STRCMP_SET(macinfo);
4711 ELSE_IF_STRCMP_SET(pubnames);
4712 ELSE_IF_STRCMP_SET(pubtypes);
4713 ELSE_IF_STRCMP_SET(ranges);
4714 ELSE_IF_STRCMP_SET(str);
4715 ELSE_IF_STRCMP_SET(types);
4716#undef ELSE_IF_STRCMP_SET
4717 else
4718 {
4719 AssertMsgFailed(("%s\n", pszSection));
4720 return VINF_SUCCESS;
4721 }
4722
4723 /*
4724 * Record the section.
4725 */
4726 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pvUser;
4727 AssertMsgReturn(!pThis->aSections[enmSect].fPresent, ("duplicate %s\n", pszSection), VINF_SUCCESS /*ignore*/);
4728
4729 pThis->aSections[enmSect].fPresent = true;
4730 pThis->aSections[enmSect].offFile = pDbgInfo->offFile;
4731 pThis->aSections[enmSect].pv = NULL;
4732 pThis->aSections[enmSect].cb = (size_t)pDbgInfo->cb;
4733 pThis->aSections[enmSect].iDbgInfo = pDbgInfo->iDbgInfo;
4734 if (pThis->aSections[enmSect].cb != pDbgInfo->cb)
4735 pThis->aSections[enmSect].cb = ~(size_t)0;
4736
4737 return VINF_SUCCESS;
4738}
4739
4740
4741static int rtDbgModDwarfTryOpenDbgFile(PRTDBGMODINT pDbgMod, PRTDBGMODDWARF pThis, RTLDRARCH enmArch)
4742{
4743 if ( !pDbgMod->pszDbgFile
4744 || RTPathIsSame(pDbgMod->pszDbgFile, pDbgMod->pszImgFile) == (int)true /* returns VERR too */)
4745 return VERR_DBG_NO_MATCHING_INTERPRETER;
4746
4747 /*
4748 * Only open the image.
4749 */
4750 PRTDBGMODINT pDbgInfoMod = (PRTDBGMODINT)RTMemAllocZ(sizeof(*pDbgInfoMod));
4751 if (!pDbgInfoMod)
4752 return VERR_NO_MEMORY;
4753
4754 int rc;
4755 pDbgInfoMod->u32Magic = RTDBGMOD_MAGIC;
4756 pDbgInfoMod->cRefs = 1;
4757 if (RTStrCacheRetain(pDbgMod->pszDbgFile) != UINT32_MAX)
4758 {
4759 pDbgInfoMod->pszImgFile = pDbgMod->pszDbgFile;
4760 if (RTStrCacheRetain(pDbgMod->pszName) != UINT32_MAX)
4761 {
4762 pDbgInfoMod->pszName = pDbgMod->pszName;
4763 pDbgInfoMod->pImgVt = &g_rtDbgModVtImgLdr;
4764 rc = pDbgInfoMod->pImgVt->pfnTryOpen(pDbgInfoMod, enmArch);
4765 if (RT_SUCCESS(rc))
4766 {
4767 pThis->pDbgInfoMod = pDbgInfoMod;
4768 pThis->pNestedMod = pDbgInfoMod;
4769 return VINF_SUCCESS;
4770 }
4771
4772 RTStrCacheRelease(g_hDbgModStrCache, pDbgInfoMod->pszName);
4773 }
4774 else
4775 rc = VERR_NO_STR_MEMORY;
4776 RTStrCacheRelease(g_hDbgModStrCache, pDbgInfoMod->pszImgFile);
4777 }
4778 else
4779 rc = VERR_NO_STR_MEMORY;
4780 RTMemFree(pDbgInfoMod);
4781 return rc;
4782}
4783
4784
4785/** @interface_method_impl{RTDBGMODVTDBG,pfnTryOpen} */
4786static DECLCALLBACK(int) rtDbgModDwarf_TryOpen(PRTDBGMODINT pMod, RTLDRARCH enmArch)
4787{
4788 /*
4789 * DWARF is only supported when part of an image.
4790 */
4791 if (!pMod->pImgVt)
4792 return VERR_DBG_NO_MATCHING_INTERPRETER;
4793
4794 /*
4795 * Create the module instance data.
4796 */
4797 PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)RTMemAllocZ(sizeof(*pThis));
4798 if (!pThis)
4799 return VERR_NO_MEMORY;
4800 pThis->pDbgInfoMod = pMod;
4801 pThis->pImgMod = pMod;
4802 RTListInit(&pThis->CompileUnitList);
4803 /** @todo better fUseLinkAddress heuristics! */
4804 if ( (pMod->pszDbgFile && strstr(pMod->pszDbgFile, "mach_kernel"))
4805 || (pMod->pszImgFile && strstr(pMod->pszImgFile, "mach_kernel"))
4806 || (pMod->pszImgFileSpecified && strstr(pMod->pszImgFileSpecified, "mach_kernel")) )
4807 pThis->fUseLinkAddress = true;
4808
4809#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
4810 AssertCompile(RT_ELEMENTS(pThis->aDieAllocators) == 2);
4811 pThis->aDieAllocators[0].cbMax = sizeof(RTDWARFDIE);
4812 pThis->aDieAllocators[1].cbMax = sizeof(RTDWARFDIECOMPILEUNIT);
4813 for (uint32_t i = 0; i < RT_ELEMENTS(g_aTagDescs); i++)
4814 if (g_aTagDescs[i].pDesc && g_aTagDescs[i].pDesc->cbDie > pThis->aDieAllocators[1].cbMax)
4815 pThis->aDieAllocators[1].cbMax = (uint32_t)g_aTagDescs[i].pDesc->cbDie;
4816 pThis->aDieAllocators[1].cbMax = RT_ALIGN_32(pThis->aDieAllocators[1].cbMax, sizeof(uint64_t));
4817
4818 for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aDieAllocators); i++)
4819 {
4820 int rc = RTMemCacheCreate(&pThis->aDieAllocators[i].hMemCache, pThis->aDieAllocators[i].cbMax, sizeof(uint64_t),
4821 UINT32_MAX, NULL /*pfnCtor*/, NULL /*pfnDtor*/, NULL /*pvUser*/, 0 /*fFlags*/);
4822 if (RT_FAILURE(rc))
4823 {
4824 while (i-- > 0)
4825 RTMemCacheDestroy(pThis->aDieAllocators[i].hMemCache);
4826 RTMemFree(pThis);
4827 return rc;
4828 }
4829 }
4830#endif
4831
4832 /*
4833 * If the debug file name is set, let's see if it's an ELF image with DWARF
4834 * inside it. In that case we'll have to deal with two image modules, one
4835 * for segments and address translation and one for the debug information.
4836 */
4837 if (pMod->pszDbgFile != NULL)
4838 rtDbgModDwarfTryOpenDbgFile(pMod, pThis, enmArch);
4839
4840 /*
4841 * Enumerate the debug info in the module, looking for DWARF bits.
4842 */
4843 int rc = pThis->pDbgInfoMod->pImgVt->pfnEnumDbgInfo(pThis->pDbgInfoMod, rtDbgModDwarfEnumCallback, pThis);
4844 if (RT_SUCCESS(rc))
4845 {
4846 if (pThis->aSections[krtDbgModDwarfSect_info].fPresent)
4847 {
4848 /*
4849 * Extract / explode the data we want (symbols and line numbers)
4850 * storing them in a container module.
4851 */
4852 rc = RTDbgModCreate(&pThis->hCnt, pMod->pszName, 0 /*cbSeg*/, 0 /*fFlags*/);
4853 if (RT_SUCCESS(rc))
4854 {
4855 pMod->pvDbgPriv = pThis;
4856
4857 rc = rtDbgModDwarfAddSegmentsFromImage(pThis);
4858 if (RT_SUCCESS(rc))
4859 rc = rtDwarfInfo_LoadAll(pThis);
4860 if (RT_SUCCESS(rc))
4861 rc = rtDwarfSyms_LoadAll(pThis);
4862 if (RT_SUCCESS(rc))
4863 rc = rtDwarfLine_ExplodeAll(pThis);
4864 if (RT_SUCCESS(rc) && pThis->iWatcomPass == 1)
4865 {
4866 rc = rtDbgModDwarfAddSegmentsFromPass1(pThis);
4867 pThis->iWatcomPass = 2;
4868 if (RT_SUCCESS(rc))
4869 rc = rtDwarfInfo_LoadAll(pThis);
4870 if (RT_SUCCESS(rc))
4871 rc = rtDwarfSyms_LoadAll(pThis);
4872 if (RT_SUCCESS(rc))
4873 rc = rtDwarfLine_ExplodeAll(pThis);
4874 }
4875 if (RT_SUCCESS(rc))
4876 {
4877 /*
4878 * Free the cached abbreviations and unload all sections.
4879 */
4880 pThis->cCachedAbbrevsAlloced = 0;
4881 RTMemFree(pThis->paCachedAbbrevs);
4882 pThis->paCachedAbbrevs = NULL;
4883
4884 for (unsigned iSect = 0; iSect < RT_ELEMENTS(pThis->aSections); iSect++)
4885 if (pThis->aSections[iSect].pv)
4886 pThis->pDbgInfoMod->pImgVt->pfnUnmapPart(pThis->pDbgInfoMod, pThis->aSections[iSect].cb,
4887 &pThis->aSections[iSect].pv);
4888
4889 /** @todo Kill pThis->CompileUnitList and the alloc caches. */
4890 return VINF_SUCCESS;
4891 }
4892
4893 /* bail out. */
4894 RTDbgModRelease(pThis->hCnt);
4895 pMod->pvDbgPriv = NULL;
4896 }
4897 }
4898 else
4899 rc = VERR_DBG_NO_MATCHING_INTERPRETER;
4900 }
4901
4902 RTMemFree(pThis->paCachedAbbrevs);
4903
4904#ifdef RTDBGMODDWARF_WITH_MEM_CACHE
4905 uint32_t i = RT_ELEMENTS(pThis->aDieAllocators);
4906 while (i-- > 0)
4907 {
4908 RTMemCacheDestroy(pThis->aDieAllocators[i].hMemCache);
4909 pThis->aDieAllocators[i].hMemCache = NIL_RTMEMCACHE;
4910 }
4911#endif
4912
4913 RTMemFree(pThis);
4914
4915 return rc;
4916}
4917
4918
4919
4920/** Virtual function table for the DWARF debug info reader. */
4921DECL_HIDDEN_CONST(RTDBGMODVTDBG) const g_rtDbgModVtDbgDwarf =
4922{
4923 /*.u32Magic = */ RTDBGMODVTDBG_MAGIC,
4924 /*.fSupports = */ RT_DBGTYPE_DWARF,
4925 /*.pszName = */ "dwarf",
4926 /*.pfnTryOpen = */ rtDbgModDwarf_TryOpen,
4927 /*.pfnClose = */ rtDbgModDwarf_Close,
4928
4929 /*.pfnRvaToSegOff = */ rtDbgModDwarf_RvaToSegOff,
4930 /*.pfnImageSize = */ rtDbgModDwarf_ImageSize,
4931
4932 /*.pfnSegmentAdd = */ rtDbgModDwarf_SegmentAdd,
4933 /*.pfnSegmentCount = */ rtDbgModDwarf_SegmentCount,
4934 /*.pfnSegmentByIndex = */ rtDbgModDwarf_SegmentByIndex,
4935
4936 /*.pfnSymbolAdd = */ rtDbgModDwarf_SymbolAdd,
4937 /*.pfnSymbolCount = */ rtDbgModDwarf_SymbolCount,
4938 /*.pfnSymbolByOrdinal = */ rtDbgModDwarf_SymbolByOrdinal,
4939 /*.pfnSymbolByName = */ rtDbgModDwarf_SymbolByName,
4940 /*.pfnSymbolByAddr = */ rtDbgModDwarf_SymbolByAddr,
4941
4942 /*.pfnLineAdd = */ rtDbgModDwarf_LineAdd,
4943 /*.pfnLineCount = */ rtDbgModDwarf_LineCount,
4944 /*.pfnLineByOrdinal = */ rtDbgModDwarf_LineByOrdinal,
4945 /*.pfnLineByAddr = */ rtDbgModDwarf_LineByAddr,
4946
4947 /*.u32EndMagic = */ RTDBGMODVTDBG_MAGIC
4948};
4949
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette