?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
crypt32: Don't fail chain creation if signature doesn't match.
[wine/wine64.git] / dlls / dbghelp / dwarf.c
blob66c761c3626c0b01474b83b9f0f75e5d32c25a2b
1 /*
2 * File dwarf.c - read dwarf2 information from the ELF modules
3 *
4 * Copyright (C) 2005, Raphael Junqueira
5 * Copyright (C) 2006, Eric Pouech
6 *
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.
11 *
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.
16 *
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
20 */
21
22 #include "config.h"
23
24 #include <sys/types.h>
25 #include <fcntl.h>
26 #ifdef HAVE_SYS_STAT_H
27 # include <sys/stat.h>
28 #endif
29 #ifdef HAVE_SYS_MMAN_H
30 #include <sys/mman.h>
31 #endif
32 #include <limits.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #ifdef HAVE_UNISTD_H
36 # include <unistd.h>
37 #endif
38 #include <stdio.h>
39 #ifndef PATH_MAX
40 #define PATH_MAX MAX_PATH
41 #endif
42 #include <assert.h>
43 #include <stdarg.h>
44
45 #include "windef.h"
46 #include "winbase.h"
47 #include "winuser.h"
48 #include "ole2.h"
49 #include "oleauto.h"
50
51 #include "dbghelp_private.h"
52
53 #include "wine/debug.h"
54
55 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_dwarf);
56
57 /* FIXME:
58 * - Functions:
59 * o unspecified parameters
60 * o inlined functions
61 * o Debug{Start|End}Point
62 * o CFA
63 * - Udt
64 * o proper types loading (nesting)
65 */
66
67 #if 0
68 static void dump(const void* ptr, unsigned len)
69 {
70 int i, j;
71 BYTE msg[128];
72 static const char hexof[] = "0123456789abcdef";
73 const BYTE* x = (const BYTE*)ptr;
74
75 for (i = 0; i < len; i += 16)
76 {
77 sprintf(msg, "%08x: ", i);
78 memset(msg + 10, ' ', 3 * 16 + 1 + 16);
79 for (j = 0; j < min(16, len - i); j++)
80 {
81 msg[10 + 3 * j + 0] = hexof[x[i + j] >> 4];
82 msg[10 + 3 * j + 1] = hexof[x[i + j] & 15];
83 msg[10 + 3 * j + 2] = ' ';
84 msg[10 + 3 * 16 + 1 + j] = (x[i + j] >= 0x20 && x[i + j] < 0x7f) ?
85 x[i + j] : '.';
86 }
87 msg[10 + 3 * 16] = ' ';
88 msg[10 + 3 * 16 + 1 + 16] = '\0';
89 TRACE("%s\n", msg);
90 }
91 }
92 #endif
93
94 /**
95 *
96 * Main Specs:
97 * http://www.eagercon.com/dwarf/dwarf3std.htm
98 * http://www.eagercon.com/dwarf/dwarf-2.0.0.pdf
99 *
100 * dwarf2.h: http://www.hakpetzna.com/b/binutils/dwarf2_8h-source.html
101 *
102 * example of projects who do dwarf2 parsing:
103 * http://www.x86-64.org/cgi-bin/cvsweb.cgi/binutils.dead/binutils/readelf.c?rev=1.1.1.2
104 * http://elis.ugent.be/diota/log/ltrace_elf.c
105 */
106 #include "dwarf.h"
107
108 /**
109 * Parsers
110 */
111
112 typedef struct dwarf2_abbrev_entry_attr_s
113 {
114 unsigned long attribute;
115 unsigned long form;
116 struct dwarf2_abbrev_entry_attr_s* next;
117 } dwarf2_abbrev_entry_attr_t;
118
119 typedef struct dwarf2_abbrev_entry_s
120 {
121 unsigned long entry_code;
122 unsigned long tag;
123 unsigned char have_child;
124 unsigned num_attr;
125 dwarf2_abbrev_entry_attr_t* attrs;
126 } dwarf2_abbrev_entry_t;
127
128 struct dwarf2_block
129 {
130 unsigned size;
131 const unsigned char* ptr;
132 };
133
134 struct attribute
135 {
136 unsigned long form;
137 union
138 {
139 unsigned long uvalue;
140 long svalue;
141 const char* string;
142 struct dwarf2_block block;
143 } u;
144 };
145
146 typedef struct dwarf2_debug_info_s
147 {
148 const dwarf2_abbrev_entry_t*abbrev;
149 struct symt* symt;
150 const unsigned char** data;
151 struct vector children;
152 } dwarf2_debug_info_t;
153
154 typedef struct dwarf2_section_s
155 {
156 const unsigned char* address;
157 unsigned size;
158 } dwarf2_section_t;
159
160 enum dwarf2_sections {section_debug, section_string, section_abbrev, section_line, section_max};
161
162 typedef struct dwarf2_traverse_context_s
163 {
164 const unsigned char* data;
165 const unsigned char* start_data;
166 const unsigned char* end_data;
167 unsigned char word_size;
168 } dwarf2_traverse_context_t;
169
170 typedef struct dwarf2_parse_context_s
171 {
172 const dwarf2_section_t* sections;
173 unsigned section;
174 struct pool pool;
175 struct module* module;
176 const struct elf_thunk_area*thunks;
177 struct sparse_array abbrev_table;
178 struct sparse_array debug_info_table;
179 unsigned long load_offset;
180 unsigned long ref_offset;
181 unsigned char word_size;
182 } dwarf2_parse_context_t;
183
184 /* stored in the dbghelp's module internal structure for later reuse */
185 struct dwarf2_module_info_s
186 {
187 dwarf2_section_t debug_loc;
188 };
189
190 #define loc_dwarf2_location_list (loc_user + 0)
191 #define loc_dwarf2_block (loc_user + 1)
192
193 /* forward declarations */
194 static struct symt* dwarf2_parse_enumeration_type(dwarf2_parse_context_t* ctx, dwarf2_debug_info_t* entry);
195
196 static unsigned char dwarf2_get_byte(const unsigned char* ptr)
197 {
198 return *ptr;
199 }
200
201 static unsigned char dwarf2_parse_byte(dwarf2_traverse_context_t* ctx)
202 {
203 unsigned char uvalue = dwarf2_get_byte(ctx->data);
204 ctx->data += 1;
205 return uvalue;
206 }
207
208 static unsigned short dwarf2_get_u2(const unsigned char* ptr)
209 {
210 return *(const unsigned short*)ptr;
211 }
212
213 static unsigned short dwarf2_parse_u2(dwarf2_traverse_context_t* ctx)
214 {
215 unsigned short uvalue = dwarf2_get_u2(ctx->data);
216 ctx->data += 2;
217 return uvalue;
218 }
219
220 static unsigned long dwarf2_get_u4(const unsigned char* ptr)
221 {
222 return *(const unsigned long*)ptr;
223 }
224
225 static unsigned long dwarf2_parse_u4(dwarf2_traverse_context_t* ctx)
226 {
227 unsigned long uvalue = dwarf2_get_u4(ctx->data);
228 ctx->data += 4;
229 return uvalue;
230 }
231
232 static unsigned long dwarf2_get_leb128_as_unsigned(const unsigned char* ptr, const unsigned char** end)
233 {
234 unsigned long ret = 0;
235 unsigned char byte;
236 unsigned shift = 0;
237
238 do
239 {
240 byte = dwarf2_get_byte(ptr++);
241 ret |= (byte & 0x7f) << shift;
242 shift += 7;
243 } while (byte & 0x80);
244
245 if (end) *end = ptr;
246 return ret;
247 }
248
249 static unsigned long dwarf2_leb128_as_unsigned(dwarf2_traverse_context_t* ctx)
250 {
251 unsigned long ret;
252
253 assert(ctx);
254
255 ret = dwarf2_get_leb128_as_unsigned(ctx->data, &ctx->data);
256
257 return ret;
258 }
259
260 static long dwarf2_get_leb128_as_signed(const unsigned char* ptr, const unsigned char** end)
261 {
262 long ret = 0;
263 unsigned char byte;
264 unsigned shift = 0;
265 const unsigned size = sizeof(int) * 8;
266
267 do
268 {
269 byte = dwarf2_get_byte(ptr++);
270 ret |= (byte & 0x7f) << shift;
271 shift += 7;
272 } while (byte & 0x80);
273 if (end) *end = ptr;
274
275 /* as spec: sign bit of byte is 2nd high order bit (80x40)
276 * -> 0x80 is used as flag.
277 */
278 if ((shift < size) && (byte & 0x40))
279 {
280 ret |= - (1 << shift);
281 }
282 return ret;
283 }
284
285 static long dwarf2_leb128_as_signed(dwarf2_traverse_context_t* ctx)
286 {
287 long ret = 0;
288
289 assert(ctx);
290
291 ret = dwarf2_get_leb128_as_signed(ctx->data, &ctx->data);
292 return ret;
293 }
294
295 static unsigned dwarf2_leb128_length(const dwarf2_traverse_context_t* ctx)
296 {
297 unsigned ret;
298 for (ret = 0; ctx->data[ret] & 0x80; ret++);
299 return ret + 1;
300 }
301
302 static unsigned long dwarf2_get_addr(const unsigned char* ptr, unsigned word_size)
303 {
304 unsigned long ret;
305
306 switch (word_size)
307 {
308 case 4:
309 ret = dwarf2_get_u4(ptr);
310 break;
311 default:
312 FIXME("Unsupported Word Size %u\n", word_size);
313 ret = 0;
314 }
315 return ret;
316 }
317
318 static unsigned long dwarf2_parse_addr(dwarf2_traverse_context_t* ctx)
319 {
320 unsigned long ret = dwarf2_get_addr(ctx->data, ctx->word_size);
321 ctx->data += ctx->word_size;
322 return ret;
323 }
324
325 static const char* dwarf2_debug_traverse_ctx(const dwarf2_traverse_context_t* ctx)
326 {
327 return wine_dbg_sprintf("ctx(%p)", ctx->data);
328 }
329
330 static const char* dwarf2_debug_ctx(const dwarf2_parse_context_t* ctx)
331 {
332 return wine_dbg_sprintf("ctx(%p,%s)",
333 ctx, debugstr_w(ctx->module->module.ModuleName));
334 }
335
336 static const char* dwarf2_debug_di(const dwarf2_debug_info_t* di)
337 {
338 return wine_dbg_sprintf("debug_info(abbrev:%p,symt:%p)",
339 di->abbrev, di->symt);
340 }
341
342 static dwarf2_abbrev_entry_t*
343 dwarf2_abbrev_table_find_entry(const struct sparse_array* abbrev_table,
344 unsigned long entry_code)
345 {
346 assert( NULL != abbrev_table );
347 return sparse_array_find(abbrev_table, entry_code);
348 }
349
350 static void dwarf2_parse_abbrev_set(dwarf2_traverse_context_t* abbrev_ctx,
351 struct sparse_array* abbrev_table,
352 struct pool* pool)
353 {
354 unsigned long entry_code;
355 dwarf2_abbrev_entry_t* abbrev_entry;
356 dwarf2_abbrev_entry_attr_t* new = NULL;
357 dwarf2_abbrev_entry_attr_t* last = NULL;
358 unsigned long attribute;
359 unsigned long form;
360
361 assert( NULL != abbrev_ctx );
362
363 TRACE("%s, end at %p\n",
364 dwarf2_debug_traverse_ctx(abbrev_ctx), abbrev_ctx->end_data);
365
366 sparse_array_init(abbrev_table, sizeof(dwarf2_abbrev_entry_t), 32);
367 while (abbrev_ctx->data < abbrev_ctx->end_data)
368 {
369 TRACE("now at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx));
370 entry_code = dwarf2_leb128_as_unsigned(abbrev_ctx);
371 TRACE("found entry_code %lu\n", entry_code);
372 if (!entry_code)
373 {
374 TRACE("NULL entry code at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx));
375 break;
376 }
377 abbrev_entry = sparse_array_add(abbrev_table, entry_code, pool);
378 assert( NULL != abbrev_entry );
379
380 abbrev_entry->entry_code = entry_code;
381 abbrev_entry->tag = dwarf2_leb128_as_unsigned(abbrev_ctx);
382 abbrev_entry->have_child = dwarf2_parse_byte(abbrev_ctx);
383 abbrev_entry->attrs = NULL;
384 abbrev_entry->num_attr = 0;
385
386 TRACE("table:(%p,#%u) entry_code(%lu) tag(0x%lx) have_child(%u) -> %p\n",
387 abbrev_table, sparse_array_length(abbrev_table),
388 entry_code, abbrev_entry->tag, abbrev_entry->have_child, abbrev_entry);
389
390 last = NULL;
391 while (1)
392 {
393 attribute = dwarf2_leb128_as_unsigned(abbrev_ctx);
394 form = dwarf2_leb128_as_unsigned(abbrev_ctx);
395 if (!attribute) break;
396
397 new = pool_alloc(pool, sizeof(dwarf2_abbrev_entry_attr_t));
398 assert(new);
399
400 new->attribute = attribute;
401 new->form = form;
402 new->next = NULL;
403 if (abbrev_entry->attrs) last->next = new;
404 else abbrev_entry->attrs = new;
405 last = new;
406 abbrev_entry->num_attr++;
407 }
408 }
409 TRACE("found %u entries\n", sparse_array_length(abbrev_table));
410 }
411
412 static void dwarf2_swallow_attribute(dwarf2_traverse_context_t* ctx,
413 const dwarf2_abbrev_entry_attr_t* abbrev_attr)
414 {
415 unsigned step;
416
417 TRACE("(attr:0x%lx,form:0x%lx)\n", abbrev_attr->attribute, abbrev_attr->form);
418
419 switch (abbrev_attr->form)
420 {
421 case DW_FORM_ref_addr:
422 case DW_FORM_addr: step = ctx->word_size; break;
423 case DW_FORM_flag:
424 case DW_FORM_data1:
425 case DW_FORM_ref1: step = 1; break;
426 case DW_FORM_data2:
427 case DW_FORM_ref2: step = 2; break;
428 case DW_FORM_data4:
429 case DW_FORM_ref4:
430 case DW_FORM_strp: step = 4; break;
431 case DW_FORM_data8:
432 case DW_FORM_ref8: step = 8; break;
433 case DW_FORM_sdata:
434 case DW_FORM_ref_udata:
435 case DW_FORM_udata: step = dwarf2_leb128_length(ctx); break;
436 case DW_FORM_string: step = strlen((const char*)ctx->data) + 1; break;
437 case DW_FORM_block: step = dwarf2_leb128_as_unsigned(ctx); break;
438 case DW_FORM_block1: step = dwarf2_parse_byte(ctx); break;
439 case DW_FORM_block2: step = dwarf2_parse_u2(ctx); break;
440 case DW_FORM_block4: step = dwarf2_parse_u4(ctx); break;
441 default:
442 FIXME("Unhandled attribute form %lx\n", abbrev_attr->form);
443 return;
444 }
445 ctx->data += step;
446 }
447
448 static void dwarf2_fill_attr(const dwarf2_parse_context_t* ctx,
449 const dwarf2_abbrev_entry_attr_t* abbrev_attr,
450 const unsigned char* data,
451 struct attribute* attr)
452 {
453 attr->form = abbrev_attr->form;
454 switch (attr->form)
455 {
456 case DW_FORM_ref_addr:
457 case DW_FORM_addr:
458 attr->u.uvalue = dwarf2_get_addr(data, ctx->word_size);
459 TRACE("addr<0x%lx>\n", attr->u.uvalue);
460 break;
461
462 case DW_FORM_flag:
463 attr->u.uvalue = dwarf2_get_byte(data);
464 TRACE("flag<0x%lx>\n", attr->u.uvalue);
465 break;
466
467 case DW_FORM_data1:
468 attr->u.uvalue = dwarf2_get_byte(data);
469 TRACE("data1<%lu>\n", attr->u.uvalue);
470 break;
471
472 case DW_FORM_data2:
473 attr->u.uvalue = dwarf2_get_u2(data);
474 TRACE("data2<%lu>\n", attr->u.uvalue);
475 break;
476
477 case DW_FORM_data4:
478 attr->u.uvalue = dwarf2_get_u4(data);
479 TRACE("data4<%lu>\n", attr->u.uvalue);
480 break;
481
482 case DW_FORM_data8:
483 FIXME("Unhandled 64bits support\n");
484 break;
485
486 case DW_FORM_ref1:
487 attr->u.uvalue = ctx->ref_offset + dwarf2_get_byte(data);
488 TRACE("ref1<0x%lx>\n", attr->u.uvalue);
489 break;
490
491 case DW_FORM_ref2:
492 attr->u.uvalue = ctx->ref_offset + dwarf2_get_u2(data);
493 TRACE("ref2<0x%lx>\n", attr->u.uvalue);
494 break;
495
496 case DW_FORM_ref4:
497 attr->u.uvalue = ctx->ref_offset + dwarf2_get_u4(data);
498 TRACE("ref4<0x%lx>\n", attr->u.uvalue);
499 break;
500
501 case DW_FORM_ref8:
502 FIXME("Unhandled 64 bit support\n");
503 break;
504
505 case DW_FORM_sdata:
506 attr->u.svalue = dwarf2_get_leb128_as_signed(data, NULL);
507 break;
508
509 case DW_FORM_ref_udata:
510 attr->u.uvalue = dwarf2_get_leb128_as_unsigned(data, NULL);
511 break;
512
513 case DW_FORM_udata:
514 attr->u.uvalue = dwarf2_get_leb128_as_unsigned(data, NULL);
515 break;
516
517 case DW_FORM_string:
518 attr->u.string = (const char *)data;
519 TRACE("string<%s>\n", attr->u.string);
520 break;
521
522 case DW_FORM_strp:
523 {
524 unsigned long offset = dwarf2_get_u4(data);
525 attr->u.string = (const char*)ctx->sections[section_string].address + offset;
526 }
527 TRACE("strp<%s>\n", attr->u.string);
528 break;
529
530 case DW_FORM_block:
531 attr->u.block.size = dwarf2_get_leb128_as_unsigned(data, &attr->u.block.ptr);
532 break;
533
534 case DW_FORM_block1:
535 attr->u.block.size = dwarf2_get_byte(data);
536 attr->u.block.ptr = data + 1;
537 break;
538
539 case DW_FORM_block2:
540 attr->u.block.size = dwarf2_get_u2(data);
541 attr->u.block.ptr = data + 2;
542 break;
543
544 case DW_FORM_block4:
545 attr->u.block.size = dwarf2_get_u4(data);
546 attr->u.block.ptr = data + 4;
547 break;
548
549 default:
550 FIXME("Unhandled attribute form %lx\n", abbrev_attr->form);
551 break;
552 }
553 }
554
555 static BOOL dwarf2_find_attribute(const dwarf2_parse_context_t* ctx,
556 const dwarf2_debug_info_t* di,
557 unsigned at, struct attribute* attr)
558 {
559 unsigned i, ai = 0;
560 dwarf2_abbrev_entry_attr_t* abbrev_attr;
561 dwarf2_abbrev_entry_attr_t* abstract_abbrev_attr;
562
563 while (di)
564 {
565 abstract_abbrev_attr = NULL;
566 for (i = 0, abbrev_attr = di->abbrev->attrs; abbrev_attr; i++, abbrev_attr = abbrev_attr->next)
567 {
568 if (abbrev_attr->attribute == at)
569 {
570 dwarf2_fill_attr(ctx, abbrev_attr, di->data[i], attr);
571 return TRUE;
572 }
573 if (abbrev_attr->attribute == DW_AT_abstract_origin &&
574 at != DW_AT_sibling)
575 {
576 abstract_abbrev_attr = abbrev_attr;
577 ai = i;
578 }
579 }
580 /* do we have an abstract origin debug entry to look into ? */
581 if (!abstract_abbrev_attr) break;
582 dwarf2_fill_attr(ctx, abstract_abbrev_attr, di->data[ai], attr);
583 if (!(di = sparse_array_find(&ctx->debug_info_table, attr->u.uvalue)))
584 FIXME("Should have found the debug info entry\n");
585 }
586 return FALSE;
587 }
588
589 static void dwarf2_load_one_entry(dwarf2_parse_context_t*, dwarf2_debug_info_t*,
590 struct symt_compiland*);
591
592 #define Wine_DW_no_register 0x7FFFFFFF
593
594 static unsigned dwarf2_map_register(int regno)
595 {
596 unsigned reg;
597
598 switch (regno)
599 {
600 case Wine_DW_no_register: FIXME("What the heck map reg 0x%x\n",regno); reg = 0; break;
601 case 0: reg = CV_REG_EAX; break;
602 case 1: reg = CV_REG_ECX; break;
603 case 2: reg = CV_REG_EDX; break;
604 case 3: reg = CV_REG_EBX; break;
605 case 4: reg = CV_REG_ESP; break;
606 case 5: reg = CV_REG_EBP; break;
607 case 6: reg = CV_REG_ESI; break;
608 case 7: reg = CV_REG_EDI; break;
609 case 8: reg = CV_REG_EIP; break;
610 case 9: reg = CV_REG_EFLAGS; break;
611 case 10: reg = CV_REG_CS; break;
612 case 11: reg = CV_REG_SS; break;
613 case 12: reg = CV_REG_DS; break;
614 case 13: reg = CV_REG_ES; break;
615 case 14: reg = CV_REG_FS; break;
616 case 15: reg = CV_REG_GS; break;
617 case 16: case 17: case 18: case 19:
618 case 20: case 21: case 22: case 23:
619 reg = CV_REG_ST0 + regno - 16; break;
620 case 24: reg = CV_REG_CTRL; break;
621 case 25: reg = CV_REG_STAT; break;
622 case 26: reg = CV_REG_TAG; break;
623 /*
624 reg: fiseg 27
625 reg: fioff 28
626 reg: foseg 29
627 reg: fooff 30
628 reg: fop 31
629 */
630 case 32: case 33: case 34: case 35:
631 case 36: case 37: case 38: case 39:
632 reg = CV_REG_XMM0 + regno - 32; break;
633 case 40: reg = CV_REG_MXCSR; break;
634 default:
635 FIXME("Don't know how to map register %d\n", regno);
636 return 0;
637 }
638 return reg;
639 }
640
641 static enum location_error
642 compute_location(dwarf2_traverse_context_t* ctx, struct location* loc,
643 HANDLE hproc, const struct location* frame)
644 {
645 unsigned long stack[64];
646 unsigned stk;
647 unsigned char op;
648 BOOL piece_found = FALSE;
649
650 stack[stk = 0] = 0;
651
652 loc->kind = loc_absolute;
653 loc->reg = Wine_DW_no_register;
654
655 while (ctx->data < ctx->end_data)
656 {
657 op = dwarf2_parse_byte(ctx);
658 switch (op)
659 {
660 case DW_OP_addr: stack[++stk] = dwarf2_parse_addr(ctx); break;
661 case DW_OP_const1u: stack[++stk] = dwarf2_parse_byte(ctx); break;
662 case DW_OP_const1s: stack[++stk] = (long)(signed char)dwarf2_parse_byte(ctx); break;
663 case DW_OP_const2u: stack[++stk] = dwarf2_parse_u2(ctx); break;
664 case DW_OP_const2s: stack[++stk] = (long)(short)dwarf2_parse_u2(ctx); break;
665 case DW_OP_const4u: stack[++stk] = dwarf2_parse_u4(ctx); break;
666 case DW_OP_const4s: stack[++stk] = dwarf2_parse_u4(ctx); break;
667 case DW_OP_constu: stack[++stk] = dwarf2_leb128_as_unsigned(ctx); break;
668 case DW_OP_consts: stack[++stk] = dwarf2_leb128_as_signed(ctx); break;
669 case DW_OP_plus_uconst:
670 stack[stk] += dwarf2_leb128_as_unsigned(ctx); break;
671 case DW_OP_reg0: case DW_OP_reg1: case DW_OP_reg2: case DW_OP_reg3:
672 case DW_OP_reg4: case DW_OP_reg5: case DW_OP_reg6: case DW_OP_reg7:
673 case DW_OP_reg8: case DW_OP_reg9: case DW_OP_reg10: case DW_OP_reg11:
674 case DW_OP_reg12: case DW_OP_reg13: case DW_OP_reg14: case DW_OP_reg15:
675 case DW_OP_reg16: case DW_OP_reg17: case DW_OP_reg18: case DW_OP_reg19:
676 case DW_OP_reg20: case DW_OP_reg21: case DW_OP_reg22: case DW_OP_reg23:
677 case DW_OP_reg24: case DW_OP_reg25: case DW_OP_reg26: case DW_OP_reg27:
678 case DW_OP_reg28: case DW_OP_reg29: case DW_OP_reg30: case DW_OP_reg31:
679 /* dbghelp APIs don't know how to cope with this anyway
680 * (for example 'long long' stored in two registers)
681 * FIXME: We should tell winedbg how to deal with it (sigh)
682 */
683 if (!piece_found)
684 {
685 if (loc->reg != Wine_DW_no_register)
686 FIXME("Only supporting one reg (%d -> %d)\n",
687 loc->reg, dwarf2_map_register(op - DW_OP_reg0));
688 loc->reg = dwarf2_map_register(op - DW_OP_reg0);
689 }
690 loc->kind = loc_register;
691 break;
692 case DW_OP_breg0: case DW_OP_breg1: case DW_OP_breg2: case DW_OP_breg3:
693 case DW_OP_breg4: case DW_OP_breg5: case DW_OP_breg6: case DW_OP_breg7:
694 case DW_OP_breg8: case DW_OP_breg9: case DW_OP_breg10: case DW_OP_breg11:
695 case DW_OP_breg12: case DW_OP_breg13: case DW_OP_breg14: case DW_OP_breg15:
696 case DW_OP_breg16: case DW_OP_breg17: case DW_OP_breg18: case DW_OP_breg19:
697 case DW_OP_breg20: case DW_OP_breg21: case DW_OP_breg22: case DW_OP_breg23:
698 case DW_OP_breg24: case DW_OP_breg25: case DW_OP_breg26: case DW_OP_breg27:
699 case DW_OP_breg28: case DW_OP_breg29: case DW_OP_breg30: case DW_OP_breg31:
700 /* dbghelp APIs don't know how to cope with this anyway
701 * (for example 'long long' stored in two registers)
702 * FIXME: We should tell winedbg how to deal with it (sigh)
703 */
704 if (!piece_found)
705 {
706 if (loc->reg != Wine_DW_no_register)
707 FIXME("Only supporting one reg (%d -> %d)\n",
708 loc->reg, dwarf2_map_register(op - DW_OP_breg0));
709 loc->reg = dwarf2_map_register(op - DW_OP_breg0);
710 }
711 stack[++stk] = dwarf2_leb128_as_signed(ctx);
712 loc->kind = loc_regrel;
713 break;
714 case DW_OP_fbreg:
715 if (loc->reg != Wine_DW_no_register)
716 FIXME("Only supporting one reg (%d -> -2)\n", loc->reg);
717 if (frame && frame->kind == loc_register)
718 {
719 loc->kind = loc_regrel;
720 loc->reg = frame->reg;
721 stack[++stk] = dwarf2_leb128_as_signed(ctx);
722 }
723 else if (frame && frame->kind == loc_regrel)
724 {
725 loc->kind = loc_regrel;
726 loc->reg = frame->reg;
727 stack[++stk] = dwarf2_leb128_as_signed(ctx) + frame->offset;
728 }
729 else
730 {
731 /* FIXME: this could be later optimized by not recomputing
732 * this very location expression
733 */
734 loc->kind = loc_dwarf2_block;
735 stack[++stk] = dwarf2_leb128_as_signed(ctx);
736 }
737 break;
738 case DW_OP_piece:
739 {
740 unsigned sz = dwarf2_leb128_as_unsigned(ctx);
741 WARN("Not handling OP_piece (size=%d)\n", sz);
742 piece_found = TRUE;
743 }
744 break;
745 case DW_OP_deref:
746 if (!stk)
747 {
748 FIXME("Unexpected empty stack\n");
749 return loc_err_internal;
750 }
751 if (loc->reg != Wine_DW_no_register)
752 {
753 WARN("Too complex expression for deref\n");
754 return loc_err_too_complex;
755 }
756 if (hproc)
757 {
758 DWORD addr = stack[stk--];
759 DWORD deref;
760
761 if (!ReadProcessMemory(hproc, (void*)addr, &deref, sizeof(deref), NULL))
762 {
763 WARN("Couldn't read memory at %x\n", addr);
764 return loc_err_cant_read;
765 }
766 stack[++stk] = deref;
767 }
768 else
769 {
770 loc->kind = loc_dwarf2_block;
771 }
772 break;
773 default:
774 FIXME("Unhandled attr op: %x\n", op);
775 return loc_err_internal;
776 }
777 }
778 loc->offset = stack[stk];
779 return 0;
780 }
781
782 static BOOL dwarf2_compute_location_attr(dwarf2_parse_context_t* ctx,
783 const dwarf2_debug_info_t* di,
784 unsigned long dw,
785 struct location* loc,
786 const struct location* frame)
787 {
788 struct attribute xloc;
789
790 if (!dwarf2_find_attribute(ctx, di, dw, &xloc)) return FALSE;
791
792 switch (xloc.form)
793 {
794 case DW_FORM_data1: case DW_FORM_data2:
795 case DW_FORM_udata: case DW_FORM_sdata:
796 loc->kind = loc_absolute;
797 loc->reg = 0;
798 loc->offset = xloc.u.uvalue;
799 return TRUE;
800 case DW_FORM_data4: case DW_FORM_data8:
801 loc->kind = loc_dwarf2_location_list;
802 loc->reg = Wine_DW_no_register;
803 loc->offset = xloc.u.uvalue;
804 return TRUE;
805 }
806
807 /* assume we have a block form */
808
809 if (xloc.u.block.size)
810 {
811 dwarf2_traverse_context_t lctx;
812 enum location_error err;
813
814 lctx.data = xloc.u.block.ptr;
815 lctx.end_data = xloc.u.block.ptr + xloc.u.block.size;
816 lctx.word_size = ctx->word_size;
817
818 err = compute_location(&lctx, loc, NULL, frame);
819 if (err < 0)
820 {
821 loc->kind = loc_error;
822 loc->reg = err;
823 }
824 else if (loc->kind == loc_dwarf2_block)
825 {
826 unsigned* ptr = pool_alloc(&ctx->module->pool,
827 sizeof(unsigned) + xloc.u.block.size);
828 *ptr = xloc.u.block.size;
829 memcpy(ptr + 1, xloc.u.block.ptr, xloc.u.block.size);
830 loc->offset = (unsigned long)ptr;
831 }
832 }
833 return TRUE;
834 }
835
836 static struct symt* dwarf2_lookup_type(dwarf2_parse_context_t* ctx,
837 const dwarf2_debug_info_t* di)
838 {
839 struct attribute attr;
840
841 if (dwarf2_find_attribute(ctx, di, DW_AT_type, &attr))
842 {
843 dwarf2_debug_info_t* type;
844
845 type = sparse_array_find(&ctx->debug_info_table, attr.u.uvalue);
846 if (!type) FIXME("Unable to find back reference to type %lx\n", attr.u.uvalue);
847 if (!type->symt)
848 {
849 /* load the debug info entity */
850 dwarf2_load_one_entry(ctx, type, NULL);
851 }
852 return type->symt;
853 }
854 return NULL;
855 }
856
857 /******************************************************************
858 * dwarf2_read_one_debug_info
859 *
860 * Loads into memory one debug info entry, and recursively its children (if any)
861 */
862 static BOOL dwarf2_read_one_debug_info(dwarf2_parse_context_t* ctx,
863 dwarf2_traverse_context_t* traverse,
864 dwarf2_debug_info_t** pdi)
865 {
866 const dwarf2_abbrev_entry_t*abbrev;
867 unsigned long entry_code;
868 unsigned long offset;
869 dwarf2_debug_info_t* di;
870 dwarf2_debug_info_t* child;
871 dwarf2_debug_info_t** where;
872 dwarf2_abbrev_entry_attr_t* attr;
873 unsigned i;
874 struct attribute sibling;
875
876 offset = traverse->data - ctx->sections[ctx->section].address;
877 entry_code = dwarf2_leb128_as_unsigned(traverse);
878 TRACE("found entry_code %lu at 0x%lx\n", entry_code, offset);
879 if (!entry_code)
880 {
881 *pdi = NULL;
882 return TRUE;
883 }
884 abbrev = dwarf2_abbrev_table_find_entry(&ctx->abbrev_table, entry_code);
885 if (!abbrev)
886 {
887 WARN("Cannot find abbrev entry for %lu at 0x%lx\n", entry_code, offset);
888 return FALSE;
889 }
890 di = sparse_array_add(&ctx->debug_info_table, offset, &ctx->pool);
891 if (!di) return FALSE;
892 di->abbrev = abbrev;
893 di->symt = NULL;
894
895 if (abbrev->num_attr)
896 {
897 di->data = pool_alloc(&ctx->pool, abbrev->num_attr * sizeof(const char*));
898 for (i = 0, attr = abbrev->attrs; attr; i++, attr = attr->next)
899 {
900 di->data[i] = traverse->data;
901 dwarf2_swallow_attribute(traverse, attr);
902 }
903 }
904 else di->data = NULL;
905 if (abbrev->have_child)
906 {
907 vector_init(&di->children, sizeof(dwarf2_debug_info_t*), 16);
908 while (traverse->data < traverse->end_data)
909 {
910 if (!dwarf2_read_one_debug_info(ctx, traverse, &child)) return FALSE;
911 if (!child) break;
912 where = vector_add(&di->children, &ctx->pool);
913 if (!where) return FALSE;
914 *where = child;
915 }
916 }
917 if (dwarf2_find_attribute(ctx, di, DW_AT_sibling, &sibling) &&
918 traverse->data != ctx->sections[ctx->section].address + sibling.u.uvalue)
919 {
920 WARN("setting cursor for %s to next sibling <0x%lx>\n",
921 dwarf2_debug_traverse_ctx(traverse), sibling.u.uvalue);
922 traverse->data = ctx->sections[ctx->section].address + sibling.u.uvalue;
923 }
924 *pdi = di;
925 return TRUE;
926 }
927
928 static struct symt* dwarf2_parse_base_type(dwarf2_parse_context_t* ctx,
929 dwarf2_debug_info_t* di)
930 {
931 struct attribute name;
932 struct attribute size;
933 struct attribute encoding;
934 enum BasicType bt;
935
936 if (di->symt) return di->symt;
937
938 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
939
940 if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name))
941 name.u.string = NULL;
942 if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &size)) size.u.uvalue = 0;
943 if (!dwarf2_find_attribute(ctx, di, DW_AT_encoding, &encoding)) encoding.u.uvalue = DW_ATE_void;
944
945 switch (encoding.u.uvalue)
946 {
947 case DW_ATE_void: bt = btVoid; break;
948 case DW_ATE_address: bt = btULong; break;
949 case DW_ATE_boolean: bt = btBool; break;
950 case DW_ATE_complex_float: bt = btComplex; break;
951 case DW_ATE_float: bt = btFloat; break;
952 case DW_ATE_signed: bt = btInt; break;
953 case DW_ATE_unsigned: bt = btUInt; break;
954 case DW_ATE_signed_char: bt = btChar; break;
955 case DW_ATE_unsigned_char: bt = btChar; break;
956 default: bt = btNoType; break;
957 }
958 di->symt = &symt_new_basic(ctx->module, bt, name.u.string, size.u.uvalue)->symt;
959 if (di->abbrev->have_child) FIXME("Unsupported children\n");
960 return di->symt;
961 }
962
963 static struct symt* dwarf2_parse_typedef(dwarf2_parse_context_t* ctx,
964 dwarf2_debug_info_t* di)
965 {
966 struct symt* ref_type;
967 struct attribute name;
968
969 if (di->symt) return di->symt;
970
971 TRACE("%s, for %lu\n", dwarf2_debug_ctx(ctx), di->abbrev->entry_code);
972
973 if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL;
974 ref_type = dwarf2_lookup_type(ctx, di);
975
976 if (name.u.string)
977 di->symt = &symt_new_typedef(ctx->module, ref_type, name.u.string)->symt;
978 if (di->abbrev->have_child) FIXME("Unsupported children\n");
979 return di->symt;
980 }
981
982 static struct symt* dwarf2_parse_pointer_type(dwarf2_parse_context_t* ctx,
983 dwarf2_debug_info_t* di)
984 {
985 struct symt* ref_type;
986 struct attribute size;
987
988 if (di->symt) return di->symt;
989
990 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
991
992 if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &size)) size.u.uvalue = 0;
993 if (!(ref_type = dwarf2_lookup_type(ctx, di)))
994 ref_type = &symt_new_basic(ctx->module, btVoid, "void", 0)->symt;
995
996 di->symt = &symt_new_pointer(ctx->module, ref_type)->symt;
997 if (di->abbrev->have_child) FIXME("Unsupported children\n");
998 return di->symt;
999 }
1000
1001 static struct symt* dwarf2_parse_array_type(dwarf2_parse_context_t* ctx,
1002 dwarf2_debug_info_t* di)
1003 {
1004 struct symt* ref_type;
1005 struct symt* idx_type = NULL;
1006 struct attribute min, max, cnt;
1007 dwarf2_debug_info_t* child;
1008 int i;
1009
1010 if (di->symt) return di->symt;
1011
1012 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1013
1014 if (!di->abbrev->have_child)
1015 {
1016 FIXME("array without range information\n");
1017 return NULL;
1018 }
1019 ref_type = dwarf2_lookup_type(ctx, di);
1020
1021 for (i=0; i<vector_length(&di->children); i++)
1022 {
1023 child = *(dwarf2_debug_info_t**)vector_at(&di->children, i);
1024 switch (child->abbrev->tag)
1025 {
1026 case DW_TAG_subrange_type:
1027 idx_type = dwarf2_lookup_type(ctx, child);
1028 if (!dwarf2_find_attribute(ctx, child, DW_AT_lower_bound, &min))
1029 min.u.uvalue = 0;
1030 if (!dwarf2_find_attribute(ctx, child, DW_AT_upper_bound, &max))
1031 max.u.uvalue = 0;
1032 if (dwarf2_find_attribute(ctx, child, DW_AT_count, &cnt))
1033 max.u.uvalue = min.u.uvalue + cnt.u.uvalue;
1034 break;
1035 default:
1036 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1037 child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1038 break;
1039 }
1040 }
1041 di->symt = &symt_new_array(ctx->module, min.u.uvalue, max.u.uvalue, ref_type, idx_type)->symt;
1042 return di->symt;
1043 }
1044
1045 static struct symt* dwarf2_parse_const_type(dwarf2_parse_context_t* ctx,
1046 dwarf2_debug_info_t* di)
1047 {
1048 struct symt* ref_type;
1049
1050 if (di->symt) return di->symt;
1051
1052 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1053
1054 ref_type = dwarf2_lookup_type(ctx, di);
1055 if (di->abbrev->have_child) FIXME("Unsupported children\n");
1056 di->symt = ref_type;
1057
1058 return ref_type;
1059 }
1060
1061 static struct symt* dwarf2_parse_volatile_type(dwarf2_parse_context_t* ctx,
1062 dwarf2_debug_info_t* di)
1063 {
1064 struct symt* ref_type;
1065
1066 if (di->symt) return di->symt;
1067
1068 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1069
1070 ref_type = dwarf2_lookup_type(ctx, di);
1071 if (di->abbrev->have_child) FIXME("Unsupported children\n");
1072 di->symt = ref_type;
1073
1074 return ref_type;
1075 }
1076
1077 static struct symt* dwarf2_parse_reference_type(dwarf2_parse_context_t* ctx,
1078 dwarf2_debug_info_t* di)
1079 {
1080 struct symt* ref_type = NULL;
1081
1082 if (di->symt) return di->symt;
1083
1084 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1085
1086 ref_type = dwarf2_lookup_type(ctx, di);
1087 /* FIXME: for now, we hard-wire C++ references to pointers */
1088 di->symt = &symt_new_pointer(ctx->module, ref_type)->symt;
1089
1090 if (di->abbrev->have_child) FIXME("Unsupported children\n");
1091
1092 return di->symt;
1093 }
1094
1095 static void dwarf2_parse_udt_member(dwarf2_parse_context_t* ctx,
1096 const dwarf2_debug_info_t* di,
1097 struct symt_udt* parent)
1098 {
1099 struct symt* elt_type;
1100 struct attribute name;
1101 struct attribute bit_size;
1102 struct attribute bit_offset;
1103 struct location loc;
1104
1105 assert(parent);
1106
1107 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1108
1109 if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL;
1110 elt_type = dwarf2_lookup_type(ctx, di);
1111 if (dwarf2_compute_location_attr(ctx, di, DW_AT_data_member_location, &loc, NULL))
1112 {
1113 if (loc.kind != loc_absolute)
1114 {
1115 FIXME("Found register, while not expecting it\n");
1116 loc.offset = 0;
1117 }
1118 else
1119 TRACE("found member_location at %s -> %lu\n",
1120 dwarf2_debug_ctx(ctx), loc.offset);
1121 }
1122 else
1123 loc.offset = 0;
1124 if (!dwarf2_find_attribute(ctx, di, DW_AT_bit_size, &bit_size))
1125 bit_size.u.uvalue = 0;
1126 if (dwarf2_find_attribute(ctx, di, DW_AT_bit_offset, &bit_offset))
1127 {
1128 /* FIXME: we should only do this when implementation is LSB (which is
1129 * the case on i386 processors)
1130 */
1131 struct attribute nbytes;
1132 if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &nbytes))
1133 {
1134 DWORD64 size;
1135 nbytes.u.uvalue = symt_get_info(elt_type, TI_GET_LENGTH, &size) ? (unsigned long)size : 0;
1136 }
1137 bit_offset.u.uvalue = nbytes.u.uvalue * 8 - bit_offset.u.uvalue - bit_size.u.uvalue;
1138 }
1139 else bit_offset.u.uvalue = 0;
1140 symt_add_udt_element(ctx->module, parent, name.u.string, elt_type,
1141 (loc.offset << 3) + bit_offset.u.uvalue,
1142 bit_size.u.uvalue);
1143
1144 if (di->abbrev->have_child) FIXME("Unsupported children\n");
1145 }
1146
1147 static struct symt* dwarf2_parse_udt_type(dwarf2_parse_context_t* ctx,
1148 dwarf2_debug_info_t* di,
1149 enum UdtKind udt)
1150 {
1151 struct attribute name;
1152 struct attribute size;
1153
1154 if (di->symt) return di->symt;
1155
1156 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1157
1158 if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL;
1159 if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &size)) size.u.uvalue = 0;
1160
1161 di->symt = &symt_new_udt(ctx->module, name.u.string, size.u.uvalue, udt)->symt;
1162
1163 if (di->abbrev->have_child) /** any interest to not have child ? */
1164 {
1165 dwarf2_debug_info_t* child;
1166 int i;
1167
1168 for (i=0; i<vector_length(&di->children); i++)
1169 {
1170 child = *(dwarf2_debug_info_t**)vector_at(&di->children, i);
1171
1172 switch (child->abbrev->tag)
1173 {
1174 case DW_TAG_member:
1175 /* FIXME: should I follow the sibling stuff ?? */
1176 dwarf2_parse_udt_member(ctx, child, (struct symt_udt*)di->symt);
1177 break;
1178 case DW_TAG_enumeration_type:
1179 dwarf2_parse_enumeration_type(ctx, child);
1180 break;
1181 case DW_TAG_structure_type:
1182 case DW_TAG_class_type:
1183 case DW_TAG_union_type:
1184 /* FIXME: we need to handle nested udt definitions */
1185 break;
1186 default:
1187 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1188 child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1189 break;
1190 }
1191 }
1192 }
1193
1194 return di->symt;
1195 }
1196
1197 static void dwarf2_parse_enumerator(dwarf2_parse_context_t* ctx,
1198 const dwarf2_debug_info_t* di,
1199 struct symt_enum* parent)
1200 {
1201 struct attribute name;
1202 struct attribute value;
1203
1204 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1205
1206 if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) return;
1207 if (!dwarf2_find_attribute(ctx, di, DW_AT_const_value, &value)) value.u.svalue = 0;
1208 symt_add_enum_element(ctx->module, parent, name.u.string, value.u.svalue);
1209
1210 if (di->abbrev->have_child) FIXME("Unsupported children\n");
1211 }
1212
1213 static struct symt* dwarf2_parse_enumeration_type(dwarf2_parse_context_t* ctx,
1214 dwarf2_debug_info_t* di)
1215 {
1216 struct attribute name;
1217 struct attribute size;
1218
1219 if (di->symt) return di->symt;
1220
1221 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1222
1223 if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL;
1224 if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &size)) size.u.uvalue = 0;
1225
1226 di->symt = &symt_new_enum(ctx->module, name.u.string)->symt;
1227
1228 if (di->abbrev->have_child) /* any interest to not have child ? */
1229 {
1230 dwarf2_debug_info_t* child;
1231 int i;
1232
1233 /* FIXME: should we use the sibling stuff ?? */
1234 for (i=0; i<vector_length(&di->children); i++)
1235 {
1236 child = *(dwarf2_debug_info_t**)vector_at(&di->children, i);
1237
1238 switch (child->abbrev->tag)
1239 {
1240 case DW_TAG_enumerator:
1241 dwarf2_parse_enumerator(ctx, child, (struct symt_enum*)di->symt);
1242 break;
1243 default:
1244 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1245 di->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1246 }
1247 }
1248 }
1249 return di->symt;
1250 }
1251
1252 /* structure used to pass information around when parsing a subprogram */
1253 typedef struct dwarf2_subprogram_s
1254 {
1255 dwarf2_parse_context_t* ctx;
1256 struct symt_compiland* compiland;
1257 struct symt_function* func;
1258 BOOL non_computed_variable;
1259 struct location frame;
1260 } dwarf2_subprogram_t;
1261
1262 /******************************************************************
1263 * dwarf2_parse_variable
1264 *
1265 * Parses any variable (parameter, local/global variable)
1266 */
1267 static void dwarf2_parse_variable(dwarf2_subprogram_t* subpgm,
1268 struct symt_block* block,
1269 dwarf2_debug_info_t* di)
1270 {
1271 struct symt* param_type;
1272 struct attribute name, value;
1273 struct location loc;
1274 BOOL is_pmt;
1275
1276 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1277
1278 is_pmt = !block && di->abbrev->tag == DW_TAG_formal_parameter;
1279 param_type = dwarf2_lookup_type(subpgm->ctx, di);
1280
1281 if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_name, &name)) {
1282 /* cannot do much without the name, the functions below won't like it. */
1283 return;
1284 }
1285 if (dwarf2_compute_location_attr(subpgm->ctx, di, DW_AT_location,
1286 &loc, &subpgm->frame))
1287 {
1288 struct attribute ext;
1289
1290 TRACE("found parameter %s (kind=%d, offset=%ld, reg=%d) at %s\n",
1291 name.u.string, loc.kind, loc.offset, loc.reg,
1292 dwarf2_debug_ctx(subpgm->ctx));
1293
1294 switch (loc.kind)
1295 {
1296 case loc_absolute:
1297 /* it's a global variable */
1298 /* FIXME: we don't handle its scope yet */
1299 if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_external, &ext))
1300 ext.u.uvalue = 0;
1301 symt_new_global_variable(subpgm->ctx->module, subpgm->compiland,
1302 name.u.string, !ext.u.uvalue,
1303 subpgm->ctx->load_offset + loc.offset,
1304 0, param_type);
1305 break;
1306 default:
1307 subpgm->non_computed_variable = TRUE;
1308 /* fall through */
1309 case loc_register:
1310 case loc_regrel:
1311 /* either a pmt/variable relative to frame pointer or
1312 * pmt/variable in a register
1313 */
1314 assert(subpgm->func);
1315 symt_add_func_local(subpgm->ctx->module, subpgm->func,
1316 is_pmt ? DataIsParam : DataIsLocal,
1317 &loc, block, param_type, name.u.string);
1318 break;
1319 }
1320 }
1321 else if (dwarf2_find_attribute(subpgm->ctx, di, DW_AT_const_value, &value))
1322 {
1323 VARIANT v;
1324 if (subpgm->func) WARN("Unsupported constant %s in function\n", name.u.string);
1325 if (is_pmt) FIXME("Unsupported constant (parameter) %s in function\n", name.u.string);
1326 switch (value.form)
1327 {
1328 case DW_FORM_data1:
1329 case DW_FORM_data2:
1330 case DW_FORM_data4:
1331 case DW_FORM_udata:
1332 v.n1.n2.vt = VT_UI4;
1333 v.n1.n2.n3.lVal = value.u.uvalue;
1334 break;
1335
1336 case DW_FORM_sdata:
1337 v.n1.n2.vt = VT_I4;
1338 v.n1.n2.n3.lVal = value.u.svalue;
1339 break;
1340
1341 case DW_FORM_strp:
1342 case DW_FORM_string:
1343 /* FIXME: native doesn't report const strings from here !!
1344 * however, the value of the string is in the code somewhere
1345 */
1346 v.n1.n2.vt = VT_I1 | VT_BYREF;
1347 v.n1.n2.n3.byref = pool_strdup(&subpgm->ctx->module->pool, value.u.string);
1348 break;
1349
1350 case DW_FORM_data8:
1351 case DW_FORM_block:
1352 case DW_FORM_block1:
1353 case DW_FORM_block2:
1354 case DW_FORM_block4:
1355
1356 default:
1357 FIXME("Unsupported form for const value %s (%lx)\n",
1358 name.u.string, value.form);
1359 v.n1.n2.vt = VT_EMPTY;
1360 }
1361 di->symt = &symt_new_constant(subpgm->ctx->module, subpgm->compiland,
1362 name.u.string, param_type, &v)->symt;
1363 }
1364 if (is_pmt && subpgm->func && subpgm->func->type)
1365 symt_add_function_signature_parameter(subpgm->ctx->module,
1366 (struct symt_function_signature*)subpgm->func->type,
1367 param_type);
1368
1369 if (di->abbrev->have_child) FIXME("Unsupported children\n");
1370 }
1371
1372 static void dwarf2_parse_subprogram_label(dwarf2_subprogram_t* subpgm,
1373 const dwarf2_debug_info_t* di)
1374 {
1375 struct attribute name;
1376 struct attribute low_pc;
1377 struct location loc;
1378
1379 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1380
1381 if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_low_pc, &low_pc)) low_pc.u.uvalue = 0;
1382 if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_name, &name))
1383 name.u.string = NULL;
1384
1385 loc.kind = loc_absolute;
1386 loc.offset = subpgm->ctx->load_offset + low_pc.u.uvalue;
1387 symt_add_function_point(subpgm->ctx->module, subpgm->func, SymTagLabel,
1388 &loc, name.u.string);
1389 }
1390
1391 static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t* subpgm,
1392 struct symt_block* parent_block,
1393 const dwarf2_debug_info_t* di);
1394
1395 static void dwarf2_parse_inlined_subroutine(dwarf2_subprogram_t* subpgm,
1396 struct symt_block* parent_block,
1397 const dwarf2_debug_info_t* di)
1398 {
1399 struct symt_block* block;
1400 struct attribute low_pc;
1401 struct attribute high_pc;
1402
1403 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1404
1405 if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_low_pc, &low_pc)) low_pc.u.uvalue = 0;
1406 if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_high_pc, &high_pc)) high_pc.u.uvalue = 0;
1407
1408 block = symt_open_func_block(subpgm->ctx->module, subpgm->func, parent_block,
1409 subpgm->ctx->load_offset + low_pc.u.uvalue - subpgm->func->address,
1410 high_pc.u.uvalue - low_pc.u.uvalue);
1411
1412 if (di->abbrev->have_child) /** any interest to not have child ? */
1413 {
1414 dwarf2_debug_info_t* child;
1415 int i;
1416
1417 for (i=0; i<vector_length(&di->children); i++)
1418 {
1419 child = *(dwarf2_debug_info_t**)vector_at(&di->children, i);
1420
1421 switch (child->abbrev->tag)
1422 {
1423 case DW_TAG_formal_parameter:
1424 case DW_TAG_variable:
1425 dwarf2_parse_variable(subpgm, block, child);
1426 break;
1427 case DW_TAG_lexical_block:
1428 dwarf2_parse_subprogram_block(subpgm, block, child);
1429 break;
1430 case DW_TAG_inlined_subroutine:
1431 dwarf2_parse_inlined_subroutine(subpgm, block, child);
1432 break;
1433 case DW_TAG_label:
1434 dwarf2_parse_subprogram_label(subpgm, child);
1435 break;
1436 default:
1437 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1438 child->abbrev->tag, dwarf2_debug_ctx(subpgm->ctx),
1439 dwarf2_debug_di(di));
1440 }
1441 }
1442 }
1443 symt_close_func_block(subpgm->ctx->module, subpgm->func, block, 0);
1444 }
1445
1446 static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t* subpgm,
1447 struct symt_block* parent_block,
1448 const dwarf2_debug_info_t* di)
1449 {
1450 struct symt_block* block;
1451 struct attribute low_pc;
1452 struct attribute high_pc;
1453
1454 TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1455
1456 if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_low_pc, &low_pc))
1457 low_pc.u.uvalue = 0;
1458 if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_high_pc, &high_pc))
1459 high_pc.u.uvalue = 0;
1460
1461 block = symt_open_func_block(subpgm->ctx->module, subpgm->func, parent_block,
1462 subpgm->ctx->load_offset + low_pc.u.uvalue - subpgm->func->address,
1463 high_pc.u.uvalue - low_pc.u.uvalue);
1464
1465 if (di->abbrev->have_child) /** any interest to not have child ? */
1466 {
1467 dwarf2_debug_info_t* child;
1468 int i;
1469
1470 for (i=0; i<vector_length(&di->children); i++)
1471 {
1472 child = *(dwarf2_debug_info_t**)vector_at(&di->children, i);
1473
1474 switch (child->abbrev->tag)
1475 {
1476 case DW_TAG_inlined_subroutine:
1477 dwarf2_parse_inlined_subroutine(subpgm, block, child);
1478 break;
1479 case DW_TAG_variable:
1480 dwarf2_parse_variable(subpgm, block, child);
1481 break;
1482 case DW_TAG_lexical_block:
1483 dwarf2_parse_subprogram_block(subpgm, block, child);
1484 break;
1485 case DW_TAG_subprogram:
1486 /* FIXME: likely a declaration (to be checked)
1487 * skip it for now
1488 */
1489 break;
1490 case DW_TAG_formal_parameter:
1491 /* FIXME: likely elements for exception handling (GCC flavor)
1492 * Skip it for now
1493 */
1494 break;
1495 case DW_TAG_label:
1496 dwarf2_parse_subprogram_label(subpgm, child);
1497 break;
1498 case DW_TAG_class_type:
1499 case DW_TAG_structure_type:
1500 case DW_TAG_union_type:
1501 case DW_TAG_enumeration_type:
1502 case DW_TAG_typedef:
1503 /* the type referred to will be loaded when we need it, so skip it */
1504 break;
1505 default:
1506 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1507 child->abbrev->tag, dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1508 }
1509 }
1510 }
1511
1512 symt_close_func_block(subpgm->ctx->module, subpgm->func, block, 0);
1513 }
1514
1515 static struct symt* dwarf2_parse_subprogram(dwarf2_parse_context_t* ctx,
1516 dwarf2_debug_info_t* di,
1517 struct symt_compiland* compiland)
1518 {
1519 struct attribute name;
1520 struct attribute low_pc;
1521 struct attribute high_pc;
1522 struct attribute is_decl;
1523 struct attribute inline_flags;
1524 struct symt* ret_type;
1525 struct symt_function_signature* sig_type;
1526 dwarf2_subprogram_t subpgm;
1527
1528 if (di->symt) return di->symt;
1529
1530 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1531
1532 if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL;
1533 /* if it's an abstract representation of an inline function, there should be
1534 * a concrete object that we'll handle
1535 */
1536 if (dwarf2_find_attribute(ctx, di, DW_AT_inline, &inline_flags))
1537 {
1538 TRACE("Function %s declared as inlined (%ld)... skipping\n",
1539 name.u.string ? name.u.string : "(null)", inline_flags.u.uvalue);
1540 return NULL;
1541 }
1542
1543 if (!dwarf2_find_attribute(ctx, di, DW_AT_low_pc, &low_pc)) low_pc.u.uvalue = 0;
1544 if (!dwarf2_find_attribute(ctx, di, DW_AT_high_pc, &high_pc)) high_pc.u.uvalue = 0;
1545 /* As functions (defined as inline assembly) get debug info with dwarf
1546 * (not the case for stabs), we just drop Wine's thunks here...
1547 * Actual thunks will be created in elf_module from the symbol table
1548 */
1549 if (elf_is_in_thunk_area(ctx->load_offset + low_pc.u.uvalue,
1550 ctx->thunks) >= 0)
1551 return NULL;
1552 if (!dwarf2_find_attribute(ctx, di, DW_AT_declaration, &is_decl))
1553 is_decl.u.uvalue = 0;
1554
1555 if (!(ret_type = dwarf2_lookup_type(ctx, di)))
1556 ret_type = &symt_new_basic(ctx->module, btVoid, "void", 0)->symt;
1557
1558 /* FIXME: assuming C source code */
1559 sig_type = symt_new_function_signature(ctx->module, ret_type, CV_CALL_FAR_C);
1560 if (!is_decl.u.uvalue)
1561 {
1562 subpgm.func = symt_new_function(ctx->module, compiland, name.u.string,
1563 ctx->load_offset + low_pc.u.uvalue,
1564 high_pc.u.uvalue - low_pc.u.uvalue,
1565 &sig_type->symt);
1566 di->symt = &subpgm.func->symt;
1567 }
1568 else subpgm.func = NULL;
1569
1570 subpgm.ctx = ctx;
1571 subpgm.compiland = compiland;
1572 if (!dwarf2_compute_location_attr(ctx, di, DW_AT_frame_base,
1573 &subpgm.frame, NULL))
1574 {
1575 /* on stack !! */
1576 subpgm.frame.kind = loc_regrel;
1577 subpgm.frame.reg = 0;
1578 subpgm.frame.offset = 0;
1579 }
1580 subpgm.non_computed_variable = FALSE;
1581
1582 if (di->abbrev->have_child) /** any interest to not have child ? */
1583 {
1584 dwarf2_debug_info_t* child;
1585 int i;
1586
1587 for (i=0; i<vector_length(&di->children); i++)
1588 {
1589 child = *(dwarf2_debug_info_t**)vector_at(&di->children, i);
1590
1591 switch (child->abbrev->tag)
1592 {
1593 case DW_TAG_variable:
1594 case DW_TAG_formal_parameter:
1595 dwarf2_parse_variable(&subpgm, NULL, child);
1596 break;
1597 case DW_TAG_lexical_block:
1598 dwarf2_parse_subprogram_block(&subpgm, NULL, child);
1599 break;
1600 case DW_TAG_inlined_subroutine:
1601 dwarf2_parse_inlined_subroutine(&subpgm, NULL, child);
1602 break;
1603 case DW_TAG_subprogram:
1604 /* FIXME: likely a declaration (to be checked)
1605 * skip it for now
1606 */
1607 break;
1608 case DW_TAG_label:
1609 dwarf2_parse_subprogram_label(&subpgm, child);
1610 break;
1611 case DW_TAG_class_type:
1612 case DW_TAG_structure_type:
1613 case DW_TAG_union_type:
1614 case DW_TAG_enumeration_type:
1615 case DW_TAG_typedef:
1616 /* the type referred to will be loaded when we need it, so skip it */
1617 break;
1618 case DW_TAG_unspecified_parameters:
1619 /* FIXME: no support in dbghelp's internals so far */
1620 break;
1621 default:
1622 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1623 child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1624 }
1625 }
1626 }
1627
1628 if (subpgm.non_computed_variable || subpgm.frame.kind >= loc_user)
1629 {
1630 symt_add_function_point(ctx->module, subpgm.func, SymTagCustom,
1631 &subpgm.frame, NULL);
1632 }
1633 symt_normalize_function(subpgm.ctx->module, subpgm.func);
1634
1635 return di->symt;
1636 }
1637
1638 static struct symt* dwarf2_parse_subroutine_type(dwarf2_parse_context_t* ctx,
1639 dwarf2_debug_info_t* di)
1640 {
1641 struct symt* ret_type;
1642 struct symt_function_signature* sig_type;
1643
1644 if (di->symt) return di->symt;
1645
1646 TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1647
1648 if (!(ret_type = dwarf2_lookup_type(ctx, di)))
1649 ret_type = &symt_new_basic(ctx->module, btVoid, "void", 0)->symt;
1650
1651 /* FIXME: assuming C source code */
1652 sig_type = symt_new_function_signature(ctx->module, ret_type, CV_CALL_FAR_C);
1653
1654 if (di->abbrev->have_child) /** any interest to not have child ? */
1655 {
1656 dwarf2_debug_info_t* child;
1657 int i;
1658
1659 for (i=0; i<vector_length(&di->children); i++)
1660 {
1661 child = *(dwarf2_debug_info_t**)vector_at(&di->children, i);
1662
1663 switch (child->abbrev->tag)
1664 {
1665 case DW_TAG_formal_parameter:
1666 symt_add_function_signature_parameter(ctx->module, sig_type,
1667 dwarf2_lookup_type(ctx, child));
1668 break;
1669 case DW_TAG_unspecified_parameters:
1670 WARN("Unsupported unspecified parameters\n");
1671 break;
1672 }
1673 }
1674 }
1675
1676 return di->symt = &sig_type->symt;
1677 }
1678
1679 static void dwarf2_load_one_entry(dwarf2_parse_context_t* ctx,
1680 dwarf2_debug_info_t* di,
1681 struct symt_compiland* compiland)
1682 {
1683 switch (di->abbrev->tag)
1684 {
1685 case DW_TAG_typedef:
1686 dwarf2_parse_typedef(ctx, di);
1687 break;
1688 case DW_TAG_base_type:
1689 dwarf2_parse_base_type(ctx, di);
1690 break;
1691 case DW_TAG_pointer_type:
1692 dwarf2_parse_pointer_type(ctx, di);
1693 break;
1694 case DW_TAG_class_type:
1695 dwarf2_parse_udt_type(ctx, di, UdtClass);
1696 break;
1697 case DW_TAG_structure_type:
1698 dwarf2_parse_udt_type(ctx, di, UdtStruct);
1699 break;
1700 case DW_TAG_union_type:
1701 dwarf2_parse_udt_type(ctx, di, UdtUnion);
1702 break;
1703 case DW_TAG_array_type:
1704 dwarf2_parse_array_type(ctx, di);
1705 break;
1706 case DW_TAG_const_type:
1707 dwarf2_parse_const_type(ctx, di);
1708 break;
1709 case DW_TAG_volatile_type:
1710 dwarf2_parse_volatile_type(ctx, di);
1711 break;
1712 case DW_TAG_reference_type:
1713 dwarf2_parse_reference_type(ctx, di);
1714 break;
1715 case DW_TAG_enumeration_type:
1716 dwarf2_parse_enumeration_type(ctx, di);
1717 break;
1718 case DW_TAG_subprogram:
1719 dwarf2_parse_subprogram(ctx, di, compiland);
1720 break;
1721 case DW_TAG_subroutine_type:
1722 dwarf2_parse_subroutine_type(ctx, di);
1723 break;
1724 case DW_TAG_variable:
1725 {
1726 dwarf2_subprogram_t subpgm;
1727
1728 subpgm.ctx = ctx;
1729 subpgm.compiland = compiland;
1730 subpgm.func = NULL;
1731 subpgm.frame.kind = loc_absolute;
1732 subpgm.frame.offset = 0;
1733 subpgm.frame.reg = Wine_DW_no_register;
1734 dwarf2_parse_variable(&subpgm, NULL, di);
1735 }
1736 break;
1737 default:
1738 FIXME("Unhandled Tag type 0x%lx at %s, for %lu\n",
1739 di->abbrev->tag, dwarf2_debug_ctx(ctx), di->abbrev->entry_code);
1740 }
1741 }
1742
1743 static void dwarf2_set_line_number(struct module* module, unsigned long address,
1744 const struct vector* v, unsigned file, unsigned line)
1745 {
1746 struct symt_function* func;
1747 struct symt_ht* symt;
1748 unsigned* psrc;
1749
1750 if (!file || !(psrc = vector_at(v, file - 1))) return;
1751
1752 TRACE("%s %lx %s %u\n",
1753 debugstr_w(module->module.ModuleName), address, source_get(module, *psrc), line);
1754 if (!(symt = symt_find_nearest(module, address)) ||
1755 symt->symt.tag != SymTagFunction) return;
1756 func = (struct symt_function*)symt;
1757 symt_add_func_line(module, func, *psrc, line, address - func->address);
1758 }
1759
1760 static BOOL dwarf2_parse_line_numbers(const dwarf2_section_t* sections,
1761 dwarf2_parse_context_t* ctx,
1762 const char* compile_dir,
1763 unsigned long offset)
1764 {
1765 dwarf2_traverse_context_t traverse;
1766 unsigned long length;
1767 unsigned version, header_len, insn_size, default_stmt;
1768 unsigned line_range, opcode_base;
1769 int line_base;
1770 const unsigned char* opcode_len;
1771 struct vector dirs;
1772 struct vector files;
1773 const char** p;
1774
1775 /* section with line numbers stripped */
1776 if (sections[section_line].address == ELF_NO_MAP)
1777 return FALSE;
1778
1779 traverse.data = sections[section_line].address + offset;
1780 traverse.start_data = traverse.data;
1781 traverse.end_data = traverse.data + 4;
1782 traverse.word_size = ctx->word_size;
1783
1784 length = dwarf2_parse_u4(&traverse);
1785 traverse.end_data = traverse.start_data + length;
1786
1787 version = dwarf2_parse_u2(&traverse);
1788 header_len = dwarf2_parse_u4(&traverse);
1789 insn_size = dwarf2_parse_byte(&traverse);
1790 default_stmt = dwarf2_parse_byte(&traverse);
1791 line_base = (signed char)dwarf2_parse_byte(&traverse);
1792 line_range = dwarf2_parse_byte(&traverse);
1793 opcode_base = dwarf2_parse_byte(&traverse);
1794
1795 opcode_len = traverse.data;
1796 traverse.data += opcode_base - 1;
1797
1798 vector_init(&dirs, sizeof(const char*), 4);
1799 p = vector_add(&dirs, &ctx->pool);
1800 *p = compile_dir ? compile_dir : ".";
1801 while (*traverse.data)
1802 {
1803 const char* rel = (const char*)traverse.data;
1804 unsigned rellen = strlen(rel);
1805 TRACE("Got include %s\n", rel);
1806 traverse.data += rellen + 1;
1807 p = vector_add(&dirs, &ctx->pool);
1808
1809 if (*rel == '/' || !compile_dir)
1810 *p = rel;
1811 else
1812 {
1813 /* include directory relative to compile directory */
1814 unsigned baselen = strlen(compile_dir);
1815 char* tmp = pool_alloc(&ctx->pool, baselen + 1 + rellen + 1);
1816 strcpy(tmp, compile_dir);
1817 if (tmp[baselen - 1] != '/') tmp[baselen++] = '/';
1818 strcpy(&tmp[baselen], rel);
1819 *p = tmp;
1820 }
1821
1822 }
1823 traverse.data++;
1824
1825 vector_init(&files, sizeof(unsigned), 16);
1826 while (*traverse.data)
1827 {
1828 unsigned int dir_index, mod_time, length;
1829 const char* name;
1830 const char* dir;
1831 unsigned* psrc;
1832
1833 name = (const char*)traverse.data;
1834 traverse.data += strlen(name) + 1;
1835 dir_index = dwarf2_leb128_as_unsigned(&traverse);
1836 mod_time = dwarf2_leb128_as_unsigned(&traverse);
1837 length = dwarf2_leb128_as_unsigned(&traverse);
1838 dir = *(const char**)vector_at(&dirs, dir_index);
1839 TRACE("Got file %s/%s (%u,%u)\n", dir, name, mod_time, length);
1840 psrc = vector_add(&files, &ctx->pool);
1841 *psrc = source_new(ctx->module, dir, name);
1842 }
1843 traverse.data++;
1844
1845 while (traverse.data < traverse.end_data)
1846 {
1847 unsigned long address = 0;
1848 unsigned file = 1;
1849 unsigned line = 1;
1850 unsigned is_stmt = default_stmt;
1851 BOOL basic_block = FALSE, end_sequence = FALSE;
1852 unsigned opcode, extopcode, i;
1853
1854 while (!end_sequence)
1855 {
1856 opcode = dwarf2_parse_byte(&traverse);
1857 TRACE("Got opcode %x\n", opcode);
1858
1859 if (opcode >= opcode_base)
1860 {
1861 unsigned delta = opcode - opcode_base;
1862
1863 address += (delta / line_range) * insn_size;
1864 line += line_base + (delta % line_range);
1865 basic_block = TRUE;
1866 dwarf2_set_line_number(ctx->module, address, &files, file, line);
1867 }
1868 else
1869 {
1870 switch (opcode)
1871 {
1872 case DW_LNS_copy:
1873 basic_block = FALSE;
1874 dwarf2_set_line_number(ctx->module, address, &files, file, line);
1875 break;
1876 case DW_LNS_advance_pc:
1877 address += insn_size * dwarf2_leb128_as_unsigned(&traverse);
1878 break;
1879 case DW_LNS_advance_line:
1880 line += dwarf2_leb128_as_signed(&traverse);
1881 break;
1882 case DW_LNS_set_file:
1883 file = dwarf2_leb128_as_unsigned(&traverse);
1884 break;
1885 case DW_LNS_set_column:
1886 dwarf2_leb128_as_unsigned(&traverse);
1887 break;
1888 case DW_LNS_negate_stmt:
1889 is_stmt = !is_stmt;
1890 break;
1891 case DW_LNS_set_basic_block:
1892 basic_block = 1;
1893 break;
1894 case DW_LNS_const_add_pc:
1895 address += ((255 - opcode_base) / line_range) * insn_size;
1896 break;
1897 case DW_LNS_fixed_advance_pc:
1898 address += dwarf2_parse_u2(&traverse);
1899 break;
1900 case DW_LNS_extended_op:
1901 dwarf2_leb128_as_unsigned(&traverse);
1902 extopcode = dwarf2_parse_byte(&traverse);
1903 switch (extopcode)
1904 {
1905 case DW_LNE_end_sequence:
1906 dwarf2_set_line_number(ctx->module, address, &files, file, line);
1907 end_sequence = TRUE;
1908 break;
1909 case DW_LNE_set_address:
1910 address = ctx->load_offset + dwarf2_parse_addr(&traverse);
1911 break;
1912 case DW_LNE_define_file:
1913 FIXME("not handled %s\n", traverse.data);
1914 traverse.data += strlen((const char *)traverse.data) + 1;
1915 dwarf2_leb128_as_unsigned(&traverse);
1916 dwarf2_leb128_as_unsigned(&traverse);
1917 dwarf2_leb128_as_unsigned(&traverse);
1918 break;
1919 default:
1920 FIXME("Unsupported extended opcode %x\n", extopcode);
1921 break;
1922 }
1923 break;
1924 default:
1925 WARN("Unsupported opcode %x\n", opcode);
1926 for (i = 0; i < opcode_len[opcode]; i++)
1927 dwarf2_leb128_as_unsigned(&traverse);
1928 break;
1929 }
1930 }
1931 }
1932 }
1933 return TRUE;
1934 }
1935
1936 static BOOL dwarf2_parse_compilation_unit(const dwarf2_section_t* sections,
1937 const dwarf2_comp_unit_t* comp_unit,
1938 struct module* module,
1939 const struct elf_thunk_area* thunks,
1940 const unsigned char* comp_unit_cursor,
1941 unsigned long load_offset)
1942 {
1943 dwarf2_parse_context_t ctx;
1944 dwarf2_traverse_context_t traverse;
1945 dwarf2_traverse_context_t abbrev_ctx;
1946 dwarf2_debug_info_t* di;
1947 BOOL ret = FALSE;
1948
1949 TRACE("Compilation Unit Header found at 0x%x:\n",
1950 comp_unit_cursor - sections[section_debug].address);
1951 TRACE("- length: %lu\n", comp_unit->length);
1952 TRACE("- version: %u\n", comp_unit->version);
1953 TRACE("- abbrev_offset: %lu\n", comp_unit->abbrev_offset);
1954 TRACE("- word_size: %u\n", comp_unit->word_size);
1955
1956 if (comp_unit->version != 2)
1957 {
1958 WARN("%u DWARF version unsupported. Wine dbghelp only support DWARF 2.\n",
1959 comp_unit->version);
1960 return FALSE;
1961 }
1962
1963 pool_init(&ctx.pool, 65536);
1964 ctx.sections = sections;
1965 ctx.section = section_debug;
1966 ctx.module = module;
1967 ctx.word_size = comp_unit->word_size;
1968 ctx.thunks = thunks;
1969 ctx.load_offset = load_offset;
1970 ctx.ref_offset = comp_unit_cursor - sections[section_debug].address;
1971
1972 traverse.start_data = comp_unit_cursor + sizeof(dwarf2_comp_unit_stream_t);
1973 traverse.data = traverse.start_data;
1974 traverse.word_size = comp_unit->word_size;
1975 traverse.end_data = comp_unit_cursor + comp_unit->length + sizeof(unsigned);
1976
1977 abbrev_ctx.start_data = sections[section_abbrev].address + comp_unit->abbrev_offset;
1978 abbrev_ctx.data = abbrev_ctx.start_data;
1979 abbrev_ctx.end_data = sections[section_abbrev].address + sections[section_abbrev].size;
1980 abbrev_ctx.word_size = comp_unit->word_size;
1981 dwarf2_parse_abbrev_set(&abbrev_ctx, &ctx.abbrev_table, &ctx.pool);
1982
1983 sparse_array_init(&ctx.debug_info_table, sizeof(dwarf2_debug_info_t), 128);
1984 dwarf2_read_one_debug_info(&ctx, &traverse, &di);
1985
1986 if (di->abbrev->tag == DW_TAG_compile_unit)
1987 {
1988 struct attribute name;
1989 dwarf2_debug_info_t** pdi = NULL;
1990 struct attribute stmt_list, low_pc;
1991 struct attribute comp_dir;
1992
1993 if (!dwarf2_find_attribute(&ctx, di, DW_AT_name, &name))
1994 name.u.string = NULL;
1995
1996 /* get working directory of current compilation unit */
1997 if (!dwarf2_find_attribute(&ctx, di, DW_AT_comp_dir, &comp_dir))
1998 comp_dir.u.string = NULL;
1999
2000 if (!dwarf2_find_attribute(&ctx, di, DW_AT_low_pc, &low_pc))
2001 low_pc.u.uvalue = 0;
2002 di->symt = &symt_new_compiland(module,
2003 ctx.load_offset + low_pc.u.uvalue,
2004 source_new(module, comp_dir.u.string, name.u.string))->symt;
2005
2006 if (di->abbrev->have_child)
2007 {
2008 int i;
2009 for (i=0; i<vector_length(&di->children); i++)
2010 {
2011 pdi = vector_at(&di->children, i);
2012 dwarf2_load_one_entry(&ctx, *pdi, (struct symt_compiland*)di->symt);
2013 }
2014 }
2015 if (dwarf2_find_attribute(&ctx, di, DW_AT_stmt_list, &stmt_list))
2016 {
2017 if (dwarf2_parse_line_numbers(sections, &ctx, comp_dir.u.string, stmt_list.u.uvalue))
2018 module->module.LineNumbers = TRUE;
2019 }
2020 ret = TRUE;
2021 }
2022 else FIXME("Should have a compilation unit here\n");
2023 pool_destroy(&ctx.pool);
2024 return ret;
2025 }
2026
2027 static BOOL dwarf2_lookup_loclist(const struct module* module, const BYTE* start,
2028 unsigned long ip,
2029 dwarf2_traverse_context_t* lctx)
2030 {
2031 DWORD beg, end;
2032 const BYTE* ptr = start;
2033 DWORD len;
2034
2035 while (ptr < module->dwarf2_info->debug_loc.address + module->dwarf2_info->debug_loc.size)
2036 {
2037 beg = dwarf2_get_u4(ptr); ptr += 4;
2038 end = dwarf2_get_u4(ptr); ptr += 4;
2039 if (!beg && !end) break;
2040 len = dwarf2_get_u2(ptr); ptr += 2;
2041
2042 if (beg <= ip && ip < end)
2043 {
2044 lctx->data = ptr;
2045 lctx->end_data = ptr + len;
2046 lctx->word_size = 4; /* FIXME word size !!! */
2047 return TRUE;
2048 }
2049 ptr += len;
2050 }
2051 WARN("Couldn't find ip in location list\n");
2052 return FALSE;
2053 }
2054
2055 static enum location_error loc_compute_frame(struct process* pcs,
2056 const struct module* module,
2057 const struct symt_function* func,
2058 DWORD ip, struct location* frame)
2059 {
2060 struct symt** psym = NULL;
2061 struct location* pframe;
2062 dwarf2_traverse_context_t lctx;
2063 enum location_error err;
2064 int i;
2065
2066 for (i=0; i<vector_length(&func->vchildren); i++)
2067 {
2068 psym = vector_at(&func->vchildren, i);
2069 if ((*psym)->tag == SymTagCustom)
2070 {
2071 pframe = &((struct symt_function_point*)*psym)->loc;
2072
2073 /* First, recompute the frame information, if needed */
2074 switch (pframe->kind)
2075 {
2076 case loc_regrel:
2077 case loc_register:
2078 *frame = *pframe;
2079 break;
2080 case loc_dwarf2_location_list:
2081 WARN("Searching loclist for %s\n", func->hash_elt.name);
2082 if (!dwarf2_lookup_loclist(module,
2083 module->dwarf2_info->debug_loc.address + pframe->offset,
2084 ip, &lctx))
2085 return loc_err_out_of_scope;
2086 if ((err = compute_location(&lctx, frame, pcs->handle, NULL)) < 0) return err;
2087 if (frame->kind >= loc_user)
2088 {
2089 WARN("Couldn't compute runtime frame location\n");
2090 return loc_err_too_complex;
2091 }
2092 break;
2093 default:
2094 WARN("Unsupported frame kind %d\n", pframe->kind);
2095 return loc_err_internal;
2096 }
2097 return 0;
2098 }
2099 }
2100 WARN("Couldn't find Custom function point, whilst location list offset is searched\n");
2101 return loc_err_internal;
2102 }
2103
2104 static void dwarf2_location_compute(struct process* pcs,
2105 const struct module* module,
2106 const struct symt_function* func,
2107 struct location* loc)
2108 {
2109 struct location frame;
2110 DWORD ip;
2111 int err;
2112 dwarf2_traverse_context_t lctx;
2113
2114 if (!func->container || func->container->tag != SymTagCompiland)
2115 {
2116 WARN("We'd expect function %s's container to exist and be a compiland\n", func->hash_elt.name);
2117 err = loc_err_internal;
2118 }
2119 else
2120 {
2121 /* instruction pointer relative to compiland's start */
2122 ip = pcs->ctx_frame.InstructionOffset - ((struct symt_compiland*)func->container)->address;
2123
2124 if ((err = loc_compute_frame(pcs, module, func, ip, &frame)) == 0)
2125 {
2126 switch (loc->kind)
2127 {
2128 case loc_dwarf2_location_list:
2129 /* Then, if the variable has a location list, find it !! */
2130 if (dwarf2_lookup_loclist(module,
2131 module->dwarf2_info->debug_loc.address + loc->offset,
2132 ip, &lctx))
2133 goto do_compute;
2134 err = loc_err_out_of_scope;
2135 break;
2136 case loc_dwarf2_block:
2137 /* or if we have a copy of an existing block, get ready for it */
2138 {
2139 unsigned* ptr = (unsigned*)loc->offset;
2140
2141 lctx.data = (const BYTE*)(ptr + 1);
2142 lctx.end_data = lctx.data + *ptr;
2143 lctx.word_size = 4; /* FIXME !! */
2144 }
2145 do_compute:
2146 /* now get the variable */
2147 err = compute_location(&lctx, loc, pcs->handle, &frame);
2148 break;
2149 case loc_register:
2150 case loc_regrel:
2151 /* nothing to do */
2152 break;
2153 default:
2154 WARN("Unsupported local kind %d\n", loc->kind);
2155 err = loc_err_internal;
2156 }
2157 }
2158 }
2159 if (err < 0)
2160 {
2161 loc->kind = loc_register;
2162 loc->reg = err;
2163 }
2164 }
2165
2166 BOOL dwarf2_parse(struct module* module, unsigned long load_offset,
2167 const struct elf_thunk_area* thunks,
2168 const unsigned char* debug, unsigned int debug_size,
2169 const unsigned char* abbrev, unsigned int abbrev_size,
2170 const unsigned char* str, unsigned int str_size,
2171 const unsigned char* line, unsigned int line_size,
2172 const unsigned char* loclist, unsigned int loclist_size)
2173 {
2174 dwarf2_section_t section[section_max];
2175 unsigned char* ptr;
2176 const unsigned char*comp_unit_cursor = debug;
2177 const unsigned char*end_debug = debug + debug_size;
2178
2179 module->loc_compute = dwarf2_location_compute;
2180
2181 section[section_debug].address = debug;
2182 section[section_debug].size = debug_size;
2183 section[section_abbrev].address = abbrev;
2184 section[section_abbrev].size = abbrev_size;
2185 section[section_string].address = str;
2186 section[section_string].size = str_size;
2187 section[section_line].address = line;
2188 section[section_line].size = line_size;
2189
2190 if (loclist_size)
2191 {
2192 /* initialize the dwarf2 specific info block for this module.
2193 * As we'll need later on the .debug_loc section content, we copy it in
2194 * the module structure for later reuse
2195 */
2196 module->dwarf2_info = HeapAlloc(GetProcessHeap(), 0, sizeof(*module->dwarf2_info) + loclist_size);
2197 if (!module->dwarf2_info) return FALSE;
2198 ptr = (unsigned char*)(module->dwarf2_info + 1);
2199 memcpy(ptr, loclist, loclist_size);
2200 module->dwarf2_info->debug_loc.address = ptr;
2201 module->dwarf2_info->debug_loc.size = loclist_size;
2202 }
2203
2204 while (comp_unit_cursor < end_debug)
2205 {
2206 const dwarf2_comp_unit_stream_t* comp_unit_stream;
2207 dwarf2_comp_unit_t comp_unit;
2208
2209 comp_unit_stream = (const dwarf2_comp_unit_stream_t*) comp_unit_cursor;
2210 comp_unit.length = *(const unsigned long*) comp_unit_stream->length;
2211 comp_unit.version = *(const unsigned short*) comp_unit_stream->version;
2212 comp_unit.abbrev_offset = *(const unsigned long*) comp_unit_stream->abbrev_offset;
2213 comp_unit.word_size = *(const unsigned char*) comp_unit_stream->word_size;
2214
2215 dwarf2_parse_compilation_unit(section, &comp_unit, module,
2216 thunks, comp_unit_cursor, load_offset);
2217 comp_unit_cursor += comp_unit.length + sizeof(unsigned);
2218 }
2219 module->module.SymType = SymDia;
2220 module->module.CVSig = 'D' | ('W' << 8) | ('A' << 16) | ('R' << 24);
2221 /* FIXME: we could have a finer grain here */
2222 module->module.GlobalSymbols = TRUE;
2223 module->module.TypeInfo = TRUE;
2224 module->module.SourceIndexed = TRUE;
2225 module->module.Publics = TRUE;
2226 return TRUE;
2227 }