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

   1 /*
   2  * File stabs.c - read stabs information from the modules
   3  *
   4  * Copyright (C) 1996,      Eric Youngdale.
   5  *               1999-2004, 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *
  22  * Maintenance Information
  23  * -----------------------
  24  *
  25  * For documentation on the stabs format see for example
  26  *   The "stabs" debug format
  27  *     by Julia Menapace, Jim Kingdon, David Mackenzie
  28  *     of Cygnus Support
  29  *     available (hopefully) from http:\\sources.redhat.com\gdb\onlinedocs
  30  */
  31
  32 #include "config.h"
  33
  34 #include <sys/types.h>
  35 #include <fcntl.h>
  36 #include <sys/stat.h>
  37 #ifdef HAVE_SYS_MMAN_H
  38 #include <sys/mman.h>
  39 #endif
  40 #include <limits.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #ifdef HAVE_UNISTD_H
  44 # include <unistd.h>
  45 #endif
  46 #include <stdio.h>
  47 #ifndef PATH_MAX
  48 #define PATH_MAX MAX_PATH
  49 #endif
  50 #include <assert.h>
  51 #include <stdarg.h>
  52
  53 #include "windef.h"
  54 #include "winbase.h"
  55 #include "winreg.h"
  56 #include "winnls.h"
  57
  58 #include "dbghelp_private.h"
  59
  60 #include "wine/debug.h"
  61
  62 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_stabs);
  63
  64 #ifndef N_UNDF
  65 #define N_UNDF          0x00
  66 #endif
  67
  68 #define N_GSYM          0x20
  69 #define N_FUN           0x24
  70 #define N_STSYM         0x26
  71 #define N_LCSYM         0x28
  72 #define N_MAIN          0x2a
  73 #define N_ROSYM         0x2c
  74 #define N_OPT           0x3c
  75 #define N_RSYM          0x40
  76 #define N_SLINE         0x44
  77 #define N_SO            0x64
  78 #define N_LSYM          0x80
  79 #define N_BINCL         0x82
  80 #define N_SOL           0x84
  81 #define N_PSYM          0xa0
  82 #define N_EINCL         0xa2
  83 #define N_LBRAC         0xc0
  84 #define N_EXCL          0xc2
  85 #define N_RBRAC         0xe0
  86
  87 struct stab_nlist
  88 {
  89     union
  90     {
  91         char*                   n_name;
  92         struct stab_nlist*      n_next;
  93         long                    n_strx;
  94     } n_un;
  95     unsigned char       n_type;
  96     char                n_other;
  97     short               n_desc;
  98     unsigned long       n_value;
  99 };
 100
 101 static void stab_strcpy(char* dest, int sz, const char* source)
 102 {
 103     char*       ptr = dest;
 104     /*
 105      * A strcpy routine that stops when we hit the ':' character.
 106      * Faster than copying the whole thing, and then nuking the
 107      * ':'.
 108      * Takes also care of (valid) a::b constructs
 109      */
 110     while (*source != '\0')
 111     {
 112         if (source[0] != ':' && sz-- > 0) *ptr++ = *source++;
 113         else if (source[1] == ':' && (sz -= 2) > 0)
 114         {
 115             *ptr++ = *source++;
 116             *ptr++ = *source++;
 117         }
 118         else break;
 119     }
 120     *ptr-- = '\0';
 121     /* GCC emits, in some cases, a .<digit>+ suffix.
 122      * This is used for static variable inside functions, so
 123      * that we can have several such variables with same name in
 124      * the same compilation unit
 125      * We simply ignore that suffix when present (we also get rid
 126      * of it in ELF symtab parsing)
 127      */
 128     if (ptr >= dest && isdigit(*ptr))
 129     {
 130         while (ptr > dest && isdigit(*ptr)) ptr--;
 131         if (*ptr == '.') *ptr = '\0';
 132     }
 133     assert(sz > 0);
 134 }
 135
 136 typedef struct
 137 {
 138    char*                name;
 139    unsigned long        value;
 140    struct symt**        vector;
 141    int                  nrofentries;
 142 } include_def;
 143
 144 #define MAX_INCLUDES    5120
 145
 146 static include_def*             include_defs = NULL;
 147 static int                      num_include_def = 0;
 148 static int                      num_alloc_include_def = 0;
 149 static int                      cu_include_stack[MAX_INCLUDES];
 150 static int                      cu_include_stk_idx = 0;
 151 static struct symt**            cu_vector = NULL;
 152 static int                      cu_nrofentries = 0;
 153 static struct symt_basic*       stabs_basic[36];
 154
 155 static int stabs_new_include(const char* file, unsigned long val)
 156 {
 157     if (num_include_def == num_alloc_include_def)
 158     {
 159         num_alloc_include_def += 256;
 160         if (!include_defs)
 161             include_defs = HeapAlloc(GetProcessHeap(), 0,
 162                                      sizeof(include_defs[0]) * num_alloc_include_def);
 163         else
 164             include_defs = HeapReAlloc(GetProcessHeap(), 0, include_defs,
 165                                        sizeof(include_defs[0]) * num_alloc_include_def);
 166         memset(include_defs + num_include_def, 0, sizeof(include_defs[0]) * 256);
 167     }
 168     include_defs[num_include_def].name = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(file) + 1), file);
 169     include_defs[num_include_def].value = val;
 170     include_defs[num_include_def].vector = NULL;
 171     include_defs[num_include_def].nrofentries = 0;
 172
 173     return num_include_def++;
 174 }
 175
 176 static int stabs_find_include(const char* file, unsigned long val)
 177 {
 178     int         i;
 179
 180     for (i = 0; i < num_include_def; i++)
 181     {
 182         if (val == include_defs[i].value &&
 183             strcmp(file, include_defs[i].name) == 0)
 184             return i;
 185     }
 186     return -1;
 187 }
 188
 189 static int stabs_add_include(int idx)
 190 {
 191     if (idx < 0) return -1;
 192     cu_include_stk_idx++;
 193
 194     /* if this happens, just bump MAX_INCLUDES */
 195     /* we could also handle this as another dynarray */
 196     assert(cu_include_stk_idx < MAX_INCLUDES);
 197     cu_include_stack[cu_include_stk_idx] = idx;
 198     return cu_include_stk_idx;
 199 }
 200
 201 static void stabs_reset_includes(void)
 202 {
 203     /*
 204      * The struct symt:s that we would need to use are reset when
 205      * we start a new file. (at least the ones in filenr == 0)
 206      */
 207     cu_include_stk_idx = 0;/* keep 0 as index for the .c file itself */
 208     memset(cu_vector, 0, sizeof(cu_vector[0]) * cu_nrofentries);
 209 }
 210
 211 static void stabs_free_includes(void)
 212 {
 213     int i;
 214
 215     stabs_reset_includes();
 216     for (i = 0; i < num_include_def; i++)
 217     {
 218         HeapFree(GetProcessHeap(), 0, include_defs[i].name);
 219         HeapFree(GetProcessHeap(), 0, include_defs[i].vector);
 220     }
 221     HeapFree(GetProcessHeap(), 0, include_defs);
 222     include_defs = NULL;
 223     num_include_def = 0;
 224     num_alloc_include_def = 0;
 225     HeapFree(GetProcessHeap(), 0, cu_vector);
 226     cu_vector = NULL;
 227     cu_nrofentries = 0;
 228 }
 229
 230 static struct symt** stabs_find_ref(long filenr, long subnr)
 231 {
 232     struct symt**       ret;
 233
 234     /* FIXME: I could perhaps create a dummy include_def for each compilation
 235      * unit which would allow not to handle those two cases separately
 236      */
 237     if (filenr == 0)
 238     {
 239         if (cu_nrofentries <= subnr)
 240         {
 241             if (!cu_vector)
 242                 cu_vector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 243                                       sizeof(cu_vector[0]) * (subnr+1));
 244             else
 245                 cu_vector = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 246                                         cu_vector, sizeof(cu_vector[0]) * (subnr+1));
 247             cu_nrofentries = subnr + 1;
 248         }
 249         ret = &cu_vector[subnr];
 250     }
 251     else
 252     {
 253         include_def*    idef;
 254
 255         assert(filenr <= cu_include_stk_idx);
 256         idef = &include_defs[cu_include_stack[filenr]];
 257
 258         if (idef->nrofentries <= subnr)
 259         {
 260             if (!idef->vector)
 261                 idef->vector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 262                                          sizeof(idef->vector[0]) * (subnr+1));
 263             else
 264                 idef->vector = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 265                                            idef->vector, sizeof(idef->vector[0]) * (subnr+1));
 266             idef->nrofentries = subnr + 1;
 267         }
 268         ret = &idef->vector[subnr];
 269     }
 270     TRACE("(%ld,%ld) => %p (%p)\n", filenr, subnr, ret, *ret);
 271     return ret;
 272 }
 273
 274 static struct symt** stabs_read_type_enum(const char** x)
 275 {
 276     long        filenr, subnr;
 277
 278     if (**x == '(')
 279     {
 280         (*x)++;                                 /* '('   */
 281         filenr = strtol(*x, (char**)x, 10);     /* <int> */
 282         (*x)++;                                 /* ','   */
 283         subnr = strtol(*x, (char**)x, 10);      /* <int> */
 284         (*x)++;                                 /* ')'   */
 285     }
 286     else
 287     {
 288         filenr = 0;
 289         subnr = strtol(*x, (char**)x, 10);      /* <int> */
 290     }
 291     return stabs_find_ref(filenr, subnr);
 292 }
 293
 294 #define PTS_DEBUG
 295 struct ParseTypedefData
 296 {
 297     const char*         ptr;
 298     char                buf[1024];
 299     int                 idx;
 300     struct module*      module;
 301 #ifdef PTS_DEBUG
 302     struct PTS_Error
 303     {
 304         const char*         ptr;
 305         unsigned            line;
 306     } errors[16];
 307     int                 err_idx;
 308 #endif
 309 };
 310
 311 #ifdef PTS_DEBUG
 312 static void stabs_pts_push(struct ParseTypedefData* ptd, unsigned line)
 313 {
 314     assert(ptd->err_idx < sizeof(ptd->errors) / sizeof(ptd->errors[0]));
 315     ptd->errors[ptd->err_idx].line = line;
 316     ptd->errors[ptd->err_idx].ptr = ptd->ptr;
 317     ptd->err_idx++;
 318 }
 319 #define PTS_ABORTIF(ptd, t) do { if (t) { stabs_pts_push((ptd), __LINE__); return -1;} } while (0)
 320 #else
 321 #define PTS_ABORTIF(ptd, t) do { if (t) return -1; } while (0)
 322 #endif
 323
 324 static int stabs_get_basic(struct ParseTypedefData* ptd, unsigned basic, struct symt** symt)
 325 {
 326     PTS_ABORTIF(ptd, basic >= sizeof(stabs_basic) / sizeof(stabs_basic[0]));
 327
 328     if (!stabs_basic[basic])
 329     {
 330         switch (basic)
 331         {
 332         case  1: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "int", 4); break;
 333         case  2: stabs_basic[basic] = symt_new_basic(ptd->module, btChar,    "char", 1); break;
 334         case  3: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "short int", 2); break;
 335         case  4: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "long int", 4); break;
 336         case  5: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned char", 1); break;
 337         case  6: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "signed char", 1); break;
 338         case  7: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned short int", 2); break;
 339         case  8: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned int", 4); break;
 340         case  9: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned", 2); break;
 341         case 10: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "unsigned long int", 2); break;
 342         case 11: stabs_basic[basic] = symt_new_basic(ptd->module, btVoid,    "void", 0); break;
 343         case 12: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat,   "float", 4); break;
 344         case 13: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat,   "double", 8); break;
 345         case 14: stabs_basic[basic] = symt_new_basic(ptd->module, btFloat,   "long double", 12); break;
 346         case 15: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "integer", 4); break;
 347         case 16: stabs_basic[basic] = symt_new_basic(ptd->module, btBool,    "bool", 1); break;
 348         /*    case 17: short real */
 349         /*    case 18: real */
 350         case 25: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "float complex", 8); break;
 351         case 26: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "double complex", 16); break;
 352         case 30: stabs_basic[basic] = symt_new_basic(ptd->module, btWChar,   "wchar_t", 2); break;
 353         case 31: stabs_basic[basic] = symt_new_basic(ptd->module, btInt,     "long long int", 8); break;
 354         case 32: stabs_basic[basic] = symt_new_basic(ptd->module, btUInt,    "long long unsigned", 8); break;
 355             /* starting at 35 are wine extensions (especially for R implementation) */
 356         case 35: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "long double complex", 24); break;
 357         default: PTS_ABORTIF(ptd, 1);
 358         }
 359     }
 360     *symt = &stabs_basic[basic]->symt;
 361     return 0;
 362 }
 363
 364 static int stabs_pts_read_type_def(struct ParseTypedefData* ptd,
 365                                    const char* typename, struct symt** dt);
 366
 367 static int stabs_pts_read_id(struct ParseTypedefData* ptd)
 368 {
 369     const char*         first = ptd->ptr;
 370     unsigned int        template = 0;
 371     char                ch;
 372
 373     while ((ch = *ptd->ptr++) != '\0')
 374     {
 375         switch (ch)
 376         {
 377         case ':':
 378             if (template == 0)
 379             {
 380                 unsigned int len = ptd->ptr - first - 1;
 381                 PTS_ABORTIF(ptd, len >= sizeof(ptd->buf) - ptd->idx);
 382                 memcpy(ptd->buf + ptd->idx, first, len);
 383                 ptd->buf[ptd->idx + len] = '\0';
 384                 ptd->idx += len + 1;
 385                 return 0;
 386             }
 387             break;
 388         case '<': template++; break;
 389         case '>': PTS_ABORTIF(ptd, template == 0); template--; break;
 390         }
 391     }
 392     return -1;
 393 }
 394
 395 static int stabs_pts_read_number(struct ParseTypedefData* ptd, long* v)
 396 {
 397     char*       last;
 398
 399     *v = strtol(ptd->ptr, &last, 10);
 400     PTS_ABORTIF(ptd, last == ptd->ptr);
 401     ptd->ptr = last;
 402     return 0;
 403 }
 404
 405 static int stabs_pts_read_type_reference(struct ParseTypedefData* ptd,
 406                                          long* filenr, long* subnr)
 407 {
 408     if (*ptd->ptr == '(')
 409     {
 410         /* '(' <int> ',' <int> ')' */
 411         ptd->ptr++;
 412         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, filenr) == -1);
 413         PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 414         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, subnr) == -1);
 415         PTS_ABORTIF(ptd, *ptd->ptr++ != ')');
 416     }
 417     else
 418     {
 419         *filenr = 0;
 420         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, subnr) == -1);
 421     }
 422     return 0;
 423 }
 424
 425 struct pts_range_value
 426 {
 427     unsigned long long  val;
 428     int                 sign;
 429 };
 430
 431 static int stabs_pts_read_range_value(struct ParseTypedefData* ptd, struct pts_range_value* prv)
 432 {
 433     char*       last;
 434
 435     switch (*ptd->ptr)
 436     {
 437     case '0':
 438         while (*ptd->ptr == '0') ptd->ptr++;
 439         if (*ptd->ptr >= '1' && *ptd->ptr <= '7')
 440         {
 441             switch (ptd->ptr[1])
 442             {
 443             case '0':
 444                 PTS_ABORTIF(ptd, ptd->ptr[0] != '1');
 445                 prv->sign = -1;
 446                 prv->val = 0;
 447                 while (isdigit(*ptd->ptr)) prv->val = (prv->val << 3) + *ptd->ptr++ - '0';
 448                 break;
 449             case '7':
 450                 prv->sign = 1;
 451                 prv->val = 0;
 452                 while (isdigit(*ptd->ptr)) prv->val = (prv->val << 3) + *ptd->ptr++ - '0';
 453                 break;
 454             default: PTS_ABORTIF(ptd, 1); break;
 455             }
 456         } else prv->sign = 0;
 457         break;
 458     case '-':
 459         prv->sign = -1;
 460         prv->val = strtoull(++ptd->ptr, &last, 10);
 461         ptd->ptr = last;
 462         break;
 463     case '+':
 464     default:
 465         prv->sign = 1;
 466         prv->val = strtoull(ptd->ptr, &last, 10);
 467         ptd->ptr = last;
 468         break;
 469     }
 470     return 0;
 471 }
 472
 473 static int stabs_pts_read_range(struct ParseTypedefData* ptd, const char* typename,
 474                                 struct symt** dt)
 475 {
 476     struct symt*                ref;
 477     struct pts_range_value      lo;
 478     struct pts_range_value      hi;
 479     unsigned                    size;
 480     enum BasicType              bt;
 481     int                         i;
 482     unsigned long long          v;
 483
 484     /* type ';' <int> ';' <int> ';' */
 485     PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref) == -1);
 486     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
 487     PTS_ABORTIF(ptd, stabs_pts_read_range_value(ptd, &lo) == -1);
 488     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
 489     PTS_ABORTIF(ptd, stabs_pts_read_range_value(ptd, &hi) == -1);
 490     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
 491
 492     /* basically, we don't use ref... in some cases, for example, float is declared
 493      * as a derivated type of int... which won't help us... so we guess the types
 494      * from the various formats
 495      */
 496     if (lo.sign == 0 && hi.sign < 0)
 497     {
 498         bt = btUInt;
 499         size = hi.val;
 500     }
 501     else if (lo.sign < 0 && hi.sign == 0)
 502     {
 503         bt = btUInt;
 504         size = lo.val;
 505     }
 506     else if (lo.sign > 0 && hi.sign == 0)
 507     {
 508         bt = btFloat;
 509         size = lo.val;
 510     }
 511     else if (lo.sign < 0 && hi.sign > 0)
 512     {
 513         v = 1 << 7;
 514         for (i = 7; i < 64; i += 8)
 515         {
 516             if (lo.val == v && hi.val == v - 1)
 517             {
 518                 bt = btInt;
 519                 size = (i + 1) / 8;
 520                 break;
 521             }
 522             v <<= 8;
 523         }
 524         PTS_ABORTIF(ptd, i >= 64);
 525     }
 526     else if (lo.sign == 0 && hi.sign > 0)
 527     {
 528         if (hi.val == 127) /* specific case for char... */
 529         {
 530             bt = btChar;
 531             size = 1;
 532         }
 533         else
 534         {
 535             v = 1;
 536             for (i = 8; i <= 64; i += 8)
 537             {
 538                 v <<= 8;
 539                 if (hi.val + 1 == v)
 540                 {
 541                     bt = btUInt;
 542                     size = (i + 1) / 8;
 543                     break;
 544                 }
 545             }
 546             PTS_ABORTIF(ptd, i > 64);
 547         }
 548     }
 549     else PTS_ABORTIF(ptd, 1);
 550
 551     *dt = &symt_new_basic(ptd->module, bt, typename, size)->symt;
 552     return 0;
 553 }
 554
 555 static inline int stabs_pts_read_method_info(struct ParseTypedefData* ptd)
 556 {
 557     struct symt*        dt;
 558     char*               tmp;
 559     char                mthd;
 560
 561     do
 562     {
 563         /* get type of return value */
 564         PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
 565         if (*ptd->ptr == ';') ptd->ptr++;
 566
 567         /* get types of parameters */
 568         if (*ptd->ptr == ':')
 569         {
 570             PTS_ABORTIF(ptd, !(tmp = strchr(ptd->ptr + 1, ';')));
 571             ptd->ptr = tmp + 1;
 572         }
 573         PTS_ABORTIF(ptd, !(*ptd->ptr >= '0' && *ptd->ptr <= '9'));
 574         ptd->ptr++;
 575         PTS_ABORTIF(ptd, !(ptd->ptr[0] >= 'A' && *ptd->ptr <= 'D'));
 576         mthd = *++ptd->ptr;
 577         PTS_ABORTIF(ptd, mthd != '.' && mthd != '?' && mthd != '*');
 578         ptd->ptr++;
 579         if (mthd == '*')
 580         {
 581             long int            ofs;
 582             struct symt*        dt;
 583
 584             PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &ofs) == -1);
 585             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 586             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
 587             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 588         }
 589     } while (*ptd->ptr != ';');
 590     ptd->ptr++;
 591
 592     return 0;
 593 }
 594
 595 static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd,
 596                                            struct symt_udt* sdt)
 597 {
 598     long                sz, ofs;
 599     struct symt*        adt;
 600     struct symt*        dt = NULL;
 601     int                 idx;
 602     int                 doadd;
 603
 604     PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &sz) == -1);
 605
 606     doadd = symt_set_udt_size(ptd->module, sdt, sz);
 607     if (*ptd->ptr == '!') /* C++ inheritence */
 608     {
 609         long     num_classes;
 610
 611         ptd->ptr++;
 612         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &num_classes) == -1);
 613         PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 614         while (--num_classes >= 0)
 615         {
 616             ptd->ptr += 2; /* skip visibility and inheritence */
 617             PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &ofs) == -1);
 618             PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 619
 620             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &adt) == -1);
 621
 622             if (doadd)
 623             {
 624                 char    tmp[256];
 625                 WCHAR*  name;
 626                 DWORD   size;
 627
 628                 symt_get_info(adt, TI_GET_SYMNAME, &name);
 629                 strcpy(tmp, "__inherited_class_");
 630                 WideCharToMultiByte(CP_ACP, 0, name, -1,
 631                                     tmp + strlen(tmp), sizeof(tmp) - strlen(tmp),
 632                                     NULL, NULL);
 633                 HeapFree(GetProcessHeap(), 0, name);
 634                 /* FIXME: TI_GET_LENGTH will not always work, especially when adt
 635                  * has just been seen as a forward definition and not the real stuff
 636                  * yet.
 637                  * As we don't use much the size of members in structs, this may not
 638                  * be much of a problem
 639                  */
 640                 symt_get_info(adt, TI_GET_LENGTH, &size);
 641                 symt_add_udt_element(ptd->module, sdt, tmp, adt, ofs, size * 8);
 642             }
 643             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 644         }
 645
 646     }
 647     /* if the structure has already been filled, just redo the parsing
 648      * but don't store results into the struct
 649      * FIXME: there's a quite ugly memory leak in there...
 650      */
 651
 652     /* Now parse the individual elements of the structure/union. */
 653     while (*ptd->ptr != ';')
 654     {
 655         /* agg_name : type ',' <int:offset> ',' <int:size> */
 656         idx = ptd->idx;
 657
 658         if (ptd->ptr[0] == '$' && ptd->ptr[1] == 'v')
 659         {
 660             long        x;
 661
 662             if (ptd->ptr[2] == 'f')
 663             {
 664                 /* C++ virtual method table */
 665                 ptd->ptr += 3;
 666                 stabs_read_type_enum(&ptd->ptr);
 667                 PTS_ABORTIF(ptd, *ptd->ptr++ != ':');
 668                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
 669                 PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 670                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &x) == -1);
 671                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 672                 ptd->idx = idx;
 673                 continue;
 674             }
 675             else if (ptd->ptr[2] == 'b')
 676             {
 677                 ptd->ptr += 3;
 678                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
 679                 PTS_ABORTIF(ptd, *ptd->ptr++ != ':');
 680                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
 681                 PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 682                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &x) == -1);
 683                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 684                 ptd->idx = idx;
 685                 continue;
 686             }
 687         }
 688
 689         PTS_ABORTIF(ptd, stabs_pts_read_id(ptd) == -1);
 690         /* Ref. TSDF R2.130 Section 7.4.  When the field name is a method name
 691          * it is followed by two colons rather than one.
 692          */
 693         if (*ptd->ptr == ':')
 694         {
 695             ptd->ptr++;
 696             stabs_pts_read_method_info(ptd);
 697             ptd->idx = idx;
 698             continue;
 699         }
 700         else
 701         {
 702             /* skip C++ member protection /0 /1 or /2 */
 703             if (*ptd->ptr == '/') ptd->ptr += 2;
 704         }
 705         PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &adt) == -1);
 706
 707         switch (*ptd->ptr++)
 708         {
 709         case ',':
 710             PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &ofs) == -1);
 711             PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 712             PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &sz) == -1);
 713             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 714
 715             if (doadd) symt_add_udt_element(ptd->module, sdt, ptd->buf + idx, adt, ofs, sz);
 716             break;
 717         case ':':
 718             {
 719                 char* tmp;
 720                 /* method parameters... terminated by ';' */
 721                 PTS_ABORTIF(ptd, !(tmp = strchr(ptd->ptr, ';')));
 722                 ptd->ptr = tmp + 1;
 723             }
 724             break;
 725         default:
 726             PTS_ABORTIF(ptd, TRUE);
 727         }
 728         ptd->idx = idx;
 729     }
 730     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 731     if (*ptd->ptr == '~')
 732     {
 733         ptd->ptr++;
 734         PTS_ABORTIF(ptd, *ptd->ptr++ != '%');
 735         PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &dt) == -1);
 736         PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 737     }
 738     return 0;
 739 }
 740
 741 static inline int stabs_pts_read_enum(struct ParseTypedefData* ptd,
 742                                       struct symt_enum* edt)
 743 {
 744     long        value;
 745     int         idx;
 746
 747     while (*ptd->ptr != ';')
 748     {
 749         idx = ptd->idx;
 750         PTS_ABORTIF(ptd, stabs_pts_read_id(ptd) == -1);
 751         PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &value) == -1);
 752         PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 753         symt_add_enum_element(ptd->module, edt, ptd->buf + idx, value);
 754         ptd->idx = idx;
 755     }
 756     ptd->ptr++;
 757     return 0;
 758 }
 759
 760 static inline int stabs_pts_read_array(struct ParseTypedefData* ptd,
 761                                        struct symt** adt)
 762 {
 763     long                lo, hi;
 764     struct symt*        rdt;
 765
 766     /* ar<typeinfo_nodef>;<int>;<int>;<typeinfo> */
 767
 768     PTS_ABORTIF(ptd, *ptd->ptr++ != 'r');
 769     /* FIXME: range type is lost, always assume int */
 770     PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &rdt) == -1);
 771     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
 772     PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &lo) == -1);
 773     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
 774     PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &hi) == -1);
 775     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
 776
 777     PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &rdt) == -1);
 778
 779     *adt = &symt_new_array(ptd->module, lo, hi, rdt)->symt;
 780     return 0;
 781 }
 782
 783 static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typename,
 784                                    struct symt** ret_dt)
 785 {
 786     int                 idx;
 787     long                sz = -1;
 788     struct symt*        new_dt = NULL; /* newly created data type */
 789     struct symt*        ref_dt;            /* referenced data type (pointer...) */
 790     long                filenr1, subnr1, tmp;
 791
 792     /* things are a bit complicated because of the way the typedefs are stored inside
 793      * the file, because addresses can change when realloc is done, so we must call
 794      * over and over stabs_find_ref() to keep the correct values around
 795      */
 796     PTS_ABORTIF(ptd, stabs_pts_read_type_reference(ptd, &filenr1, &subnr1) == -1);
 797
 798     while (*ptd->ptr == '=')
 799     {
 800         ptd->ptr++;
 801         PTS_ABORTIF(ptd, new_dt != btNoType);
 802
 803         /* first handle attribute if any */
 804         switch (*ptd->ptr)
 805         {
 806         case '@':
 807             if (*++ptd->ptr == 's')
 808             {
 809                 ptd->ptr++;
 810                 if (stabs_pts_read_number(ptd, &sz) == -1)
 811                 {
 812                     ERR("Not an attribute... NIY\n");
 813                     ptd->ptr -= 2;
 814                     return -1;
 815                 }
 816                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 817             }
 818             break;
 819         }
 820         /* then the real definitions */
 821         switch (*ptd->ptr++)
 822         {
 823         case '*':
 824         case '&':
 825             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1);
 826             new_dt = &symt_new_pointer(ptd->module, ref_dt)->symt;
 827            break;
 828         case 'k': /* 'const' modifier */
 829         case 'B': /* 'volatile' modifier */
 830             /* just kinda ignore the modifier, I guess -gmt */
 831             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, typename, &new_dt) == -1);
 832             break;
 833         case '(':
 834             ptd->ptr--;
 835             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, typename, &new_dt) == -1);
 836             break;
 837         case 'a':
 838             PTS_ABORTIF(ptd, stabs_pts_read_array(ptd, &new_dt) == -1);
 839             break;
 840         case 'r':
 841             PTS_ABORTIF(ptd, stabs_pts_read_range(ptd, typename, &new_dt) == -1);
 842             assert(!*stabs_find_ref(filenr1, subnr1));
 843             *stabs_find_ref(filenr1, subnr1) = new_dt;
 844             break;
 845         case 'f':
 846             PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1);
 847             new_dt = &symt_new_function_signature(ptd->module, ref_dt)->symt;
 848             break;
 849         case 'e':
 850             new_dt = &symt_new_enum(ptd->module, typename)->symt;
 851             PTS_ABORTIF(ptd, stabs_pts_read_enum(ptd, (struct symt_enum*)new_dt) == -1);
 852             break;
 853         case 's':
 854         case 'u':
 855             {
 856                 struct symt_udt*    udt;
 857                 enum UdtKind kind = (ptd->ptr[-1] == 's') ? UdtStruct : UdtUnion;
 858                 /* udt can have been already defined in a forward definition */
 859                 udt = (struct symt_udt*)*stabs_find_ref(filenr1, subnr1);
 860                 if (!udt)
 861                 {
 862                     udt = symt_new_udt(ptd->module, typename, 0, kind);
 863                     /* we need to set it here, because a struct can hold a pointer
 864                      * to itself
 865                      */
 866                     new_dt = *stabs_find_ref(filenr1, subnr1) = &udt->symt;
 867                 }
 868                 else
 869                 {
 870                     unsigned l1, l2;
 871                     if (udt->symt.tag != SymTagUDT)
 872                     {
 873                         ERR("Forward declaration (%p/%s) is not an aggregate (%u)\n",
 874                             udt, symt_get_name(&udt->symt), udt->symt.tag);
 875                         return -1;
 876                     }
 877                     /* FIXME: we currently don't correctly construct nested C++
 878                      * classes names. Therefore, we could be here with either:
 879                      * - typename and udt->hash_elt.name being the same string
 880                      *   (non embedded case)
 881                      * - typename being foo::bar while udt->hash_elt.name being
 882                      *   just bar
 883                      * So, we twist the comparison to test both occurrences. When
 884                      * we have proper C++ types in this file, this twist has to be
 885                      * removed
 886                      */
 887                     l1 = strlen(udt->hash_elt.name);
 888                     l2 = strlen(typename);
 889                     if (l1 > l2 || strcmp(udt->hash_elt.name, typename + l2 - l1))
 890                         ERR("Forward declaration name mismatch %s <> %s\n",
 891                             udt->hash_elt.name, typename);
 892                     new_dt = &udt->symt;
 893                 }
 894                 PTS_ABORTIF(ptd, stabs_pts_read_aggregate(ptd, udt) == -1);
 895             }
 896             break;
 897         case 'x':
 898             idx = ptd->idx;
 899             tmp = *ptd->ptr++;
 900             PTS_ABORTIF(ptd, stabs_pts_read_id(ptd) == -1);
 901             switch (tmp)
 902             {
 903             case 'e':
 904                 new_dt = &symt_new_enum(ptd->module, ptd->buf + idx)->symt;
 905                 break;
 906             case 's':
 907                 new_dt = &symt_new_udt(ptd->module, ptd->buf + idx, 0, UdtStruct)->symt;
 908                 break;
 909             case 'u':
 910                 new_dt = &symt_new_udt(ptd->module, ptd->buf + idx, 0, UdtUnion)->symt;
 911                 break;
 912             default:
 913                 return -1;
 914             }
 915             ptd->idx = idx;
 916             break;
 917         case '-':
 918             {
 919                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &tmp) == -1);
 920                 PTS_ABORTIF(ptd, stabs_get_basic(ptd, tmp, &new_dt) == -1);
 921                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 922             }
 923             break;
 924         case '#':
 925             if (*ptd->ptr == '#')
 926             {
 927                 ptd->ptr++;
 928                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1);
 929                 new_dt = &symt_new_function_signature(ptd->module, ref_dt)->symt;
 930             }
 931             else
 932             {
 933                 struct symt*    cls_dt;
 934                 struct symt*    pmt_dt;
 935
 936                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &cls_dt) == -1);
 937                 PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 938                 PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1);
 939                 new_dt = &symt_new_function_signature(ptd->module, ref_dt)->symt;
 940                 while (*ptd->ptr == ',')
 941                 {
 942                     ptd->ptr++;
 943                     PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &pmt_dt) == -1);
 944                 }
 945             }
 946             break;
 947         case 'R':
 948             {
 949                 long    type, len, unk;
 950                 int     basic;
 951
 952                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &type) == -1);
 953                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');   /* ';' */
 954                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &len) == -1);
 955                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');   /* ';' */
 956                 PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &unk) == -1);
 957                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');   /* ';' */
 958
 959                 switch (type) /* see stabs_get_basic for the details */
 960                 {
 961                 case 1: basic = 12; break;
 962                 case 2: basic = 13; break;
 963                 case 3: basic = 25; break;
 964                 case 4: basic = 26; break;
 965                 case 5: basic = 35; break;
 966                 case 6: basic = 14; break;
 967                 default: PTS_ABORTIF(ptd, 1);
 968                 }
 969                 PTS_ABORTIF(ptd, stabs_get_basic(ptd, basic, &new_dt) == -1);
 970             }
 971             break;
 972         default:
 973             ERR("Unknown type '%c'\n", ptd->ptr[-1]);
 974             return -1;
 975         }
 976     }
 977
 978     if (!new_dt)
 979     {
 980         /* is it a forward declaration that has been filled ? */
 981         new_dt = *stabs_find_ref(filenr1, subnr1);
 982         /* if not, this should be void (which is defined as a ref to itself, but we
 983          * don't correctly catch it)
 984          */
 985         if (!new_dt && typename)
 986         {
 987             new_dt = &symt_new_basic(ptd->module, btVoid, typename, 0)->symt;
 988             PTS_ABORTIF(ptd, strcmp(typename, "void"));
 989         }
 990     }
 991
 992     *stabs_find_ref(filenr1, subnr1) = *ret_dt = new_dt;
 993
 994     TRACE("Adding (%ld,%ld) %s\n", filenr1, subnr1, typename);
 995
 996     return 0;
 997 }
 998
 999 static int stabs_parse_typedef(struct module* module, const char* ptr,
1000                                const char* typename)
1001 {
1002     struct ParseTypedefData     ptd;
1003     struct symt*                dt;
1004     int                         ret = -1;
1005
1006     /* check for already existing definition */
1007
1008     TRACE("%s => %s\n", typename, debugstr_a(ptr));
1009     ptd.module = module;
1010     ptd.idx = 0;
1011 #ifdef PTS_DEBUG
1012     ptd.err_idx = 0;
1013 #endif
1014     for (ptd.ptr = ptr - 1; ;)
1015     {
1016         ptd.ptr = strchr(ptd.ptr + 1, ':');
1017         if (ptd.ptr == NULL || *++ptd.ptr != ':') break;
1018     }
1019     if (ptd.ptr)
1020     {
1021         if (*ptd.ptr != '(') ptd.ptr++;
1022         /* most of type definitions take one char, except Tt */
1023         if (*ptd.ptr != '(') ptd.ptr++;
1024         ret = stabs_pts_read_type_def(&ptd, typename, &dt);
1025     }
1026
1027     if (ret == -1 || *ptd.ptr)
1028     {
1029 #ifdef PTS_DEBUG
1030         int     i;
1031         TRACE("Failure on %s\n", debugstr_a(ptr));
1032         if (ret == -1)
1033         {
1034             for (i = 0; i < ptd.err_idx; i++)
1035             {
1036                 TRACE("[%d]: line %d => %s\n",
1037                       i, ptd.errors[i].line, debugstr_a(ptd.errors[i].ptr));
1038             }
1039         }
1040         else
1041             TRACE("[0]: => %s\n", debugstr_a(ptd.ptr));
1042
1043 #else
1044         ERR("Failure on %s at %s\n", debugstr_a(ptr), debugstr_a(ptd.ptr));
1045 #endif
1046         return FALSE;
1047     }
1048
1049     return TRUE;
1050 }
1051
1052 static struct symt* stabs_parse_type(const char* stab)
1053 {
1054     const char* c = stab - 1;
1055
1056     /*
1057      * Look through the stab definition, and figure out what struct symt
1058      * this represents.  If we have something we know about, assign the
1059      * type.
1060      * According to "The \"stabs\" debug format" (Rev 2.130) the name may be
1061      * a C++ name and contain double colons e.g. foo::bar::baz:t5=*6.
1062      */
1063     do
1064     {
1065         if ((c = strchr(c + 1, ':')) == NULL) return NULL;
1066     } while (*++c == ':');
1067
1068     /*
1069      * The next characters say more about the type (i.e. data, function, etc)
1070      * of symbol.  Skip them.  (C++ for example may have Tt).
1071      * Actually this is a very weak description; I think Tt is the only
1072      * multiple combination we should see.
1073      */
1074     while (*c && *c != '(' && !isdigit(*c))
1075         c++;
1076     /*
1077      * The next is either an integer or a (integer,integer).
1078      * The stabs_read_type_enum() takes care that stab_types is large enough.
1079      */
1080     return *stabs_read_type_enum(&c);
1081 }
1082
1083 struct pending_loc_var
1084 {
1085     char                name[256];
1086     struct symt*        type;
1087     unsigned            offset;
1088     unsigned            regno;
1089 };
1090
1091 /******************************************************************
1092  *              stabs_finalize_function
1093  *
1094  * Ends function creation: mainly:
1095  * - cleans up line number information
1096  * - tries to set up a debug-start tag (FIXME: heuristic to be enhanced)
1097  * - for stabs which have abolute address in them, initializes the size of the
1098  *   function (assuming that current function ends where next function starts)
1099  */
1100 static void stabs_finalize_function(struct module* module, struct symt_function* func,
1101                                     unsigned long size)
1102 {
1103     IMAGEHLP_LINE       il;
1104
1105     if (!func) return;
1106     symt_normalize_function(module, func);
1107     /* To define the debug-start of the function, we use the second line number.
1108      * Not 100% bullet proof, but better than nothing
1109      */
1110     if (symt_fill_func_line_info(module, func, func->address, &il) &&
1111         symt_get_func_line_next(module, &il))
1112     {
1113         symt_add_function_point(module, func, SymTagFuncDebugStart,
1114                                 il.Address - func->address, NULL);
1115     }
1116     if (size) func->size = size;
1117 }
1118
1119 BOOL stabs_parse(struct module* module, unsigned long load_offset,
1120                  const void* pv_stab_ptr, int stablen,
1121                  const char* strs, int strtablen)
1122 {
1123     struct symt_function*       curr_func = NULL;
1124     struct symt_block*          block = NULL;
1125     struct symt_compiland*      compiland = NULL;
1126     char                        currpath[PATH_MAX]; /* path to current file */
1127     char                        srcpath[PATH_MAX]; /* path to directory source file is in */
1128     int                         i, j;
1129     int                         nstab;
1130     const char*                 ptr;
1131     char*                       stabbuff;
1132     unsigned int                stabbufflen;
1133     const struct stab_nlist*    stab_ptr = pv_stab_ptr;
1134     const char*                 strs_end;
1135     int                         strtabinc;
1136     char                        symname[4096];
1137     unsigned                    incl[32];
1138     int                         incl_stk = -1;
1139     int                         source_idx = -1;
1140     struct pending_loc_var*     pending_vars = NULL;
1141     unsigned                    num_pending_vars = 0;
1142     unsigned                    num_allocated_pending_vars = 0;
1143     BOOL                        ret = TRUE;
1144
1145     nstab = stablen / sizeof(struct stab_nlist);
1146     strs_end = strs + strtablen;
1147
1148     memset(srcpath, 0, sizeof(srcpath));
1149     memset(stabs_basic, 0, sizeof(stabs_basic));
1150
1151     /*
1152      * Allocate a buffer into which we can build stab strings for cases
1153      * where the stab is continued over multiple lines.
1154      */
1155     stabbufflen = 65536;
1156     stabbuff = HeapAlloc(GetProcessHeap(), 0, stabbufflen);
1157
1158     strtabinc = 0;
1159     stabbuff[0] = '\0';
1160     for (i = 0; i < nstab; i++, stab_ptr++)
1161     {
1162         ptr = strs + stab_ptr->n_un.n_strx;
1163         if ((ptr > strs_end) || (ptr + strlen(ptr) > strs_end))
1164         {
1165             WARN("Bad stabs string %p\n", ptr);
1166             continue;
1167         }
1168         if (ptr[strlen(ptr) - 1] == '\\')
1169         {
1170             /*
1171              * Indicates continuation.  Append this to the buffer, and go onto the
1172              * next record.  Repeat the process until we find a stab without the
1173              * '/' character, as this indicates we have the whole thing.
1174              */
1175             unsigned    len = strlen(ptr);
1176             if (strlen(stabbuff) + len > stabbufflen)
1177             {
1178                 stabbufflen += 65536;
1179                 stabbuff = HeapReAlloc(GetProcessHeap(), 0, stabbuff, stabbufflen);
1180             }
1181             strncat(stabbuff, ptr, len - 1);
1182             continue;
1183         }
1184         else if (stabbuff[0] != '\0')
1185         {
1186             strcat(stabbuff, ptr);
1187             ptr = stabbuff;
1188         }
1189
1190         /* only symbol entries contain a typedef */
1191         switch (stab_ptr->n_type)
1192         {
1193         case N_GSYM:
1194         case N_LCSYM:
1195         case N_STSYM:
1196         case N_RSYM:
1197         case N_LSYM:
1198         case N_ROSYM:
1199             if (strchr(ptr, '=') != NULL)
1200             {
1201                 /*
1202                  * The stabs aren't in writable memory, so copy it over so we are
1203                  * sure we can scribble on it.
1204                  */
1205                 if (ptr != stabbuff)
1206                 {
1207                     strcpy(stabbuff, ptr);
1208                     ptr = stabbuff;
1209                 }
1210                 stab_strcpy(symname, sizeof(symname), ptr);
1211                 if (!stabs_parse_typedef(module, ptr, symname))
1212                 {
1213                     /* skip this definition */
1214                     stabbuff[0] = '\0';
1215                     continue;
1216                 }
1217             }
1218         }
1219
1220 #if 0
1221         const char* defs[] = {"","","","",                      /* 00 */
1222                               "","","","",                      /* 08 */
1223                               "","","","",                      /* 10 */
1224                               "","","","",                      /* 18 */
1225                               "gsym","","fun","stsym",          /* 20 */
1226                               "lcsym","main","rosym","",        /* 28 */
1227                               "","","","",                      /* 30 */
1228                               "","","opt","",                   /* 38 */
1229                               "rsym","","sline","",             /* 40 */
1230                               "","","","",                      /* 48 */
1231                               "","","","",                      /* 50 */
1232                               "","","","",                      /* 58 */
1233                               "","","so","",                    /* 60 */
1234                               "","","","",                      /* 68 */
1235                               "","","","",                      /* 70 */
1236                               "","","","",                      /* 78 */
1237                               "lsym","bincl","sol","",          /* 80 */
1238                               "","","","",                      /* 88 */
1239                               "","","","",                      /* 90 */
1240                               "","","","",                      /* 98 */
1241                               "psym","eincl","","",             /* a0 */
1242                               "","","","",                      /* a8 */
1243                               "","","","",                      /* b0 */
1244                               "","","","",                      /* b8 */
1245                               "lbrac","excl","","",             /* c0 */
1246                               "","","","",                      /* c8 */
1247                               "","","","",                      /* d0 */
1248                               "","","","",                      /* d8 */
1249                               "rbrac","","","",                 /* e0 */
1250         };
1251
1252         FIXME("Got %s<%u> %u/%lu (%s)\n",
1253               defs[stab_ptr->n_type / 2], stab_ptr->n_type, stab_ptr->n_desc, stab_ptr->n_value, debugstr_a(ptr));
1254 #endif
1255
1256         switch (stab_ptr->n_type)
1257         {
1258         case N_GSYM:
1259             /*
1260              * These are useless with ELF.  They have no value, and you have to
1261              * read the normal symbol table to get the address.  Thus we
1262              * ignore them, and when we process the normal symbol table
1263              * we should do the right thing.
1264              *
1265              * With a.out or mingw, they actually do make some amount of sense.
1266              */
1267             stab_strcpy(symname, sizeof(symname), ptr);
1268             symt_new_global_variable(module, compiland, symname, TRUE /* FIXME */,
1269                                      load_offset + stab_ptr->n_value, 0,
1270                                      stabs_parse_type(ptr));
1271             break;
1272         case N_LCSYM:
1273         case N_STSYM:
1274             /* These are static symbols and BSS symbols. */
1275             stab_strcpy(symname, sizeof(symname), ptr);
1276             symt_new_global_variable(module, compiland, symname, TRUE /* FIXME */,
1277                                      load_offset + stab_ptr->n_value, 0,
1278                                      stabs_parse_type(ptr));
1279             break;
1280         case N_LBRAC:
1281             block = symt_open_func_block(module, curr_func, block,
1282                                          stab_ptr->n_value, 0);
1283             for (j = 0; j < num_pending_vars; j++)
1284             {
1285                 symt_add_func_local(module, curr_func, pending_vars[j].regno,
1286                                     pending_vars[j].offset,
1287                                     block, pending_vars[j].type, pending_vars[j].name);
1288             }
1289             num_pending_vars = 0;
1290             break;
1291         case N_RBRAC:
1292             block = symt_close_func_block(module, curr_func, block,
1293                                           stab_ptr->n_value);
1294             break;
1295         case N_PSYM:
1296             /* These are function parameters. */
1297             if (curr_func != NULL)
1298             {
1299                 struct symt*    param_type = stabs_parse_type(ptr);
1300                 stab_strcpy(symname, sizeof(symname), ptr);
1301                 symt_add_func_local(module, curr_func, 0, stab_ptr->n_value,
1302                                     NULL, param_type, symname);
1303                 symt_add_function_signature_parameter(module,
1304                                                       (struct symt_function_signature*)curr_func->type,
1305                                                       param_type);
1306             }
1307             break;
1308         case N_RSYM:
1309             /* These are registers (as local variables) */
1310             if (curr_func != NULL)
1311             {
1312                 unsigned reg;
1313
1314                 if (num_pending_vars == num_allocated_pending_vars)
1315                 {
1316                     num_allocated_pending_vars += 8;
1317                     if (!pending_vars)
1318                         pending_vars = HeapAlloc(GetProcessHeap(), 0,
1319                                                  num_allocated_pending_vars * sizeof(pending_vars[0]));
1320                     else
1321                         pending_vars = HeapReAlloc(GetProcessHeap(), 0, pending_vars,
1322                                                    num_allocated_pending_vars * sizeof(pending_vars[0]));
1323                 }
1324                 switch (stab_ptr->n_value)
1325                 {
1326                 case  0: reg = CV_REG_EAX; break;
1327                 case  1: reg = CV_REG_ECX; break;
1328                 case  2: reg = CV_REG_EDX; break;
1329                 case  3: reg = CV_REG_EBX; break;
1330                 case  4: reg = CV_REG_ESP; break;
1331                 case  5: reg = CV_REG_EBP; break;
1332                 case  6: reg = CV_REG_ESI; break;
1333                 case  7: reg = CV_REG_EDI; break;
1334                 case 11:
1335                 case 12:
1336                 case 13:
1337                 case 14:
1338                 case 15:
1339                 case 16:
1340                 case 17:
1341                 case 18:
1342                 case 19: reg = CV_REG_ST0 + stab_ptr->n_value - 12; break;
1343                 default:
1344                     FIXME("Unknown register value (%lu)\n", stab_ptr->n_value);
1345                     reg = CV_REG_NONE;
1346                     break;
1347                 }
1348
1349                 stab_strcpy(pending_vars[num_pending_vars].name,
1350                             sizeof(pending_vars[num_pending_vars].name), ptr);
1351                 pending_vars[num_pending_vars].type   = stabs_parse_type(ptr);
1352                 pending_vars[num_pending_vars].offset = 0;
1353                 pending_vars[num_pending_vars].regno  = reg;
1354                 num_pending_vars++;
1355             }
1356             break;
1357         case N_LSYM:
1358             /* These are local variables */
1359             if (curr_func != NULL)
1360             {
1361                 if (num_pending_vars == num_allocated_pending_vars)
1362                 {
1363                     num_allocated_pending_vars += 8;
1364                     if (!pending_vars)
1365                         pending_vars = HeapAlloc(GetProcessHeap(), 0,
1366                                                  num_allocated_pending_vars * sizeof(pending_vars[0]));
1367                     else
1368                         pending_vars = HeapReAlloc(GetProcessHeap(), 0, pending_vars,
1369                                                    num_allocated_pending_vars * sizeof(pending_vars[0]));
1370                 }
1371                 stab_strcpy(pending_vars[num_pending_vars].name,
1372                             sizeof(pending_vars[num_pending_vars].name), ptr);
1373                 pending_vars[num_pending_vars].type   = stabs_parse_type(ptr);
1374                 pending_vars[num_pending_vars].offset = stab_ptr->n_value;
1375                 pending_vars[num_pending_vars].regno  = 0;
1376                 num_pending_vars++;
1377             }
1378             break;
1379         case N_SLINE:
1380             /*
1381              * This is a line number.  These are always relative to the start
1382              * of the function (N_FUN), and this makes the lookup easier.
1383              */
1384             if (curr_func != NULL)
1385             {
1386                 assert(source_idx >= 0);
1387                 symt_add_func_line(module, curr_func, source_idx,
1388                                    stab_ptr->n_desc, stab_ptr->n_value);
1389             }
1390             break;
1391         case N_FUN:
1392             /*
1393              * For now, just declare the various functions.  Later
1394              * on, we will add the line number information and the
1395              * local symbols.
1396              */
1397             /*
1398              * Copy the string to a temp buffer so we
1399              * can kill everything after the ':'.  We do
1400              * it this way because otherwise we end up dirtying
1401              * all of the pages related to the stabs, and that
1402              * sucks up swap space like crazy.
1403              */
1404             stab_strcpy(symname, sizeof(symname), ptr);
1405             if (*symname)
1406             {
1407                 struct symt_function_signature* func_type;
1408
1409                 if (curr_func)
1410                 {
1411                     /* First, clean up the previous function we were working on.
1412                      * Assume size of the func is the delta between current offset
1413                      * and offset of last function
1414                      */
1415                     stabs_finalize_function(module, curr_func,
1416                                             stab_ptr->n_value ?
1417                                                 (load_offset + stab_ptr->n_value - curr_func->address) : 0);
1418                 }
1419                 func_type = symt_new_function_signature(module,
1420                                                         stabs_parse_type(ptr));
1421                 curr_func = symt_new_function(module, compiland, symname,
1422                                               load_offset + stab_ptr->n_value, 0,
1423                                               &func_type->symt);
1424             }
1425             else
1426             {
1427                 /* some versions of GCC to use a N_FUN "" to mark the end of a function
1428                  * and n_value contains the size of the func
1429                  */
1430                 stabs_finalize_function(module, curr_func, stab_ptr->n_value);
1431                 curr_func = NULL;
1432             }
1433             break;
1434         case N_SO:
1435             /*
1436              * This indicates a new source file.  Append the records
1437              * together, to build the correct path name.
1438              */
1439             if (*ptr == '\0') /* end of N_SO file */
1440             {
1441                 /* Nuke old path. */
1442                 srcpath[0] = '\0';
1443                 stabs_finalize_function(module, curr_func, 0);
1444                 curr_func = NULL;
1445                 source_idx = -1;
1446                 incl_stk = -1;
1447                 assert(block == NULL);
1448                 compiland = NULL;
1449             }
1450             else
1451             {
1452                 int len = strlen(ptr);
1453                 if (ptr[len-1] != '/')
1454                 {
1455                     strcpy(currpath, srcpath);
1456                     strcat(currpath, ptr);
1457                     stabs_reset_includes();
1458                     compiland = symt_new_compiland(module, currpath);
1459                     source_idx = source_new(module, currpath);
1460                 }
1461                 else
1462                     strcpy(srcpath, ptr);
1463             }
1464             break;
1465         case N_SOL:
1466             if (*ptr != '/')
1467             {
1468                 strcpy(currpath, srcpath);
1469                 strcat(currpath, ptr);
1470             }
1471             else
1472                 strcpy(currpath, ptr);
1473             source_idx = source_new(module, currpath);
1474             break;
1475         case N_UNDF:
1476             strs += strtabinc;
1477             strtabinc = stab_ptr->n_value;
1478             /* I'm not sure this is needed, so trace it before we obsolete it */
1479             if (curr_func)
1480             {
1481                 FIXME("UNDF: curr_func %s\n", curr_func->hash_elt.name);
1482                 stabs_finalize_function(module, curr_func, 0); /* FIXME */
1483                 curr_func = NULL;
1484             }
1485             break;
1486         case N_OPT:
1487             /* Ignore this. We don't care what it points to. */
1488             break;
1489         case N_BINCL:
1490             stabs_add_include(stabs_new_include(ptr, stab_ptr->n_value));
1491             assert(incl_stk < (int)(sizeof(incl) / sizeof(incl[0])) - 1);
1492             incl[++incl_stk] = source_idx;
1493             source_idx = source_new(module, ptr);
1494             break;
1495         case N_EINCL:
1496             assert(incl_stk >= 0);
1497             source_idx = incl[incl_stk--];
1498             break;
1499         case N_EXCL:
1500             if (stabs_add_include(stabs_find_include(ptr, stab_ptr->n_value)) < 0)
1501             {
1502                 ERR("Excluded header not found (%s,%ld)\n", ptr, stab_ptr->n_value);
1503                 module_reset_debug_info(module);
1504                 ret = FALSE;
1505                 goto done;
1506             }
1507             break;
1508         case N_MAIN:
1509             /* Always ignore these. GCC doesn't even generate them. */
1510             break;
1511         default:
1512             ERR("Unknown stab type 0x%02x\n", stab_ptr->n_type);
1513             break;
1514         }
1515         stabbuff[0] = '\0';
1516         TRACE("0x%02x %lx %s\n",
1517               stab_ptr->n_type, stab_ptr->n_value, debugstr_a(strs + stab_ptr->n_un.n_strx));
1518     }
1519     module->module.SymType = SymDia;
1520 done:
1521     HeapFree(GetProcessHeap(), 0, stabbuff);
1522     stabs_free_includes();
1523     HeapFree(GetProcessHeap(), 0, pending_vars);
1524
1525     return ret;
1526 }