2 * File dwarf.c - read dwarf2 information from the ELF modules
4 * Copyright (C) 2005, Raphael Junqueira
5 * Copyright (C) 2006, Eric Pouech
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include <sys/types.h>
26 #ifdef HAVE_SYS_STAT_H
27 # include <sys/stat.h>
29 #ifdef HAVE_SYS_MMAN_H
40 #define PATH_MAX MAX_PATH
50 #include "dbghelp_private.h"
52 #include "wine/debug.h"
54 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_dwarf
);
58 * o unspecified parameters
60 * o Debug{Start|End}Point
63 * o proper types loading (nesting)
67 static void dump(const void* ptr
, unsigned len
)
71 static const char hexof
[] = "0123456789abcdef";
72 const BYTE
* x
= (const BYTE
*)ptr
;
74 for (i
= 0; i
< len
; i
+= 16)
76 sprintf(msg
, "%08x: ", i
);
77 memset(msg
+ 10, ' ', 3 * 16 + 1 + 16);
78 for (j
= 0; j
< min(16, len
- i
); j
++)
80 msg
[10 + 3 * j
+ 0] = hexof
[x
[i
+ j
] >> 4];
81 msg
[10 + 3 * j
+ 1] = hexof
[x
[i
+ j
] & 15];
82 msg
[10 + 3 * j
+ 2] = ' ';
83 msg
[10 + 3 * 16 + 1 + j
] = (x
[i
+ j
] >= 0x20 && x
[i
+ j
] < 0x7f) ?
86 msg
[10 + 3 * 16] = ' ';
87 msg
[10 + 3 * 16 + 1 + 16] = '\0';
96 * http://www.eagercon.com/dwarf/dwarf3std.htm
97 * http://www.eagercon.com/dwarf/dwarf-2.0.0.pdf
99 * dwarf2.h: http://www.hakpetzna.com/b/binutils/dwarf2_8h-source.html
101 * example of projects who do dwarf2 parsing:
102 * http://www.x86-64.org/cgi-bin/cvsweb.cgi/binutils.dead/binutils/readelf.c?rev=1.1.1.2
103 * http://elis.ugent.be/diota/log/ltrace_elf.c
111 typedef struct dwarf2_abbrev_entry_attr_s
{
112 unsigned long attribute
;
114 struct dwarf2_abbrev_entry_attr_s
* next
;
115 } dwarf2_abbrev_entry_attr_t
;
117 typedef struct dwarf2_abbrev_entry_s
119 unsigned long entry_code
;
121 unsigned char have_child
;
123 dwarf2_abbrev_entry_attr_t
* attrs
;
124 } dwarf2_abbrev_entry_t
;
129 const unsigned char* ptr
;
134 unsigned long uvalue
;
137 struct dwarf2_block
* block
;
140 typedef struct dwarf2_debug_info_s
142 unsigned long offset
;
143 const dwarf2_abbrev_entry_t
*abbrev
;
145 union attribute
* attributes
;
146 struct vector children
;
147 } dwarf2_debug_info_t
;
150 typedef struct dwarf2_section_s
152 const unsigned char* address
;
156 enum dwarf2_sections
{section_debug
, section_string
, section_abbrev
, section_line
, section_max
};
158 typedef struct dwarf2_traverse_context_s
160 const dwarf2_section_t
* sections
;
162 const unsigned char* data
;
163 const unsigned char* start_data
;
164 const unsigned char* end_data
;
165 unsigned long offset
;
166 unsigned char word_size
;
167 } dwarf2_traverse_context_t
;
169 typedef struct dwarf2_parse_context_s
172 struct module
* module
;
173 struct sparse_array abbrev_table
;
174 struct sparse_array debug_info_table
;
175 unsigned char word_size
;
176 } dwarf2_parse_context_t
;
178 /* forward declarations */
179 static struct symt
* dwarf2_parse_enumeration_type(dwarf2_parse_context_t
* ctx
, dwarf2_debug_info_t
* entry
);
181 static unsigned char dwarf2_parse_byte(dwarf2_traverse_context_t
* ctx
)
183 unsigned char uvalue
= *(const unsigned char*) ctx
->data
;
188 static unsigned short dwarf2_parse_u2(dwarf2_traverse_context_t
* ctx
)
190 unsigned short uvalue
= *(const unsigned short*) ctx
->data
;
195 static unsigned long dwarf2_parse_u4(dwarf2_traverse_context_t
* ctx
)
197 unsigned long uvalue
= *(const unsigned int*) ctx
->data
;
202 static unsigned long dwarf2_leb128_as_unsigned(dwarf2_traverse_context_t
* ctx
)
204 unsigned long ret
= 0;
208 assert( NULL
!= ctx
);
212 byte
= dwarf2_parse_byte(ctx
);
213 ret
|= (byte
& 0x7f) << shift
;
215 } while (byte
& 0x80);
220 static long dwarf2_leb128_as_signed(dwarf2_traverse_context_t
* ctx
)
225 const unsigned size
= sizeof(int) * 8;
227 assert( NULL
!= ctx
);
231 byte
= dwarf2_parse_byte(ctx
);
232 ret
|= (byte
& 0x7f) << shift
;
234 } while (byte
& 0x80);
236 /* as spec: sign bit of byte is 2nd high order bit (80x40)
237 * -> 0x80 is used as flag.
239 if ((shift
< size
) && (byte
& 0x40))
241 ret
|= - (1 << shift
);
246 static unsigned long dwarf2_parse_addr(dwarf2_traverse_context_t
* ctx
)
250 switch (ctx
->word_size
)
253 ret
= dwarf2_parse_u4(ctx
);
256 FIXME("Unsupported Word Size %u\n", ctx
->word_size
);
262 static const char* dwarf2_debug_traverse_ctx(const dwarf2_traverse_context_t
* ctx
)
264 return wine_dbg_sprintf("ctx(0x%x)", ctx
->data
- ctx
->sections
[ctx
->section
].address
);
267 static const char* dwarf2_debug_ctx(const dwarf2_parse_context_t
* ctx
)
269 return wine_dbg_sprintf("ctx(%p,%s)", ctx
, ctx
->module
->module
.ModuleName
);
272 static const char* dwarf2_debug_di(dwarf2_debug_info_t
* di
)
274 return wine_dbg_sprintf("debug_info(offset:0x%lx,abbrev:%p,symt:%p)",
275 di
->offset
, di
->abbrev
, di
->symt
);
278 static dwarf2_abbrev_entry_t
*
279 dwarf2_abbrev_table_find_entry(struct sparse_array
* abbrev_table
,
280 unsigned long entry_code
)
282 assert( NULL
!= abbrev_table
);
283 return sparse_array_find(abbrev_table
, entry_code
);
286 static void dwarf2_parse_abbrev_set(dwarf2_traverse_context_t
* abbrev_ctx
,
287 struct sparse_array
* abbrev_table
,
290 unsigned long entry_code
;
291 dwarf2_abbrev_entry_t
* abbrev_entry
;
292 dwarf2_abbrev_entry_attr_t
* new = NULL
;
293 dwarf2_abbrev_entry_attr_t
* last
= NULL
;
294 unsigned long attribute
;
297 assert( NULL
!= abbrev_ctx
);
299 TRACE("%s, end at %p\n",
300 dwarf2_debug_traverse_ctx(abbrev_ctx
), abbrev_ctx
->end_data
);
302 sparse_array_init(abbrev_table
, sizeof(dwarf2_abbrev_entry_t
), 32);
303 while (abbrev_ctx
->data
< abbrev_ctx
->end_data
)
305 TRACE("now at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx
));
306 entry_code
= dwarf2_leb128_as_unsigned(abbrev_ctx
);
307 TRACE("found entry_code %lu\n", entry_code
);
310 TRACE("NULL entry code at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx
));
313 abbrev_entry
= sparse_array_add(abbrev_table
, entry_code
, pool
);
314 assert( NULL
!= abbrev_entry
);
316 abbrev_entry
->entry_code
= entry_code
;
317 abbrev_entry
->tag
= dwarf2_leb128_as_unsigned(abbrev_ctx
);
318 abbrev_entry
->have_child
= dwarf2_parse_byte(abbrev_ctx
);
319 abbrev_entry
->attrs
= NULL
;
320 abbrev_entry
->num_attr
= 0;
322 TRACE("table:(%p,#%u) entry_code(%lu) tag(0x%lx) have_child(%u) -> %p\n",
323 abbrev_table
, sparse_array_length(abbrev_table
),
324 entry_code
, abbrev_entry
->tag
, abbrev_entry
->have_child
, abbrev_entry
);
329 attribute
= dwarf2_leb128_as_unsigned(abbrev_ctx
);
330 form
= dwarf2_leb128_as_unsigned(abbrev_ctx
);
331 if (!attribute
) break;
333 new = pool_alloc(pool
, sizeof(dwarf2_abbrev_entry_attr_t
));
336 new->attribute
= attribute
;
339 if (abbrev_entry
->attrs
) last
->next
= new;
340 else abbrev_entry
->attrs
= new;
342 abbrev_entry
->num_attr
++;
345 TRACE("found %u entries\n", sparse_array_length(abbrev_table
));
348 static void dwarf2_parse_attr_into_di(struct pool
* pool
,
349 dwarf2_traverse_context_t
* ctx
,
350 const dwarf2_abbrev_entry_attr_t
* abbrev_attr
,
351 union attribute
* attr
)
354 TRACE("(attr:0x%lx,form:0x%lx)\n", abbrev_attr
->attribute
, abbrev_attr
->form
);
356 switch (abbrev_attr
->form
) {
357 case DW_FORM_ref_addr
:
359 attr
->uvalue
= dwarf2_parse_addr(ctx
);
360 TRACE("addr<0x%lx>\n", attr
->uvalue
);
364 attr
->uvalue
= dwarf2_parse_byte(ctx
);
365 TRACE("flag<0x%lx>\n", attr
->uvalue
);
369 attr
->uvalue
= dwarf2_parse_byte(ctx
);
370 TRACE("data1<%lu>\n", attr
->uvalue
);
374 attr
->uvalue
= dwarf2_parse_u2(ctx
);
375 TRACE("data2<%lu>\n", attr
->uvalue
);
379 attr
->uvalue
= dwarf2_parse_u4(ctx
);
380 TRACE("data4<%lu>\n", attr
->uvalue
);
384 FIXME("Unhandled 64bits support\n");
389 attr
->uvalue
= ctx
->offset
+ dwarf2_parse_byte(ctx
);
390 TRACE("ref1<0x%lx>\n", attr
->uvalue
);
394 attr
->uvalue
= ctx
->offset
+ dwarf2_parse_u2(ctx
);
395 TRACE("ref2<0x%lx>\n", attr
->uvalue
);
399 attr
->uvalue
= ctx
->offset
+ dwarf2_parse_u4(ctx
);
400 TRACE("ref4<0x%lx>\n", attr
->uvalue
);
404 FIXME("Unhandled 64 bit support\n");
409 attr
->svalue
= dwarf2_leb128_as_signed(ctx
);
412 case DW_FORM_ref_udata
:
413 attr
->uvalue
= dwarf2_leb128_as_unsigned(ctx
);
417 attr
->uvalue
= dwarf2_leb128_as_unsigned(ctx
);
421 attr
->string
= (const char*)ctx
->data
;
422 ctx
->data
+= strlen(attr
->string
) + 1;
423 TRACE("string<%s>\n", attr
->string
);
428 unsigned long offset
= dwarf2_parse_u4(ctx
);
429 attr
->string
= (const char*)ctx
->sections
[section_string
].address
+ offset
;
431 TRACE("strp<%s>\n", attr
->string
);
434 attr
->block
= pool_alloc(pool
, sizeof(struct dwarf2_block
));
435 attr
->block
->size
= dwarf2_leb128_as_unsigned(ctx
);
436 attr
->block
->ptr
= ctx
->data
;
437 ctx
->data
+= attr
->block
->size
;
441 attr
->block
= pool_alloc(pool
, sizeof(struct dwarf2_block
));
442 attr
->block
->size
= dwarf2_parse_byte(ctx
);
443 attr
->block
->ptr
= ctx
->data
;
444 ctx
->data
+= attr
->block
->size
;
448 attr
->block
= pool_alloc(pool
, sizeof(struct dwarf2_block
));
449 attr
->block
->size
= dwarf2_parse_u2(ctx
);
450 attr
->block
->ptr
= ctx
->data
;
451 ctx
->data
+= attr
->block
->size
;
455 attr
->block
= pool_alloc(pool
, sizeof(struct dwarf2_block
));
456 attr
->block
->size
= dwarf2_parse_u4(ctx
);
457 attr
->block
->ptr
= ctx
->data
;
458 ctx
->data
+= attr
->block
->size
;
462 FIXME("Unhandled attribute form %lx\n", abbrev_attr
->form
);
467 static BOOL
dwarf2_find_attribute(const dwarf2_debug_info_t
* di
,
468 unsigned at
, union attribute
* attr
)
471 dwarf2_abbrev_entry_attr_t
* abbrev_attr
;
473 for (i
= 0, abbrev_attr
= di
->abbrev
->attrs
; abbrev_attr
; i
++, abbrev_attr
= abbrev_attr
->next
)
475 if (abbrev_attr
->attribute
== at
)
477 *attr
= di
->attributes
[i
];
484 static void dwarf2_find_name(dwarf2_parse_context_t
* ctx
,
485 const dwarf2_debug_info_t
* di
,
486 union attribute
* attr
, const char* pfx
)
490 if (!dwarf2_find_attribute(di
, DW_AT_name
, attr
))
492 char* tmp
= pool_alloc(&ctx
->pool
, strlen(pfx
) + 16);
493 if (tmp
) sprintf(tmp
, "%s_%d", pfx
, index
++);
498 static void dwarf2_load_one_entry(dwarf2_parse_context_t
*, dwarf2_debug_info_t
*,
499 struct symt_compiland
*);
501 #define Wine_DW_no_register -1
502 #define Wine_DW_frame_register -2
504 static unsigned long dwarf2_compute_location(dwarf2_parse_context_t
* ctx
,
505 struct dwarf2_block
* block
,
508 unsigned long loc
[64];
511 if (in_register
) *in_register
= Wine_DW_no_register
;
516 dwarf2_traverse_context_t lctx
;
518 BOOL piece_found
= FALSE
;
520 lctx
.data
= block
->ptr
;
521 lctx
.end_data
= block
->ptr
+ block
->size
;
522 lctx
.word_size
= ctx
->word_size
;
524 while (lctx
.data
< lctx
.end_data
)
526 op
= dwarf2_parse_byte(&lctx
);
529 case DW_OP_addr
: loc
[++stk
] = dwarf2_parse_addr(&lctx
); break;
530 case DW_OP_const1u
: loc
[++stk
] = dwarf2_parse_byte(&lctx
); break;
531 case DW_OP_const1s
: loc
[++stk
] = (long)(signed char)dwarf2_parse_byte(&lctx
); break;
532 case DW_OP_const2u
: loc
[++stk
] = dwarf2_parse_u2(&lctx
); break;
533 case DW_OP_const2s
: loc
[++stk
] = (long)(short)dwarf2_parse_u2(&lctx
); break;
534 case DW_OP_const4u
: loc
[++stk
] = dwarf2_parse_u4(&lctx
); break;
535 case DW_OP_const4s
: loc
[++stk
] = dwarf2_parse_u4(&lctx
); break;
536 case DW_OP_constu
: loc
[++stk
] = dwarf2_leb128_as_unsigned(&lctx
); break;
537 case DW_OP_consts
: loc
[++stk
] = dwarf2_leb128_as_signed(&lctx
); break;
538 case DW_OP_plus_uconst
:
539 loc
[stk
] += dwarf2_leb128_as_unsigned(&lctx
); break;
540 case DW_OP_reg0
: case DW_OP_reg1
: case DW_OP_reg2
: case DW_OP_reg3
:
541 case DW_OP_reg4
: case DW_OP_reg5
: case DW_OP_reg6
: case DW_OP_reg7
:
542 case DW_OP_reg8
: case DW_OP_reg9
: case DW_OP_reg10
: case DW_OP_reg11
:
543 case DW_OP_reg12
: case DW_OP_reg13
: case DW_OP_reg14
: case DW_OP_reg15
:
544 case DW_OP_reg16
: case DW_OP_reg17
: case DW_OP_reg18
: case DW_OP_reg19
:
545 case DW_OP_reg20
: case DW_OP_reg21
: case DW_OP_reg22
: case DW_OP_reg23
:
546 case DW_OP_reg24
: case DW_OP_reg25
: case DW_OP_reg26
: case DW_OP_reg27
:
547 case DW_OP_reg28
: case DW_OP_reg29
: case DW_OP_reg30
: case DW_OP_reg31
:
550 /* dbghelp APIs don't know how to cope with this anyway
551 * (for example 'long long' stored in two registers)
552 * FIXME: We should tell winedbg how to deal with it (sigh)
554 if (!piece_found
|| (op
- DW_OP_reg0
!= *in_register
+ 1))
556 if (*in_register
!= Wine_DW_no_register
)
557 FIXME("Only supporting one reg (%d -> %d)\n",
558 *in_register
, op
- DW_OP_reg0
);
559 *in_register
= op
- DW_OP_reg0
;
562 else FIXME("Found register, while not expecting it\n");
567 if (*in_register
!= Wine_DW_no_register
)
568 FIXME("Only supporting one reg (%d -> -2)\n", *in_register
);
569 *in_register
= Wine_DW_frame_register
;
571 else FIXME("Found register, while not expecting it\n");
572 loc
[++stk
] = dwarf2_leb128_as_signed(&lctx
);
576 unsigned sz
= dwarf2_leb128_as_unsigned(&lctx
);
577 WARN("Not handling OP_piece directly (size=%d)\n", sz
);
582 FIXME("Unhandled attr op: %x\n", op
);
590 static struct symt
* dwarf2_lookup_type(dwarf2_parse_context_t
* ctx
,
591 const dwarf2_debug_info_t
* di
)
593 union attribute attr
;
595 if (dwarf2_find_attribute(di
, DW_AT_type
, &attr
))
597 dwarf2_debug_info_t
* type
;
599 type
= sparse_array_find(&ctx
->debug_info_table
, attr
.uvalue
);
600 if (!type
) FIXME("Unable to find back reference to type %lx\n", attr
.uvalue
);
603 /* load the debug info entity */
604 dwarf2_load_one_entry(ctx
, type
, NULL
);
611 /******************************************************************
612 * dwarf2_read_one_debug_info
614 * Loads into memory one debug info entry, and recursively its children (if any)
616 static BOOL
dwarf2_read_one_debug_info(dwarf2_parse_context_t
* ctx
,
617 dwarf2_traverse_context_t
* traverse
,
618 dwarf2_debug_info_t
** pdi
)
620 const dwarf2_abbrev_entry_t
*abbrev
;
621 unsigned long entry_code
;
622 unsigned long offset
;
623 dwarf2_debug_info_t
* di
;
624 dwarf2_debug_info_t
* child
;
625 dwarf2_debug_info_t
** where
;
626 dwarf2_abbrev_entry_attr_t
* attr
;
628 union attribute sibling
;
630 offset
= traverse
->data
- traverse
->sections
[traverse
->section
].address
;
631 entry_code
= dwarf2_leb128_as_unsigned(traverse
);
632 TRACE("found entry_code %lu at 0x%lx\n", entry_code
, offset
);
638 abbrev
= dwarf2_abbrev_table_find_entry(&ctx
->abbrev_table
, entry_code
);
641 WARN("Cannot find abbrev entry for %lu at 0x%lx\n", entry_code
, offset
);
644 di
= sparse_array_add(&ctx
->debug_info_table
, offset
, &ctx
->pool
);
645 if (!di
) return FALSE
;
650 if (abbrev
->num_attr
)
652 di
->attributes
= pool_alloc(&ctx
->pool
,
653 abbrev
->num_attr
* sizeof(union attribute
));
654 for (i
= 0, attr
= abbrev
->attrs
; attr
; i
++, attr
= attr
->next
)
656 dwarf2_parse_attr_into_di(&ctx
->pool
, traverse
, attr
, &di
->attributes
[i
]);
659 else di
->attributes
= NULL
;
660 if (abbrev
->have_child
)
662 vector_init(&di
->children
, sizeof(dwarf2_debug_info_t
*), 16);
663 while (traverse
->data
< traverse
->end_data
)
665 if (!dwarf2_read_one_debug_info(ctx
, traverse
, &child
)) return FALSE
;
667 where
= vector_add(&di
->children
, &ctx
->pool
);
668 if (!where
) return FALSE
;
672 if (dwarf2_find_attribute(di
, DW_AT_sibling
, &sibling
) &&
673 traverse
->data
!= traverse
->sections
[traverse
->section
].address
+ sibling
.uvalue
)
675 WARN("setting cursor for %s to next sibling <0x%lx>\n",
676 dwarf2_debug_traverse_ctx(traverse
), sibling
.uvalue
);
677 traverse
->data
= traverse
->sections
[traverse
->section
].address
+ sibling
.uvalue
;
683 static struct symt
* dwarf2_parse_base_type(dwarf2_parse_context_t
* ctx
,
684 dwarf2_debug_info_t
* di
)
686 union attribute name
;
687 union attribute size
;
688 union attribute encoding
;
691 if (di
->symt
) return di
->symt
;
693 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
695 dwarf2_find_name(ctx
, di
, &name
, "base_type");
696 if (!dwarf2_find_attribute(di
, DW_AT_byte_size
, &size
)) size
.uvalue
= 0;
697 if (!dwarf2_find_attribute(di
, DW_AT_encoding
, &encoding
)) encoding
.uvalue
= DW_ATE_void
;
699 switch (encoding
.uvalue
)
701 case DW_ATE_void
: bt
= btVoid
; break;
702 case DW_ATE_address
: bt
= btULong
; break;
703 case DW_ATE_boolean
: bt
= btBool
; break;
704 case DW_ATE_complex_float
: bt
= btComplex
; break;
705 case DW_ATE_float
: bt
= btFloat
; break;
706 case DW_ATE_signed
: bt
= btInt
; break;
707 case DW_ATE_unsigned
: bt
= btUInt
; break;
708 case DW_ATE_signed_char
: bt
= btChar
; break;
709 case DW_ATE_unsigned_char
: bt
= btChar
; break;
710 default: bt
= btNoType
; break;
712 di
->symt
= &symt_new_basic(ctx
->module
, bt
, name
.string
, size
.uvalue
)->symt
;
713 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
717 static struct symt
* dwarf2_parse_typedef(dwarf2_parse_context_t
* ctx
,
718 dwarf2_debug_info_t
* di
)
720 struct symt
* ref_type
;
721 union attribute name
;
723 if (di
->symt
) return di
->symt
;
725 TRACE("%s, for %lu\n", dwarf2_debug_ctx(ctx
), di
->abbrev
->entry_code
);
727 dwarf2_find_name(ctx
, di
, &name
, "typedef");
728 ref_type
= dwarf2_lookup_type(ctx
, di
);
732 di
->symt
= &symt_new_typedef(ctx
->module
, ref_type
, name
.string
)->symt
;
734 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
738 static struct symt
* dwarf2_parse_pointer_type(dwarf2_parse_context_t
* ctx
,
739 dwarf2_debug_info_t
* di
)
741 struct symt
* ref_type
;
742 union attribute size
;
744 if (di
->symt
) return di
->symt
;
746 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
748 if (!dwarf2_find_attribute(di
, DW_AT_byte_size
, &size
)) size
.uvalue
= 0;
749 ref_type
= dwarf2_lookup_type(ctx
, di
);
751 di
->symt
= &symt_new_pointer(ctx
->module
, ref_type
)->symt
;
752 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
756 static struct symt
* dwarf2_parse_array_type(dwarf2_parse_context_t
* ctx
,
757 dwarf2_debug_info_t
* di
)
759 struct symt
* ref_type
;
760 struct symt
* idx_type
= NULL
;
761 union attribute min
, max
, cnt
;
762 dwarf2_debug_info_t
** pchild
= NULL
;
763 dwarf2_debug_info_t
* child
;
765 if (di
->symt
) return di
->symt
;
767 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
769 if (!di
->abbrev
->have_child
)
771 FIXME("array without range information\n");
774 ref_type
= dwarf2_lookup_type(ctx
, di
);
776 while ((pchild
= vector_iter_up(&di
->children
, pchild
)))
779 switch (child
->abbrev
->tag
)
781 case DW_TAG_subrange_type
:
782 idx_type
= dwarf2_lookup_type(ctx
, child
);
783 if (!dwarf2_find_attribute(child
, DW_AT_lower_bound
, &min
))
785 if (!dwarf2_find_attribute(child
, DW_AT_upper_bound
, &max
))
787 if (dwarf2_find_attribute(child
, DW_AT_count
, &cnt
))
788 max
.uvalue
= min
.uvalue
+ cnt
.uvalue
;
791 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
792 child
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
796 di
->symt
= &symt_new_array(ctx
->module
, min
.uvalue
, max
.uvalue
, ref_type
, idx_type
)->symt
;
800 static struct symt
* dwarf2_parse_const_type(dwarf2_parse_context_t
* ctx
,
801 dwarf2_debug_info_t
* di
)
803 struct symt
* ref_type
;
805 if (di
->symt
) return di
->symt
;
807 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
809 ref_type
= dwarf2_lookup_type(ctx
, di
);
810 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
816 static struct symt
* dwarf2_parse_reference_type(dwarf2_parse_context_t
* ctx
,
817 dwarf2_debug_info_t
* di
)
819 struct symt
* ref_type
= NULL
;
821 if (di
->symt
) return di
->symt
;
823 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
825 ref_type
= dwarf2_lookup_type(ctx
, di
);
826 /* FIXME: for now, we hard-wire C++ references to pointers */
827 di
->symt
= &symt_new_pointer(ctx
->module
, ref_type
)->symt
;
829 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
834 static void dwarf2_parse_udt_member(dwarf2_parse_context_t
* ctx
,
835 dwarf2_debug_info_t
* di
,
836 struct symt_udt
* parent
)
838 struct symt
* elt_type
;
839 union attribute name
;
841 unsigned long offset
= 0;
842 union attribute bit_size
;
843 union attribute bit_offset
;
847 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
849 dwarf2_find_name(ctx
, di
, &name
, "udt_member");
850 elt_type
= dwarf2_lookup_type(ctx
, di
);
851 if (dwarf2_find_attribute(di
, DW_AT_data_member_location
, &loc
))
853 TRACE("found member_location at %s\n", dwarf2_debug_ctx(ctx
));
854 offset
= dwarf2_compute_location(ctx
, loc
.block
, NULL
);
855 TRACE("found offset:%lu\n", offset
);
857 if (!dwarf2_find_attribute(di
, DW_AT_bit_size
, &bit_size
)) bit_size
.uvalue
= 0;
858 if (dwarf2_find_attribute(di
, DW_AT_bit_offset
, &bit_offset
))
860 /* FIXME: we should only do this when implementation is LSB (which is
861 * the case on i386 processors)
863 union attribute nbytes
;
864 if (!dwarf2_find_attribute(di
, DW_AT_byte_size
, &nbytes
))
867 nbytes
.uvalue
= symt_get_info(elt_type
, TI_GET_LENGTH
, &size
) ? (unsigned long)size
: 0;
869 bit_offset
.uvalue
= nbytes
.uvalue
* 8 - bit_offset
.uvalue
- bit_size
.uvalue
;
871 else bit_offset
.uvalue
= 0;
872 symt_add_udt_element(ctx
->module
, parent
, name
.string
, elt_type
,
873 (offset
<< 3) + bit_offset
.uvalue
, bit_size
.uvalue
);
875 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
878 static struct symt
* dwarf2_parse_udt_type(dwarf2_parse_context_t
* ctx
,
879 dwarf2_debug_info_t
* di
,
882 union attribute name
;
883 union attribute size
;
885 if (di
->symt
) return di
->symt
;
887 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
889 dwarf2_find_name(ctx
, di
, &name
, "udt");
890 if (!dwarf2_find_attribute(di
, DW_AT_byte_size
, &size
)) size
.uvalue
= 0;
892 di
->symt
= &symt_new_udt(ctx
->module
, name
.string
, size
.uvalue
, udt
)->symt
;
894 if (di
->abbrev
->have_child
) /** any interest to not have child ? */
896 dwarf2_debug_info_t
** pchild
= NULL
;
897 dwarf2_debug_info_t
* child
;
899 while ((pchild
= vector_iter_up(&di
->children
, pchild
)))
903 switch (child
->abbrev
->tag
)
906 /* FIXME: should I follow the sibling stuff ?? */
907 dwarf2_parse_udt_member(ctx
, child
, (struct symt_udt
*)di
->symt
);
909 case DW_TAG_enumeration_type
:
910 dwarf2_parse_enumeration_type(ctx
, child
);
912 case DW_TAG_structure_type
:
913 case DW_TAG_class_type
:
914 case DW_TAG_union_type
:
915 /* FIXME: we need to handle nested udt definitions */
918 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
919 child
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
928 static void dwarf2_parse_enumerator(dwarf2_parse_context_t
* ctx
,
929 dwarf2_debug_info_t
* di
,
930 struct symt_enum
* parent
)
932 union attribute name
;
933 union attribute value
;
935 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
937 dwarf2_find_name(ctx
, di
, &name
, "enum_value");
938 if (!dwarf2_find_attribute(di
, DW_AT_const_value
, &value
)) value
.svalue
= 0;
939 symt_add_enum_element(ctx
->module
, parent
, name
.string
, value
.svalue
);
941 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
944 static struct symt
* dwarf2_parse_enumeration_type(dwarf2_parse_context_t
* ctx
,
945 dwarf2_debug_info_t
* di
)
947 union attribute name
;
948 union attribute size
;
950 if (di
->symt
) return di
->symt
;
952 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
954 dwarf2_find_name(ctx
, di
, &name
, "enum");
955 if (!dwarf2_find_attribute(di
, DW_AT_byte_size
, &size
)) size
.uvalue
= 0;
957 di
->symt
= &symt_new_enum(ctx
->module
, name
.string
)->symt
;
959 if (di
->abbrev
->have_child
) /* any interest to not have child ? */
961 dwarf2_debug_info_t
** pchild
= NULL
;
962 dwarf2_debug_info_t
* child
;
964 /* FIXME: should we use the sibling stuff ?? */
965 while ((pchild
= vector_iter_up(&di
->children
, pchild
)))
969 switch (child
->abbrev
->tag
)
971 case DW_TAG_enumerator
:
972 dwarf2_parse_enumerator(ctx
, child
, (struct symt_enum
*)di
->symt
);
975 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
976 di
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
983 static unsigned dwarf2_map_register(int regno
)
989 case Wine_DW_no_register
: FIXME("What the heck\n"); reg
= 0; break;
990 /* FIXME: this is a dirty hack */
991 case Wine_DW_frame_register
: reg
= 0; break;
992 case 0: reg
= CV_REG_EAX
; break;
993 case 1: reg
= CV_REG_ECX
; break;
994 case 2: reg
= CV_REG_EDX
; break;
995 case 3: reg
= CV_REG_EBX
; break;
996 case 4: reg
= CV_REG_ESP
; break;
997 case 5: reg
= CV_REG_EBP
; break;
998 case 6: reg
= CV_REG_ESI
; break;
999 case 7: reg
= CV_REG_EDI
; break;
1000 case 8: reg
= CV_REG_EIP
; break;
1001 case 9: reg
= CV_REG_EFLAGS
; break;
1002 case 10: reg
= CV_REG_CS
; break;
1003 case 11: reg
= CV_REG_SS
; break;
1004 case 12: reg
= CV_REG_DS
; break;
1005 case 13: reg
= CV_REG_ES
; break;
1006 case 14: reg
= CV_REG_FS
; break;
1007 case 15: reg
= CV_REG_GS
; break;
1008 case 16: case 17: case 18: case 19:
1009 case 20: case 21: case 22: case 23:
1010 reg
= CV_REG_ST0
+ regno
- 16; break;
1011 case 24: reg
= CV_REG_CTRL
; break;
1012 case 25: reg
= CV_REG_STAT
; break;
1013 case 26: reg
= CV_REG_TAG
; break;
1021 case 32: case 33: case 34: case 35:
1022 case 36: case 37: case 38: case 39:
1023 reg
= CV_REG_XMM0
+ regno
- 32; break;
1024 case 40: reg
= CV_REG_MXCSR
; break;
1026 FIXME("Don't know how to map register %d\n", regno
);
1032 /* structure used to pass information around when parsing a subprogram */
1033 typedef struct dwarf2_subprogram_s
1035 dwarf2_parse_context_t
* ctx
;
1036 struct symt_compiland
* compiland
;
1037 struct symt_function
* func
;
1040 } dwarf2_subprogram_t
;
1042 /******************************************************************
1043 * dwarf2_parse_variable
1045 * Parses any variable (parameter, local/global variable)
1047 static void dwarf2_parse_variable(dwarf2_subprogram_t
* subpgm
,
1048 struct symt_block
* block
,
1049 dwarf2_debug_info_t
* di
)
1051 struct symt
* param_type
;
1052 union attribute loc
;
1053 BOOL is_pmt
= di
->abbrev
->tag
== DW_TAG_formal_parameter
;
1055 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1057 param_type
= dwarf2_lookup_type(subpgm
->ctx
, di
);
1058 if (dwarf2_find_attribute(di
, DW_AT_location
, &loc
))
1060 union attribute name
;
1061 union attribute ext
;
1065 dwarf2_find_name(subpgm
->ctx
, di
, &name
, "parameter");
1066 offset
= dwarf2_compute_location(subpgm
->ctx
, loc
.block
, &in_reg
);
1067 TRACE("found parameter %s/%ld (reg=%d) at %s\n",
1068 name
.string
, offset
, in_reg
, dwarf2_debug_ctx(subpgm
->ctx
));
1071 case Wine_DW_no_register
:
1072 /* it's a global variable */
1073 /* FIXME: we don't handle it's scope yet */
1074 if (!dwarf2_find_attribute(di
, DW_AT_external
, &ext
))
1076 symt_new_global_variable(subpgm
->ctx
->module
, subpgm
->compiland
,
1077 name
.string
, !ext
.uvalue
,
1078 subpgm
->ctx
->module
->module
.BaseOfImage
+ offset
,
1081 case Wine_DW_frame_register
:
1082 in_reg
= subpgm
->frame_reg
;
1083 offset
+= subpgm
->frame_offset
;
1086 /* either a pmt/variable relative to frame pointer or
1087 * pmt/variable in a register
1089 symt_add_func_local(subpgm
->ctx
->module
, subpgm
->func
,
1090 is_pmt
? DataIsParam
: DataIsLocal
,
1091 dwarf2_map_register(in_reg
), offset
,
1092 block
, param_type
, name
.string
);
1096 if (is_pmt
&& subpgm
->func
&& subpgm
->func
->type
)
1097 symt_add_function_signature_parameter(subpgm
->ctx
->module
,
1098 (struct symt_function_signature
*)subpgm
->func
->type
,
1101 if (di
->abbrev
->have_child
) FIXME("Unsupported children\n");
1104 static void dwarf2_parse_subprogram_label(dwarf2_subprogram_t
* subpgm
,
1105 dwarf2_debug_info_t
* di
)
1107 union attribute name
;
1108 union attribute low_pc
;
1110 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1112 if (!dwarf2_find_attribute(di
, DW_AT_low_pc
, &low_pc
)) low_pc
.uvalue
= 0;
1113 dwarf2_find_name(subpgm
->ctx
, di
, &name
, "label");
1115 symt_add_function_point(subpgm
->ctx
->module
, subpgm
->func
, SymTagLabel
,
1116 subpgm
->ctx
->module
->module
.BaseOfImage
+ low_pc
.uvalue
, name
.string
);
1119 static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t
* subpgm
,
1120 struct symt_block
* block_parent
,
1121 dwarf2_debug_info_t
* di
);
1123 static void dwarf2_parse_inlined_subroutine(dwarf2_subprogram_t
* subpgm
,
1124 dwarf2_debug_info_t
* di
)
1126 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1128 /* FIXME: attributes to handle:
1134 if (di
->abbrev
->have_child
) /** any interest to not have child ? */
1136 dwarf2_debug_info_t
** pchild
= NULL
;
1137 dwarf2_debug_info_t
* child
;
1139 while ((pchild
= vector_iter_up(&di
->children
, pchild
)))
1143 switch (child
->abbrev
->tag
)
1145 case DW_TAG_formal_parameter
:
1146 /* FIXME: this is not properly supported yet
1147 * dwarf2_parse_subprogram_parameter(ctx, child, NULL);
1150 case DW_TAG_variable
:
1152 * dwarf2_parse_variable(ctx, child);
1155 case DW_TAG_lexical_block
:
1157 dwarf2_parse_subprogram_block(ctx, child, func);
1160 case DW_TAG_inlined_subroutine
:
1162 dwarf2_parse_inlined_subroutine(subpgm
, child
);
1165 dwarf2_parse_subprogram_label(subpgm
, child
);
1168 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1169 child
->abbrev
->tag
, dwarf2_debug_ctx(subpgm
->ctx
),
1170 dwarf2_debug_di(di
));
1176 static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t
* subpgm
,
1177 struct symt_block
* parent_block
,
1178 dwarf2_debug_info_t
* di
)
1180 struct symt_block
* block
;
1181 union attribute low_pc
;
1182 union attribute high_pc
;
1184 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1186 if (!dwarf2_find_attribute(di
, DW_AT_low_pc
, &low_pc
)) low_pc
.uvalue
= 0;
1187 if (!dwarf2_find_attribute(di
, DW_AT_high_pc
, &high_pc
)) high_pc
.uvalue
= 0;
1189 block
= symt_open_func_block(subpgm
->ctx
->module
, subpgm
->func
, parent_block
,
1190 low_pc
.uvalue
, high_pc
.uvalue
- low_pc
.uvalue
);
1192 if (di
->abbrev
->have_child
) /** any interest to not have child ? */
1194 dwarf2_debug_info_t
** pchild
= NULL
;
1195 dwarf2_debug_info_t
* child
;
1197 while ((pchild
= vector_iter_up(&di
->children
, pchild
)))
1201 switch (child
->abbrev
->tag
)
1203 case DW_TAG_inlined_subroutine
:
1204 dwarf2_parse_inlined_subroutine(subpgm
, child
);
1206 case DW_TAG_variable
:
1207 dwarf2_parse_variable(subpgm
, block
, child
);
1209 case DW_TAG_lexical_block
:
1210 dwarf2_parse_subprogram_block(subpgm
, block
, child
);
1212 case DW_TAG_subprogram
:
1213 /* FIXME: likely a declaration (to be checked)
1217 case DW_TAG_formal_parameter
:
1218 /* FIXME: likely elements for exception handling (GCC flavor)
1222 case DW_TAG_class_type
:
1223 case DW_TAG_structure_type
:
1224 case DW_TAG_union_type
:
1225 case DW_TAG_enumeration_type
:
1226 /* the type referred to will be loaded when we need it, so skip it */
1229 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1230 child
->abbrev
->tag
, dwarf2_debug_ctx(subpgm
->ctx
), dwarf2_debug_di(di
));
1235 symt_close_func_block(subpgm
->ctx
->module
, subpgm
->func
, block
, 0);
1238 static struct symt
* dwarf2_parse_subprogram(dwarf2_parse_context_t
* ctx
,
1239 dwarf2_debug_info_t
* di
,
1240 struct symt_compiland
* compiland
)
1242 union attribute name
;
1243 union attribute low_pc
;
1244 union attribute high_pc
;
1245 union attribute is_decl
;
1246 union attribute inline_flags
;
1247 union attribute frame
;
1248 struct symt
* ret_type
;
1249 struct symt_function_signature
* sig_type
;
1250 dwarf2_subprogram_t subpgm
;
1252 if (di
->symt
) return di
->symt
;
1254 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1256 if (!dwarf2_find_attribute(di
, DW_AT_low_pc
, &low_pc
)) low_pc
.uvalue
= 0;
1257 if (!dwarf2_find_attribute(di
, DW_AT_high_pc
, &high_pc
)) high_pc
.uvalue
= 0;
1258 if (!dwarf2_find_attribute(di
, DW_AT_declaration
, &is_decl
)) is_decl
.uvalue
= 0;
1259 if (!dwarf2_find_attribute(di
, DW_AT_inline
, &inline_flags
)) inline_flags
.uvalue
= 0;
1260 dwarf2_find_name(ctx
, di
, &name
, "subprogram");
1261 ret_type
= dwarf2_lookup_type(ctx
, di
);
1263 /* FIXME: assuming C source code */
1264 sig_type
= symt_new_function_signature(ctx
->module
, ret_type
, CV_CALL_FAR_C
);
1265 if (!is_decl
.uvalue
)
1267 subpgm
.func
= symt_new_function(ctx
->module
, compiland
, name
.string
,
1268 ctx
->module
->module
.BaseOfImage
+ low_pc
.uvalue
,
1269 high_pc
.uvalue
- low_pc
.uvalue
,
1271 di
->symt
= &subpgm
.func
->symt
;
1273 else subpgm
.func
= NULL
;
1276 subpgm
.compiland
= compiland
;
1277 if (dwarf2_find_attribute(di
, DW_AT_frame_base
, &frame
))
1279 subpgm
.frame_offset
= dwarf2_compute_location(ctx
, frame
.block
, &subpgm
.frame_reg
);
1280 TRACE("For %s got %ld/%d\n", name
.string
, subpgm
.frame_offset
, subpgm
.frame_reg
);
1282 else /* on stack !! */
1284 subpgm
.frame_reg
= 0;
1285 subpgm
.frame_offset
= 0;
1288 if (di
->abbrev
->have_child
) /** any interest to not have child ? */
1290 dwarf2_debug_info_t
** pchild
= NULL
;
1291 dwarf2_debug_info_t
* child
;
1293 while ((pchild
= vector_iter_up(&di
->children
, pchild
)))
1297 switch (child
->abbrev
->tag
)
1299 case DW_TAG_variable
:
1300 case DW_TAG_formal_parameter
:
1301 dwarf2_parse_variable(&subpgm
, NULL
, child
);
1303 case DW_TAG_lexical_block
:
1304 dwarf2_parse_subprogram_block(&subpgm
, NULL
, child
);
1306 case DW_TAG_inlined_subroutine
:
1307 dwarf2_parse_inlined_subroutine(&subpgm
, child
);
1309 case DW_TAG_subprogram
:
1310 /* FIXME: likely a declaration (to be checked)
1315 dwarf2_parse_subprogram_label(&subpgm
, child
);
1317 case DW_TAG_class_type
:
1318 case DW_TAG_structure_type
:
1319 case DW_TAG_union_type
:
1320 case DW_TAG_enumeration_type
:
1321 case DW_TAG_typedef
:
1322 /* the type referred to will be loaded when we need it, so skip it */
1324 case DW_TAG_unspecified_parameters
:
1325 /* FIXME: no support in dbghelp's internals so far */
1328 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1329 child
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), dwarf2_debug_di(di
));
1334 symt_normalize_function(subpgm
.ctx
->module
, subpgm
.func
);
1339 static void dwarf2_load_one_entry(dwarf2_parse_context_t
* ctx
,
1340 dwarf2_debug_info_t
* di
,
1341 struct symt_compiland
* compiland
)
1343 switch (di
->abbrev
->tag
)
1345 case DW_TAG_typedef
:
1346 dwarf2_parse_typedef(ctx
, di
);
1348 case DW_TAG_base_type
:
1349 dwarf2_parse_base_type(ctx
, di
);
1351 case DW_TAG_pointer_type
:
1352 dwarf2_parse_pointer_type(ctx
, di
);
1354 case DW_TAG_class_type
:
1355 dwarf2_parse_udt_type(ctx
, di
, UdtClass
);
1357 case DW_TAG_structure_type
:
1358 dwarf2_parse_udt_type(ctx
, di
, UdtStruct
);
1360 case DW_TAG_union_type
:
1361 dwarf2_parse_udt_type(ctx
, di
, UdtUnion
);
1363 case DW_TAG_array_type
:
1364 dwarf2_parse_array_type(ctx
, di
);
1366 case DW_TAG_const_type
:
1367 dwarf2_parse_const_type(ctx
, di
);
1369 case DW_TAG_reference_type
:
1370 dwarf2_parse_reference_type(ctx
, di
);
1372 case DW_TAG_enumeration_type
:
1373 dwarf2_parse_enumeration_type(ctx
, di
);
1375 case DW_TAG_subprogram
:
1376 dwarf2_parse_subprogram(ctx
, di
, compiland
);
1379 WARN("Unhandled Tag type 0x%lx at %s, for %lu\n",
1380 di
->abbrev
->tag
, dwarf2_debug_ctx(ctx
), di
->abbrev
->entry_code
);
1384 static void dwarf2_set_line_number(struct module
* module
, unsigned long address
,
1385 struct vector
* v
, unsigned file
, unsigned line
)
1387 struct symt_function
* func
;
1391 if (!file
|| !(psrc
= vector_at(v
, file
- 1))) return;
1393 TRACE("%s %lx %s %u\n", module
->module
.ModuleName
, address
, source_get(module
, *psrc
), line
);
1394 if ((idx
= symt_find_nearest(module
, address
)) == -1 ||
1395 module
->addr_sorttab
[idx
]->symt
.tag
!= SymTagFunction
) return;
1396 func
= (struct symt_function
*)module
->addr_sorttab
[idx
];
1397 symt_add_func_line(module
, func
, *psrc
, line
, address
- func
->address
);
1400 static void dwarf2_parse_line_numbers(const dwarf2_section_t
* sections
,
1401 dwarf2_parse_context_t
* ctx
,
1402 unsigned long offset
)
1404 dwarf2_traverse_context_t traverse
;
1405 unsigned long length
;
1406 unsigned version
, header_len
, insn_size
, default_stmt
;
1407 unsigned line_range
, opcode_base
;
1409 const unsigned char* opcode_len
;
1411 struct vector files
;
1414 traverse
.sections
= sections
;
1415 traverse
.section
= section_line
;
1416 traverse
.data
= sections
[section_line
].address
+ offset
;
1417 traverse
.start_data
= traverse
.data
;
1418 traverse
.end_data
= traverse
.data
+ 4;
1419 traverse
.offset
= offset
;
1420 traverse
.word_size
= ctx
->word_size
;
1422 length
= dwarf2_parse_u4(&traverse
);
1423 traverse
.end_data
= traverse
.start_data
+ length
;
1425 version
= dwarf2_parse_u2(&traverse
);
1426 header_len
= dwarf2_parse_u4(&traverse
);
1427 insn_size
= dwarf2_parse_byte(&traverse
);
1428 default_stmt
= dwarf2_parse_byte(&traverse
);
1429 line_base
= (signed char)dwarf2_parse_byte(&traverse
);
1430 line_range
= dwarf2_parse_byte(&traverse
);
1431 opcode_base
= dwarf2_parse_byte(&traverse
);
1433 opcode_len
= traverse
.data
;
1434 traverse
.data
+= opcode_base
- 1;
1436 vector_init(&dirs
, sizeof(const char*), 4);
1437 p
= vector_add(&dirs
, &ctx
->pool
);
1439 while (*traverse
.data
)
1441 TRACE("Got include %s\n", (const char*)traverse
.data
);
1442 p
= vector_add(&dirs
, &ctx
->pool
);
1443 *p
= (const char *)traverse
.data
;
1444 traverse
.data
+= strlen((const char *)traverse
.data
) + 1;
1448 vector_init(&files
, sizeof(unsigned), 16);
1449 while (*traverse
.data
)
1451 unsigned int dir_index
, mod_time
, length
;
1456 name
= (const char*)traverse
.data
;
1457 traverse
.data
+= strlen(name
) + 1;
1458 dir_index
= dwarf2_leb128_as_unsigned(&traverse
);
1459 mod_time
= dwarf2_leb128_as_unsigned(&traverse
);
1460 length
= dwarf2_leb128_as_unsigned(&traverse
);
1461 dir
= *(const char**)vector_at(&dirs
, dir_index
);
1462 TRACE("Got file %s/%s (%u,%u)\n", dir
, name
, mod_time
, length
);
1463 psrc
= vector_add(&files
, &ctx
->pool
);
1464 *psrc
= source_new(ctx
->module
, dir
, name
);
1468 while (traverse
.data
< traverse
.end_data
)
1470 unsigned long address
= 0;
1473 unsigned is_stmt
= default_stmt
;
1474 BOOL basic_block
= FALSE
, end_sequence
= FALSE
;
1475 unsigned opcode
, extopcode
, i
;
1477 while (!end_sequence
)
1479 opcode
= dwarf2_parse_byte(&traverse
);
1480 TRACE("Got opcode %x\n", opcode
);
1482 if (opcode
>= opcode_base
)
1484 unsigned delta
= opcode
- opcode_base
;
1486 address
+= (delta
/ line_range
) * insn_size
;
1487 line
+= line_base
+ (delta
% line_range
);
1489 dwarf2_set_line_number(ctx
->module
, address
, &files
, file
, line
);
1496 basic_block
= FALSE
;
1497 dwarf2_set_line_number(ctx
->module
, address
, &files
, file
, line
);
1499 case DW_LNS_advance_pc
:
1500 address
+= insn_size
* dwarf2_leb128_as_unsigned(&traverse
);
1502 case DW_LNS_advance_line
:
1503 line
+= dwarf2_leb128_as_signed(&traverse
);
1505 case DW_LNS_set_file
:
1506 file
= dwarf2_leb128_as_unsigned(&traverse
);
1508 case DW_LNS_set_column
:
1509 dwarf2_leb128_as_unsigned(&traverse
);
1511 case DW_LNS_negate_stmt
:
1514 case DW_LNS_set_basic_block
:
1517 case DW_LNS_const_add_pc
:
1518 address
+= ((255 - opcode_base
) / line_range
) * insn_size
;
1520 case DW_LNS_fixed_advance_pc
:
1521 address
+= dwarf2_parse_u2(&traverse
);
1523 case DW_LNS_extended_op
:
1524 dwarf2_leb128_as_unsigned(&traverse
);
1525 extopcode
= dwarf2_parse_byte(&traverse
);
1528 case DW_LNE_end_sequence
:
1529 dwarf2_set_line_number(ctx
->module
, address
, &files
, file
, line
);
1530 end_sequence
= TRUE
;
1532 case DW_LNE_set_address
:
1533 address
= ctx
->module
->module
.BaseOfImage
+ dwarf2_parse_addr(&traverse
);
1535 case DW_LNE_define_file
:
1536 FIXME("not handled %s\n", traverse
.data
);
1537 traverse
.data
+= strlen((const char *)traverse
.data
) + 1;
1538 dwarf2_leb128_as_unsigned(&traverse
);
1539 dwarf2_leb128_as_unsigned(&traverse
);
1540 dwarf2_leb128_as_unsigned(&traverse
);
1543 FIXME("Unsupported extended opcode %x\n", extopcode
);
1548 WARN("Unsupported opcode %x\n", opcode
);
1549 for (i
= 0; i
< opcode_len
[opcode
]; i
++)
1550 dwarf2_leb128_as_unsigned(&traverse
);
1558 static BOOL
dwarf2_parse_compilation_unit(const dwarf2_section_t
* sections
,
1559 const dwarf2_comp_unit_t
* comp_unit
,
1560 struct module
* module
,
1561 const unsigned char* comp_unit_cursor
)
1563 dwarf2_parse_context_t ctx
;
1564 dwarf2_traverse_context_t traverse
;
1565 dwarf2_traverse_context_t abbrev_ctx
;
1566 dwarf2_debug_info_t
* di
;
1569 TRACE("Compilation Unit Header found at 0x%x:\n",
1570 comp_unit_cursor
- sections
[section_debug
].address
);
1571 TRACE("- length: %lu\n", comp_unit
->length
);
1572 TRACE("- version: %u\n", comp_unit
->version
);
1573 TRACE("- abbrev_offset: %lu\n", comp_unit
->abbrev_offset
);
1574 TRACE("- word_size: %u\n", comp_unit
->word_size
);
1576 if (comp_unit
->version
!= 2)
1578 WARN("%u DWARF version unsupported. Wine dbghelp only support DWARF 2.\n",
1579 comp_unit
->version
);
1583 pool_init(&ctx
.pool
, 65536);
1584 ctx
.module
= module
;
1585 ctx
.word_size
= comp_unit
->word_size
;
1587 traverse
.sections
= sections
;
1588 traverse
.section
= section_debug
;
1589 traverse
.start_data
= comp_unit_cursor
+ sizeof(dwarf2_comp_unit_stream_t
);
1590 traverse
.data
= traverse
.start_data
;
1591 traverse
.offset
= comp_unit_cursor
- sections
[section_debug
].address
;
1592 traverse
.word_size
= comp_unit
->word_size
;
1593 traverse
.end_data
= comp_unit_cursor
+ comp_unit
->length
+ sizeof(unsigned);
1595 abbrev_ctx
.sections
= sections
;
1596 abbrev_ctx
.section
= section_abbrev
;
1597 abbrev_ctx
.start_data
= sections
[section_abbrev
].address
+ comp_unit
->abbrev_offset
;
1598 abbrev_ctx
.data
= abbrev_ctx
.start_data
;
1599 abbrev_ctx
.end_data
= sections
[section_abbrev
].address
+ sections
[section_abbrev
].size
;
1600 abbrev_ctx
.offset
= comp_unit
->abbrev_offset
;
1601 abbrev_ctx
.word_size
= comp_unit
->word_size
;
1602 dwarf2_parse_abbrev_set(&abbrev_ctx
, &ctx
.abbrev_table
, &ctx
.pool
);
1604 sparse_array_init(&ctx
.debug_info_table
, sizeof(dwarf2_debug_info_t
), 128);
1605 dwarf2_read_one_debug_info(&ctx
, &traverse
, &di
);
1607 if (di
->abbrev
->tag
== DW_TAG_compile_unit
)
1609 union attribute name
;
1610 dwarf2_debug_info_t
** pdi
= NULL
;
1611 union attribute stmt_list
;
1613 TRACE("beginning at 0x%lx, for %lu\n", di
->offset
, di
->abbrev
->entry_code
);
1615 dwarf2_find_name(&ctx
, di
, &name
, "compiland");
1616 di
->symt
= &symt_new_compiland(module
, source_new(module
, NULL
, name
.string
))->symt
;
1618 if (di
->abbrev
->have_child
)
1620 while ((pdi
= vector_iter_up(&di
->children
, pdi
)))
1622 dwarf2_load_one_entry(&ctx
, *pdi
, (struct symt_compiland
*)di
->symt
);
1625 if (dwarf2_find_attribute(di
, DW_AT_stmt_list
, &stmt_list
))
1627 dwarf2_parse_line_numbers(sections
, &ctx
, stmt_list
.uvalue
);
1631 else FIXME("Should have a compilation unit here\n");
1632 pool_destroy(&ctx
.pool
);
1636 BOOL
dwarf2_parse(struct module
* module
, unsigned long load_offset
,
1637 const unsigned char* debug
, unsigned int debug_size
,
1638 const unsigned char* abbrev
, unsigned int abbrev_size
,
1639 const unsigned char* str
, unsigned int str_size
,
1640 const unsigned char* line
, unsigned int line_size
)
1642 dwarf2_section_t section
[section_max
];
1643 const unsigned char*comp_unit_cursor
= debug
;
1644 const unsigned char*end_debug
= debug
+ debug_size
;
1646 section
[section_debug
].address
= debug
;
1647 section
[section_debug
].size
= debug_size
;
1648 section
[section_abbrev
].address
= abbrev
;
1649 section
[section_abbrev
].size
= abbrev_size
;
1650 section
[section_string
].address
= str
;
1651 section
[section_string
].size
= str_size
;
1652 section
[section_line
].address
= line
;
1653 section
[section_line
].size
= line_size
;
1655 while (comp_unit_cursor
< end_debug
)
1657 const dwarf2_comp_unit_stream_t
* comp_unit_stream
;
1658 dwarf2_comp_unit_t comp_unit
;
1660 comp_unit_stream
= (const dwarf2_comp_unit_stream_t
*) comp_unit_cursor
;
1661 comp_unit
.length
= *(unsigned long*) comp_unit_stream
->length
;
1662 comp_unit
.version
= *(unsigned short*) comp_unit_stream
->version
;
1663 comp_unit
.abbrev_offset
= *(unsigned long*) comp_unit_stream
->abbrev_offset
;
1664 comp_unit
.word_size
= *(unsigned char*) comp_unit_stream
->word_size
;
1666 dwarf2_parse_compilation_unit(section
, &comp_unit
, module
, comp_unit_cursor
);
1667 comp_unit_cursor
+= comp_unit
.length
+ sizeof(unsigned);
1669 module
->module
.SymType
= SymDia
;