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