git.oblomov.eu Git - wine/blob - dlls/dbghelp/dwarf.c

   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 "winreg.h"
  48 #include "winnls.h"
  49
  50 #include "dbghelp_private.h"
  51
  52 #include "wine/debug.h"
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_dwarf);
  55
  56 /* FIXME:
  57  * - Functions:
  58  *      o unspecified parameters
  59  *      o inlined functions
  60  *      o Debug{Start|End}Point
  61  *      o CFA
  62  * - Udt
  63  *      o proper types loading (nesting)
  64  */
  65
  66 #if 0
  67 static void dump(const void* ptr, unsigned len)
  68 {
  69     int         i, j;
  70     BYTE        msg[128];
  71     static const char hexof[] = "0123456789abcdef";
  72     const       BYTE* x = (const BYTE*)ptr;
  73
  74     for (i = 0; i < len; i += 16)
  75     {
  76         sprintf(msg, "%08x: ", i);
  77         memset(msg + 10, ' ', 3 * 16 + 1 + 16);
  78         for (j = 0; j < min(16, len - i); j++)
  79         {
  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) ?
  84                 x[i + j] : '.';
  85         }
  86         msg[10 + 3 * 16] = ' ';
  87         msg[10 + 3 * 16 + 1 + 16] = '\0';
  88         TRACE("%s\n", msg);
  89     }
  90 }
  91 #endif
  92
  93 /**
  94  *
  95  * Main Specs:
  96  *  http://www.eagercon.com/dwarf/dwarf3std.htm
  97  *  http://www.eagercon.com/dwarf/dwarf-2.0.0.pdf
  98  *
  99  * dwarf2.h: http://www.hakpetzna.com/b/binutils/dwarf2_8h-source.html
 100  *
 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
 104  */
 105 #include "dwarf.h"
 106
 107 /**
 108  * Parsers
 109  */
 110
 111 typedef struct dwarf2_abbrev_entry_attr_s {
 112   unsigned long attribute;
 113   unsigned long form;
 114   struct dwarf2_abbrev_entry_attr_s* next;
 115 } dwarf2_abbrev_entry_attr_t;
 116
 117 typedef struct dwarf2_abbrev_entry_s
 118 {
 119     unsigned long entry_code;
 120     unsigned long tag;
 121     unsigned char have_child;
 122     unsigned num_attr;
 123     dwarf2_abbrev_entry_attr_t* attrs;
 124 } dwarf2_abbrev_entry_t;
 125
 126 struct dwarf2_block
 127 {
 128     unsigned                    size;
 129     const unsigned char*        ptr;
 130 };
 131
 132 union attribute
 133 {
 134     unsigned long                   uvalue;
 135     long                            svalue;
 136     const char*                     string;
 137     struct dwarf2_block*            block;
 138 };
 139
 140 typedef struct dwarf2_debug_info_s
 141 {
 142     unsigned long               offset;
 143     const dwarf2_abbrev_entry_t*abbrev;
 144     struct symt*                symt;
 145     union attribute*            attributes;
 146     struct vector               children;
 147 } dwarf2_debug_info_t;
 148
 149
 150 typedef struct dwarf2_section_s
 151 {
 152     const unsigned char*        address;
 153     unsigned                    size;
 154 } dwarf2_section_t;
 155
 156 enum dwarf2_sections {section_debug, section_string, section_abbrev, section_line, section_max};
 157
 158 typedef struct dwarf2_traverse_context_s
 159 {
 160     const dwarf2_section_t*     sections;
 161     unsigned                    section;
 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;
 168
 169 typedef struct dwarf2_parse_context_s
 170 {
 171     struct pool                 pool;
 172     struct module*              module;
 173     const struct elf_thunk_area*thunks;
 174     struct sparse_array         abbrev_table;
 175     struct sparse_array         debug_info_table;
 176     unsigned char               word_size;
 177 } dwarf2_parse_context_t;
 178
 179 /* forward declarations */
 180 static struct symt* dwarf2_parse_enumeration_type(dwarf2_parse_context_t* ctx, dwarf2_debug_info_t* entry);
 181
 182 static unsigned char dwarf2_parse_byte(dwarf2_traverse_context_t* ctx)
 183 {
 184     unsigned char uvalue = *(const unsigned char*) ctx->data;
 185     ctx->data += 1;
 186     return uvalue;
 187 }
 188
 189 static unsigned short dwarf2_parse_u2(dwarf2_traverse_context_t* ctx)
 190 {
 191     unsigned short uvalue = *(const unsigned short*) ctx->data;
 192     ctx->data += 2;
 193     return uvalue;
 194 }
 195
 196 static unsigned long dwarf2_parse_u4(dwarf2_traverse_context_t* ctx)
 197 {
 198     unsigned long uvalue = *(const unsigned int*) ctx->data;
 199     ctx->data += 4;
 200     return uvalue;
 201 }
 202
 203 static unsigned long dwarf2_leb128_as_unsigned(dwarf2_traverse_context_t* ctx)
 204 {
 205     unsigned long ret = 0;
 206     unsigned char byte;
 207     unsigned shift = 0;
 208
 209     assert( NULL != ctx );
 210
 211     do
 212     {
 213         byte = dwarf2_parse_byte(ctx);
 214         ret |= (byte & 0x7f) << shift;
 215         shift += 7;
 216     } while (byte & 0x80);
 217
 218     return ret;
 219 }
 220
 221 static long dwarf2_leb128_as_signed(dwarf2_traverse_context_t* ctx)
 222 {
 223     long ret = 0;
 224     unsigned char byte;
 225     unsigned shift = 0;
 226     const unsigned size = sizeof(int) * 8;
 227
 228     assert( NULL != ctx );
 229
 230     do
 231     {
 232         byte = dwarf2_parse_byte(ctx);
 233         ret |= (byte & 0x7f) << shift;
 234         shift += 7;
 235     } while (byte & 0x80);
 236
 237     /* as spec: sign bit of byte is 2nd high order bit (80x40)
 238      *  -> 0x80 is used as flag.
 239      */
 240     if ((shift < size) && (byte & 0x40))
 241     {
 242         ret |= - (1 << shift);
 243     }
 244     return ret;
 245 }
 246
 247 static unsigned long dwarf2_parse_addr(dwarf2_traverse_context_t* ctx)
 248 {
 249     unsigned long ret;
 250
 251     switch (ctx->word_size)
 252     {
 253     case 4:
 254         ret = dwarf2_parse_u4(ctx);
 255         break;
 256     default:
 257         FIXME("Unsupported Word Size %u\n", ctx->word_size);
 258         ret = 0;
 259     }
 260     return ret;
 261 }
 262
 263 static const char* dwarf2_debug_traverse_ctx(const dwarf2_traverse_context_t* ctx)
 264 {
 265     return wine_dbg_sprintf("ctx(0x%x)", ctx->data - ctx->sections[ctx->section].address);
 266 }
 267
 268 static const char* dwarf2_debug_ctx(const dwarf2_parse_context_t* ctx)
 269 {
 270     return wine_dbg_sprintf("ctx(%p,%s)", ctx, ctx->module->module.ModuleName);
 271 }
 272
 273 static const char* dwarf2_debug_di(dwarf2_debug_info_t* di)
 274 {
 275     return wine_dbg_sprintf("debug_info(offset:0x%lx,abbrev:%p,symt:%p)",
 276                             di->offset, di->abbrev, di->symt);
 277 }
 278
 279 static dwarf2_abbrev_entry_t*
 280 dwarf2_abbrev_table_find_entry(struct sparse_array* abbrev_table,
 281                                unsigned long entry_code)
 282 {
 283     assert( NULL != abbrev_table );
 284     return sparse_array_find(abbrev_table, entry_code);
 285 }
 286
 287 static void dwarf2_parse_abbrev_set(dwarf2_traverse_context_t* abbrev_ctx,
 288                                     struct sparse_array* abbrev_table,
 289                                     struct pool* pool)
 290 {
 291     unsigned long entry_code;
 292     dwarf2_abbrev_entry_t* abbrev_entry;
 293     dwarf2_abbrev_entry_attr_t* new = NULL;
 294     dwarf2_abbrev_entry_attr_t* last = NULL;
 295     unsigned long attribute;
 296     unsigned long form;
 297
 298     assert( NULL != abbrev_ctx );
 299
 300     TRACE("%s, end at %p\n",
 301           dwarf2_debug_traverse_ctx(abbrev_ctx), abbrev_ctx->end_data);
 302
 303     sparse_array_init(abbrev_table, sizeof(dwarf2_abbrev_entry_t), 32);
 304     while (abbrev_ctx->data < abbrev_ctx->end_data)
 305     {
 306         TRACE("now at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx));
 307         entry_code = dwarf2_leb128_as_unsigned(abbrev_ctx);
 308         TRACE("found entry_code %lu\n", entry_code);
 309         if (!entry_code)
 310         {
 311             TRACE("NULL entry code at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx));
 312             break;
 313         }
 314         abbrev_entry = sparse_array_add(abbrev_table, entry_code, pool);
 315         assert( NULL != abbrev_entry );
 316
 317         abbrev_entry->entry_code = entry_code;
 318         abbrev_entry->tag        = dwarf2_leb128_as_unsigned(abbrev_ctx);
 319         abbrev_entry->have_child = dwarf2_parse_byte(abbrev_ctx);
 320         abbrev_entry->attrs      = NULL;
 321         abbrev_entry->num_attr   = 0;
 322
 323         TRACE("table:(%p,#%u) entry_code(%lu) tag(0x%lx) have_child(%u) -> %p\n",
 324               abbrev_table, sparse_array_length(abbrev_table),
 325               entry_code, abbrev_entry->tag, abbrev_entry->have_child, abbrev_entry);
 326
 327         last = NULL;
 328         while (1)
 329         {
 330             attribute = dwarf2_leb128_as_unsigned(abbrev_ctx);
 331             form = dwarf2_leb128_as_unsigned(abbrev_ctx);
 332             if (!attribute) break;
 333
 334             new = pool_alloc(pool, sizeof(dwarf2_abbrev_entry_attr_t));
 335             assert(new);
 336
 337             new->attribute = attribute;
 338             new->form      = form;
 339             new->next      = NULL;
 340             if (abbrev_entry->attrs)    last->next = new;
 341             else                        abbrev_entry->attrs = new;
 342             last = new;
 343             abbrev_entry->num_attr++;
 344         }
 345     }
 346     TRACE("found %u entries\n", sparse_array_length(abbrev_table));
 347 }
 348
 349 static void dwarf2_parse_attr_into_di(struct pool* pool,
 350                                       dwarf2_traverse_context_t* ctx,
 351                                       const dwarf2_abbrev_entry_attr_t* abbrev_attr,
 352                                       union attribute* attr)
 353
 354 {
 355     TRACE("(attr:0x%lx,form:0x%lx)\n", abbrev_attr->attribute, abbrev_attr->form);
 356
 357     switch (abbrev_attr->form) {
 358     case DW_FORM_ref_addr:
 359     case DW_FORM_addr:
 360         attr->uvalue = dwarf2_parse_addr(ctx);
 361         TRACE("addr<0x%lx>\n", attr->uvalue);
 362         break;
 363
 364     case DW_FORM_flag:
 365         attr->uvalue = dwarf2_parse_byte(ctx);
 366         TRACE("flag<0x%lx>\n", attr->uvalue);
 367         break;
 368
 369     case DW_FORM_data1:
 370         attr->uvalue = dwarf2_parse_byte(ctx);
 371         TRACE("data1<%lu>\n", attr->uvalue);
 372         break;
 373
 374     case DW_FORM_data2:
 375         attr->uvalue = dwarf2_parse_u2(ctx);
 376         TRACE("data2<%lu>\n", attr->uvalue);
 377         break;
 378
 379     case DW_FORM_data4:
 380         attr->uvalue = dwarf2_parse_u4(ctx);
 381         TRACE("data4<%lu>\n", attr->uvalue);
 382         break;
 383
 384     case DW_FORM_data8:
 385         FIXME("Unhandled 64bits support\n");
 386         ctx->data += 8;
 387         break;
 388
 389     case DW_FORM_ref1:
 390         attr->uvalue = ctx->offset + dwarf2_parse_byte(ctx);
 391         TRACE("ref1<0x%lx>\n", attr->uvalue);
 392         break;
 393
 394     case DW_FORM_ref2:
 395         attr->uvalue = ctx->offset + dwarf2_parse_u2(ctx);
 396         TRACE("ref2<0x%lx>\n", attr->uvalue);
 397         break;
 398
 399     case DW_FORM_ref4:
 400         attr->uvalue = ctx->offset + dwarf2_parse_u4(ctx);
 401         TRACE("ref4<0x%lx>\n", attr->uvalue);
 402         break;
 403
 404     case DW_FORM_ref8:
 405         FIXME("Unhandled 64 bit support\n");
 406         ctx->data += 8;
 407         break;
 408
 409     case DW_FORM_sdata:
 410         attr->svalue = dwarf2_leb128_as_signed(ctx);
 411         break;
 412
 413     case DW_FORM_ref_udata:
 414         attr->uvalue = dwarf2_leb128_as_unsigned(ctx);
 415         break;
 416
 417     case DW_FORM_udata:
 418         attr->uvalue = dwarf2_leb128_as_unsigned(ctx);
 419         break;
 420
 421     case DW_FORM_string:
 422         attr->string = (const char*)ctx->data;
 423         ctx->data += strlen(attr->string) + 1;
 424         TRACE("string<%s>\n", attr->string);
 425         break;
 426
 427     case DW_FORM_strp:
 428         {
 429             unsigned long offset = dwarf2_parse_u4(ctx);
 430             attr->string = (const char*)ctx->sections[section_string].address + offset;
 431         }
 432         TRACE("strp<%s>\n", attr->string);
 433         break;
 434     case DW_FORM_block:
 435         attr->block = pool_alloc(pool, sizeof(struct dwarf2_block));
 436         attr->block->size = dwarf2_leb128_as_unsigned(ctx);
 437         attr->block->ptr  = ctx->data;
 438         ctx->data += attr->block->size;
 439         break;
 440
 441     case DW_FORM_block1:
 442         attr->block = pool_alloc(pool, sizeof(struct dwarf2_block));
 443         attr->block->size = dwarf2_parse_byte(ctx);
 444         attr->block->ptr  = ctx->data;
 445         ctx->data += attr->block->size;
 446         break;
 447
 448     case DW_FORM_block2:
 449         attr->block = pool_alloc(pool, sizeof(struct dwarf2_block));
 450         attr->block->size = dwarf2_parse_u2(ctx);
 451         attr->block->ptr  = ctx->data;
 452         ctx->data += attr->block->size;
 453         break;
 454
 455     case DW_FORM_block4:
 456         attr->block = pool_alloc(pool, sizeof(struct dwarf2_block));
 457         attr->block->size = dwarf2_parse_u4(ctx);
 458         attr->block->ptr  = ctx->data;
 459         ctx->data += attr->block->size;
 460         break;
 461
 462     default:
 463         FIXME("Unhandled attribute form %lx\n", abbrev_attr->form);
 464         break;
 465     }
 466 }
 467
 468 static BOOL dwarf2_find_attribute(const dwarf2_debug_info_t* di,
 469                                   unsigned at, union attribute* attr)
 470 {
 471     unsigned                    i;
 472     dwarf2_abbrev_entry_attr_t* abbrev_attr;
 473
 474     for (i = 0, abbrev_attr = di->abbrev->attrs; abbrev_attr; i++, abbrev_attr = abbrev_attr->next)
 475     {
 476         if (abbrev_attr->attribute == at)
 477         {
 478             *attr = di->attributes[i];
 479             return TRUE;
 480         }
 481     }
 482     return FALSE;
 483 }
 484
 485 static void dwarf2_find_name(dwarf2_parse_context_t* ctx,
 486                              const dwarf2_debug_info_t* di,
 487                              union attribute* attr, const char* pfx)
 488 {
 489     static      int index;
 490
 491     if (!dwarf2_find_attribute(di, DW_AT_name, attr))
 492     {
 493         char* tmp = pool_alloc(&ctx->pool, strlen(pfx) + 16);
 494         if (tmp) sprintf(tmp, "%s_%d", pfx, index++);
 495         attr->string = tmp;
 496     }
 497 }
 498
 499 static void dwarf2_load_one_entry(dwarf2_parse_context_t*, dwarf2_debug_info_t*,
 500                                   struct symt_compiland*);
 501
 502 #define Wine_DW_no_register     -1
 503 #define Wine_DW_frame_register  -2
 504
 505 static unsigned long dwarf2_compute_location(dwarf2_parse_context_t* ctx,
 506                                              struct dwarf2_block* block,
 507                                              int* in_register)
 508 {
 509     unsigned long loc[64];
 510     unsigned stk;
 511
 512     if (in_register) *in_register = Wine_DW_no_register;
 513     loc[stk = 0] = 0;
 514
 515     if (block->size)
 516     {
 517         dwarf2_traverse_context_t  lctx;
 518         unsigned char op;
 519         BOOL piece_found = FALSE;
 520
 521         lctx.data = block->ptr;
 522         lctx.end_data = block->ptr + block->size;
 523         lctx.word_size = ctx->word_size;
 524
 525         while (lctx.data < lctx.end_data)
 526         {
 527             op = dwarf2_parse_byte(&lctx);
 528             switch (op)
 529             {
 530             case DW_OP_addr:    loc[++stk] = dwarf2_parse_addr(&lctx); break;
 531             case DW_OP_const1u: loc[++stk] = dwarf2_parse_byte(&lctx); break;
 532             case DW_OP_const1s: loc[++stk] = (long)(signed char)dwarf2_parse_byte(&lctx); break;
 533             case DW_OP_const2u: loc[++stk] = dwarf2_parse_u2(&lctx); break;
 534             case DW_OP_const2s: loc[++stk] = (long)(short)dwarf2_parse_u2(&lctx); break;
 535             case DW_OP_const4u: loc[++stk] = dwarf2_parse_u4(&lctx); break;
 536             case DW_OP_const4s: loc[++stk] = dwarf2_parse_u4(&lctx); break;
 537             case DW_OP_constu:  loc[++stk] = dwarf2_leb128_as_unsigned(&lctx); break;
 538             case DW_OP_consts:  loc[++stk] = dwarf2_leb128_as_signed(&lctx); break;
 539             case DW_OP_plus_uconst:
 540                                 loc[stk] += dwarf2_leb128_as_unsigned(&lctx); break;
 541             case DW_OP_reg0:  case DW_OP_reg1:  case DW_OP_reg2:  case DW_OP_reg3:
 542             case DW_OP_reg4:  case DW_OP_reg5:  case DW_OP_reg6:  case DW_OP_reg7:
 543             case DW_OP_reg8:  case DW_OP_reg9:  case DW_OP_reg10: case DW_OP_reg11:
 544             case DW_OP_reg12: case DW_OP_reg13: case DW_OP_reg14: case DW_OP_reg15:
 545             case DW_OP_reg16: case DW_OP_reg17: case DW_OP_reg18: case DW_OP_reg19:
 546             case DW_OP_reg20: case DW_OP_reg21: case DW_OP_reg22: case DW_OP_reg23:
 547             case DW_OP_reg24: case DW_OP_reg25: case DW_OP_reg26: case DW_OP_reg27:
 548             case DW_OP_reg28: case DW_OP_reg29: case DW_OP_reg30: case DW_OP_reg31:
 549                 if (in_register)
 550                 {
 551                     /* dbghelp APIs don't know how to cope with this anyway
 552                      * (for example 'long long' stored in two registers)
 553                      * FIXME: We should tell winedbg how to deal with it (sigh)
 554                      */
 555                     if (!piece_found || (op - DW_OP_reg0 != *in_register + 1))
 556                     {
 557                         if (*in_register != Wine_DW_no_register)
 558                             FIXME("Only supporting one reg (%d -> %d)\n",
 559                                   *in_register, op - DW_OP_reg0);
 560                         *in_register = op - DW_OP_reg0;
 561                     }
 562                 }
 563                 else FIXME("Found register, while not expecting it\n");
 564                 break;
 565             case DW_OP_fbreg:
 566                 if (in_register)
 567                 {
 568                     if (*in_register != Wine_DW_no_register)
 569                         FIXME("Only supporting one reg (%d -> -2)\n", *in_register);
 570                     *in_register = Wine_DW_frame_register;
 571                 }
 572                 else FIXME("Found register, while not expecting it\n");
 573                 loc[++stk] = dwarf2_leb128_as_signed(&lctx);
 574                 break;
 575             case DW_OP_piece:
 576                 {
 577                     unsigned sz = dwarf2_leb128_as_unsigned(&lctx);
 578                     WARN("Not handling OP_piece directly (size=%d)\n", sz);
 579                     piece_found = TRUE;
 580                 }
 581                 break;
 582             default:
 583                 FIXME("Unhandled attr op: %x\n", op);
 584                 return loc[stk];
 585             }
 586         }
 587     }
 588     return loc[stk];
 589 }
 590
 591 static struct symt* dwarf2_lookup_type(dwarf2_parse_context_t* ctx,
 592                                        const dwarf2_debug_info_t* di)
 593 {
 594     union attribute     attr;
 595
 596     if (dwarf2_find_attribute(di, DW_AT_type, &attr))
 597     {
 598         dwarf2_debug_info_t*    type;
 599
 600         type = sparse_array_find(&ctx->debug_info_table, attr.uvalue);
 601         if (!type) FIXME("Unable to find back reference to type %lx\n", attr.uvalue);
 602         if (!type->symt)
 603         {
 604             /* load the debug info entity */
 605             dwarf2_load_one_entry(ctx, type, NULL);
 606         }
 607         return type->symt;
 608     }
 609     return NULL;
 610 }
 611
 612 /******************************************************************
 613  *              dwarf2_read_one_debug_info
 614  *
 615  * Loads into memory one debug info entry, and recursively its children (if any)
 616  */
 617 static BOOL dwarf2_read_one_debug_info(dwarf2_parse_context_t* ctx,
 618                                        dwarf2_traverse_context_t* traverse,
 619                                        dwarf2_debug_info_t** pdi)
 620 {
 621     const dwarf2_abbrev_entry_t*abbrev;
 622     unsigned long               entry_code;
 623     unsigned long               offset;
 624     dwarf2_debug_info_t*        di;
 625     dwarf2_debug_info_t*        child;
 626     dwarf2_debug_info_t**       where;
 627     dwarf2_abbrev_entry_attr_t* attr;
 628     unsigned                    i;
 629     union attribute             sibling;
 630
 631     offset = traverse->data - traverse->sections[traverse->section].address;
 632     entry_code = dwarf2_leb128_as_unsigned(traverse);
 633     TRACE("found entry_code %lu at 0x%lx\n", entry_code, offset);
 634     if (!entry_code)
 635     {
 636         *pdi = NULL;
 637         return TRUE;
 638     }
 639     abbrev = dwarf2_abbrev_table_find_entry(&ctx->abbrev_table, entry_code);
 640     if (!abbrev)
 641     {
 642         WARN("Cannot find abbrev entry for %lu at 0x%lx\n", entry_code, offset);
 643         return FALSE;
 644     }
 645     di = sparse_array_add(&ctx->debug_info_table, offset, &ctx->pool);
 646     if (!di) return FALSE;
 647     di->offset = offset;
 648     di->abbrev = abbrev;
 649     di->symt   = NULL;
 650
 651     if (abbrev->num_attr)
 652     {
 653         di->attributes = pool_alloc(&ctx->pool,
 654                                     abbrev->num_attr * sizeof(union attribute));
 655         for (i = 0, attr = abbrev->attrs; attr; i++, attr = attr->next)
 656         {
 657             dwarf2_parse_attr_into_di(&ctx->pool, traverse, attr, &di->attributes[i]);
 658         }
 659     }
 660     else di->attributes = NULL;
 661     if (abbrev->have_child)
 662     {
 663         vector_init(&di->children, sizeof(dwarf2_debug_info_t*), 16);
 664         while (traverse->data < traverse->end_data)
 665         {
 666             if (!dwarf2_read_one_debug_info(ctx, traverse, &child)) return FALSE;
 667             if (!child) break;
 668             where = vector_add(&di->children, &ctx->pool);
 669             if (!where) return FALSE;
 670             *where = child;
 671         }
 672     }
 673     if (dwarf2_find_attribute(di, DW_AT_sibling, &sibling) &&
 674         traverse->data != traverse->sections[traverse->section].address + sibling.uvalue)
 675     {
 676         WARN("setting cursor for %s to next sibling <0x%lx>\n",
 677              dwarf2_debug_traverse_ctx(traverse), sibling.uvalue);
 678         traverse->data = traverse->sections[traverse->section].address + sibling.uvalue;
 679     }
 680     *pdi = di;
 681     return TRUE;
 682 }
 683
 684 static struct symt* dwarf2_parse_base_type(dwarf2_parse_context_t* ctx,
 685                                            dwarf2_debug_info_t* di)
 686 {
 687     union attribute name;
 688     union attribute size;
 689     union attribute encoding;
 690     enum BasicType bt;
 691
 692     if (di->symt) return di->symt;
 693
 694     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 695
 696     dwarf2_find_name(ctx, di, &name, "base_type");
 697     if (!dwarf2_find_attribute(di, DW_AT_byte_size, &size)) size.uvalue = 0;
 698     if (!dwarf2_find_attribute(di, DW_AT_encoding, &encoding)) encoding.uvalue = DW_ATE_void;
 699
 700     switch (encoding.uvalue)
 701     {
 702     case DW_ATE_void:           bt = btVoid; break;
 703     case DW_ATE_address:        bt = btULong; break;
 704     case DW_ATE_boolean:        bt = btBool; break;
 705     case DW_ATE_complex_float:  bt = btComplex; break;
 706     case DW_ATE_float:          bt = btFloat; break;
 707     case DW_ATE_signed:         bt = btInt; break;
 708     case DW_ATE_unsigned:       bt = btUInt; break;
 709     case DW_ATE_signed_char:    bt = btChar; break;
 710     case DW_ATE_unsigned_char:  bt = btChar; break;
 711     default:                    bt = btNoType; break;
 712     }
 713     di->symt = &symt_new_basic(ctx->module, bt, name.string, size.uvalue)->symt;
 714     if (di->abbrev->have_child) FIXME("Unsupported children\n");
 715     return di->symt;
 716 }
 717
 718 static struct symt* dwarf2_parse_typedef(dwarf2_parse_context_t* ctx,
 719                                          dwarf2_debug_info_t* di)
 720 {
 721     struct symt* ref_type;
 722     union attribute name;
 723
 724     if (di->symt) return di->symt;
 725
 726     TRACE("%s, for %lu\n", dwarf2_debug_ctx(ctx), di->abbrev->entry_code);
 727
 728     dwarf2_find_name(ctx, di, &name, "typedef");
 729     ref_type = dwarf2_lookup_type(ctx, di);
 730
 731     if (name.string)
 732     {
 733         di->symt = &symt_new_typedef(ctx->module, ref_type, name.string)->symt;
 734     }
 735     if (di->abbrev->have_child) FIXME("Unsupported children\n");
 736     return di->symt;
 737 }
 738
 739 static struct symt* dwarf2_parse_pointer_type(dwarf2_parse_context_t* ctx,
 740                                               dwarf2_debug_info_t* di)
 741 {
 742     struct symt* ref_type;
 743     union attribute size;
 744
 745     if (di->symt) return di->symt;
 746
 747     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 748
 749     if (!dwarf2_find_attribute(di, DW_AT_byte_size, &size)) size.uvalue = 0;
 750     ref_type = dwarf2_lookup_type(ctx, di);
 751
 752     di->symt = &symt_new_pointer(ctx->module, ref_type)->symt;
 753     if (di->abbrev->have_child) FIXME("Unsupported children\n");
 754     return di->symt;
 755 }
 756
 757 static struct symt* dwarf2_parse_array_type(dwarf2_parse_context_t* ctx,
 758                                             dwarf2_debug_info_t* di)
 759 {
 760     struct symt* ref_type;
 761     struct symt* idx_type = NULL;
 762     union attribute min, max, cnt;
 763     dwarf2_debug_info_t** pchild = NULL;
 764     dwarf2_debug_info_t* child;
 765
 766     if (di->symt) return di->symt;
 767
 768     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 769
 770     if (!di->abbrev->have_child)
 771     {
 772         FIXME("array without range information\n");
 773         return NULL;
 774     }
 775     ref_type = dwarf2_lookup_type(ctx, di);
 776
 777     while ((pchild = vector_iter_up(&di->children, pchild)))
 778     {
 779         child = *pchild;
 780         switch (child->abbrev->tag)
 781         {
 782         case DW_TAG_subrange_type:
 783             idx_type = dwarf2_lookup_type(ctx, child);
 784             if (!dwarf2_find_attribute(child, DW_AT_lower_bound, &min))
 785                 min.uvalue = 0;
 786             if (!dwarf2_find_attribute(child, DW_AT_upper_bound, &max))
 787                 max.uvalue = 0;
 788             if (dwarf2_find_attribute(child, DW_AT_count, &cnt))
 789                 max.uvalue = min.uvalue + cnt.uvalue;
 790             break;
 791         default:
 792             FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
 793                   child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 794             break;
 795         }
 796     }
 797     di->symt = &symt_new_array(ctx->module, min.uvalue, max.uvalue, ref_type, idx_type)->symt;
 798     return di->symt;
 799 }
 800
 801 static struct symt* dwarf2_parse_const_type(dwarf2_parse_context_t* ctx,
 802                                             dwarf2_debug_info_t* di)
 803 {
 804     struct symt* ref_type;
 805
 806     if (di->symt) return di->symt;
 807
 808     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 809
 810     ref_type = dwarf2_lookup_type(ctx, di);
 811     if (di->abbrev->have_child) FIXME("Unsupported children\n");
 812     di->symt = ref_type;
 813
 814     return ref_type;
 815 }
 816
 817 static struct symt* dwarf2_parse_reference_type(dwarf2_parse_context_t* ctx,
 818                                                 dwarf2_debug_info_t* di)
 819 {
 820     struct symt* ref_type = NULL;
 821
 822     if (di->symt) return di->symt;
 823
 824     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 825
 826     ref_type = dwarf2_lookup_type(ctx, di);
 827     /* FIXME: for now, we hard-wire C++ references to pointers */
 828     di->symt = &symt_new_pointer(ctx->module, ref_type)->symt;
 829
 830     if (di->abbrev->have_child) FIXME("Unsupported children\n");
 831
 832     return di->symt;
 833 }
 834
 835 static void dwarf2_parse_udt_member(dwarf2_parse_context_t* ctx,
 836                                     dwarf2_debug_info_t* di,
 837                                     struct symt_udt* parent)
 838 {
 839     struct symt* elt_type;
 840     union attribute name;
 841     union attribute loc;
 842     unsigned long offset = 0;
 843     union attribute bit_size;
 844     union attribute bit_offset;
 845
 846     assert(parent);
 847
 848     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 849
 850     dwarf2_find_name(ctx, di, &name, "udt_member");
 851     elt_type = dwarf2_lookup_type(ctx, di);
 852     if (dwarf2_find_attribute(di, DW_AT_data_member_location, &loc))
 853     {
 854         TRACE("found member_location at %s\n", dwarf2_debug_ctx(ctx));
 855         offset = dwarf2_compute_location(ctx, loc.block, NULL);
 856         TRACE("found offset:%lu\n", offset);
 857     }
 858     if (!dwarf2_find_attribute(di, DW_AT_bit_size, &bit_size))   bit_size.uvalue = 0;
 859     if (dwarf2_find_attribute(di, DW_AT_bit_offset, &bit_offset))
 860     {
 861         /* FIXME: we should only do this when implementation is LSB (which is
 862          * the case on i386 processors)
 863          */
 864         union attribute nbytes;
 865         if (!dwarf2_find_attribute(di, DW_AT_byte_size, &nbytes))
 866         {
 867             DWORD64     size;
 868             nbytes.uvalue = symt_get_info(elt_type, TI_GET_LENGTH, &size) ? (unsigned long)size : 0;
 869         }
 870         bit_offset.uvalue = nbytes.uvalue * 8 - bit_offset.uvalue - bit_size.uvalue;
 871     }
 872     else bit_offset.uvalue = 0;
 873     symt_add_udt_element(ctx->module, parent, name.string, elt_type,
 874                          (offset << 3) + bit_offset.uvalue, bit_size.uvalue);
 875
 876     if (di->abbrev->have_child) FIXME("Unsupported children\n");
 877 }
 878
 879 static struct symt* dwarf2_parse_udt_type(dwarf2_parse_context_t* ctx,
 880                                           dwarf2_debug_info_t* di,
 881                                           enum UdtKind udt)
 882 {
 883     union attribute name;
 884     union attribute size;
 885
 886     if (di->symt) return di->symt;
 887
 888     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 889
 890     dwarf2_find_name(ctx, di, &name, "udt");
 891     if (!dwarf2_find_attribute(di, DW_AT_byte_size, &size)) size.uvalue = 0;
 892
 893     di->symt = &symt_new_udt(ctx->module, name.string, size.uvalue, udt)->symt;
 894
 895     if (di->abbrev->have_child) /** any interest to not have child ? */
 896     {
 897         dwarf2_debug_info_t**    pchild = NULL;
 898         dwarf2_debug_info_t*    child;
 899
 900         while ((pchild = vector_iter_up(&di->children, pchild)))
 901         {
 902             child = *pchild;
 903
 904             switch (child->abbrev->tag)
 905             {
 906             case DW_TAG_member:
 907                 /* FIXME: should I follow the sibling stuff ?? */
 908                 dwarf2_parse_udt_member(ctx, child, (struct symt_udt*)di->symt);
 909                 break;
 910             case DW_TAG_enumeration_type:
 911                 dwarf2_parse_enumeration_type(ctx, child);
 912                 break;
 913             case DW_TAG_structure_type:
 914             case DW_TAG_class_type:
 915             case DW_TAG_union_type:
 916                 /* FIXME: we need to handle nested udt definitions */
 917                 break;
 918             default:
 919                 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
 920                       child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 921                 break;
 922             }
 923         }
 924     }
 925
 926     return di->symt;
 927 }
 928
 929 static void dwarf2_parse_enumerator(dwarf2_parse_context_t* ctx,
 930                                     dwarf2_debug_info_t* di,
 931                                     struct symt_enum* parent)
 932 {
 933     union attribute name;
 934     union attribute value;
 935
 936     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 937
 938     dwarf2_find_name(ctx, di, &name, "enum_value");
 939     if (!dwarf2_find_attribute(di, DW_AT_const_value, &value)) value.svalue = 0;
 940     symt_add_enum_element(ctx->module, parent, name.string, value.svalue);
 941
 942     if (di->abbrev->have_child) FIXME("Unsupported children\n");
 943 }
 944
 945 static struct symt* dwarf2_parse_enumeration_type(dwarf2_parse_context_t* ctx,
 946                                                   dwarf2_debug_info_t* di)
 947 {
 948     union attribute name;
 949     union attribute size;
 950
 951     if (di->symt) return di->symt;
 952
 953     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 954
 955     dwarf2_find_name(ctx, di, &name, "enum");
 956     if (!dwarf2_find_attribute(di, DW_AT_byte_size, &size)) size.uvalue = 0;
 957
 958     di->symt = &symt_new_enum(ctx->module, name.string)->symt;
 959
 960     if (di->abbrev->have_child) /* any interest to not have child ? */
 961     {
 962         dwarf2_debug_info_t**   pchild = NULL;
 963         dwarf2_debug_info_t*    child;
 964
 965         /* FIXME: should we use the sibling stuff ?? */
 966         while ((pchild = vector_iter_up(&di->children, pchild)))
 967         {
 968             child = *pchild;
 969
 970             switch (child->abbrev->tag)
 971             {
 972             case DW_TAG_enumerator:
 973                 dwarf2_parse_enumerator(ctx, child, (struct symt_enum*)di->symt);
 974                 break;
 975             default:
 976                 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
 977                       di->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
 978             }
 979         }
 980     }
 981     return di->symt;
 982 }
 983
 984 static unsigned dwarf2_map_register(int regno)
 985 {
 986     unsigned    reg;
 987
 988     switch (regno)
 989     {
 990     case Wine_DW_no_register: FIXME("What the heck\n"); reg = 0; break;
 991     /* FIXME: this is a dirty hack */
 992     case Wine_DW_frame_register: reg = 0;          break;
 993     case  0: reg = CV_REG_EAX; break;
 994     case  1: reg = CV_REG_ECX; break;
 995     case  2: reg = CV_REG_EDX; break;
 996     case  3: reg = CV_REG_EBX; break;
 997     case  4: reg = CV_REG_ESP; break;
 998     case  5: reg = CV_REG_EBP; break;
 999     case  6: reg = CV_REG_ESI; break;
1000     case  7: reg = CV_REG_EDI; break;
1001     case  8: reg = CV_REG_EIP; break;
1002     case  9: reg = CV_REG_EFLAGS; break;
1003     case 10: reg = CV_REG_CS;  break;
1004     case 11: reg = CV_REG_SS;  break;
1005     case 12: reg = CV_REG_DS;  break;
1006     case 13: reg = CV_REG_ES;  break;
1007     case 14: reg = CV_REG_FS;  break;
1008     case 15: reg = CV_REG_GS;  break;
1009     case 16: case 17: case 18: case 19:
1010     case 20: case 21: case 22: case 23:
1011         reg = CV_REG_ST0 + regno - 16; break;
1012     case 24: reg = CV_REG_CTRL; break;
1013     case 25: reg = CV_REG_STAT; break;
1014     case 26: reg = CV_REG_TAG; break;
1015 /*
1016 reg: fiseg 27
1017 reg: fioff 28
1018 reg: foseg 29
1019 reg: fooff 30
1020 reg: fop   31
1021 */
1022     case 32: case 33: case 34: case 35:
1023     case 36: case 37: case 38: case 39:
1024         reg = CV_REG_XMM0 + regno - 32; break;
1025     case 40: reg = CV_REG_MXCSR; break;
1026     default:
1027         FIXME("Don't know how to map register %d\n", regno);
1028         return 0;
1029     }
1030     return reg;
1031 }
1032
1033 /* structure used to pass information around when parsing a subprogram */
1034 typedef struct dwarf2_subprogram_s
1035 {
1036     dwarf2_parse_context_t*     ctx;
1037     struct symt_compiland*      compiland;
1038     struct symt_function*       func;
1039     long                        frame_offset;
1040     int                         frame_reg;
1041 } dwarf2_subprogram_t;
1042
1043 /******************************************************************
1044  *              dwarf2_parse_variable
1045  *
1046  * Parses any variable (parameter, local/global variable)
1047  */
1048 static void dwarf2_parse_variable(dwarf2_subprogram_t* subpgm,
1049                                   struct symt_block* block,
1050                                   dwarf2_debug_info_t* di)
1051 {
1052     struct symt* param_type;
1053     union attribute loc;
1054     BOOL is_pmt = di->abbrev->tag == DW_TAG_formal_parameter;
1055
1056     TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1057
1058     param_type = dwarf2_lookup_type(subpgm->ctx, di);
1059     if (dwarf2_find_attribute(di, DW_AT_location, &loc))
1060     {
1061         union attribute name;
1062         union attribute ext;
1063         long offset;
1064         int in_reg;
1065
1066         dwarf2_find_name(subpgm->ctx, di, &name, "parameter");
1067         offset = dwarf2_compute_location(subpgm->ctx, loc.block, &in_reg);
1068         TRACE("found parameter %s/%ld (reg=%d) at %s\n",
1069               name.string, offset, in_reg, dwarf2_debug_ctx(subpgm->ctx));
1070         switch (in_reg)
1071         {
1072         case Wine_DW_no_register:
1073             /* it's a global variable */
1074             /* FIXME: we don't handle it's scope yet */
1075             if (!dwarf2_find_attribute(di, DW_AT_external, &ext))
1076                 ext.uvalue = 0;
1077             symt_new_global_variable(subpgm->ctx->module, subpgm->compiland,
1078                                      name.string, !ext.uvalue,
1079                                      subpgm->ctx->module->module.BaseOfImage + offset,
1080                                      0, param_type);
1081             break;
1082         case Wine_DW_frame_register:
1083             in_reg = subpgm->frame_reg;
1084             offset += subpgm->frame_offset;
1085             /* fall through */
1086         default:
1087             /* either a pmt/variable relative to frame pointer or
1088              * pmt/variable in a register
1089              */
1090             symt_add_func_local(subpgm->ctx->module, subpgm->func,
1091                                 is_pmt ? DataIsParam : DataIsLocal,
1092                                 dwarf2_map_register(in_reg), offset,
1093                                 block, param_type, name.string);
1094             break;
1095         }
1096     }
1097     if (is_pmt && subpgm->func && subpgm->func->type)
1098         symt_add_function_signature_parameter(subpgm->ctx->module,
1099                                               (struct symt_function_signature*)subpgm->func->type,
1100                                               param_type);
1101
1102     if (di->abbrev->have_child) FIXME("Unsupported children\n");
1103 }
1104
1105 static void dwarf2_parse_subprogram_label(dwarf2_subprogram_t* subpgm,
1106                                           dwarf2_debug_info_t* di)
1107 {
1108     union attribute name;
1109     union attribute low_pc;
1110
1111     TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1112
1113     if (!dwarf2_find_attribute(di, DW_AT_low_pc, &low_pc)) low_pc.uvalue = 0;
1114     dwarf2_find_name(subpgm->ctx, di, &name, "label");
1115
1116     symt_add_function_point(subpgm->ctx->module, subpgm->func, SymTagLabel,
1117                             subpgm->ctx->module->module.BaseOfImage + low_pc.uvalue, name.string);
1118 }
1119
1120 static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t* subpgm,
1121                                           struct symt_block* block_parent,
1122                                           dwarf2_debug_info_t* di);
1123
1124 static void dwarf2_parse_inlined_subroutine(dwarf2_subprogram_t* subpgm,
1125                                             dwarf2_debug_info_t* di)
1126 {
1127     TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1128
1129     /* FIXME: attributes to handle:
1130        DW_AT_low_pc:
1131        DW_AT_high_pc:
1132        DW_AT_name:
1133     */
1134
1135     if (di->abbrev->have_child) /** any interest to not have child ? */
1136     {
1137         dwarf2_debug_info_t**   pchild = NULL;
1138         dwarf2_debug_info_t*    child;
1139
1140         while ((pchild = vector_iter_up(&di->children, pchild)))
1141         {
1142             child = *pchild;
1143
1144             switch (child->abbrev->tag)
1145             {
1146             case DW_TAG_formal_parameter:
1147                 /* FIXME: this is not properly supported yet
1148                  * dwarf2_parse_subprogram_parameter(ctx, child, NULL);
1149                  */
1150                 break;
1151             case DW_TAG_variable:
1152                 /* FIXME:
1153                  * dwarf2_parse_variable(ctx, child);
1154                  */
1155                 break;
1156             case DW_TAG_lexical_block:
1157                 /* FIXME:
1158                    dwarf2_parse_subprogram_block(ctx, child, func);
1159                 */
1160                 break;
1161             case DW_TAG_inlined_subroutine:
1162                 /* FIXME */
1163                 dwarf2_parse_inlined_subroutine(subpgm, child);
1164                 break;
1165             case DW_TAG_label:
1166                 dwarf2_parse_subprogram_label(subpgm, child);
1167                 break;
1168             default:
1169                 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1170                       child->abbrev->tag, dwarf2_debug_ctx(subpgm->ctx),
1171                       dwarf2_debug_di(di));
1172             }
1173         }
1174     }
1175 }
1176
1177 static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t* subpgm,
1178                                           struct symt_block* parent_block,
1179                                           dwarf2_debug_info_t* di)
1180 {
1181     struct symt_block*  block;
1182     union attribute     low_pc;
1183     union attribute     high_pc;
1184
1185     TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1186
1187     if (!dwarf2_find_attribute(di, DW_AT_low_pc, &low_pc)) low_pc.uvalue = 0;
1188     if (!dwarf2_find_attribute(di, DW_AT_high_pc, &high_pc)) high_pc.uvalue = 0;
1189
1190     block = symt_open_func_block(subpgm->ctx->module, subpgm->func, parent_block,
1191                                  low_pc.uvalue, high_pc.uvalue - low_pc.uvalue);
1192
1193     if (di->abbrev->have_child) /** any interest to not have child ? */
1194     {
1195         dwarf2_debug_info_t**   pchild = NULL;
1196         dwarf2_debug_info_t*    child;
1197
1198         while ((pchild = vector_iter_up(&di->children, pchild)))
1199         {
1200             child = *pchild;
1201
1202             switch (child->abbrev->tag)
1203             {
1204             case DW_TAG_inlined_subroutine:
1205                 dwarf2_parse_inlined_subroutine(subpgm, child);
1206                 break;
1207             case DW_TAG_variable:
1208                 dwarf2_parse_variable(subpgm, block, child);
1209                 break;
1210             case DW_TAG_lexical_block:
1211                 dwarf2_parse_subprogram_block(subpgm, block, child);
1212                 break;
1213             case DW_TAG_subprogram:
1214                 /* FIXME: likely a declaration (to be checked)
1215                  * skip it for now
1216                  */
1217                 break;
1218             case DW_TAG_formal_parameter:
1219                 /* FIXME: likely elements for exception handling (GCC flavor)
1220                  * Skip it for now
1221                  */
1222                 break;
1223             case DW_TAG_class_type:
1224             case DW_TAG_structure_type:
1225             case DW_TAG_union_type:
1226             case DW_TAG_enumeration_type:
1227                 /* the type referred to will be loaded when we need it, so skip it */
1228                 break;
1229             default:
1230                 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1231                       child->abbrev->tag, dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di));
1232             }
1233         }
1234     }
1235
1236     symt_close_func_block(subpgm->ctx->module, subpgm->func, block, 0);
1237 }
1238
1239 static struct symt* dwarf2_parse_subprogram(dwarf2_parse_context_t* ctx,
1240                                             dwarf2_debug_info_t* di,
1241                                             struct symt_compiland* compiland)
1242 {
1243     union attribute name;
1244     union attribute low_pc;
1245     union attribute high_pc;
1246     union attribute is_decl;
1247     union attribute inline_flags;
1248     union attribute frame;
1249     struct symt* ret_type;
1250     struct symt_function_signature* sig_type;
1251     dwarf2_subprogram_t subpgm;
1252
1253     if (di->symt) return di->symt;
1254
1255     TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1256
1257     if (!dwarf2_find_attribute(di, DW_AT_low_pc, &low_pc)) low_pc.uvalue = 0;
1258     if (!dwarf2_find_attribute(di, DW_AT_high_pc, &high_pc)) high_pc.uvalue = 0;
1259     /* As functions (defined as inline assembly) get debug info with dwarf
1260      * (not the case for stabs), we just drop Wine's thunks here...
1261      * Actual thunks will be created in elf_module from the symbol table
1262      */
1263     if (elf_is_in_thunk_area(ctx->module->module.BaseOfImage + low_pc.uvalue,
1264                              ctx->thunks) >= 0)
1265         return NULL;
1266     if (!dwarf2_find_attribute(di, DW_AT_declaration, &is_decl)) is_decl.uvalue = 0;
1267     if (!dwarf2_find_attribute(di, DW_AT_inline, &inline_flags)) inline_flags.uvalue = 0;
1268     dwarf2_find_name(ctx, di, &name, "subprogram");
1269     ret_type = dwarf2_lookup_type(ctx, di);
1270
1271     /* FIXME: assuming C source code */
1272     sig_type = symt_new_function_signature(ctx->module, ret_type, CV_CALL_FAR_C);
1273     if (!is_decl.uvalue)
1274     {
1275         subpgm.func = symt_new_function(ctx->module, compiland, name.string,
1276                                         ctx->module->module.BaseOfImage + low_pc.uvalue,
1277                                         high_pc.uvalue - low_pc.uvalue,
1278                                         &sig_type->symt);
1279         di->symt = &subpgm.func->symt;
1280     }
1281     else subpgm.func = NULL;
1282
1283     subpgm.ctx = ctx;
1284     subpgm.compiland = compiland;
1285     if (dwarf2_find_attribute(di, DW_AT_frame_base, &frame))
1286     {
1287         subpgm.frame_offset = dwarf2_compute_location(ctx, frame.block, &subpgm.frame_reg);
1288         TRACE("For %s got %ld/%d\n", name.string, subpgm.frame_offset, subpgm.frame_reg);
1289     }
1290     else /* on stack !! */
1291     {
1292         subpgm.frame_reg = 0;
1293         subpgm.frame_offset = 0;
1294     }
1295
1296     if (di->abbrev->have_child) /** any interest to not have child ? */
1297     {
1298         dwarf2_debug_info_t**   pchild = NULL;
1299         dwarf2_debug_info_t*    child;
1300
1301         while ((pchild = vector_iter_up(&di->children, pchild)))
1302         {
1303             child = *pchild;
1304
1305             switch (child->abbrev->tag)
1306             {
1307             case DW_TAG_variable:
1308             case DW_TAG_formal_parameter:
1309                 dwarf2_parse_variable(&subpgm, NULL, child);
1310                 break;
1311             case DW_TAG_lexical_block:
1312                 dwarf2_parse_subprogram_block(&subpgm, NULL, child);
1313                 break;
1314             case DW_TAG_inlined_subroutine:
1315                 dwarf2_parse_inlined_subroutine(&subpgm, child);
1316                 break;
1317             case DW_TAG_subprogram:
1318                 /* FIXME: likely a declaration (to be checked)
1319                  * skip it for now
1320                  */
1321                 break;
1322             case DW_TAG_label:
1323                 dwarf2_parse_subprogram_label(&subpgm, child);
1324                 break;
1325             case DW_TAG_class_type:
1326             case DW_TAG_structure_type:
1327             case DW_TAG_union_type:
1328             case DW_TAG_enumeration_type:
1329             case DW_TAG_typedef:
1330                 /* the type referred to will be loaded when we need it, so skip it */
1331                 break;
1332             case DW_TAG_unspecified_parameters:
1333                 /* FIXME: no support in dbghelp's internals so far */
1334                 break;
1335             default:
1336                 FIXME("Unhandled Tag type 0x%lx at %s, for %s\n",
1337                       child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
1338             }
1339         }
1340     }
1341
1342     symt_normalize_function(subpgm.ctx->module, subpgm.func);
1343
1344     return di->symt;
1345 }
1346
1347 static void dwarf2_load_one_entry(dwarf2_parse_context_t* ctx,
1348                                   dwarf2_debug_info_t* di,
1349                                   struct symt_compiland* compiland)
1350 {
1351     switch (di->abbrev->tag)
1352     {
1353     case DW_TAG_typedef:
1354         dwarf2_parse_typedef(ctx, di);
1355         break;
1356     case DW_TAG_base_type:
1357         dwarf2_parse_base_type(ctx, di);
1358         break;
1359     case DW_TAG_pointer_type:
1360         dwarf2_parse_pointer_type(ctx, di);
1361         break;
1362     case DW_TAG_class_type:
1363         dwarf2_parse_udt_type(ctx, di, UdtClass);
1364         break;
1365     case DW_TAG_structure_type:
1366         dwarf2_parse_udt_type(ctx, di, UdtStruct);
1367         break;
1368     case DW_TAG_union_type:
1369         dwarf2_parse_udt_type(ctx, di, UdtUnion);
1370         break;
1371     case DW_TAG_array_type:
1372         dwarf2_parse_array_type(ctx, di);
1373         break;
1374     case DW_TAG_const_type:
1375         dwarf2_parse_const_type(ctx, di);
1376         break;
1377     case DW_TAG_reference_type:
1378         dwarf2_parse_reference_type(ctx, di);
1379         break;
1380     case DW_TAG_enumeration_type:
1381         dwarf2_parse_enumeration_type(ctx, di);
1382         break;
1383     case DW_TAG_subprogram:
1384         dwarf2_parse_subprogram(ctx, di, compiland);
1385         break;
1386     default:
1387         WARN("Unhandled Tag type 0x%lx at %s, for %lu\n",
1388              di->abbrev->tag, dwarf2_debug_ctx(ctx), di->abbrev->entry_code);
1389     }
1390 }
1391
1392 static void dwarf2_set_line_number(struct module* module, unsigned long address,
1393                                    struct vector* v, unsigned file, unsigned line)
1394 {
1395     struct symt_function*       func;
1396     int                         idx;
1397     unsigned*                   psrc;
1398
1399     if (!file || !(psrc = vector_at(v, file - 1))) return;
1400
1401     TRACE("%s %lx %s %u\n", module->module.ModuleName, address, source_get(module, *psrc), line);
1402     if ((idx = symt_find_nearest(module, address)) == -1 ||
1403         module->addr_sorttab[idx]->symt.tag != SymTagFunction) return;
1404     func = (struct symt_function*)module->addr_sorttab[idx];
1405     symt_add_func_line(module, func, *psrc, line, address - func->address);
1406 }
1407
1408 static void dwarf2_parse_line_numbers(const dwarf2_section_t* sections,
1409                                       dwarf2_parse_context_t* ctx,
1410                                       unsigned long offset)
1411 {
1412     dwarf2_traverse_context_t   traverse;
1413     unsigned long               length;
1414     unsigned                    version, header_len, insn_size, default_stmt;
1415     unsigned                    line_range, opcode_base;
1416     int                         line_base;
1417     const unsigned char*        opcode_len;
1418     struct vector               dirs;
1419     struct vector               files;
1420     const char**                p;
1421
1422     traverse.sections = sections;
1423     traverse.section = section_line;
1424     traverse.data = sections[section_line].address + offset;
1425     traverse.start_data = traverse.data;
1426     traverse.end_data = traverse.data + 4;
1427     traverse.offset = offset;
1428     traverse.word_size = ctx->word_size;
1429
1430     length = dwarf2_parse_u4(&traverse);
1431     traverse.end_data = traverse.start_data + length;
1432
1433     version = dwarf2_parse_u2(&traverse);
1434     header_len = dwarf2_parse_u4(&traverse);
1435     insn_size = dwarf2_parse_byte(&traverse);
1436     default_stmt = dwarf2_parse_byte(&traverse);
1437     line_base = (signed char)dwarf2_parse_byte(&traverse);
1438     line_range = dwarf2_parse_byte(&traverse);
1439     opcode_base = dwarf2_parse_byte(&traverse);
1440
1441     opcode_len = traverse.data;
1442     traverse.data += opcode_base - 1;
1443
1444     vector_init(&dirs, sizeof(const char*), 4);
1445     p = vector_add(&dirs, &ctx->pool);
1446     *p = ".";
1447     while (*traverse.data)
1448     {
1449         TRACE("Got include %s\n", (const char*)traverse.data);
1450         p = vector_add(&dirs, &ctx->pool);
1451         *p = (const char *)traverse.data;
1452         traverse.data += strlen((const char *)traverse.data) + 1;
1453     }
1454     traverse.data++;
1455
1456     vector_init(&files, sizeof(unsigned), 16);
1457     while (*traverse.data)
1458     {
1459         unsigned int    dir_index, mod_time, length;
1460         const char*     name;
1461         const char*     dir;
1462         unsigned*       psrc;
1463
1464         name = (const char*)traverse.data;
1465         traverse.data += strlen(name) + 1;
1466         dir_index = dwarf2_leb128_as_unsigned(&traverse);
1467         mod_time = dwarf2_leb128_as_unsigned(&traverse);
1468         length = dwarf2_leb128_as_unsigned(&traverse);
1469         dir = *(const char**)vector_at(&dirs, dir_index);
1470         TRACE("Got file %s/%s (%u,%u)\n", dir, name, mod_time, length);
1471         psrc = vector_add(&files, &ctx->pool);
1472         *psrc = source_new(ctx->module, dir, name);
1473     }
1474     traverse.data++;
1475
1476     while (traverse.data < traverse.end_data)
1477     {
1478         unsigned long address = 0;
1479         unsigned file = 1;
1480         unsigned line = 1;
1481         unsigned is_stmt = default_stmt;
1482         BOOL basic_block = FALSE, end_sequence = FALSE;
1483         unsigned opcode, extopcode, i;
1484
1485         while (!end_sequence)
1486         {
1487             opcode = dwarf2_parse_byte(&traverse);
1488             TRACE("Got opcode %x\n", opcode);
1489
1490             if (opcode >= opcode_base)
1491             {
1492                 unsigned delta = opcode - opcode_base;
1493
1494                 address += (delta / line_range) * insn_size;
1495                 line += line_base + (delta % line_range);
1496                 basic_block = TRUE;
1497                 dwarf2_set_line_number(ctx->module, address, &files, file, line);
1498             }
1499             else
1500             {
1501                 switch (opcode)
1502                 {
1503                 case DW_LNS_copy:
1504                     basic_block = FALSE;
1505                     dwarf2_set_line_number(ctx->module, address, &files, file, line);
1506                     break;
1507                 case DW_LNS_advance_pc:
1508                     address += insn_size * dwarf2_leb128_as_unsigned(&traverse);
1509                     break;
1510                 case DW_LNS_advance_line:
1511                     line += dwarf2_leb128_as_signed(&traverse);
1512                     break;
1513                 case DW_LNS_set_file:
1514                     file = dwarf2_leb128_as_unsigned(&traverse);
1515                     break;
1516                 case DW_LNS_set_column:
1517                     dwarf2_leb128_as_unsigned(&traverse);
1518                     break;
1519                 case DW_LNS_negate_stmt:
1520                     is_stmt = !is_stmt;
1521                     break;
1522                 case DW_LNS_set_basic_block:
1523                     basic_block = 1;
1524                     break;
1525                 case DW_LNS_const_add_pc:
1526                     address += ((255 - opcode_base) / line_range) * insn_size;
1527                     break;
1528                 case DW_LNS_fixed_advance_pc:
1529                     address += dwarf2_parse_u2(&traverse);
1530                     break;
1531                 case DW_LNS_extended_op:
1532                     dwarf2_leb128_as_unsigned(&traverse);
1533                     extopcode = dwarf2_parse_byte(&traverse);
1534                     switch (extopcode)
1535                     {
1536                     case DW_LNE_end_sequence:
1537                         dwarf2_set_line_number(ctx->module, address, &files, file, line);
1538                         end_sequence = TRUE;
1539                         break;
1540                     case DW_LNE_set_address:
1541                         address = ctx->module->module.BaseOfImage + dwarf2_parse_addr(&traverse);
1542                         break;
1543                     case DW_LNE_define_file:
1544                         FIXME("not handled %s\n", traverse.data);
1545                         traverse.data += strlen((const char *)traverse.data) + 1;
1546                         dwarf2_leb128_as_unsigned(&traverse);
1547                         dwarf2_leb128_as_unsigned(&traverse);
1548                         dwarf2_leb128_as_unsigned(&traverse);
1549                         break;
1550                     default:
1551                         FIXME("Unsupported extended opcode %x\n", extopcode);
1552                         break;
1553                     }
1554                     break;
1555                 default:
1556                     WARN("Unsupported opcode %x\n", opcode);
1557                     for (i = 0; i < opcode_len[opcode]; i++)
1558                         dwarf2_leb128_as_unsigned(&traverse);
1559                     break;
1560                 }
1561             }
1562         }
1563     }
1564 }
1565
1566 static BOOL dwarf2_parse_compilation_unit(const dwarf2_section_t* sections,
1567                                           const dwarf2_comp_unit_t* comp_unit,
1568                                           struct module* module,
1569                                           const struct elf_thunk_area* thunks,
1570                                           const unsigned char* comp_unit_cursor)
1571 {
1572     dwarf2_parse_context_t ctx;
1573     dwarf2_traverse_context_t traverse;
1574     dwarf2_traverse_context_t abbrev_ctx;
1575     dwarf2_debug_info_t* di;
1576     BOOL ret = FALSE;
1577
1578     TRACE("Compilation Unit Header found at 0x%x:\n",
1579           comp_unit_cursor - sections[section_debug].address);
1580     TRACE("- length:        %lu\n", comp_unit->length);
1581     TRACE("- version:       %u\n",  comp_unit->version);
1582     TRACE("- abbrev_offset: %lu\n", comp_unit->abbrev_offset);
1583     TRACE("- word_size:     %u\n",  comp_unit->word_size);
1584
1585     if (comp_unit->version != 2)
1586     {
1587         WARN("%u DWARF version unsupported. Wine dbghelp only support DWARF 2.\n",
1588              comp_unit->version);
1589         return FALSE;
1590     }
1591
1592     pool_init(&ctx.pool, 65536);
1593     ctx.module = module;
1594     ctx.word_size = comp_unit->word_size;
1595     ctx.thunks = thunks;
1596
1597     traverse.sections = sections;
1598     traverse.section = section_debug;
1599     traverse.start_data = comp_unit_cursor + sizeof(dwarf2_comp_unit_stream_t);
1600     traverse.data = traverse.start_data;
1601     traverse.offset = comp_unit_cursor - sections[section_debug].address;
1602     traverse.word_size = comp_unit->word_size;
1603     traverse.end_data = comp_unit_cursor + comp_unit->length + sizeof(unsigned);
1604
1605     abbrev_ctx.sections = sections;
1606     abbrev_ctx.section = section_abbrev;
1607     abbrev_ctx.start_data = sections[section_abbrev].address + comp_unit->abbrev_offset;
1608     abbrev_ctx.data = abbrev_ctx.start_data;
1609     abbrev_ctx.end_data = sections[section_abbrev].address + sections[section_abbrev].size;
1610     abbrev_ctx.offset = comp_unit->abbrev_offset;
1611     abbrev_ctx.word_size = comp_unit->word_size;
1612     dwarf2_parse_abbrev_set(&abbrev_ctx, &ctx.abbrev_table, &ctx.pool);
1613
1614     sparse_array_init(&ctx.debug_info_table, sizeof(dwarf2_debug_info_t), 128);
1615     dwarf2_read_one_debug_info(&ctx, &traverse, &di);
1616
1617     if (di->abbrev->tag == DW_TAG_compile_unit)
1618     {
1619         union attribute             name;
1620         dwarf2_debug_info_t**       pdi = NULL;
1621         union attribute             stmt_list;
1622
1623         TRACE("beginning at 0x%lx, for %lu\n", di->offset, di->abbrev->entry_code);
1624
1625         dwarf2_find_name(&ctx, di, &name, "compiland");
1626         di->symt = &symt_new_compiland(module, source_new(module, NULL, name.string))->symt;
1627
1628         if (di->abbrev->have_child)
1629         {
1630             while ((pdi = vector_iter_up(&di->children, pdi)))
1631             {
1632                 dwarf2_load_one_entry(&ctx, *pdi, (struct symt_compiland*)di->symt);
1633             }
1634         }
1635         if (dwarf2_find_attribute(di, DW_AT_stmt_list, &stmt_list))
1636         {
1637             dwarf2_parse_line_numbers(sections, &ctx, stmt_list.uvalue);
1638         }
1639         ret = TRUE;
1640     }
1641     else FIXME("Should have a compilation unit here\n");
1642     pool_destroy(&ctx.pool);
1643     return ret;
1644 }
1645
1646 BOOL dwarf2_parse(struct module* module, unsigned long load_offset,
1647                   const struct elf_thunk_area* thunks,
1648                   const unsigned char* debug, unsigned int debug_size,
1649                   const unsigned char* abbrev, unsigned int abbrev_size,
1650                   const unsigned char* str, unsigned int str_size,
1651                   const unsigned char* line, unsigned int line_size)
1652 {
1653     dwarf2_section_t    section[section_max];
1654     const unsigned char*comp_unit_cursor = debug;
1655     const unsigned char*end_debug = debug + debug_size;
1656
1657     section[section_debug].address = debug;
1658     section[section_debug].size = debug_size;
1659     section[section_abbrev].address = abbrev;
1660     section[section_abbrev].size = abbrev_size;
1661     section[section_string].address = str;
1662     section[section_string].size = str_size;
1663     section[section_line].address = line;
1664     section[section_line].size = line_size;
1665
1666     while (comp_unit_cursor < end_debug)
1667     {
1668         const dwarf2_comp_unit_stream_t* comp_unit_stream;
1669         dwarf2_comp_unit_t comp_unit;
1670
1671         comp_unit_stream = (const dwarf2_comp_unit_stream_t*) comp_unit_cursor;
1672         comp_unit.length = *(unsigned long*)  comp_unit_stream->length;
1673         comp_unit.version = *(unsigned short*) comp_unit_stream->version;
1674         comp_unit.abbrev_offset = *(unsigned long*) comp_unit_stream->abbrev_offset;
1675         comp_unit.word_size = *(unsigned char*) comp_unit_stream->word_size;
1676
1677         dwarf2_parse_compilation_unit(section, &comp_unit, module,
1678                                       thunks, comp_unit_cursor);
1679         comp_unit_cursor += comp_unit.length + sizeof(unsigned);
1680     }
1681     module->module.SymType = SymDia;
1682     module->module.CVSig = 'D' | ('W' << 8) | ('A' << 16) | ('R' << 24);
1683     /* FIXME: we could have a finer grain here */
1684     module->module.LineNumbers = TRUE;
1685     module->module.GlobalSymbols = TRUE;
1686     module->module.TypeInfo = TRUE;
1687     module->module.SourceIndexed = TRUE;
1688     module->module.Publics = TRUE;
1689     return TRUE;
1690 }