2 * File dwarf.c - read dwarf2 information from the ELF modules
4 * Copyright (C) 2005, Raphael Junqueira
5 * Copyright (C) 2006-2010, Eric Pouech
6 * Copyright (C) 2010, Alexandre Julliard
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #define NONAMELESSUNION
27 #include <sys/types.h>
29 #ifdef HAVE_SYS_STAT_H
30 # include <sys/stat.h>
32 #ifdef HAVE_SYS_MMAN_H
43 #define PATH_MAX MAX_PATH
54 #include "dbghelp_private.h"
55 #include "image_private.h"
57 #include "wine/debug.h"
59 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_dwarf
);
63 * o unspecified parameters
65 * o Debug{Start|End}Point
68 * o proper types loading (nesting)
72 static void dump(const void* ptr
, unsigned len
)
76 static const char hexof
[] = "0123456789abcdef";
79 for (i
= 0; i
< len
; i
+= 16)
81 sprintf(msg
, "%08x: ", i
);
82 memset(msg
+ 10, ' ', 3 * 16 + 1 + 16);
83 for (j
= 0; j
< min(16, len
- i
); j
++)
85 msg
[10 + 3 * j
+ 0] = hexof
[x
[i
+ j
] >> 4];
86 msg
[10 + 3 * j
+ 1] = hexof
[x
[i
+ j
] & 15];
87 msg
[10 + 3 * j
+ 2] = ' ';
88 msg
[10 + 3 * 16 + 1 + j
] = (x
[i
+ j
] >= 0x20 && x
[i
+ j
] < 0x7f) ?
91 msg
[10 + 3 * 16] = ' ';
92 msg
[10 + 3 * 16 + 1 + 16] = '\0';
101 * http://www.eagercon.com/dwarf/dwarf3std.htm
102 * http://www.eagercon.com/dwarf/dwarf-2.0.0.pdf
104 * dwarf2.h: http://www.hakpetzna.com/b/binutils/dwarf2_8h-source.html
106 * example of projects who do dwarf2 parsing:
107 * http://www.x86-64.org/cgi-bin/cvsweb.cgi/binutils.dead/binutils/readelf.c?rev=1.1.1.2
108 * http://elis.ugent.be/diota/log/ltrace_elf.c
116 typedef struct dwarf2_abbrev_entry_attr_s
118 unsigned long attribute
;
120 struct dwarf2_abbrev_entry_attr_s
* next
;
121 } dwarf2_abbrev_entry_attr_t
;
123 typedef struct dwarf2_abbrev_entry_s
125 unsigned long entry_code
;
127 unsigned char have_child
;
129 dwarf2_abbrev_entry_attr_t
* attrs
;
130 } dwarf2_abbrev_entry_t
;
135 const unsigned char* ptr
;
143 unsigned long uvalue
;
147 struct dwarf2_block block
;
151 typedef struct dwarf2_debug_info_s
153 const dwarf2_abbrev_entry_t
*abbrev
;
155 const unsigned char** data
;
156 struct vector children
;
157 } dwarf2_debug_info_t
;
159 typedef struct dwarf2_section_s
161 const unsigned char* address
;
166 enum dwarf2_sections
{section_debug
, section_string
, section_abbrev
, section_line
, section_ranges
, section_max
};
168 typedef struct dwarf2_traverse_context_s
170 const unsigned char* data
;
171 const unsigned char* end_data
;
172 unsigned char word_size
;
173 } dwarf2_traverse_context_t
;
175 /* symt_cache indexes */
182 typedef struct dwarf2_parse_context_s
184 const dwarf2_section_t
* sections
;
187 struct module
* module
;
188 const struct elf_thunk_area
*thunks
;
189 struct sparse_array abbrev_table
;
190 struct sparse_array debug_info_table
;
191 unsigned long load_offset
;
192 unsigned long ref_offset
;
193 struct symt
* symt_cache
[sc_num
]; /* void, int1, int2, int4 */
194 } dwarf2_parse_context_t
;
196 /* stored in the dbghelp's module internal structure for later reuse */
197 struct dwarf2_module_info_s
199 dwarf2_section_t debug_loc
;
200 dwarf2_section_t debug_frame
;
201 dwarf2_section_t eh_frame
;
202 unsigned char word_size
;
205 #define loc_dwarf2_location_list (loc_user + 0)
206 #define loc_dwarf2_block (loc_user + 1)
208 /* forward declarations */
209 static struct symt
* dwarf2_parse_enumeration_type(dwarf2_parse_context_t
* ctx
, dwarf2_debug_info_t
* entry
);
211 static unsigned char dwarf2_get_byte(const unsigned char* ptr
)
216 static unsigned char dwarf2_parse_byte(dwarf2_traverse_context_t
* ctx
)
218 unsigned char uvalue
= dwarf2_get_byte(ctx
->data
);
223 static unsigned short dwarf2_get_u2(const unsigned char* ptr
)
225 return *(const UINT16
*)ptr
;
228 static unsigned short dwarf2_parse_u2(dwarf2_traverse_context_t
* ctx
)
230 unsigned short uvalue
= dwarf2_get_u2(ctx
->data
);
235 static unsigned long dwarf2_get_u4(const unsigned char* ptr
)
237 return *(const UINT32
*)ptr
;
240 static unsigned long dwarf2_parse_u4(dwarf2_traverse_context_t
* ctx
)
242 unsigned long uvalue
= dwarf2_get_u4(ctx
->data
);
247 static DWORD64
dwarf2_get_u8(const unsigned char* ptr
)
249 return *(const UINT64
*)ptr
;
252 static DWORD64
dwarf2_parse_u8(dwarf2_traverse_context_t
* ctx
)
254 DWORD64 uvalue
= dwarf2_get_u8(ctx
->data
);
259 static unsigned long dwarf2_get_leb128_as_unsigned(const unsigned char* ptr
, const unsigned char** end
)
261 unsigned long ret
= 0;
267 byte
= dwarf2_get_byte(ptr
++);
268 ret
|= (byte
& 0x7f) << shift
;
270 } while (byte
& 0x80);
276 static unsigned long dwarf2_leb128_as_unsigned(dwarf2_traverse_context_t
* ctx
)
282 ret
= dwarf2_get_leb128_as_unsigned(ctx
->data
, &ctx
->data
);
287 static long dwarf2_get_leb128_as_signed(const unsigned char* ptr
, const unsigned char** end
)
292 const unsigned size
= sizeof(int) * 8;
296 byte
= dwarf2_get_byte(ptr
++);
297 ret
|= (byte
& 0x7f) << shift
;
299 } while (byte
& 0x80);
302 /* as spec: sign bit of byte is 2nd high order bit (80x40)
303 * -> 0x80 is used as flag.
305 if ((shift
< size
) && (byte
& 0x40))
307 ret
|= - (1 << shift
);
312 static long dwarf2_leb128_as_signed(dwarf2_traverse_context_t
* ctx
)
318 ret
= dwarf2_get_leb128_as_signed(ctx
->data
, &ctx
->data
);
322 static unsigned dwarf2_leb128_length(const dwarf2_traverse_context_t
* ctx
)
325 for (ret
= 0; ctx
->data
[ret
] & 0x80; ret
++);
329 /******************************************************************
332 * Returns an address.
333 * We assume that in all cases word size from Dwarf matches the size of
334 * addresses in platform where the exec is compiled.
336 static unsigned long dwarf2_get_addr(const unsigned char* ptr
, unsigned word_size
)
343 ret
= dwarf2_get_u4(ptr
);
346 ret
= dwarf2_get_u8(ptr
);
349 FIXME("Unsupported Word Size %u\n", word_size
);
355 static unsigned long dwarf2_parse_addr(dwarf2_traverse_context_t
* ctx
)
357 unsigned long ret
= dwarf2_get_addr(ctx
->data
, ctx
->word_size
);
358 ctx
->data
+= ctx
->word_size
;
362 static const char* dwarf2_debug_traverse_ctx(const dwarf2_traverse_context_t
* ctx
)
364 return wine_dbg_sprintf("ctx(%p)", ctx
->data
);
367 static const char* dwarf2_debug_ctx(const dwarf2_parse_context_t
* ctx
)
369 return wine_dbg_sprintf("ctx(%p,%s)",
370 ctx
, debugstr_w(ctx
->module
->module
.ModuleName
));
373 static const char* dwarf2_debug_di(const dwarf2_debug_info_t
* di
)
375 return wine_dbg_sprintf("debug_info(abbrev:%p,symt:%p)",
376 di
->abbrev
, di
->symt
);
379 static dwarf2_abbrev_entry_t
*
380 dwarf2_abbrev_table_find_entry(const struct sparse_array
* abbrev_table
,
381 unsigned long entry_code
)
383 assert( NULL
!= abbrev_table
);
384 return sparse_array_find(abbrev_table
, entry_code
);
387 static void dwarf2_parse_abbrev_set(dwarf2_traverse_context_t
* abbrev_ctx
,
388 struct sparse_array
* abbrev_table
,
391 unsigned long entry_code
;
392 dwarf2_abbrev_entry_t
* abbrev_entry
;
393 dwarf2_abbrev_entry_attr_t
* new = NULL
;
394 dwarf2_abbrev_entry_attr_t
* last
= NULL
;
395 unsigned long attribute
;
398 assert( NULL
!= abbrev_ctx
);
400 TRACE("%s, end at %p\n",
401 dwarf2_debug_traverse_ctx(abbrev_ctx
), abbrev_ctx
->end_data
);
403 sparse_array_init(abbrev_table
, sizeof(dwarf2_abbrev_entry_t
), 32);
404 while (abbrev_ctx
->data
< abbrev_ctx
->end_data
)
406 TRACE("now at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx
));
407 entry_code
= dwarf2_leb128_as_unsigned(abbrev_ctx
);
408 TRACE("found entry_code %lu\n", entry_code
);
411 TRACE("NULL entry code at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx
));
414 abbrev_entry
= sparse_array_add(abbrev_table
, entry_code
, pool
);
415 assert( NULL
!= abbrev_entry
);
417 abbrev_entry
->entry_code
= entry_code
;
418 abbrev_entry
->tag
= dwarf2_leb128_as_unsigned(abbrev_ctx
);
419 abbrev_entry
->have_child
= dwarf2_parse_byte(abbrev_ctx
);
420 abbrev_entry
->attrs
= NULL
;
421 abbrev_entry
->num_attr
= 0;
423 TRACE("table:(%p,#%u) entry_code(%lu) tag(0x%lx) have_child(%u) -> %p\n",
424 abbrev_table
, sparse_array_length(abbrev_table
),
425 entry_code
, abbrev_entry
->tag
, abbrev_entry
->have_child
, abbrev_entry
);
430 attribute
= dwarf2_leb128_as_unsigned(abbrev_ctx
);
431 form
= dwarf2_leb128_as_unsigned(abbrev_ctx
);
432 if (!attribute
) break;
434 new = pool_alloc(pool
, sizeof(dwarf2_abbrev_entry_attr_t
));
437 new->attribute
= attribute
;
440 if (abbrev_entry
->attrs
) last
->next
= new;
441 else abbrev_entry
->attrs
= new;
443 abbrev_entry
->num_attr
++;
446 TRACE("found %u entries\n", sparse_array_length(abbrev_table
));
449 static void dwarf2_swallow_attribute(dwarf2_traverse_context_t
* ctx
,
450 const dwarf2_abbrev_entry_attr_t
* abbrev_attr
)
454 TRACE("(attr:0x%lx,form:0x%lx)\n", abbrev_attr
->attribute
, abbrev_attr
->form
);
456 switch (abbrev_attr
->form
)
458 case DW_FORM_ref_addr
:
459 case DW_FORM_addr
: step
= ctx
->word_size
; break;
462 case DW_FORM_ref1
: step
= 1; break;
464 case DW_FORM_ref2
: step
= 2; break;
467 case DW_FORM_strp
: step
= 4; break;
469 case DW_FORM_ref8
: step
= 8; break;
471 case DW_FORM_ref_udata
:
472 case DW_FORM_udata
: step
= dwarf2_leb128_length(ctx
); break;
473 case DW_FORM_string
: step
= strlen((const char*)ctx
->data
) + 1; break;
474 case DW_FORM_block
: step
= dwarf2_leb128_as_unsigned(ctx
); break;
475 case DW_FORM_block1
: step
= dwarf2_parse_byte(ctx
); break;
476 case DW_FORM_block2
: step
= dwarf2_parse_u2(ctx
); break;
477 case DW_FORM_block4
: step
= dwarf2_parse_u4(ctx
); break;
479 FIXME("Unhandled attribute form %lx\n", abbrev_attr
->form
);
485 static void dwarf2_fill_attr(const dwarf2_parse_context_t
* ctx
,
486 const dwarf2_abbrev_entry_attr_t
* abbrev_attr
,
487 const unsigned char* data
,
488 struct attribute
* attr
)
490 attr
->form
= abbrev_attr
->form
;
493 case DW_FORM_ref_addr
:
495 attr
->u
.uvalue
= dwarf2_get_addr(data
,
496 ctx
->module
->format_info
[DFI_DWARF
]->u
.dwarf2_info
->word_size
);
497 TRACE("addr<0x%lx>\n", attr
->u
.uvalue
);
501 attr
->u
.uvalue
= dwarf2_get_byte(data
);
502 TRACE("flag<0x%lx>\n", attr
->u
.uvalue
);
506 attr
->u
.uvalue
= dwarf2_get_byte(data
);
507 TRACE("data1<%lu>\n", attr
->u
.uvalue
);
511 attr
->u
.uvalue
= dwarf2_get_u2(data
);
512 TRACE("data2<%lu>\n", attr
->u
.uvalue
);
516 attr
->u
.uvalue
= dwarf2_get_u4(data
);
517 TRACE("data4<%lu>\n", attr
->u
.uvalue
);
521 attr
->u
.lluvalue
= dwarf2_get_u8(data
);
522 TRACE("data8<%s>\n", wine_dbgstr_longlong(attr
->u
.uvalue
));
526 attr
->u
.uvalue
= ctx
->ref_offset
+ dwarf2_get_byte(data
);
527 TRACE("ref1<0x%lx>\n", attr
->u
.uvalue
);
531 attr
->u
.uvalue
= ctx
->ref_offset
+ dwarf2_get_u2(data
);
532 TRACE("ref2<0x%lx>\n", attr
->u
.uvalue
);
536 attr
->u
.uvalue
= ctx
->ref_offset
+ dwarf2_get_u4(data
);
537 TRACE("ref4<0x%lx>\n", attr
->u
.uvalue
);
541 FIXME("Unhandled 64 bit support\n");
545 attr
->u
.svalue
= dwarf2_get_leb128_as_signed(data
, NULL
);
548 case DW_FORM_ref_udata
:
549 attr
->u
.uvalue
= dwarf2_get_leb128_as_unsigned(data
, NULL
);
553 attr
->u
.uvalue
= dwarf2_get_leb128_as_unsigned(data
, NULL
);
557 attr
->u
.string
= (const char *)data
;
558 TRACE("string<%s>\n", attr
->u
.string
);
563 unsigned long offset
= dwarf2_get_u4(data
);
564 attr
->u
.string
= (const char*)ctx
->sections
[section_string
].address
+ offset
;
566 TRACE("strp<%s>\n", attr
->u
.string
);
570 attr
->u
.block
.size
= dwarf2_get_leb128_as_unsigned(data
, &attr
->u
.block
.ptr
);
574 attr
->u
.block
.size
= dwarf2_get_byte(data
);
575 attr
->u
.block
.ptr
= data
+ 1;
579 attr
->u
.block
.size
= dwarf2_get_u2(data
);
580 attr
->u
.block
.ptr
= data
+ 2;
584 attr
->u
.block
.size
= dwarf2_get_u4(data
);
585 attr
->u
.block
.ptr
= data
+ 4;
589 FIXME("Unhandled attribute form %lx\n", abbrev_attr
->form
);
594 static BOOL
dwarf2_find_attribute(const dwarf2_parse_context_t
* ctx
,
595 const dwarf2_debug_info_t
* di
,
596 unsigned at
, struct attribute
* attr
)
599 dwarf2_abbrev_entry_attr_t
* abbrev_attr
;
600 dwarf2_abbrev_entry_attr_t
* abstract_abbrev_attr
;
604 abstract_abbrev_attr
= NULL
;
605 for (i
= 0, abbrev_attr
= di
->abbrev
->attrs
; abbrev_attr
; i
++, abbrev_attr
= abbrev_attr
->next
)
607 if (abbrev_attr
->attribute
== at
)
609 dwarf2_fill_attr(ctx
, abbrev_attr
, di
->data
[i
], attr
);
612 if (abbrev_attr
->attribute
== DW_AT_abstract_origin
&&
615 abstract_abbrev_attr
= abbrev_attr
;
619 /* do we have an abstract origin debug entry to look into ? */
620 if (!abstract_abbrev_attr
) break;
621 dwarf2_fill_attr(ctx
, abstract_abbrev_attr
, di
->data
[ai
], attr
);
622 if (!(di
= sparse_array_find(&ctx
->debug_info_table
, attr
->u
.uvalue
)))
623 FIXME("Should have found the debug info entry\n");
628 static void dwarf2_load_one_entry(dwarf2_parse_context_t
*, dwarf2_debug_info_t
*,
629 struct symt_compiland
*);
631 #define Wine_DW_no_register 0x7FFFFFFF
633 static unsigned dwarf2_map_register(int regno
)
635 if (regno
== Wine_DW_no_register
)
637 FIXME("What the heck map reg 0x%x\n",regno
);
640 return dbghelp_current_cpu
->map_dwarf_register(regno
);
643 static enum location_error
644 compute_location(dwarf2_traverse_context_t
* ctx
, struct location
* loc
,
645 HANDLE hproc
, const struct location
* frame
)
647 DWORD_PTR tmp
, stack
[64];
650 BOOL piece_found
= FALSE
;
654 loc
->kind
= loc_absolute
;
655 loc
->reg
= Wine_DW_no_register
;
657 while (ctx
->data
< ctx
->end_data
)
659 op
= dwarf2_parse_byte(ctx
);
661 if (op
>= DW_OP_lit0
&& op
<= DW_OP_lit31
)
662 stack
[++stk
] = op
- DW_OP_lit0
;
663 else if (op
>= DW_OP_reg0
&& op
<= DW_OP_reg31
)
665 /* dbghelp APIs don't know how to cope with this anyway
666 * (for example 'long long' stored in two registers)
667 * FIXME: We should tell winedbg how to deal with it (sigh)
671 if (loc
->reg
!= Wine_DW_no_register
)
672 FIXME("Only supporting one reg (%d -> %d)\n",
673 loc
->reg
, dwarf2_map_register(op
- DW_OP_reg0
));
674 loc
->reg
= dwarf2_map_register(op
- DW_OP_reg0
);
676 loc
->kind
= loc_register
;
678 else if (op
>= DW_OP_breg0
&& op
<= DW_OP_breg31
)
680 /* dbghelp APIs don't know how to cope with this anyway
681 * (for example 'long long' stored in two registers)
682 * FIXME: We should tell winedbg how to deal with it (sigh)
686 if (loc
->reg
!= Wine_DW_no_register
)
687 FIXME("Only supporting one breg (%d -> %d)\n",
688 loc
->reg
, dwarf2_map_register(op
- DW_OP_breg0
));
689 loc
->reg
= dwarf2_map_register(op
- DW_OP_breg0
);
691 stack
[++stk
] = dwarf2_leb128_as_signed(ctx
);
692 loc
->kind
= loc_regrel
;
696 case DW_OP_nop
: break;
697 case DW_OP_addr
: stack
[++stk
] = dwarf2_parse_addr(ctx
); break;
698 case DW_OP_const1u
: stack
[++stk
] = dwarf2_parse_byte(ctx
); break;
699 case DW_OP_const1s
: stack
[++stk
] = dwarf2_parse_byte(ctx
); break;
700 case DW_OP_const2u
: stack
[++stk
] = dwarf2_parse_u2(ctx
); break;
701 case DW_OP_const2s
: stack
[++stk
] = dwarf2_parse_u2(ctx
); break;
702 case DW_OP_const4u
: stack
[++stk
] = dwarf2_parse_u4(ctx
); break;
703 case DW_OP_const4s
: stack
[++stk
] = dwarf2_parse_u4(ctx
); break;
704 case DW_OP_const8u
: stack
[++stk
] = dwarf2_parse_u8(ctx
); break;
705 case DW_OP_const8s
: stack
[++stk
] = dwarf2_parse_u8(ctx
); break;
706 case DW_OP_constu
: stack
[++stk
] = dwarf2_leb128_as_unsigned(ctx
); break;
707 case DW_OP_consts
: stack
[++stk
] = dwarf2_leb128_as_signed(ctx
); break;
708 case DW_OP_dup
: stack
[stk
+ 1] = stack
[stk
]; stk
++; break;
709 case DW_OP_drop
: stk
--; break;
710 case DW_OP_over
: stack
[stk
+ 1] = stack
[stk
- 1]; stk
++; break;
711 case DW_OP_pick
: stack
[stk
+ 1] = stack
[stk
- dwarf2_parse_byte(ctx
)]; stk
++; break;
712 case DW_OP_swap
: tmp
= stack
[stk
]; stack
[stk
] = stack
[stk
-1]; stack
[stk
-1] = tmp
; break;
713 case DW_OP_rot
: tmp
= stack
[stk
]; stack
[stk
] = stack
[stk
-1]; stack
[stk
-1] = stack
[stk
-2]; stack
[stk
-2] = tmp
; break;
714 case DW_OP_abs
: stack
[stk
] = labs(stack
[stk
]); break;
715 case DW_OP_neg
: stack
[stk
] = -stack
[stk
]; break;
716 case DW_OP_not
: stack
[stk
] = ~stack
[stk
]; break;
717 case DW_OP_and
: stack
[stk
-1] &= stack
[stk
]; stk
--; break;
718 case DW_OP_or
: stack
[stk
-1] |= stack
[stk
]; stk
--; break;
719 case DW_OP_minus
: stack
[stk
-1] -= stack
[stk
]; stk
--; break;
720 case DW_OP_mul
: stack
[stk
-1] *= stack
[stk
]; stk
--; break;
721 case DW_OP_plus
: stack
[stk
-1] += stack
[stk
]; stk
--; break;
722 case DW_OP_xor
: stack
[stk
-1] ^= stack
[stk
]; stk
--; break;
723 case DW_OP_shl
: stack
[stk
-1] <<= stack
[stk
]; stk
--; break;
724 case DW_OP_shr
: stack
[stk
-1] >>= stack
[stk
]; stk
--; break;
725 case DW_OP_plus_uconst
: stack
[stk
] += dwarf2_leb128_as_unsigned(ctx
); break;
726 case DW_OP_shra
: stack
[stk
-1] = stack
[stk
-1] / (1 << stack
[stk
]); stk
--; break;
727 case DW_OP_div
: stack
[stk
-1] = stack
[stk
-1] / stack
[stk
]; stk
--; break;
728 case DW_OP_mod
: stack
[stk
-1] = stack
[stk
-1] % stack
[stk
]; stk
--; break;
729 case DW_OP_ge
: stack
[stk
-1] = (stack
[stk
-1] >= stack
[stk
]); stk
--; break;
730 case DW_OP_gt
: stack
[stk
-1] = (stack
[stk
-1] > stack
[stk
]); stk
--; break;
731 case DW_OP_le
: stack
[stk
-1] = (stack
[stk
-1] <= stack
[stk
]); stk
--; break;
732 case DW_OP_lt
: stack
[stk
-1] = (stack
[stk
-1] < stack
[stk
]); stk
--; break;
733 case DW_OP_eq
: stack
[stk
-1] = (stack
[stk
-1] == stack
[stk
]); stk
--; break;
734 case DW_OP_ne
: stack
[stk
-1] = (stack
[stk
-1] != stack
[stk
]); stk
--; break;
735 case DW_OP_skip
: tmp
= dwarf2_parse_u2(ctx
); ctx
->data
+= tmp
; break;
736 case DW_OP_bra
: tmp
= dwarf2_parse_u2(ctx
); if (!stack
[stk
--]) ctx
->data
+= tmp
; break;
738 tmp
= dwarf2_leb128_as_unsigned(ctx
);
741 if (loc
->reg
!= Wine_DW_no_register
)
742 FIXME("Only supporting one reg\n");
743 loc
->reg
= dwarf2_map_register(tmp
);
745 loc
->kind
= loc_register
;
748 tmp
= dwarf2_leb128_as_unsigned(ctx
);
749 if (loc
->reg
!= Wine_DW_no_register
)
750 FIXME("Only supporting one regx\n");
751 loc
->reg
= dwarf2_map_register(tmp
);
752 stack
[++stk
] = dwarf2_leb128_as_signed(ctx
);
753 loc
->kind
= loc_regrel
;
756 if (loc
->reg
!= Wine_DW_no_register
)
757 FIXME("Only supporting one reg (%d -> -2)\n", loc
->reg
);
758 if (frame
&& frame
->kind
== loc_register
)
760 loc
->kind
= loc_regrel
;
761 loc
->reg
= frame
->reg
;
762 stack
[++stk
] = dwarf2_leb128_as_signed(ctx
);
764 else if (frame
&& frame
->kind
== loc_regrel
)
766 loc
->kind
= loc_regrel
;
767 loc
->reg
= frame
->reg
;
768 stack
[++stk
] = dwarf2_leb128_as_signed(ctx
) + frame
->offset
;
772 /* FIXME: this could be later optimized by not recomputing
773 * this very location expression
775 loc
->kind
= loc_dwarf2_block
;
776 stack
[++stk
] = dwarf2_leb128_as_signed(ctx
);
781 unsigned sz
= dwarf2_leb128_as_unsigned(ctx
);
782 WARN("Not handling OP_piece (size=%d)\n", sz
);
789 FIXME("Unexpected empty stack\n");
790 return loc_err_internal
;
792 if (loc
->reg
!= Wine_DW_no_register
)
794 WARN("Too complex expression for deref\n");
795 return loc_err_too_complex
;
799 DWORD_PTR addr
= stack
[stk
--];
802 if (!ReadProcessMemory(hproc
, (void*)addr
, &deref
, sizeof(deref
), NULL
))
804 WARN("Couldn't read memory at %lx\n", addr
);
805 return loc_err_cant_read
;
807 stack
[++stk
] = deref
;
811 loc
->kind
= loc_dwarf2_block
;
814 case DW_OP_deref_size
:
817 FIXME("Unexpected empty stack\n");
818 return loc_err_internal
;
820 if (loc
->reg
!= Wine_DW_no_register
)
822 WARN("Too complex expression for deref\n");
823 return loc_err_too_complex
;
827 DWORD_PTR addr
= stack
[stk
--];
828 BYTE derefsize
= dwarf2_parse_byte(ctx
);
831 if (!ReadProcessMemory(hproc
, (void*)addr
, &deref
, derefsize
, NULL
))
833 WARN("Couldn't read memory at %lx\n", addr
);
834 return loc_err_cant_read
;
839 case 1: stack
[++stk
] = *(unsigned char*)&deref
; break;
840 case 2: stack
[++stk
] = *(unsigned short*)&deref
; break;
841 case 4: stack
[++stk
] = *(DWORD
*)&deref
; break;
842 case 8: if (ctx
->word_size
>= derefsize
) stack
[++stk
] = deref
; break;
847 loc
->kind
= loc_dwarf2_block
;
850 case DW_OP_stack_value
:
851 /* Expected behaviour is that this is the last instruction of this
852 * expression and just the "top of stack" value should be put to loc->offset. */
855 if (op
< DW_OP_lo_user
) /* as DW_OP_hi_user is 0xFF, we don't need to test against it */
856 FIXME("Unhandled attr op: %x\n", op
);
857 /* FIXME else unhandled extension */
858 return loc_err_internal
;
861 loc
->offset
= stack
[stk
];
865 static BOOL
dwarf2_compute_location_attr(dwarf2_parse_context_t
* ctx
,
866 const dwarf2_debug_info_t
* di
,
868 struct location
* loc
,
869 const struct location
* frame
)
871 struct attribute xloc
;
873 if (!dwarf2_find_attribute(ctx
, di
, dw
, &xloc
)) return FALSE
;
877 case DW_FORM_data1
: case DW_FORM_data2
:
878 case DW_FORM_udata
: case DW_FORM_sdata
:
879 loc
->kind
= loc_absolute
;
881 loc
->offset
= xloc
.u
.uvalue
;
883 case DW_FORM_data4
: case DW_FORM_data8
:
884 loc
->kind
= loc_dwarf2_location_list
;
885 loc
->reg
= Wine_DW_no_register
;
886 loc
->offset
= xloc
.u
.uvalue
;
893 default: FIXME("Unsupported yet form %lx\n", xloc
.form
);
897 /* assume we have a block form */
899 if (xloc
.u
.block
.size
)
901 dwarf2_traverse_context_t lctx
;
902 enum location_error err
;
904 lctx
.data
= xloc
.u
.block
.ptr
;
905 lctx
.end_data
= xloc
.u
.block
.ptr
+ xloc
.u
.block
.size
;
906 lctx
.word_size
= ctx
->module
->format_info
[DFI_DWARF
]->u
.dwarf2_info
->word_size
;
908 err
= compute_location(&lctx
, loc
, NULL
, frame
);
911 loc
->kind
= loc_error
;
914 else if (loc
->kind
== loc_dwarf2_block
)
916 unsigned* ptr
= pool_alloc(&ctx
->module
->pool
,
917 sizeof(unsigned) + xloc
.u
.block
.size
);
918 *ptr
= xloc
.u
.block
.size
;
919 memcpy(ptr
+ 1, xloc
.u
.block
.ptr
, xloc
.u
.block
.size
);
920 loc
->offset
= (unsigned long)ptr
;
926 static struct symt
* dwarf2_lookup_type(dwarf2_parse_context_t
* ctx
,
927 const dwarf2_debug_info_t
* di
)
929 struct attribute attr
;
931 if (dwarf2_find_attribute(ctx
, di
, DW_AT_type
, &attr
))
933 dwarf2_debug_info_t
* type
;
935 type
= sparse_array_find(&ctx
->debug_info_table
, attr
.u
.uvalue
);
936 if (!type
) FIXME("Unable to find back reference to type %lx\n", attr
.u
.uvalue
);
939 /* load the debug info entity */
940 dwarf2_load_one_entry(ctx
, type
, NULL
);
947 /******************************************************************
950 * read a range for a given debug_info (either using AT_range attribute, in which
951 * case we don't return all the details, or using AT_low_pc & AT_high_pc attributes)
952 * in all cases, range is relative to beginning of compilation unit
954 static BOOL
dwarf2_read_range(dwarf2_parse_context_t
* ctx
, const dwarf2_debug_info_t
* di
,
955 unsigned long* plow
, unsigned long* phigh
)
957 struct attribute range
;
959 if (dwarf2_find_attribute(ctx
, di
, DW_AT_ranges
, &range
))
961 dwarf2_traverse_context_t traverse
;
962 unsigned long low
, high
;
964 traverse
.data
= ctx
->sections
[section_ranges
].address
+ range
.u
.uvalue
;
965 traverse
.end_data
= ctx
->sections
[section_ranges
].address
+
966 ctx
->sections
[section_ranges
].size
;
967 traverse
.word_size
= ctx
->module
->format_info
[DFI_DWARF
]->u
.dwarf2_info
->word_size
;
971 while (traverse
.data
+ 2 * traverse
.word_size
< traverse
.end_data
)
973 low
= dwarf2_parse_addr(&traverse
);
974 high
= dwarf2_parse_addr(&traverse
);
975 if (low
== 0 && high
== 0) break;
976 if (low
== ULONG_MAX
) FIXME("unsupported yet (base address selection)\n");
977 if (low
< *plow
) *plow
= low
;
978 if (high
> *phigh
) *phigh
= high
;
980 if (*plow
== ULONG_MAX
|| *phigh
== 0) {FIXME("no entry found\n"); return FALSE
;}
981 if (*plow
== *phigh
) {FIXME("entry found, but low=high\n"); return FALSE
;}
987 struct attribute low_pc
;
988 struct attribute high_pc
;
990 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_low_pc
, &low_pc
) ||
991 !dwarf2_find_attribute(ctx
, di
, DW_AT_high_pc
, &high_pc
))
993 FIXME("missing low or high value\n");
996 *plow
= low_pc
.u
.uvalue
;
997 *phigh
= high_pc
.u
.uvalue
;
1002 /******************************************************************
1003 * dwarf2_read_one_debug_info
1005 * Loads into memory one debug info entry, and recursively its children (if any)
1007 static BOOL
dwarf2_read_one_debug_info(dwarf2_parse_context_t
* ctx
,
1008 dwarf2_traverse_context_t
* traverse
,
1009 dwarf2_debug_info_t
** pdi
)
1011 const dwarf2_abbrev_entry_t
*abbrev
;
1012 unsigned long entry_code
;
1013 unsigned long offset
;
1014 dwarf2_debug_info_t
* di
;
1015 dwarf2_debug_info_t
* child
;
1016 dwarf2_debug_info_t
** where
;
1017 dwarf2_abbrev_entry_attr_t
* attr
;
1019 struct attribute sibling
;
1021 offset
= traverse
->data
- ctx
->sections
[ctx
->section
].address
;
1022 entry_code
= dwarf2_leb128_as_unsigned(traverse
);
1023 TRACE("found entry_code %lu at 0x%lx\n", entry_code
, offset
);
1029 abbrev
= dwarf2_abbrev_table_find_entry(&ctx
->abbrev_table
, entry_code
);
1032 WARN("Cannot find abbrev entry for %lu at 0x%lx\n", entry_code
, offset
);
1035 di
= sparse_array_add(&ctx
->debug_info_table
, offset
, &ctx
->pool
);
1036 if (!di
) return FALSE
;
1037 di
->abbrev
= abbrev
;
1040 if (abbrev
->num_attr
)
1042 di
->data
= pool_alloc(&ctx
->pool
, abbrev
->num_attr
* sizeof(const char*));
1043 for (i
= 0, attr
= abbrev
->attrs
; attr
; i
++, attr
= attr
->next
)
1045 di
->data
[i
] = traverse
->data
;
1046 dwarf2_swallow_attribute(traverse
, attr
);
1049 else di
->data
= NULL
;
1050 if (abbrev
->have_child
)
1052 vector_init(&di
->children
, sizeof(dwarf2_debug_info_t
*), 16);
1053 while (traverse
->data
< traverse
->end_data
)
1055 if (!dwarf2_read_one_debug_info(ctx
, traverse
, &child
)) return FALSE
;
1057 where
= vector_add(&di
->children
, &ctx
->pool
);
1058 if (!where
) return FALSE
;
1062 if (dwarf2_find_attribute(ctx
, di
, DW_AT_sibling
, &sibling
) &&
1063 traverse
->data
!= ctx
->sections
[ctx
->section
].address
+ sibling
.u
.uvalue
)
1065 WARN("setting cursor for %s to next sibling <0x%lx>\n",
1066 dwarf2_debug_traverse_ctx(traverse
), sibling
.u
.uvalue
);
1067 traverse
->data
= ctx
->sections
[ctx
->section
].address
+ sibling
.u
.uvalue
;
1073 static struct symt
* dwarf2_parse_base_type(dwarf2_parse_context_t
* ctx
,
1074 dwarf2_debug_info_t
* di
)
1076 struct attribute name
;
1077 struct attribute size
;
1078 struct attribute encoding
;
1081 if (di
->symt
) return di
->symt
;
1083 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1085 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_name
, &name
))
1086 name
.u
.string
= NULL
;
1087 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_byte_size
, &size
)) size
.u
.uvalue
= 0;
1088 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_encoding
, &encoding
)) encoding
.u
.uvalue
= DW_ATE_void
;
1090 switch (encoding
.u
.uvalue
)
1092 case DW_ATE_void
: bt
= btVoid
; break;
1093 case DW_ATE_address
: bt
= btULong
; break;
1094 case DW_ATE_boolean
: bt
= btBool
; break;
1095 case DW_ATE_complex_float
: bt
= btComplex
; break;
1096 case DW_ATE_float
: bt
= btFloat
; break;
1097 case DW_ATE_signed
: bt
= btInt
; break;
1098 case DW_ATE_unsigned
: bt
= btUInt
; break;
1099 case DW_ATE_signed_char
: bt
= btChar
; break;
1100 case DW_ATE_unsigned_char
: bt
= btChar
; break;
1101 default: bt
= btNoType
; break;
1103 di
->symt
= &symt_new_basic(ctx
->module
, bt
, name
.u
.string
, size
.u
.uvalue
)->symt
;
1107 assert(size
.u
.uvalue
== 0);
1108 cache_idx
= sc_void
;
1111 switch (size
.u
.uvalue
)
1113 case 1: cache_idx
= sc_int1
; break;
1114 case 2: cache_idx
= sc_int2
; break;
1115 case 4: cache_idx
= sc_int4
; break;
1120 if (cache_idx
!= -1 && !ctx
->symt_cache
[cache_idx
])
1121 ctx
->symt_cache
[cache_idx
] = di
->symt
;
1123 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1127 static struct symt
* dwarf2_parse_typedef(dwarf2_parse_context_t
* ctx
,
1128 dwarf2_debug_info_t
* di
)
1130 struct symt
* ref_type
;
1131 struct attribute name
;
1133 if (di
->symt
) return di
->symt
;
1135 TRACE("%s, for %lu\n", dwarf2_debug_ctx(ctx
), di
->abbrev
->entry_code
);
1137 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_name
, &name
)) name
.u
.string
= NULL
;
1138 ref_type
= dwarf2_lookup_type(ctx
, di
);
1141 di
->symt
= &symt_new_typedef(ctx
->module
, ref_type
, name
.u
.string
)->symt
;
1142 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1146 static struct symt
* dwarf2_parse_pointer_type(dwarf2_parse_context_t
* ctx
,
1147 dwarf2_debug_info_t
* di
)
1149 struct symt
* ref_type
;
1150 struct attribute size
;
1152 if (di
->symt
) return di
->symt
;
1154 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1156 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_byte_size
, &size
)) size
.u
.uvalue
= sizeof(void *);
1157 if (!(ref_type
= dwarf2_lookup_type(ctx
, di
)))
1159 ref_type
= ctx
->symt_cache
[sc_void
];
1162 di
->symt
= &symt_new_pointer(ctx
->module
, ref_type
, size
.u
.uvalue
)->symt
;
1163 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1167 static struct symt
* dwarf2_parse_array_type(dwarf2_parse_context_t
* ctx
,
1168 dwarf2_debug_info_t
* di
)
1170 struct symt
* ref_type
;
1171 struct symt
* idx_type
= NULL
;
1172 struct attribute min
, max
, cnt
;
1173 dwarf2_debug_info_t
* child
;
1176 if (di
->symt
) return di
->symt
;
1178 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1180 ref_type
= dwarf2_lookup_type(ctx
, di
);
1182 if (!di
->abbrev
->have_child
)
1184 /* fake an array with unknown size */
1185 /* FIXME: int4 even on 64bit machines??? */
1186 idx_type
= ctx
->symt_cache
[sc_int4
];
1190 else for (i
= 0; i
< vector_length(&di
->children
); i
++)
1192 child
= *(dwarf2_debug_info_t
**)vector_at(&di
->children
, i
);
1193 switch (child
->abbrev
->tag
)
1195 case DW_TAG_subrange_type
:
1196 idx_type
= dwarf2_lookup_type(ctx
, child
);
1197 if (!dwarf2_find_attribute(ctx
, child
, DW_AT_lower_bound
, &min
))
1199 if (!dwarf2_find_attribute(ctx
, child
, DW_AT_upper_bound
, &max
))
1201 if (dwarf2_find_attribute(ctx
, child
, DW_AT_count
, &cnt
))
1202 max
.u
.uvalue
= min
.u
.uvalue
+ cnt
.u
.uvalue
;
1205 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1206 child
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1210 di
->symt
= &symt_new_array(ctx
->module
, min
.u
.uvalue
, max
.u
.uvalue
, ref_type
, idx_type
)->symt
;
1214 static struct symt
* dwarf2_parse_const_type(dwarf2_parse_context_t
* ctx
,
1215 dwarf2_debug_info_t
* di
)
1217 struct symt
* ref_type
;
1219 if (di
->symt
) return di
->symt
;
1221 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1223 ref_type
= dwarf2_lookup_type(ctx
, di
);
1224 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1225 di
->symt
= ref_type
;
1230 static struct symt
* dwarf2_parse_volatile_type(dwarf2_parse_context_t
* ctx
,
1231 dwarf2_debug_info_t
* di
)
1233 struct symt
* ref_type
;
1235 if (di
->symt
) return di
->symt
;
1237 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1239 ref_type
= dwarf2_lookup_type(ctx
, di
);
1240 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1241 di
->symt
= ref_type
;
1246 static struct symt
* dwarf2_parse_reference_type(dwarf2_parse_context_t
* ctx
,
1247 dwarf2_debug_info_t
* di
)
1249 struct symt
* ref_type
= NULL
;
1251 if (di
->symt
) return di
->symt
;
1253 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1255 ref_type
= dwarf2_lookup_type(ctx
, di
);
1256 /* FIXME: for now, we hard-wire C++ references to pointers */
1257 di
->symt
= &symt_new_pointer(ctx
->module
, ref_type
, sizeof(void *))->symt
;
1259 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1264 static void dwarf2_parse_udt_member(dwarf2_parse_context_t
* ctx
,
1265 const dwarf2_debug_info_t
* di
,
1266 struct symt_udt
* parent
)
1268 struct symt
* elt_type
;
1269 struct attribute name
;
1270 struct attribute bit_size
;
1271 struct attribute bit_offset
;
1272 struct location loc
;
1276 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1278 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_name
, &name
)) name
.u
.string
= NULL
;
1279 elt_type
= dwarf2_lookup_type(ctx
, di
);
1280 if (dwarf2_compute_location_attr(ctx
, di
, DW_AT_data_member_location
, &loc
, NULL
))
1282 if (loc
.kind
!= loc_absolute
)
1284 FIXME("Found register, while not expecting it\n");
1288 TRACE("found member_location at %s -> %lu\n",
1289 dwarf2_debug_ctx(ctx
), loc
.offset
);
1293 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_bit_size
, &bit_size
))
1294 bit_size
.u
.uvalue
= 0;
1295 if (dwarf2_find_attribute(ctx
, di
, DW_AT_bit_offset
, &bit_offset
))
1297 /* FIXME: we should only do this when implementation is LSB (which is
1298 * the case on i386 processors)
1300 struct attribute nbytes
;
1301 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_byte_size
, &nbytes
))
1304 nbytes
.u
.uvalue
= symt_get_info(ctx
->module
, elt_type
, TI_GET_LENGTH
, &size
) ?
1305 (unsigned long)size
: 0;
1307 bit_offset
.u
.uvalue
= nbytes
.u
.uvalue
* 8 - bit_offset
.u
.uvalue
- bit_size
.u
.uvalue
;
1309 else bit_offset
.u
.uvalue
= 0;
1310 symt_add_udt_element(ctx
->module
, parent
, name
.u
.string
, elt_type
,
1311 (loc
.offset
<< 3) + bit_offset
.u
.uvalue
,
1314 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1317 static struct symt
* dwarf2_parse_udt_type(dwarf2_parse_context_t
* ctx
,
1318 dwarf2_debug_info_t
* di
,
1321 struct attribute name
;
1322 struct attribute size
;
1324 if (di
->symt
) return di
->symt
;
1326 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1328 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_name
, &name
)) name
.u
.string
= NULL
;
1329 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_byte_size
, &size
)) size
.u
.uvalue
= 0;
1331 di
->symt
= &symt_new_udt(ctx
->module
, name
.u
.string
, size
.u
.uvalue
, udt
)->symt
;
1333 if (di
->abbrev
->have_child
) /** any interest to not have child ? */
1335 dwarf2_debug_info_t
* child
;
1338 for (i
=0; i
<vector_length(&di
->children
); i
++)
1340 child
= *(dwarf2_debug_info_t
**)vector_at(&di
->children
, i
);
1342 switch (child
->abbrev
->tag
)
1345 /* FIXME: should I follow the sibling stuff ?? */
1346 dwarf2_parse_udt_member(ctx
, child
, (struct symt_udt
*)di
->symt
);
1348 case DW_TAG_enumeration_type
:
1349 dwarf2_parse_enumeration_type(ctx
, child
);
1351 case DW_TAG_structure_type
:
1352 case DW_TAG_class_type
:
1353 case DW_TAG_union_type
:
1354 case DW_TAG_typedef
:
1355 /* FIXME: we need to handle nested udt definitions */
1356 case DW_TAG_inheritance
:
1357 case DW_TAG_subprogram
:
1358 case DW_TAG_template_type_param
:
1359 case DW_TAG_template_value_param
:
1360 case DW_TAG_variable
:
1361 case DW_TAG_imported_declaration
:
1362 case DW_TAG_ptr_to_member_type
:
1363 /* FIXME: some C++ related stuff */
1366 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1367 child
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1376 static void dwarf2_parse_enumerator(dwarf2_parse_context_t
* ctx
,
1377 const dwarf2_debug_info_t
* di
,
1378 struct symt_enum
* parent
)
1380 struct attribute name
;
1381 struct attribute value
;
1383 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1385 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_name
, &name
)) return;
1386 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_const_value
, &value
)) value
.u
.svalue
= 0;
1387 symt_add_enum_element(ctx
->module
, parent
, name
.u
.string
, value
.u
.svalue
);
1389 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1392 static struct symt
* dwarf2_parse_enumeration_type(dwarf2_parse_context_t
* ctx
,
1393 dwarf2_debug_info_t
* di
)
1395 struct attribute name
;
1396 struct attribute size
;
1397 struct symt_basic
* basetype
;
1399 if (di
->symt
) return di
->symt
;
1401 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1403 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_name
, &name
)) name
.u
.string
= NULL
;
1404 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_byte_size
, &size
)) size
.u
.uvalue
= 4;
1406 switch (size
.u
.uvalue
) /* FIXME: that's wrong */
1408 case 1: basetype
= symt_new_basic(ctx
->module
, btInt
, "char", 1); break;
1409 case 2: basetype
= symt_new_basic(ctx
->module
, btInt
, "short", 2); break;
1411 case 4: basetype
= symt_new_basic(ctx
->module
, btInt
, "int", 4); break;
1414 di
->symt
= &symt_new_enum(ctx
->module
, name
.u
.string
, &basetype
->symt
)->symt
;
1416 if (di
->abbrev
->have_child
) /* any interest to not have child ? */
1418 dwarf2_debug_info_t
* child
;
1421 /* FIXME: should we use the sibling stuff ?? */
1422 for (i
=0; i
<vector_length(&di
->children
); i
++)
1424 child
= *(dwarf2_debug_info_t
**)vector_at(&di
->children
, i
);
1426 switch (child
->abbrev
->tag
)
1428 case DW_TAG_enumerator
:
1429 dwarf2_parse_enumerator(ctx
, child
, (struct symt_enum
*)di
->symt
);
1432 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1433 di
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1440 /* structure used to pass information around when parsing a subprogram */
1441 typedef struct dwarf2_subprogram_s
1443 dwarf2_parse_context_t
* ctx
;
1444 struct symt_compiland
* compiland
;
1445 struct symt_function
* func
;
1446 BOOL non_computed_variable
;
1447 struct location frame
;
1448 } dwarf2_subprogram_t
;
1450 /******************************************************************
1451 * dwarf2_parse_variable
1453 * Parses any variable (parameter, local/global variable)
1455 static void dwarf2_parse_variable(dwarf2_subprogram_t
* subpgm
,
1456 struct symt_block
* block
,
1457 dwarf2_debug_info_t
* di
)
1459 struct symt
* param_type
;
1460 struct attribute name
, value
;
1461 struct location loc
;
1464 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1466 is_pmt
= !block
&& di
->abbrev
->tag
== DW_TAG_formal_parameter
;
1467 param_type
= dwarf2_lookup_type(subpgm
->ctx
, di
);
1469 if (!dwarf2_find_attribute(subpgm
->ctx
, di
, DW_AT_name
, &name
)) {
1470 /* cannot do much without the name, the functions below won't like it. */
1473 if (dwarf2_compute_location_attr(subpgm
->ctx
, di
, DW_AT_location
,
1474 &loc
, &subpgm
->frame
))
1476 struct attribute ext
;
1478 TRACE("found parameter %s (kind=%d, offset=%ld, reg=%d) at %s\n",
1479 name
.u
.string
, loc
.kind
, loc
.offset
, loc
.reg
,
1480 dwarf2_debug_ctx(subpgm
->ctx
));
1487 /* it's a global variable */
1488 /* FIXME: we don't handle its scope yet */
1489 if (!dwarf2_find_attribute(subpgm
->ctx
, di
, DW_AT_external
, &ext
))
1491 loc
.offset
+= subpgm
->ctx
->load_offset
;
1492 symt_new_global_variable(subpgm
->ctx
->module
, subpgm
->compiland
,
1493 name
.u
.string
, !ext
.u
.uvalue
,
1494 loc
, 0, param_type
);
1497 subpgm
->non_computed_variable
= TRUE
;
1501 /* either a pmt/variable relative to frame pointer or
1502 * pmt/variable in a register
1504 assert(subpgm
->func
);
1505 symt_add_func_local(subpgm
->ctx
->module
, subpgm
->func
,
1506 is_pmt
? DataIsParam
: DataIsLocal
,
1507 &loc
, block
, param_type
, name
.u
.string
);
1511 else if (dwarf2_find_attribute(subpgm
->ctx
, di
, DW_AT_const_value
, &value
))
1514 if (subpgm
->func
) WARN("Unsupported constant %s in function\n", name
.u
.string
);
1515 if (is_pmt
) FIXME("Unsupported constant (parameter) %s in function\n", name
.u
.string
);
1523 v
.n1
.n2
.vt
= VT_UI4
;
1524 v
.n1
.n2
.n3
.lVal
= value
.u
.uvalue
;
1528 v
.n1
.n2
.vt
= VT_UI8
;
1529 v
.n1
.n2
.n3
.llVal
= value
.u
.lluvalue
;
1534 v
.n1
.n2
.n3
.lVal
= value
.u
.svalue
;
1538 case DW_FORM_string
:
1539 /* FIXME: native doesn't report const strings from here !!
1540 * however, the value of the string is in the code somewhere
1542 v
.n1
.n2
.vt
= VT_I1
| VT_BYREF
;
1543 v
.n1
.n2
.n3
.byref
= pool_strdup(&subpgm
->ctx
->module
->pool
, value
.u
.string
);
1547 case DW_FORM_block1
:
1548 case DW_FORM_block2
:
1549 case DW_FORM_block4
:
1551 switch (value
.u
.block
.size
)
1553 case 1: v
.n1
.n2
.n3
.lVal
= *(BYTE
*)value
.u
.block
.ptr
; break;
1554 case 2: v
.n1
.n2
.n3
.lVal
= *(USHORT
*)value
.u
.block
.ptr
; break;
1555 case 4: v
.n1
.n2
.n3
.lVal
= *(DWORD
*)value
.u
.block
.ptr
; break;
1557 v
.n1
.n2
.vt
= VT_I1
| VT_BYREF
;
1558 v
.n1
.n2
.n3
.byref
= pool_alloc(&subpgm
->ctx
->module
->pool
, value
.u
.block
.size
);
1559 memcpy(v
.n1
.n2
.n3
.byref
, value
.u
.block
.ptr
, value
.u
.block
.size
);
1564 FIXME("Unsupported form for const value %s (%lx)\n",
1565 name
.u
.string
, value
.form
);
1566 v
.n1
.n2
.vt
= VT_EMPTY
;
1568 di
->symt
= &symt_new_constant(subpgm
->ctx
->module
, subpgm
->compiland
,
1569 name
.u
.string
, param_type
, &v
)->symt
;
1573 /* variable has been optimiezd away... report anyway */
1574 loc
.kind
= loc_error
;
1575 loc
.reg
= loc_err_no_location
;
1578 symt_add_func_local(subpgm
->ctx
->module
, subpgm
->func
,
1579 is_pmt
? DataIsParam
: DataIsLocal
,
1580 &loc
, block
, param_type
, name
.u
.string
);
1584 WARN("dropping global variable %s which has been optimized away\n", name
.u
.string
);
1587 if (is_pmt
&& subpgm
->func
&& subpgm
->func
->type
)
1588 symt_add_function_signature_parameter(subpgm
->ctx
->module
,
1589 (struct symt_function_signature
*)subpgm
->func
->type
,
1592 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1595 static void dwarf2_parse_subprogram_label(dwarf2_subprogram_t
* subpgm
,
1596 const dwarf2_debug_info_t
* di
)
1598 struct attribute name
;
1599 struct attribute low_pc
;
1600 struct location loc
;
1602 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1604 if (!dwarf2_find_attribute(subpgm
->ctx
, di
, DW_AT_low_pc
, &low_pc
)) low_pc
.u
.uvalue
= 0;
1605 if (!dwarf2_find_attribute(subpgm
->ctx
, di
, DW_AT_name
, &name
))
1606 name
.u
.string
= NULL
;
1608 loc
.kind
= loc_absolute
;
1609 loc
.offset
= subpgm
->ctx
->load_offset
+ low_pc
.u
.uvalue
;
1610 symt_add_function_point(subpgm
->ctx
->module
, subpgm
->func
, SymTagLabel
,
1611 &loc
, name
.u
.string
);
1614 static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t
* subpgm
,
1615 struct symt_block
* parent_block
,
1616 const dwarf2_debug_info_t
* di
);
1618 static void dwarf2_parse_inlined_subroutine(dwarf2_subprogram_t
* subpgm
,
1619 struct symt_block
* parent_block
,
1620 const dwarf2_debug_info_t
* di
)
1622 struct symt_block
* block
;
1623 unsigned long low_pc
, high_pc
;
1625 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1627 if (!dwarf2_read_range(subpgm
->ctx
, di
, &low_pc
, &high_pc
))
1629 FIXME("cannot read range\n");
1633 block
= symt_open_func_block(subpgm
->ctx
->module
, subpgm
->func
, parent_block
,
1634 subpgm
->ctx
->load_offset
+ low_pc
- subpgm
->func
->address
,
1637 if (di
->abbrev
->have_child
) /** any interest to not have child ? */
1639 dwarf2_debug_info_t
* child
;
1642 for (i
=0; i
<vector_length(&di
->children
); i
++)
1644 child
= *(dwarf2_debug_info_t
**)vector_at(&di
->children
, i
);
1646 switch (child
->abbrev
->tag
)
1648 case DW_TAG_formal_parameter
:
1649 case DW_TAG_variable
:
1650 dwarf2_parse_variable(subpgm
, block
, child
);
1652 case DW_TAG_lexical_block
:
1653 dwarf2_parse_subprogram_block(subpgm
, block
, child
);
1655 case DW_TAG_inlined_subroutine
:
1656 dwarf2_parse_inlined_subroutine(subpgm
, block
, child
);
1659 dwarf2_parse_subprogram_label(subpgm
, child
);
1662 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1663 child
->abbrev
->tag
, dwarf2_debug_ctx(subpgm
->ctx
),
1664 dwarf2_debug_di(di
));
1668 symt_close_func_block(subpgm
->ctx
->module
, subpgm
->func
, block
, 0);
1671 static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t
* subpgm
,
1672 struct symt_block
* parent_block
,
1673 const dwarf2_debug_info_t
* di
)
1675 struct symt_block
* block
;
1676 unsigned long low_pc
, high_pc
;
1678 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1680 if (!dwarf2_read_range(subpgm
->ctx
, di
, &low_pc
, &high_pc
))
1682 FIXME("no range\n");
1686 block
= symt_open_func_block(subpgm
->ctx
->module
, subpgm
->func
, parent_block
,
1687 subpgm
->ctx
->load_offset
+ low_pc
- subpgm
->func
->address
,
1690 if (di
->abbrev
->have_child
) /** any interest to not have child ? */
1692 dwarf2_debug_info_t
* child
;
1695 for (i
=0; i
<vector_length(&di
->children
); i
++)
1697 child
= *(dwarf2_debug_info_t
**)vector_at(&di
->children
, i
);
1699 switch (child
->abbrev
->tag
)
1701 case DW_TAG_inlined_subroutine
:
1702 dwarf2_parse_inlined_subroutine(subpgm
, block
, child
);
1704 case DW_TAG_variable
:
1705 dwarf2_parse_variable(subpgm
, block
, child
);
1707 case DW_TAG_lexical_block
:
1708 dwarf2_parse_subprogram_block(subpgm
, block
, child
);
1710 case DW_TAG_subprogram
:
1711 /* FIXME: likely a declaration (to be checked)
1715 case DW_TAG_formal_parameter
:
1716 /* FIXME: likely elements for exception handling (GCC flavor)
1720 case DW_TAG_imported_module
:
1721 /* C++ stuff to be silenced (for now) */
1724 dwarf2_parse_subprogram_label(subpgm
, child
);
1726 case DW_TAG_class_type
:
1727 case DW_TAG_structure_type
:
1728 case DW_TAG_union_type
:
1729 case DW_TAG_enumeration_type
:
1730 case DW_TAG_typedef
:
1731 /* the type referred to will be loaded when we need it, so skip it */
1734 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1735 child
->abbrev
->tag
, dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1740 symt_close_func_block(subpgm
->ctx
->module
, subpgm
->func
, block
, 0);
1743 static struct symt
* dwarf2_parse_subprogram(dwarf2_parse_context_t
* ctx
,
1744 dwarf2_debug_info_t
* di
,
1745 struct symt_compiland
* compiland
)
1747 struct attribute name
;
1748 unsigned long low_pc
, high_pc
;
1749 struct attribute is_decl
;
1750 struct attribute inline_flags
;
1751 struct symt
* ret_type
;
1752 struct symt_function_signature
* sig_type
;
1753 dwarf2_subprogram_t subpgm
;
1755 if (di
->symt
) return di
->symt
;
1757 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1759 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_name
, &name
))
1761 WARN("No name for function... dropping function\n");
1764 /* if it's an abstract representation of an inline function, there should be
1765 * a concrete object that we'll handle
1767 if (dwarf2_find_attribute(ctx
, di
, DW_AT_inline
, &inline_flags
))
1769 TRACE("Function %s declared as inlined (%ld)... skipping\n",
1770 name
.u
.string
? name
.u
.string
: "(null)", inline_flags
.u
.uvalue
);
1774 if (!dwarf2_read_range(ctx
, di
, &low_pc
, &high_pc
))
1776 FIXME("cannot get range\n");
1780 /* As functions (defined as inline assembly) get debug info with dwarf
1781 * (not the case for stabs), we just drop Wine's thunks here...
1782 * Actual thunks will be created in elf_module from the symbol table
1784 if (elf_is_in_thunk_area(ctx
->load_offset
+ low_pc
, ctx
->thunks
) >= 0)
1786 if (!dwarf2_find_attribute(ctx
, di
, DW_AT_declaration
, &is_decl
))
1787 is_decl
.u
.uvalue
= 0;
1789 if (!(ret_type
= dwarf2_lookup_type(ctx
, di
)))
1791 ret_type
= ctx
->symt_cache
[sc_void
];
1795 /* FIXME: assuming C source code */
1796 sig_type
= symt_new_function_signature(ctx
->module
, ret_type
, CV_CALL_FAR_C
);
1797 if (!is_decl
.u
.uvalue
)
1799 subpgm
.func
= symt_new_function(ctx
->module
, compiland
, name
.u
.string
,
1800 ctx
->load_offset
+ low_pc
, high_pc
- low_pc
,
1802 di
->symt
= &subpgm
.func
->symt
;
1804 else subpgm
.func
= NULL
;
1807 subpgm
.compiland
= compiland
;
1808 if (!dwarf2_compute_location_attr(ctx
, di
, DW_AT_frame_base
,
1809 &subpgm
.frame
, NULL
))
1812 subpgm
.frame
.kind
= loc_regrel
;
1813 subpgm
.frame
.reg
= 0;
1814 subpgm
.frame
.offset
= 0;
1816 subpgm
.non_computed_variable
= FALSE
;
1818 if (di
->abbrev
->have_child
) /** any interest to not have child ? */
1820 dwarf2_debug_info_t
* child
;
1823 for (i
=0; i
<vector_length(&di
->children
); i
++)
1825 child
= *(dwarf2_debug_info_t
**)vector_at(&di
->children
, i
);
1827 switch (child
->abbrev
->tag
)
1829 case DW_TAG_variable
:
1830 case DW_TAG_formal_parameter
:
1831 dwarf2_parse_variable(&subpgm
, NULL
, child
);
1833 case DW_TAG_lexical_block
:
1834 dwarf2_parse_subprogram_block(&subpgm
, NULL
, child
);
1836 case DW_TAG_inlined_subroutine
:
1837 dwarf2_parse_inlined_subroutine(&subpgm
, NULL
, child
);
1839 case DW_TAG_subprogram
:
1840 /* FIXME: likely a declaration (to be checked)
1845 dwarf2_parse_subprogram_label(&subpgm
, child
);
1847 case DW_TAG_class_type
:
1848 case DW_TAG_structure_type
:
1849 case DW_TAG_union_type
:
1850 case DW_TAG_enumeration_type
:
1851 case DW_TAG_typedef
:
1852 /* the type referred to will be loaded when we need it, so skip it */
1854 case DW_TAG_unspecified_parameters
:
1855 case DW_TAG_template_type_param
:
1856 case DW_TAG_template_value_param
:
1857 /* FIXME: no support in dbghelp's internals so far */
1860 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1861 child
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1866 if (subpgm
.non_computed_variable
|| subpgm
.frame
.kind
>= loc_user
)
1868 symt_add_function_point(ctx
->module
, subpgm
.func
, SymTagCustom
,
1869 &subpgm
.frame
, NULL
);
1871 if (subpgm
.func
) symt_normalize_function(subpgm
.ctx
->module
, subpgm
.func
);
1876 static struct symt
* dwarf2_parse_subroutine_type(dwarf2_parse_context_t
* ctx
,
1877 dwarf2_debug_info_t
* di
)
1879 struct symt
* ret_type
;
1880 struct symt_function_signature
* sig_type
;
1882 if (di
->symt
) return di
->symt
;
1884 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1886 if (!(ret_type
= dwarf2_lookup_type(ctx
, di
)))
1888 ret_type
= ctx
->symt_cache
[sc_void
];
1892 /* FIXME: assuming C source code */
1893 sig_type
= symt_new_function_signature(ctx
->module
, ret_type
, CV_CALL_FAR_C
);
1895 if (di
->abbrev
->have_child
) /** any interest to not have child ? */
1897 dwarf2_debug_info_t
* child
;
1900 for (i
=0; i
<vector_length(&di
->children
); i
++)
1902 child
= *(dwarf2_debug_info_t
**)vector_at(&di
->children
, i
);
1904 switch (child
->abbrev
->tag
)
1906 case DW_TAG_formal_parameter
:
1907 symt_add_function_signature_parameter(ctx
->module
, sig_type
,
1908 dwarf2_lookup_type(ctx
, child
));
1910 case DW_TAG_unspecified_parameters
:
1911 WARN("Unsupported unspecified parameters\n");
1917 return di
->symt
= &sig_type
->symt
;
1920 static void dwarf2_load_one_entry(dwarf2_parse_context_t
* ctx
,
1921 dwarf2_debug_info_t
* di
,
1922 struct symt_compiland
* compiland
)
1924 switch (di
->abbrev
->tag
)
1926 case DW_TAG_typedef
:
1927 dwarf2_parse_typedef(ctx
, di
);
1929 case DW_TAG_base_type
:
1930 dwarf2_parse_base_type(ctx
, di
);
1932 case DW_TAG_pointer_type
:
1933 dwarf2_parse_pointer_type(ctx
, di
);
1935 case DW_TAG_class_type
:
1936 dwarf2_parse_udt_type(ctx
, di
, UdtClass
);
1938 case DW_TAG_structure_type
:
1939 dwarf2_parse_udt_type(ctx
, di
, UdtStruct
);
1941 case DW_TAG_union_type
:
1942 dwarf2_parse_udt_type(ctx
, di
, UdtUnion
);
1944 case DW_TAG_array_type
:
1945 dwarf2_parse_array_type(ctx
, di
);
1947 case DW_TAG_const_type
:
1948 dwarf2_parse_const_type(ctx
, di
);
1950 case DW_TAG_volatile_type
:
1951 dwarf2_parse_volatile_type(ctx
, di
);
1953 case DW_TAG_reference_type
:
1954 dwarf2_parse_reference_type(ctx
, di
);
1956 case DW_TAG_enumeration_type
:
1957 dwarf2_parse_enumeration_type(ctx
, di
);
1959 case DW_TAG_subprogram
:
1960 dwarf2_parse_subprogram(ctx
, di
, compiland
);
1962 case DW_TAG_subroutine_type
:
1963 dwarf2_parse_subroutine_type(ctx
, di
);
1965 case DW_TAG_variable
:
1967 dwarf2_subprogram_t subpgm
;
1970 subpgm
.compiland
= compiland
;
1972 subpgm
.frame
.kind
= loc_absolute
;
1973 subpgm
.frame
.offset
= 0;
1974 subpgm
.frame
.reg
= Wine_DW_no_register
;
1975 dwarf2_parse_variable(&subpgm
, NULL
, di
);
1978 /* silence a couple of C++ defines */
1979 case DW_TAG_namespace
:
1980 case DW_TAG_imported_module
:
1981 case DW_TAG_imported_declaration
:
1982 case DW_TAG_ptr_to_member_type
:
1985 FIXME("Unhandled Tag type 0x%lx at %s, for %lu\n",
1986 di
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), di
->abbrev
->entry_code
);
1990 static void dwarf2_set_line_number(struct module
* module
, unsigned long address
,
1991 const struct vector
* v
, unsigned file
, unsigned line
)
1993 struct symt_function
* func
;
1994 struct symt_ht
* symt
;
1997 if (!file
|| !(psrc
= vector_at(v
, file
- 1))) return;
1999 TRACE("%s %lx %s %u\n",
2000 debugstr_w(module
->module
.ModuleName
), address
, source_get(module
, *psrc
), line
);
2001 if (!(symt
= symt_find_nearest(module
, address
)) ||
2002 symt
->symt
.tag
!= SymTagFunction
) return;
2003 func
= (struct symt_function
*)symt
;
2004 symt_add_func_line(module
, func
, *psrc
, line
, address
- func
->address
);
2007 static BOOL
dwarf2_parse_line_numbers(const dwarf2_section_t
* sections
,
2008 dwarf2_parse_context_t
* ctx
,
2009 const char* compile_dir
,
2010 unsigned long offset
)
2012 dwarf2_traverse_context_t traverse
;
2013 unsigned long length
;
2014 unsigned version
, header_len
, insn_size
, default_stmt
;
2015 unsigned line_range
, opcode_base
;
2017 const unsigned char* opcode_len
;
2019 struct vector files
;
2022 /* section with line numbers stripped */
2023 if (sections
[section_line
].address
== IMAGE_NO_MAP
)
2026 traverse
.data
= sections
[section_line
].address
+ offset
;
2027 traverse
.end_data
= traverse
.data
+ 4;
2028 traverse
.word_size
= ctx
->module
->format_info
[DFI_DWARF
]->u
.dwarf2_info
->word_size
;
2030 length
= dwarf2_parse_u4(&traverse
);
2031 traverse
.end_data
= sections
[section_line
].address
+ offset
+ length
;
2033 version
= dwarf2_parse_u2(&traverse
);
2034 header_len
= dwarf2_parse_u4(&traverse
);
2035 insn_size
= dwarf2_parse_byte(&traverse
);
2036 default_stmt
= dwarf2_parse_byte(&traverse
);
2037 line_base
= (signed char)dwarf2_parse_byte(&traverse
);
2038 line_range
= dwarf2_parse_byte(&traverse
);
2039 opcode_base
= dwarf2_parse_byte(&traverse
);
2041 opcode_len
= traverse
.data
;
2042 traverse
.data
+= opcode_base
- 1;
2044 vector_init(&dirs
, sizeof(const char*), 4);
2045 p
= vector_add(&dirs
, &ctx
->pool
);
2046 *p
= compile_dir
? compile_dir
: ".";
2047 while (*traverse
.data
)
2049 const char* rel
= (const char*)traverse
.data
;
2050 unsigned rellen
= strlen(rel
);
2051 TRACE("Got include %s\n", rel
);
2052 traverse
.data
+= rellen
+ 1;
2053 p
= vector_add(&dirs
, &ctx
->pool
);
2055 if (*rel
== '/' || !compile_dir
)
2059 /* include directory relative to compile directory */
2060 unsigned baselen
= strlen(compile_dir
);
2061 char* tmp
= pool_alloc(&ctx
->pool
, baselen
+ 1 + rellen
+ 1);
2062 strcpy(tmp
, compile_dir
);
2063 if (tmp
[baselen
- 1] != '/') tmp
[baselen
++] = '/';
2064 strcpy(&tmp
[baselen
], rel
);
2071 vector_init(&files
, sizeof(unsigned), 16);
2072 while (*traverse
.data
)
2074 unsigned int dir_index
, mod_time
, length
;
2079 name
= (const char*)traverse
.data
;
2080 traverse
.data
+= strlen(name
) + 1;
2081 dir_index
= dwarf2_leb128_as_unsigned(&traverse
);
2082 mod_time
= dwarf2_leb128_as_unsigned(&traverse
);
2083 length
= dwarf2_leb128_as_unsigned(&traverse
);
2084 dir
= *(const char**)vector_at(&dirs
, dir_index
);
2085 TRACE("Got file %s/%s (%u,%u)\n", dir
, name
, mod_time
, length
);
2086 psrc
= vector_add(&files
, &ctx
->pool
);
2087 *psrc
= source_new(ctx
->module
, dir
, name
);
2091 while (traverse
.data
< traverse
.end_data
)
2093 unsigned long address
= 0;
2096 unsigned is_stmt
= default_stmt
;
2097 BOOL end_sequence
= FALSE
;
2098 unsigned opcode
, extopcode
, i
;
2100 while (!end_sequence
)
2102 opcode
= dwarf2_parse_byte(&traverse
);
2103 TRACE("Got opcode %x\n", opcode
);
2105 if (opcode
>= opcode_base
)
2107 unsigned delta
= opcode
- opcode_base
;
2109 address
+= (delta
/ line_range
) * insn_size
;
2110 line
+= line_base
+ (delta
% line_range
);
2111 dwarf2_set_line_number(ctx
->module
, address
, &files
, file
, line
);
2118 dwarf2_set_line_number(ctx
->module
, address
, &files
, file
, line
);
2120 case DW_LNS_advance_pc
:
2121 address
+= insn_size
* dwarf2_leb128_as_unsigned(&traverse
);
2123 case DW_LNS_advance_line
:
2124 line
+= dwarf2_leb128_as_signed(&traverse
);
2126 case DW_LNS_set_file
:
2127 file
= dwarf2_leb128_as_unsigned(&traverse
);
2129 case DW_LNS_set_column
:
2130 dwarf2_leb128_as_unsigned(&traverse
);
2132 case DW_LNS_negate_stmt
:
2135 case DW_LNS_set_basic_block
:
2137 case DW_LNS_const_add_pc
:
2138 address
+= ((255 - opcode_base
) / line_range
) * insn_size
;
2140 case DW_LNS_fixed_advance_pc
:
2141 address
+= dwarf2_parse_u2(&traverse
);
2143 case DW_LNS_extended_op
:
2144 dwarf2_leb128_as_unsigned(&traverse
);
2145 extopcode
= dwarf2_parse_byte(&traverse
);
2148 case DW_LNE_end_sequence
:
2149 dwarf2_set_line_number(ctx
->module
, address
, &files
, file
, line
);
2150 end_sequence
= TRUE
;
2152 case DW_LNE_set_address
:
2153 address
= ctx
->load_offset
+ dwarf2_parse_addr(&traverse
);
2155 case DW_LNE_define_file
:
2156 FIXME("not handled %s\n", traverse
.data
);
2157 traverse
.data
+= strlen((const char *)traverse
.data
) + 1;
2158 dwarf2_leb128_as_unsigned(&traverse
);
2159 dwarf2_leb128_as_unsigned(&traverse
);
2160 dwarf2_leb128_as_unsigned(&traverse
);
2162 case DW_LNE_set_discriminator
:
2163 WARN("not handled %s\n", traverse
.data
);
2164 dwarf2_leb128_as_unsigned(&traverse
);
2167 FIXME("Unsupported extended opcode %x\n", extopcode
);
2172 WARN("Unsupported opcode %x\n", opcode
);
2173 for (i
= 0; i
< opcode_len
[opcode
]; i
++)
2174 dwarf2_leb128_as_unsigned(&traverse
);
2183 static BOOL
dwarf2_parse_compilation_unit(const dwarf2_section_t
* sections
,
2184 struct module
* module
,
2185 const struct elf_thunk_area
* thunks
,
2186 dwarf2_traverse_context_t
* mod_ctx
,
2187 unsigned long load_offset
)
2189 dwarf2_parse_context_t ctx
;
2190 dwarf2_traverse_context_t abbrev_ctx
;
2191 dwarf2_debug_info_t
* di
;
2192 dwarf2_traverse_context_t cu_ctx
;
2193 const unsigned char* comp_unit_start
= mod_ctx
->data
;
2194 unsigned long cu_length
;
2195 unsigned short cu_version
;
2196 unsigned long cu_abbrev_offset
;
2199 cu_length
= dwarf2_parse_u4(mod_ctx
);
2200 cu_ctx
.data
= mod_ctx
->data
;
2201 cu_ctx
.end_data
= mod_ctx
->data
+ cu_length
;
2202 mod_ctx
->data
+= cu_length
;
2203 cu_version
= dwarf2_parse_u2(&cu_ctx
);
2204 cu_abbrev_offset
= dwarf2_parse_u4(&cu_ctx
);
2205 cu_ctx
.word_size
= dwarf2_parse_byte(&cu_ctx
);
2207 TRACE("Compilation Unit Header found at 0x%x:\n",
2208 (int)(comp_unit_start
- sections
[section_debug
].address
));
2209 TRACE("- length: %lu\n", cu_length
);
2210 TRACE("- version: %u\n", cu_version
);
2211 TRACE("- abbrev_offset: %lu\n", cu_abbrev_offset
);
2212 TRACE("- word_size: %u\n", cu_ctx
.word_size
);
2214 if (cu_version
!= 2)
2216 WARN("%u DWARF version unsupported. Wine dbghelp only support DWARF 2.\n",
2221 module
->format_info
[DFI_DWARF
]->u
.dwarf2_info
->word_size
= cu_ctx
.word_size
;
2222 mod_ctx
->word_size
= cu_ctx
.word_size
;
2224 pool_init(&ctx
.pool
, 65536);
2225 ctx
.sections
= sections
;
2226 ctx
.section
= section_debug
;
2227 ctx
.module
= module
;
2228 ctx
.thunks
= thunks
;
2229 ctx
.load_offset
= load_offset
;
2230 ctx
.ref_offset
= comp_unit_start
- sections
[section_debug
].address
;
2231 memset(ctx
.symt_cache
, 0, sizeof(ctx
.symt_cache
));
2232 ctx
.symt_cache
[sc_void
] = &symt_new_basic(module
, btVoid
, "void", 0)->symt
;
2234 abbrev_ctx
.data
= sections
[section_abbrev
].address
+ cu_abbrev_offset
;
2235 abbrev_ctx
.end_data
= sections
[section_abbrev
].address
+ sections
[section_abbrev
].size
;
2236 abbrev_ctx
.word_size
= cu_ctx
.word_size
;
2237 dwarf2_parse_abbrev_set(&abbrev_ctx
, &ctx
.abbrev_table
, &ctx
.pool
);
2239 sparse_array_init(&ctx
.debug_info_table
, sizeof(dwarf2_debug_info_t
), 128);
2240 dwarf2_read_one_debug_info(&ctx
, &cu_ctx
, &di
);
2242 if (di
->abbrev
->tag
== DW_TAG_compile_unit
)
2244 struct attribute name
;
2245 dwarf2_debug_info_t
** pdi
= NULL
;
2246 struct attribute stmt_list
, low_pc
;
2247 struct attribute comp_dir
;
2249 if (!dwarf2_find_attribute(&ctx
, di
, DW_AT_name
, &name
))
2250 name
.u
.string
= NULL
;
2252 /* get working directory of current compilation unit */
2253 if (!dwarf2_find_attribute(&ctx
, di
, DW_AT_comp_dir
, &comp_dir
))
2254 comp_dir
.u
.string
= NULL
;
2256 if (!dwarf2_find_attribute(&ctx
, di
, DW_AT_low_pc
, &low_pc
))
2257 low_pc
.u
.uvalue
= 0;
2258 di
->symt
= &symt_new_compiland(module
,
2259 ctx
.load_offset
+ low_pc
.u
.uvalue
,
2260 source_new(module
, comp_dir
.u
.string
, name
.u
.string
))->symt
;
2262 if (di
->abbrev
->have_child
)
2265 for (i
=0; i
<vector_length(&di
->children
); i
++)
2267 pdi
= vector_at(&di
->children
, i
);
2268 dwarf2_load_one_entry(&ctx
, *pdi
, (struct symt_compiland
*)di
->symt
);
2271 if (dwarf2_find_attribute(&ctx
, di
, DW_AT_stmt_list
, &stmt_list
))
2273 if (dwarf2_parse_line_numbers(sections
, &ctx
, comp_dir
.u
.string
, stmt_list
.u
.uvalue
))
2274 module
->module
.LineNumbers
= TRUE
;
2278 else FIXME("Should have a compilation unit here\n");
2279 pool_destroy(&ctx
.pool
);
2283 static BOOL
dwarf2_lookup_loclist(const struct module_format
* modfmt
, const BYTE
* start
,
2284 unsigned long ip
, dwarf2_traverse_context_t
* lctx
)
2287 const BYTE
* ptr
= start
;
2290 while (ptr
< modfmt
->u
.dwarf2_info
->debug_loc
.address
+ modfmt
->u
.dwarf2_info
->debug_loc
.size
)
2292 beg
= dwarf2_get_addr(ptr
, modfmt
->u
.dwarf2_info
->word_size
); ptr
+= modfmt
->u
.dwarf2_info
->word_size
;
2293 end
= dwarf2_get_addr(ptr
, modfmt
->u
.dwarf2_info
->word_size
); ptr
+= modfmt
->u
.dwarf2_info
->word_size
;
2294 if (!beg
&& !end
) break;
2295 len
= dwarf2_get_u2(ptr
); ptr
+= 2;
2297 if (beg
<= ip
&& ip
< end
)
2300 lctx
->end_data
= ptr
+ len
;
2301 lctx
->word_size
= modfmt
->u
.dwarf2_info
->word_size
;
2306 WARN("Couldn't find ip in location list\n");
2310 static enum location_error
loc_compute_frame(struct process
* pcs
,
2311 const struct module_format
* modfmt
,
2312 const struct symt_function
* func
,
2313 DWORD_PTR ip
, struct location
* frame
)
2315 struct symt
** psym
= NULL
;
2316 struct location
* pframe
;
2317 dwarf2_traverse_context_t lctx
;
2318 enum location_error err
;
2321 for (i
=0; i
<vector_length(&func
->vchildren
); i
++)
2323 psym
= vector_at(&func
->vchildren
, i
);
2324 if ((*psym
)->tag
== SymTagCustom
)
2326 pframe
= &((struct symt_hierarchy_point
*)*psym
)->loc
;
2328 /* First, recompute the frame information, if needed */
2329 switch (pframe
->kind
)
2335 case loc_dwarf2_location_list
:
2336 WARN("Searching loclist for %s\n", func
->hash_elt
.name
);
2337 if (!dwarf2_lookup_loclist(modfmt
,
2338 modfmt
->u
.dwarf2_info
->debug_loc
.address
+ pframe
->offset
,
2340 return loc_err_out_of_scope
;
2341 if ((err
= compute_location(&lctx
, frame
, pcs
->handle
, NULL
)) < 0) return err
;
2342 if (frame
->kind
>= loc_user
)
2344 WARN("Couldn't compute runtime frame location\n");
2345 return loc_err_too_complex
;
2349 WARN("Unsupported frame kind %d\n", pframe
->kind
);
2350 return loc_err_internal
;
2355 WARN("Couldn't find Custom function point, whilst location list offset is searched\n");
2356 return loc_err_internal
;
2361 RULE_UNSET
, /* not set at all */
2362 RULE_UNDEFINED
, /* undefined value */
2363 RULE_SAME
, /* same value as previous frame */
2364 RULE_CFA_OFFSET
, /* stored at cfa offset */
2365 RULE_OTHER_REG
, /* stored in other register */
2366 RULE_EXPRESSION
, /* address specified by expression */
2367 RULE_VAL_EXPRESSION
/* value specified by expression */
2370 /* make it large enough for all CPUs */
2371 #define NB_FRAME_REGS 64
2372 #define MAX_SAVED_STATES 16
2376 ULONG_PTR cfa_offset
;
2377 unsigned char cfa_reg
;
2378 enum reg_rule cfa_rule
;
2379 enum reg_rule rules
[NB_FRAME_REGS
];
2380 ULONG_PTR regs
[NB_FRAME_REGS
];
2386 ULONG_PTR code_align
;
2387 LONG_PTR data_align
;
2388 unsigned char retaddr_reg
;
2389 unsigned char fde_encoding
;
2390 unsigned char lsda_encoding
;
2391 unsigned char signal_frame
;
2392 unsigned char aug_z_format
;
2393 unsigned char state_sp
;
2394 struct frame_state state
;
2395 struct frame_state state_stack
[MAX_SAVED_STATES
];
2398 static ULONG_PTR
dwarf2_parse_augmentation_ptr(dwarf2_traverse_context_t
* ctx
, unsigned char encoding
)
2402 if (encoding
== DW_EH_PE_omit
) return 0;
2404 switch (encoding
& 0xf0)
2409 case DW_EH_PE_pcrel
:
2410 base
= (ULONG_PTR
)ctx
->data
;
2413 FIXME("unsupported encoding %02x\n", encoding
);
2417 switch (encoding
& 0x0f)
2419 case DW_EH_PE_native
:
2420 return base
+ dwarf2_parse_addr(ctx
);
2421 case DW_EH_PE_leb128
:
2422 return base
+ dwarf2_leb128_as_unsigned(ctx
);
2423 case DW_EH_PE_data2
:
2424 return base
+ dwarf2_parse_u2(ctx
);
2425 case DW_EH_PE_data4
:
2426 return base
+ dwarf2_parse_u4(ctx
);
2427 case DW_EH_PE_data8
:
2428 return base
+ dwarf2_parse_u8(ctx
);
2429 case DW_EH_PE_signed
|DW_EH_PE_leb128
:
2430 return base
+ dwarf2_leb128_as_signed(ctx
);
2431 case DW_EH_PE_signed
|DW_EH_PE_data2
:
2432 return base
+ (signed short)dwarf2_parse_u2(ctx
);
2433 case DW_EH_PE_signed
|DW_EH_PE_data4
:
2434 return base
+ (signed int)dwarf2_parse_u4(ctx
);
2435 case DW_EH_PE_signed
|DW_EH_PE_data8
:
2436 return base
+ (LONG64
)dwarf2_parse_u8(ctx
);
2438 FIXME("unsupported encoding %02x\n", encoding
);
2443 static BOOL
parse_cie_details(dwarf2_traverse_context_t
* ctx
, struct frame_info
* info
)
2445 unsigned char version
;
2446 const char* augmentation
;
2447 const unsigned char* end
;
2450 memset(info
, 0, sizeof(*info
));
2451 info
->lsda_encoding
= DW_EH_PE_omit
;
2452 info
->aug_z_format
= 0;
2454 /* parse the CIE first */
2455 version
= dwarf2_parse_byte(ctx
);
2458 FIXME("unknown CIE version %u at %p\n", version
, ctx
->data
- 1);
2461 augmentation
= (const char*)ctx
->data
;
2462 ctx
->data
+= strlen(augmentation
) + 1;
2464 info
->code_align
= dwarf2_leb128_as_unsigned(ctx
);
2465 info
->data_align
= dwarf2_leb128_as_signed(ctx
);
2466 info
->retaddr_reg
= dwarf2_parse_byte(ctx
);
2467 info
->state
.cfa_rule
= RULE_CFA_OFFSET
;
2470 TRACE("\tparsing augmentation %s\n", augmentation
);
2471 if (*augmentation
) do
2473 switch (*augmentation
)
2476 len
= dwarf2_leb128_as_unsigned(ctx
);
2477 end
= ctx
->data
+ len
;
2478 info
->aug_z_format
= 1;
2481 info
->lsda_encoding
= dwarf2_parse_byte(ctx
);
2485 unsigned char encoding
= dwarf2_parse_byte(ctx
);
2486 /* throw away the indirect bit, as we don't care for the result */
2487 encoding
&= ~DW_EH_PE_indirect
;
2488 dwarf2_parse_augmentation_ptr(ctx
, encoding
); /* handler */
2492 info
->fde_encoding
= dwarf2_parse_byte(ctx
);
2495 info
->signal_frame
= 1;
2498 FIXME("unknown augmentation '%c'\n", *augmentation
);
2499 if (!end
) return FALSE
;
2501 } while (*++augmentation
);
2502 if (end
) ctx
->data
= end
;
2506 static BOOL
dwarf2_get_cie(unsigned long addr
, struct module
* module
, DWORD_PTR delta
,
2507 dwarf2_traverse_context_t
* fde_ctx
, dwarf2_traverse_context_t
* cie_ctx
,
2508 struct frame_info
* info
, BOOL in_eh_frame
)
2510 const unsigned char* ptr_blk
;
2511 const unsigned char* cie_ptr
;
2512 const unsigned char* last_cie_ptr
= (const unsigned char*)~0;
2514 unsigned long start
, range
;
2516 const BYTE
* start_data
= fde_ctx
->data
;
2518 cie_id
= in_eh_frame
? 0 : DW_CIE_ID
;
2519 for (; fde_ctx
->data
+ 2 * 4 < fde_ctx
->end_data
; fde_ctx
->data
= ptr_blk
)
2521 /* find the FDE for address addr (skip CIE) */
2522 len
= dwarf2_parse_u4(fde_ctx
);
2523 if (len
== 0xffffffff) FIXME("Unsupported yet 64-bit CIEs\n");
2524 ptr_blk
= fde_ctx
->data
+ len
;
2525 id
= dwarf2_parse_u4(fde_ctx
);
2528 last_cie_ptr
= fde_ctx
->data
- 8;
2529 /* we need some bits out of the CIE in order to parse all contents */
2530 if (!parse_cie_details(fde_ctx
, info
)) return FALSE
;
2531 cie_ctx
->data
= fde_ctx
->data
;
2532 cie_ctx
->end_data
= ptr_blk
;
2533 cie_ctx
->word_size
= fde_ctx
->word_size
;
2536 cie_ptr
= (in_eh_frame
) ? fde_ctx
->data
- id
- 4 : start_data
+ id
;
2537 if (cie_ptr
!= last_cie_ptr
)
2539 last_cie_ptr
= cie_ptr
;
2540 cie_ctx
->data
= cie_ptr
;
2541 cie_ctx
->word_size
= fde_ctx
->word_size
;
2542 cie_ctx
->end_data
= cie_ptr
+ 4;
2543 cie_ctx
->end_data
= cie_ptr
+ 4 + dwarf2_parse_u4(cie_ctx
);
2544 if (dwarf2_parse_u4(cie_ctx
) != cie_id
)
2546 FIXME("wrong CIE pointer\n");
2549 if (!parse_cie_details(cie_ctx
, info
)) return FALSE
;
2551 start
= delta
+ dwarf2_parse_augmentation_ptr(fde_ctx
, info
->fde_encoding
);
2552 range
= dwarf2_parse_augmentation_ptr(fde_ctx
, info
->fde_encoding
& 0x0F);
2554 if (addr
>= start
&& addr
< start
+ range
)
2556 /* reset the FDE context */
2557 fde_ctx
->end_data
= ptr_blk
;
2566 static int valid_reg(ULONG_PTR reg
)
2568 if (reg
>= NB_FRAME_REGS
) FIXME("unsupported reg %lx\n", reg
);
2569 return (reg
< NB_FRAME_REGS
);
2572 static void execute_cfa_instructions(dwarf2_traverse_context_t
* ctx
,
2573 ULONG_PTR last_ip
, struct frame_info
*info
)
2575 while (ctx
->data
< ctx
->end_data
&& info
->ip
< last_ip
+ info
->signal_frame
)
2577 enum dwarf_call_frame_info op
= dwarf2_parse_byte(ctx
);
2583 case DW_CFA_advance_loc
:
2585 ULONG_PTR offset
= (op
& 0x3f) * info
->code_align
;
2586 TRACE("%lx: DW_CFA_advance_loc %lu\n", info
->ip
, offset
);
2592 ULONG_PTR reg
= op
& 0x3f;
2593 LONG_PTR offset
= dwarf2_leb128_as_unsigned(ctx
) * info
->data_align
;
2594 if (!valid_reg(reg
)) break;
2595 TRACE("%lx: DW_CFA_offset %s, %ld\n",
2597 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)),
2599 info
->state
.regs
[reg
] = offset
;
2600 info
->state
.rules
[reg
] = RULE_CFA_OFFSET
;
2603 case DW_CFA_restore
:
2605 ULONG_PTR reg
= op
& 0x3f;
2606 if (!valid_reg(reg
)) break;
2607 TRACE("%lx: DW_CFA_restore %s\n",
2609 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)));
2610 info
->state
.rules
[reg
] = RULE_UNSET
;
2619 case DW_CFA_set_loc
:
2621 ULONG_PTR loc
= dwarf2_parse_augmentation_ptr(ctx
, info
->fde_encoding
);
2622 TRACE("%lx: DW_CFA_set_loc %lx\n", info
->ip
, loc
);
2626 case DW_CFA_advance_loc1
:
2628 ULONG_PTR offset
= dwarf2_parse_byte(ctx
) * info
->code_align
;
2629 TRACE("%lx: DW_CFA_advance_loc1 %lu\n", info
->ip
, offset
);
2633 case DW_CFA_advance_loc2
:
2635 ULONG_PTR offset
= dwarf2_parse_u2(ctx
) * info
->code_align
;
2636 TRACE("%lx: DW_CFA_advance_loc2 %lu\n", info
->ip
, offset
);
2640 case DW_CFA_advance_loc4
:
2642 ULONG_PTR offset
= dwarf2_parse_u4(ctx
) * info
->code_align
;
2643 TRACE("%lx: DW_CFA_advance_loc4 %lu\n", info
->ip
, offset
);
2647 case DW_CFA_offset_extended
:
2648 case DW_CFA_offset_extended_sf
:
2650 ULONG_PTR reg
= dwarf2_leb128_as_unsigned(ctx
);
2651 LONG_PTR offset
= (op
== DW_CFA_offset_extended
) ? dwarf2_leb128_as_unsigned(ctx
) * info
->data_align
2652 : dwarf2_leb128_as_signed(ctx
) * info
->data_align
;
2653 if (!valid_reg(reg
)) break;
2654 TRACE("%lx: DW_CFA_offset_extended %s, %ld\n",
2656 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)),
2658 info
->state
.regs
[reg
] = offset
;
2659 info
->state
.rules
[reg
] = RULE_CFA_OFFSET
;
2662 case DW_CFA_restore_extended
:
2664 ULONG_PTR reg
= dwarf2_leb128_as_unsigned(ctx
);
2665 if (!valid_reg(reg
)) break;
2666 TRACE("%lx: DW_CFA_restore_extended %s\n",
2668 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)));
2669 info
->state
.rules
[reg
] = RULE_UNSET
;
2672 case DW_CFA_undefined
:
2674 ULONG_PTR reg
= dwarf2_leb128_as_unsigned(ctx
);
2675 if (!valid_reg(reg
)) break;
2676 TRACE("%lx: DW_CFA_undefined %s\n",
2678 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)));
2679 info
->state
.rules
[reg
] = RULE_UNDEFINED
;
2682 case DW_CFA_same_value
:
2684 ULONG_PTR reg
= dwarf2_leb128_as_unsigned(ctx
);
2685 if (!valid_reg(reg
)) break;
2686 TRACE("%lx: DW_CFA_same_value %s\n",
2688 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)));
2689 info
->state
.regs
[reg
] = reg
;
2690 info
->state
.rules
[reg
] = RULE_SAME
;
2693 case DW_CFA_register
:
2695 ULONG_PTR reg
= dwarf2_leb128_as_unsigned(ctx
);
2696 ULONG_PTR reg2
= dwarf2_leb128_as_unsigned(ctx
);
2697 if (!valid_reg(reg
) || !valid_reg(reg2
)) break;
2698 TRACE("%lx: DW_CFA_register %s == %s\n",
2700 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)),
2701 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg2
)));
2702 info
->state
.regs
[reg
] = reg2
;
2703 info
->state
.rules
[reg
] = RULE_OTHER_REG
;
2706 case DW_CFA_remember_state
:
2707 TRACE("%lx: DW_CFA_remember_state\n", info
->ip
);
2708 if (info
->state_sp
>= MAX_SAVED_STATES
)
2709 FIXME("%lx: DW_CFA_remember_state too many nested saves\n", info
->ip
);
2711 info
->state_stack
[info
->state_sp
++] = info
->state
;
2713 case DW_CFA_restore_state
:
2714 TRACE("%lx: DW_CFA_restore_state\n", info
->ip
);
2715 if (!info
->state_sp
)
2716 FIXME("%lx: DW_CFA_restore_state without corresponding save\n", info
->ip
);
2718 info
->state
= info
->state_stack
[--info
->state_sp
];
2720 case DW_CFA_def_cfa
:
2721 case DW_CFA_def_cfa_sf
:
2723 ULONG_PTR reg
= dwarf2_leb128_as_unsigned(ctx
);
2724 ULONG_PTR offset
= (op
== DW_CFA_def_cfa
) ? dwarf2_leb128_as_unsigned(ctx
)
2725 : dwarf2_leb128_as_signed(ctx
) * info
->data_align
;
2726 if (!valid_reg(reg
)) break;
2727 TRACE("%lx: DW_CFA_def_cfa %s, %lu\n",
2729 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)),
2731 info
->state
.cfa_reg
= reg
;
2732 info
->state
.cfa_offset
= offset
;
2733 info
->state
.cfa_rule
= RULE_CFA_OFFSET
;
2736 case DW_CFA_def_cfa_register
:
2738 ULONG_PTR reg
= dwarf2_leb128_as_unsigned(ctx
);
2739 if (!valid_reg(reg
)) break;
2740 TRACE("%lx: DW_CFA_def_cfa_register %s\n",
2742 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)));
2743 info
->state
.cfa_reg
= reg
;
2744 info
->state
.cfa_rule
= RULE_CFA_OFFSET
;
2747 case DW_CFA_def_cfa_offset
:
2748 case DW_CFA_def_cfa_offset_sf
:
2750 ULONG_PTR offset
= (op
== DW_CFA_def_cfa_offset
) ? dwarf2_leb128_as_unsigned(ctx
)
2751 : dwarf2_leb128_as_signed(ctx
) * info
->data_align
;
2752 TRACE("%lx: DW_CFA_def_cfa_offset %lu\n", info
->ip
, offset
);
2753 info
->state
.cfa_offset
= offset
;
2754 info
->state
.cfa_rule
= RULE_CFA_OFFSET
;
2757 case DW_CFA_def_cfa_expression
:
2759 ULONG_PTR expr
= (ULONG_PTR
)ctx
->data
;
2760 ULONG_PTR len
= dwarf2_leb128_as_unsigned(ctx
);
2761 TRACE("%lx: DW_CFA_def_cfa_expression %lx-%lx\n", info
->ip
, expr
, expr
+len
);
2762 info
->state
.cfa_offset
= expr
;
2763 info
->state
.cfa_rule
= RULE_VAL_EXPRESSION
;
2767 case DW_CFA_expression
:
2768 case DW_CFA_val_expression
:
2770 ULONG_PTR reg
= dwarf2_leb128_as_unsigned(ctx
);
2771 ULONG_PTR expr
= (ULONG_PTR
)ctx
->data
;
2772 ULONG_PTR len
= dwarf2_leb128_as_unsigned(ctx
);
2773 if (!valid_reg(reg
)) break;
2774 TRACE("%lx: DW_CFA_%sexpression %s %lx-%lx\n",
2775 info
->ip
, (op
== DW_CFA_expression
) ? "" : "val_",
2776 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(reg
)),
2778 info
->state
.regs
[reg
] = expr
;
2779 info
->state
.rules
[reg
] = (op
== DW_CFA_expression
) ? RULE_EXPRESSION
: RULE_VAL_EXPRESSION
;
2783 case DW_CFA_GNU_args_size
:
2784 /* FIXME: should check that GCC is the compiler for this CU */
2786 ULONG_PTR args
= dwarf2_leb128_as_unsigned(ctx
);
2787 TRACE("%lx: DW_CFA_GNU_args_size %lu\n", info
->ip
, args
);
2792 FIXME("%lx: unknown CFA opcode %02x\n", info
->ip
, op
);
2798 /* retrieve a context register from its dwarf number */
2799 static ULONG_PTR
get_context_reg(CONTEXT
*context
, ULONG_PTR dw_reg
)
2801 unsigned regno
= dbghelp_current_cpu
->map_dwarf_register(dw_reg
), sz
;
2802 ULONG_PTR
* ptr
= dbghelp_current_cpu
->fetch_context_reg(context
, regno
, &sz
);
2804 if (sz
!= sizeof(ULONG_PTR
))
2806 FIXME("reading register %lu/%u of wrong size %u\n", dw_reg
, regno
, sz
);
2812 /* set a context register from its dwarf number */
2813 static void set_context_reg(struct cpu_stack_walk
* csw
, CONTEXT
*context
, ULONG_PTR dw_reg
,
2814 ULONG_PTR val
, BOOL isdebuggee
)
2816 unsigned regno
= dbghelp_current_cpu
->map_dwarf_register(dw_reg
), sz
;
2817 ULONG_PTR
* ptr
= dbghelp_current_cpu
->fetch_context_reg(context
, regno
, &sz
);
2823 if (sz
> sizeof(tmp
))
2825 FIXME("register %lu/%u size is too wide: %u\n", dw_reg
, regno
, sz
);
2828 if (!sw_read_mem(csw
, val
, tmp
, sz
))
2830 WARN("Couldn't read memory at %p\n", (void*)val
);
2833 memcpy(ptr
, tmp
, sz
);
2837 if (sz
!= sizeof(ULONG_PTR
))
2839 FIXME("assigning to register %lu/%u of wrong size %u\n", dw_reg
, regno
, sz
);
2846 /* copy a register from one context to another using dwarf number */
2847 static void copy_context_reg(CONTEXT
*dstcontext
, ULONG_PTR dwregdst
, CONTEXT
* srccontext
, ULONG_PTR dwregsrc
)
2849 unsigned regdstno
= dbghelp_current_cpu
->map_dwarf_register(dwregdst
), szdst
;
2850 unsigned regsrcno
= dbghelp_current_cpu
->map_dwarf_register(dwregsrc
), szsrc
;
2851 ULONG_PTR
* ptrdst
= dbghelp_current_cpu
->fetch_context_reg(dstcontext
, regdstno
, &szdst
);
2852 ULONG_PTR
* ptrsrc
= dbghelp_current_cpu
->fetch_context_reg(srccontext
, regsrcno
, &szsrc
);
2856 FIXME("Cannot copy register %lu/%u => %lu/%u because of size mismatch (%u => %u)\n",
2857 dwregsrc
, regsrcno
, dwregdst
, regdstno
, szsrc
, szdst
);
2860 memcpy(ptrdst
, ptrsrc
, szdst
);
2863 static ULONG_PTR
eval_expression(const struct module
* module
, struct cpu_stack_walk
* csw
,
2864 const unsigned char* zp
, CONTEXT
*context
)
2866 dwarf2_traverse_context_t ctx
;
2867 ULONG_PTR reg
, sz
, tmp
, stack
[64];
2872 ctx
.end_data
= zp
+ 4;
2873 len
= dwarf2_leb128_as_unsigned(&ctx
);
2874 ctx
.end_data
= ctx
.data
+ len
;
2875 ctx
.word_size
= module
->format_info
[DFI_DWARF
]->u
.dwarf2_info
->word_size
;
2877 while (ctx
.data
< ctx
.end_data
)
2879 unsigned char opcode
= dwarf2_parse_byte(&ctx
);
2881 if (opcode
>= DW_OP_lit0
&& opcode
<= DW_OP_lit31
)
2882 stack
[++sp
] = opcode
- DW_OP_lit0
;
2883 else if (opcode
>= DW_OP_reg0
&& opcode
<= DW_OP_reg31
)
2884 stack
[++sp
] = get_context_reg(context
, opcode
- DW_OP_reg0
);
2885 else if (opcode
>= DW_OP_breg0
&& opcode
<= DW_OP_breg31
)
2886 stack
[++sp
] = get_context_reg(context
, opcode
- DW_OP_breg0
) + dwarf2_leb128_as_signed(&ctx
);
2887 else switch (opcode
)
2889 case DW_OP_nop
: break;
2890 case DW_OP_addr
: stack
[++sp
] = dwarf2_parse_addr(&ctx
); break;
2891 case DW_OP_const1u
: stack
[++sp
] = dwarf2_parse_byte(&ctx
); break;
2892 case DW_OP_const1s
: stack
[++sp
] = (signed char)dwarf2_parse_byte(&ctx
); break;
2893 case DW_OP_const2u
: stack
[++sp
] = dwarf2_parse_u2(&ctx
); break;
2894 case DW_OP_const2s
: stack
[++sp
] = (short)dwarf2_parse_u2(&ctx
); break;
2895 case DW_OP_const4u
: stack
[++sp
] = dwarf2_parse_u4(&ctx
); break;
2896 case DW_OP_const4s
: stack
[++sp
] = (signed int)dwarf2_parse_u4(&ctx
); break;
2897 case DW_OP_const8u
: stack
[++sp
] = dwarf2_parse_u8(&ctx
); break;
2898 case DW_OP_const8s
: stack
[++sp
] = (LONG_PTR
)dwarf2_parse_u8(&ctx
); break;
2899 case DW_OP_constu
: stack
[++sp
] = dwarf2_leb128_as_unsigned(&ctx
); break;
2900 case DW_OP_consts
: stack
[++sp
] = dwarf2_leb128_as_signed(&ctx
); break;
2902 if (!sw_read_mem(csw
, stack
[sp
], &tmp
, sizeof(tmp
)))
2904 ERR("Couldn't read memory at %lx\n", stack
[sp
]);
2909 case DW_OP_dup
: stack
[sp
+ 1] = stack
[sp
]; sp
++; break;
2910 case DW_OP_drop
: sp
--; break;
2911 case DW_OP_over
: stack
[sp
+ 1] = stack
[sp
- 1]; sp
++; break;
2912 case DW_OP_pick
: stack
[sp
+ 1] = stack
[sp
- dwarf2_parse_byte(&ctx
)]; sp
++; break;
2913 case DW_OP_swap
: tmp
= stack
[sp
]; stack
[sp
] = stack
[sp
-1]; stack
[sp
-1] = tmp
; break;
2914 case DW_OP_rot
: tmp
= stack
[sp
]; stack
[sp
] = stack
[sp
-1]; stack
[sp
-1] = stack
[sp
-2]; stack
[sp
-2] = tmp
; break;
2915 case DW_OP_abs
: stack
[sp
] = labs(stack
[sp
]); break;
2916 case DW_OP_neg
: stack
[sp
] = -stack
[sp
]; break;
2917 case DW_OP_not
: stack
[sp
] = ~stack
[sp
]; break;
2918 case DW_OP_and
: stack
[sp
-1] &= stack
[sp
]; sp
--; break;
2919 case DW_OP_or
: stack
[sp
-1] |= stack
[sp
]; sp
--; break;
2920 case DW_OP_minus
: stack
[sp
-1] -= stack
[sp
]; sp
--; break;
2921 case DW_OP_mul
: stack
[sp
-1] *= stack
[sp
]; sp
--; break;
2922 case DW_OP_plus
: stack
[sp
-1] += stack
[sp
]; sp
--; break;
2923 case DW_OP_xor
: stack
[sp
-1] ^= stack
[sp
]; sp
--; break;
2924 case DW_OP_shl
: stack
[sp
-1] <<= stack
[sp
]; sp
--; break;
2925 case DW_OP_shr
: stack
[sp
-1] >>= stack
[sp
]; sp
--; break;
2926 case DW_OP_plus_uconst
: stack
[sp
] += dwarf2_leb128_as_unsigned(&ctx
); break;
2927 case DW_OP_shra
: stack
[sp
-1] = (LONG_PTR
)stack
[sp
-1] / (1 << stack
[sp
]); sp
--; break;
2928 case DW_OP_div
: stack
[sp
-1] = (LONG_PTR
)stack
[sp
-1] / (LONG_PTR
)stack
[sp
]; sp
--; break;
2929 case DW_OP_mod
: stack
[sp
-1] = (LONG_PTR
)stack
[sp
-1] % (LONG_PTR
)stack
[sp
]; sp
--; break;
2930 case DW_OP_ge
: stack
[sp
-1] = ((LONG_PTR
)stack
[sp
-1] >= (LONG_PTR
)stack
[sp
]); sp
--; break;
2931 case DW_OP_gt
: stack
[sp
-1] = ((LONG_PTR
)stack
[sp
-1] > (LONG_PTR
)stack
[sp
]); sp
--; break;
2932 case DW_OP_le
: stack
[sp
-1] = ((LONG_PTR
)stack
[sp
-1] <= (LONG_PTR
)stack
[sp
]); sp
--; break;
2933 case DW_OP_lt
: stack
[sp
-1] = ((LONG_PTR
)stack
[sp
-1] < (LONG_PTR
)stack
[sp
]); sp
--; break;
2934 case DW_OP_eq
: stack
[sp
-1] = (stack
[sp
-1] == stack
[sp
]); sp
--; break;
2935 case DW_OP_ne
: stack
[sp
-1] = (stack
[sp
-1] != stack
[sp
]); sp
--; break;
2936 case DW_OP_skip
: tmp
= (short)dwarf2_parse_u2(&ctx
); ctx
.data
+= tmp
; break;
2937 case DW_OP_bra
: tmp
= (short)dwarf2_parse_u2(&ctx
); if (!stack
[sp
--]) ctx
.data
+= tmp
; break;
2938 case DW_OP_GNU_encoded_addr
:
2939 tmp
= dwarf2_parse_byte(&ctx
);
2940 stack
[++sp
] = dwarf2_parse_augmentation_ptr(&ctx
, tmp
);
2943 stack
[++sp
] = get_context_reg(context
, dwarf2_leb128_as_unsigned(&ctx
));
2946 reg
= dwarf2_leb128_as_unsigned(&ctx
);
2947 tmp
= dwarf2_leb128_as_signed(&ctx
);
2948 stack
[++sp
] = get_context_reg(context
, reg
) + tmp
;
2950 case DW_OP_deref_size
:
2951 sz
= dwarf2_parse_byte(&ctx
);
2952 if (!sw_read_mem(csw
, stack
[sp
], &tmp
, sz
))
2954 ERR("Couldn't read memory at %lx\n", stack
[sp
]);
2957 /* do integral promotion */
2960 case 1: stack
[sp
] = *(unsigned char*)&tmp
; break;
2961 case 2: stack
[sp
] = *(unsigned short*)&tmp
; break;
2962 case 4: stack
[sp
] = *(unsigned int*)&tmp
; break;
2963 case 8: stack
[sp
] = *(ULONG_PTR
*)&tmp
; break; /* FIXME: won't work on 32bit platform */
2964 default: FIXME("Unknown size for deref 0x%lx\n", sz
);
2968 FIXME("unhandled opcode %02x\n", opcode
);
2974 static void apply_frame_state(const struct module
* module
, struct cpu_stack_walk
* csw
,
2975 CONTEXT
*context
, struct frame_state
*state
, ULONG_PTR
* cfa
)
2979 CONTEXT new_context
= *context
;
2981 switch (state
->cfa_rule
)
2983 case RULE_EXPRESSION
:
2984 *cfa
= eval_expression(module
, csw
, (const unsigned char*)state
->cfa_offset
, context
);
2985 if (!sw_read_mem(csw
, *cfa
, cfa
, sizeof(*cfa
)))
2987 WARN("Couldn't read memory at %p\n", (void*)*cfa
);
2991 case RULE_VAL_EXPRESSION
:
2992 *cfa
= eval_expression(module
, csw
, (const unsigned char*)state
->cfa_offset
, context
);
2995 *cfa
= get_context_reg(context
, state
->cfa_reg
) + state
->cfa_offset
;
3000 for (i
= 0; i
< NB_FRAME_REGS
; i
++)
3002 switch (state
->rules
[i
])
3005 case RULE_UNDEFINED
:
3008 case RULE_CFA_OFFSET
:
3009 set_context_reg(csw
, &new_context
, i
, *cfa
+ state
->regs
[i
], TRUE
);
3011 case RULE_OTHER_REG
:
3012 copy_context_reg(&new_context
, i
, context
, state
->regs
[i
]);
3014 case RULE_EXPRESSION
:
3015 value
= eval_expression(module
, csw
, (const unsigned char*)state
->regs
[i
], context
);
3016 set_context_reg(csw
, &new_context
, i
, value
, TRUE
);
3018 case RULE_VAL_EXPRESSION
:
3019 value
= eval_expression(module
, csw
, (const unsigned char*)state
->regs
[i
], context
);
3020 set_context_reg(csw
, &new_context
, i
, value
, FALSE
);
3024 *context
= new_context
;
3027 /***********************************************************************
3028 * dwarf2_virtual_unwind
3031 BOOL
dwarf2_virtual_unwind(struct cpu_stack_walk
* csw
, ULONG_PTR ip
, CONTEXT
* context
, ULONG_PTR
* cfa
)
3033 struct module_pair pair
;
3034 struct frame_info info
;
3035 dwarf2_traverse_context_t cie_ctx
, fde_ctx
;
3036 struct module_format
* modfmt
;
3037 const unsigned char* end
;
3040 if (!(pair
.pcs
= process_find_by_handle(csw
->hProcess
)) ||
3041 !(pair
.requested
= module_find_by_addr(pair
.pcs
, ip
, DMT_UNKNOWN
)) ||
3042 !module_get_debug(&pair
))
3044 modfmt
= pair
.effective
->format_info
[DFI_DWARF
];
3045 if (!modfmt
) return FALSE
;
3046 memset(&info
, 0, sizeof(info
));
3047 fde_ctx
.data
= modfmt
->u
.dwarf2_info
->eh_frame
.address
;
3048 fde_ctx
.end_data
= fde_ctx
.data
+ modfmt
->u
.dwarf2_info
->eh_frame
.size
;
3049 fde_ctx
.word_size
= modfmt
->u
.dwarf2_info
->word_size
;
3050 /* let offsets relative to the eh_frame sections be correctly computed, as we'll map
3051 * in this process the IMAGE section at a different address as the one expected by
3054 delta
= pair
.effective
->module
.BaseOfImage
+ modfmt
->u
.dwarf2_info
->eh_frame
.rva
-
3055 (DWORD_PTR
)modfmt
->u
.dwarf2_info
->eh_frame
.address
;
3056 if (!dwarf2_get_cie(ip
, pair
.effective
, delta
, &fde_ctx
, &cie_ctx
, &info
, TRUE
))
3058 fde_ctx
.data
= modfmt
->u
.dwarf2_info
->debug_frame
.address
;
3059 fde_ctx
.end_data
= fde_ctx
.data
+ modfmt
->u
.dwarf2_info
->debug_frame
.size
;
3060 fde_ctx
.word_size
= modfmt
->u
.dwarf2_info
->word_size
;
3061 delta
= pair
.effective
->reloc_delta
;
3062 if (!dwarf2_get_cie(ip
, pair
.effective
, delta
, &fde_ctx
, &cie_ctx
, &info
, FALSE
))
3064 TRACE("Couldn't find information for %lx\n", ip
);
3069 TRACE("function %lx/%lx code_align %lu data_align %ld retaddr %s\n",
3070 ip
, info
.ip
, info
.code_align
, info
.data_align
,
3071 dbghelp_current_cpu
->fetch_regname(dbghelp_current_cpu
->map_dwarf_register(info
.retaddr_reg
)));
3073 /* if at very beginning of function, return and use default unwinder */
3074 if (ip
== info
.ip
) return FALSE
;
3075 execute_cfa_instructions(&cie_ctx
, ip
, &info
);
3077 if (info
.aug_z_format
) /* get length of augmentation data */
3079 ULONG_PTR len
= dwarf2_leb128_as_unsigned(&fde_ctx
);
3080 end
= fde_ctx
.data
+ len
;
3083 dwarf2_parse_augmentation_ptr(&fde_ctx
, info
.lsda_encoding
); /* handler_data */
3084 if (end
) fde_ctx
.data
= end
;
3086 execute_cfa_instructions(&fde_ctx
, ip
, &info
);
3087 apply_frame_state(pair
.effective
, csw
, context
, &info
.state
, cfa
);
3092 static void dwarf2_location_compute(struct process
* pcs
,
3093 const struct module_format
* modfmt
,
3094 const struct symt_function
* func
,
3095 struct location
* loc
)
3097 struct location frame
;
3100 dwarf2_traverse_context_t lctx
;
3102 if (!func
->container
|| func
->container
->tag
!= SymTagCompiland
)
3104 WARN("We'd expect function %s's container to exist and be a compiland\n", func
->hash_elt
.name
);
3105 err
= loc_err_internal
;
3109 /* instruction pointer relative to compiland's start */
3110 ip
= pcs
->ctx_frame
.InstructionOffset
- ((struct symt_compiland
*)func
->container
)->address
;
3112 if ((err
= loc_compute_frame(pcs
, modfmt
, func
, ip
, &frame
)) == 0)
3116 case loc_dwarf2_location_list
:
3117 /* Then, if the variable has a location list, find it !! */
3118 if (dwarf2_lookup_loclist(modfmt
,
3119 modfmt
->u
.dwarf2_info
->debug_loc
.address
+ loc
->offset
,
3122 err
= loc_err_out_of_scope
;
3124 case loc_dwarf2_block
:
3125 /* or if we have a copy of an existing block, get ready for it */
3127 unsigned* ptr
= (unsigned*)loc
->offset
;
3129 lctx
.data
= (const BYTE
*)(ptr
+ 1);
3130 lctx
.end_data
= lctx
.data
+ *ptr
;
3131 lctx
.word_size
= modfmt
->u
.dwarf2_info
->word_size
;
3134 /* now get the variable */
3135 err
= compute_location(&lctx
, loc
, pcs
->handle
, &frame
);
3142 WARN("Unsupported local kind %d\n", loc
->kind
);
3143 err
= loc_err_internal
;
3149 loc
->kind
= loc_register
;
3154 static void dwarf2_module_remove(struct process
* pcs
, struct module_format
* modfmt
)
3156 HeapFree(GetProcessHeap(), 0, modfmt
);
3159 static inline BOOL
dwarf2_init_section(dwarf2_section_t
* section
, struct image_file_map
* fmap
,
3160 const char* sectname
, struct image_section_map
* ism
)
3162 struct image_section_map local_ism
;
3164 if (!ism
) ism
= &local_ism
;
3165 if (!image_find_section(fmap
, sectname
, ism
))
3167 section
->address
= NULL
;
3173 section
->address
= (const BYTE
*)image_map_section(ism
);
3174 section
->size
= image_get_map_size(ism
);
3175 section
->rva
= image_get_map_rva(ism
);
3179 BOOL
dwarf2_parse(struct module
* module
, unsigned long load_offset
,
3180 const struct elf_thunk_area
* thunks
,
3181 struct image_file_map
* fmap
)
3183 dwarf2_section_t eh_frame
, section
[section_max
];
3184 dwarf2_traverse_context_t mod_ctx
;
3185 struct image_section_map debug_sect
, debug_str_sect
, debug_abbrev_sect
,
3186 debug_line_sect
, debug_ranges_sect
, eh_frame_sect
;
3188 struct module_format
* dwarf2_modfmt
;
3190 dwarf2_init_section(&eh_frame
, fmap
, ".eh_frame", &eh_frame_sect
);
3191 dwarf2_init_section(§ion
[section_debug
], fmap
, ".debug_info", &debug_sect
);
3192 dwarf2_init_section(§ion
[section_abbrev
], fmap
, ".debug_abbrev", &debug_abbrev_sect
);
3193 dwarf2_init_section(§ion
[section_string
], fmap
, ".debug_str", &debug_str_sect
);
3194 dwarf2_init_section(§ion
[section_line
], fmap
, ".debug_line", &debug_line_sect
);
3195 dwarf2_init_section(§ion
[section_ranges
], fmap
, ".debug_ranges", &debug_ranges_sect
);
3197 /* to do anything useful we need either .eh_frame or .debug_info */
3198 if ((!eh_frame
.address
|| eh_frame
.address
== IMAGE_NO_MAP
) &&
3199 (!section
[section_debug
].address
|| section
[section_debug
].address
== IMAGE_NO_MAP
))
3205 if (fmap
->modtype
== DMT_ELF
&& debug_sect
.fmap
)
3207 /* debug info might have a different base address than .so file
3208 * when elf file is prelinked after splitting off debug info
3209 * adjust symbol base addresses accordingly
3211 load_offset
+= fmap
->u
.elf
.elf_start
- debug_sect
.fmap
->u
.elf
.elf_start
;
3214 TRACE("Loading Dwarf2 information for %s\n", debugstr_w(module
->module
.ModuleName
));
3216 mod_ctx
.data
= section
[section_debug
].address
;
3217 mod_ctx
.end_data
= mod_ctx
.data
+ section
[section_debug
].size
;
3218 mod_ctx
.word_size
= 0; /* will be correctly set later on */
3220 dwarf2_modfmt
= HeapAlloc(GetProcessHeap(), 0,
3221 sizeof(*dwarf2_modfmt
) + sizeof(*dwarf2_modfmt
->u
.dwarf2_info
));
3227 dwarf2_modfmt
->module
= module
;
3228 dwarf2_modfmt
->remove
= dwarf2_module_remove
;
3229 dwarf2_modfmt
->loc_compute
= dwarf2_location_compute
;
3230 dwarf2_modfmt
->u
.dwarf2_info
= (struct dwarf2_module_info_s
*)(dwarf2_modfmt
+ 1);
3231 dwarf2_modfmt
->u
.dwarf2_info
->word_size
= 0; /* will be correctly set later on */
3232 dwarf2_modfmt
->module
->format_info
[DFI_DWARF
] = dwarf2_modfmt
;
3234 /* As we'll need later some sections' content, we won't unmap these
3235 * sections upon existing this function
3237 dwarf2_init_section(&dwarf2_modfmt
->u
.dwarf2_info
->debug_loc
, fmap
, ".debug_loc", NULL
);
3238 dwarf2_init_section(&dwarf2_modfmt
->u
.dwarf2_info
->debug_frame
, fmap
, ".debug_frame", NULL
);
3239 dwarf2_modfmt
->u
.dwarf2_info
->eh_frame
= eh_frame
;
3241 while (mod_ctx
.data
< mod_ctx
.end_data
)
3243 dwarf2_parse_compilation_unit(section
, dwarf2_modfmt
->module
, thunks
, &mod_ctx
, load_offset
);
3245 dwarf2_modfmt
->module
->module
.SymType
= SymDia
;
3246 dwarf2_modfmt
->module
->module
.CVSig
= 'D' | ('W' << 8) | ('A' << 16) | ('R' << 24);
3247 /* FIXME: we could have a finer grain here */
3248 dwarf2_modfmt
->module
->module
.GlobalSymbols
= TRUE
;
3249 dwarf2_modfmt
->module
->module
.TypeInfo
= TRUE
;
3250 dwarf2_modfmt
->module
->module
.SourceIndexed
= TRUE
;
3251 dwarf2_modfmt
->module
->module
.Publics
= TRUE
;
3254 image_unmap_section(&debug_sect
);
3255 image_unmap_section(&debug_abbrev_sect
);
3256 image_unmap_section(&debug_str_sect
);
3257 image_unmap_section(&debug_line_sect
);
3258 image_unmap_section(&debug_ranges_sect
);
3259 if (!ret
) image_unmap_section(&eh_frame_sect
);