git.oblomov.eu Git - wine/blob - programs/winedbg/stabs.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * File stabs.c - read stabs information from the wine executable itself.
   5  *
   6  * Copyright (C) 1996, Eric Youngdale.
   7  *               1999-2003 Eric Pouech
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  *
  24  * Maintenance Information
  25  * -----------------------
  26  *
  27  * For documentation on the stabs format see for example
  28  *   The "stabs" debug format
  29  *     by Julia Menapace, Jim Kingdon, David Mackenzie
  30  *     of Cygnus Support
  31  *     available (hopefully) from http:\\sources.redhat.com\gdb\onlinedocs
  32  */
  33
  34 #include "config.h"
  35
  36 #include <sys/types.h>
  37 #include <fcntl.h>
  38 #include <sys/stat.h>
  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 #include <unistd.h>
  46 #include <stdio.h>
  47 #ifndef PATH_MAX
  48 #define PATH_MAX MAX_PATH
  49 #endif
  50
  51 #include "debugger.h"
  52
  53 #if defined(__svr4__) || defined(__sun)
  54 #define __ELF__
  55 #endif
  56
  57 #ifdef __ELF__
  58 #ifdef HAVE_ELF_H
  59 # include <elf.h>
  60 #endif
  61 #ifdef HAVE_LINK_H
  62 # include <link.h>
  63 #endif
  64 #ifdef HAVE_SYS_LINK_H
  65 # include <sys/link.h>
  66 #endif
  67 #endif
  68
  69 #ifndef N_UNDF
  70 #define N_UNDF          0x00
  71 #endif
  72
  73 #ifndef STN_UNDEF
  74 # define STN_UNDEF      0
  75 #endif
  76
  77 #define N_GSYM          0x20
  78 #define N_FUN           0x24
  79 #define N_STSYM         0x26
  80 #define N_LCSYM         0x28
  81 #define N_MAIN          0x2a
  82 #define N_ROSYM         0x2c
  83 #define N_OPT           0x3c
  84 #define N_RSYM          0x40
  85 #define N_SLINE         0x44
  86 #define N_SO            0x64
  87 #define N_LSYM          0x80
  88 #define N_BINCL         0x82
  89 #define N_SOL           0x84
  90 #define N_PSYM          0xa0
  91 #define N_EINCL         0xa2
  92 #define N_LBRAC         0xc0
  93 #define N_EXCL          0xc2
  94 #define N_RBRAC         0xe0
  95
  96 typedef struct tagELF_DBG_INFO
  97 {
  98     void *elf_addr;
  99 } ELF_DBG_INFO;
 100
 101 struct stab_nlist {
 102   union {
 103     char *n_name;
 104     struct stab_nlist *n_next;
 105     long n_strx;
 106   } n_un;
 107   unsigned char n_type;
 108   char n_other;
 109   short n_desc;
 110   unsigned long n_value;
 111 };
 112
 113 static void stab_strcpy(char * dest, int sz, const char * source)
 114 {
 115   /*
 116    * A strcpy routine that stops when we hit the ':' character.
 117    * Faster than copying the whole thing, and then nuking the
 118    * ':'.
 119    */
 120   while(*source != '\0' && *source != ':' && sz-- > 0)
 121       *dest++ = *source++;
 122   *dest = '\0';
 123   assert(sz > 0);
 124 }
 125
 126 typedef struct {
 127    char*                name;
 128    unsigned long        value;
 129    int                  idx;
 130    struct datatype**    vector;
 131    int                  nrofentries;
 132 } include_def;
 133
 134 #define MAX_INCLUDES    5120
 135
 136 static  include_def*    include_defs = NULL;
 137 static  int             num_include_def = 0;
 138 static  int             num_alloc_include_def = 0;
 139 static  int             cu_include_stack[MAX_INCLUDES];
 140 static  int             cu_include_stk_idx = 0;
 141 static  struct datatype**       cu_vector = NULL;
 142 static  int             cu_nrofentries = 0;
 143
 144 static
 145 int
 146 DEBUG_CreateInclude(const char* file, unsigned long val)
 147 {
 148   if (num_include_def == num_alloc_include_def)
 149     {
 150       num_alloc_include_def += 256;
 151       include_defs = DBG_realloc(include_defs, sizeof(include_defs[0])*num_alloc_include_def);
 152       memset(include_defs+num_include_def, 0, sizeof(include_defs[0])*256);
 153     }
 154   include_defs[num_include_def].name = DBG_strdup(file);
 155   include_defs[num_include_def].value = val;
 156   include_defs[num_include_def].vector = NULL;
 157   include_defs[num_include_def].nrofentries = 0;
 158
 159   return num_include_def++;
 160 }
 161
 162 static
 163 int
 164 DEBUG_FindInclude(const char* file, unsigned long val)
 165 {
 166   int           i;
 167
 168   for (i = 0; i < num_include_def; i++)
 169     {
 170       if (val == include_defs[i].value &&
 171           strcmp(file, include_defs[i].name) == 0)
 172         return i;
 173     }
 174   return -1;
 175 }
 176
 177 static
 178 int
 179 DEBUG_AddInclude(int idx)
 180 {
 181   ++cu_include_stk_idx;
 182
 183   /* is this happen, just bump MAX_INCLUDES */
 184   /* we could also handle this as another dynarray */
 185   assert(cu_include_stk_idx < MAX_INCLUDES);
 186
 187   cu_include_stack[cu_include_stk_idx] = idx;
 188   return cu_include_stk_idx;
 189 }
 190
 191 static
 192 void
 193 DEBUG_ResetIncludes(void)
 194 {
 195   /*
 196    * The datatypes that we would need to use are reset when
 197    * we start a new file. (at least the ones in filenr == 0
 198    */
 199   cu_include_stk_idx = 0;/* keep 0 as index for the .c file itself */
 200   memset(cu_vector, 0, sizeof(cu_vector[0]) * cu_nrofentries);
 201 }
 202
 203 static
 204 void
 205 DEBUG_FreeIncludes(void)
 206 {
 207   int   i;
 208
 209   DEBUG_ResetIncludes();
 210
 211   for (i = 0; i < num_include_def; i++)
 212     {
 213       DBG_free(include_defs[i].name);
 214       DBG_free(include_defs[i].vector);
 215     }
 216   DBG_free(include_defs);
 217   include_defs = NULL;
 218   num_include_def = 0;
 219   num_alloc_include_def = 0;
 220   DBG_free(cu_vector);
 221   cu_vector = NULL;
 222   cu_nrofentries = 0;
 223 }
 224
 225 static
 226 struct datatype**
 227 DEBUG_FileSubNr2StabEnum(int filenr, int subnr)
 228 {
 229   struct datatype** ret;
 230
 231   /* DEBUG_Printf(DBG_CHN_MESG, "creating type id for (%d,%d)\n", filenr, subnr); */
 232
 233   /* FIXME: I could perhaps create a dummy include_def for each compilation
 234    * unit which would allow not to handle those two cases separately
 235    */
 236   if (filenr == 0)
 237     {
 238       if (cu_nrofentries <= subnr)
 239         {
 240           cu_vector = DBG_realloc(cu_vector, sizeof(cu_vector[0])*(subnr+1));
 241           memset(cu_vector+cu_nrofentries, 0, sizeof(cu_vector[0])*(subnr+1-cu_nrofentries));
 242           cu_nrofentries = subnr + 1;
 243         }
 244       ret = &cu_vector[subnr];
 245     }
 246   else
 247     {
 248       include_def*      idef;
 249
 250       assert(filenr <= cu_include_stk_idx);
 251
 252       idef = &include_defs[cu_include_stack[filenr]];
 253
 254       if (idef->nrofentries <= subnr)
 255         {
 256           idef->vector = DBG_realloc(idef->vector, sizeof(idef->vector[0])*(subnr+1));
 257           memset(idef->vector + idef->nrofentries, 0, sizeof(idef->vector[0])*(subnr+1-idef->nrofentries));
 258           idef->nrofentries = subnr + 1;
 259         }
 260       ret = &idef->vector[subnr];
 261     }
 262   /* DEBUG_Printf(DBG_CHN_MESG,"(%d,%d) is %d\n",filenr,subnr,ret); */
 263   return ret;
 264 }
 265
 266 static
 267 struct datatype**
 268 DEBUG_ReadTypeEnum(char **x) {
 269     int filenr,subnr;
 270
 271     if (**x=='(') {
 272         (*x)++;                                 /* '(' */
 273         filenr=strtol(*x,x,10);                 /* <int> */
 274         (*x)++;                                 /* ',' */
 275         subnr=strtol(*x,x,10);                  /* <int> */
 276         (*x)++;                                 /* ')' */
 277     } else {
 278         filenr = 0;
 279         subnr = strtol(*x,x,10);                /* <int> */
 280     }
 281     return DEBUG_FileSubNr2StabEnum(filenr,subnr);
 282 }
 283
 284 /*#define PTS_DEBUG*/
 285 struct ParseTypedefData
 286 {
 287     char*               ptr;
 288     char                buf[1024];
 289     int                 idx;
 290 #ifdef PTS_DEBUG
 291     struct PTS_Error
 292     {
 293         char*               ptr;
 294         unsigned            line;
 295     } errors[16];
 296     int                 err_idx;
 297 #endif
 298 };
 299
 300 #ifdef PTS_DEBUG
 301 static void PTS_Push(struct ParseTypedefData* ptd, unsigned line)
 302 {
 303     assert(ptd->err_idx < sizeof(ptd->errors) / sizeof(ptd->errors[0]));
 304     ptd->errors[ptd->err_idx].line = line;
 305     ptd->errors[ptd->err_idx].ptr = ptd->ptr;
 306     ptd->err_idx++;
 307 }
 308 #define PTS_ABORTIF(ptd, t) do { if (t) { PTS_Push((ptd), __LINE__); return -1;} } while (0)
 309 #else
 310 #define PTS_ABORTIF(ptd, t) do { if (t) return -1; } while (0)
 311 #endif
 312
 313 static int DEBUG_PTS_ReadTypedef(struct ParseTypedefData* ptd, const char* typename,
 314                                  struct datatype** dt);
 315
 316 static int DEBUG_PTS_ReadID(struct ParseTypedefData* ptd)
 317 {
 318     char*               first = ptd->ptr;
 319     unsigned int        len;
 320
 321     PTS_ABORTIF(ptd, (ptd->ptr = strchr(ptd->ptr, ':')) == NULL);
 322     len = ptd->ptr - first;
 323     PTS_ABORTIF(ptd, len >= sizeof(ptd->buf) - ptd->idx);
 324     memcpy(ptd->buf + ptd->idx, first, len);
 325     ptd->buf[ptd->idx + len] = '\0';
 326     ptd->idx += len + 1;
 327     ptd->ptr++; /* ':' */
 328     return 0;
 329 }
 330
 331 static int DEBUG_PTS_ReadNum(struct ParseTypedefData* ptd, int* v)
 332 {
 333     char*       last;
 334
 335     *v = strtol(ptd->ptr, &last, 10);
 336     PTS_ABORTIF(ptd, last == ptd->ptr);
 337     ptd->ptr = last;
 338     return 0;
 339 }
 340
 341 static int DEBUG_PTS_ReadTypeReference(struct ParseTypedefData* ptd,
 342                                        int* filenr, int* subnr)
 343 {
 344     if (*ptd->ptr == '(') {
 345         /* '(' <int> ',' <int> ')' */
 346         ptd->ptr++;
 347         PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, filenr) == -1);
 348         PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 349         PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, subnr) == -1);
 350         PTS_ABORTIF(ptd, *ptd->ptr++ != ')');
 351     } else {
 352         *filenr = 0;
 353         PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, subnr) == -1);
 354     }
 355     return 0;
 356 }
 357
 358 static int DEBUG_PTS_ReadRange(struct ParseTypedefData* ptd, struct datatype** dt,
 359                                int* lo, int* hi)
 360 {
 361     /* type ';' <int> ';' <int> ';' */
 362     PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, dt) == -1);
 363     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
 364     PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, lo) == -1);
 365     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
 366     PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, hi) == -1);
 367     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');       /* ';' */
 368     return 0;
 369 }
 370
 371 static inline int DEBUG_PTS_ReadMethodInfo(struct ParseTypedefData* ptd)
 372 {
 373     struct datatype* dt;
 374     char*   tmp;
 375     char    mthd;
 376
 377     do
 378     {
 379         /* get type of return value */
 380         PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1);
 381         if (*ptd->ptr == ';') ptd->ptr++;
 382
 383         /* get types of parameters */
 384         if (*ptd->ptr == ':')
 385         {
 386             PTS_ABORTIF(ptd, !(tmp = strchr(ptd->ptr + 1, ';')));
 387             ptd->ptr = tmp + 1;
 388         }
 389         PTS_ABORTIF(ptd, !(*ptd->ptr >= '0' && *ptd->ptr <= '9'));
 390         ptd->ptr++;
 391         PTS_ABORTIF(ptd, !(ptd->ptr[0] >= 'A' && *ptd->ptr <= 'D'));
 392         mthd = *++ptd->ptr;
 393         PTS_ABORTIF(ptd, mthd != '.' && mthd != '?' && mthd != '*');
 394         ptd->ptr++;
 395         if (mthd == '*')
 396         {
 397             int              ofs;
 398             struct datatype* dt;
 399
 400             PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &ofs) == -1);
 401             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 402             PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1);
 403             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 404         }
 405     } while (*ptd->ptr != ';');
 406     ptd->ptr++;
 407
 408     return 0;
 409 }
 410
 411 static inline int DEBUG_PTS_ReadAggregate(struct ParseTypedefData* ptd,
 412                                           struct datatype* sdt)
 413 {
 414     int                 sz, ofs;
 415     struct datatype*    adt;
 416     struct datatype*    dt = NULL;
 417     int                 idx;
 418     int                 doadd;
 419
 420     PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &sz) == -1);
 421
 422     doadd = DEBUG_SetStructSize(sdt, sz);
 423     if (*ptd->ptr == '!') /* C++ inheritence */
 424     {
 425         int     num_classes;
 426         char    tmp[256];
 427
 428         ptd->ptr++;
 429         PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &num_classes) == -1);
 430         PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 431         while (--num_classes >= 0)
 432         {
 433             ptd->ptr += 2; /* skip visibility and inheritence */
 434             PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &ofs) == -1);
 435             PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 436
 437             PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &adt) == -1);
 438
 439             snprintf(tmp, sizeof(tmp), "__inherited_class_%s", DEBUG_GetName(adt));
 440             /* FIXME: DEBUG_GetObjectSize will not always work, especially when adt
 441              * has just been seen as a forward definition and not the real stuff yet.
 442              * As we don't use much the size of members in structs, this may not
 443              * be much of a problem
 444              */
 445             if (doadd) DEBUG_AddStructElement(sdt, tmp, adt, ofs, DEBUG_GetObjectSize(adt) * 8);
 446             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 447         }
 448
 449     }
 450     /* if the structure has already been filled, just redo the parsing
 451      * but don't store results into the struct
 452      * FIXME: there's a quite ugly memory leak in there...
 453      */
 454
 455     /* Now parse the individual elements of the structure/union. */
 456     while (*ptd->ptr != ';')
 457     {
 458         /* agg_name : type ',' <int:offset> ',' <int:size> */
 459         idx = ptd->idx;
 460
 461         if (ptd->ptr[0] == '$' && ptd->ptr[1] == 'v')
 462         {
 463             int                 x;
 464
 465             if (ptd->ptr[2] == 'f')
 466             {
 467                 /* C++ virtual method table */
 468                 ptd->ptr += 3;
 469                 DEBUG_ReadTypeEnum(&ptd->ptr);
 470                 PTS_ABORTIF(ptd, *ptd->ptr++ != ':');
 471                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1);
 472                 PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 473                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &x) == -1);
 474                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 475                 ptd->idx = idx;
 476                 continue;
 477             }
 478             else if (ptd->ptr[2] == 'b')
 479             {
 480                 ptd->ptr += 3;
 481                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1);
 482                 PTS_ABORTIF(ptd, *ptd->ptr++ != ':');
 483                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1);
 484                 PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 485                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &x) == -1);
 486                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 487                 ptd->idx = idx;
 488                 continue;
 489             }
 490         }
 491
 492         PTS_ABORTIF(ptd, DEBUG_PTS_ReadID(ptd) == -1);
 493         /* Ref. TSDF R2.130 Section 7.4.  When the field name is a method name
 494          * it is followed by two colons rather than one.
 495          */
 496         if (*ptd->ptr == ':')
 497         {
 498             ptd->ptr++;
 499             DEBUG_PTS_ReadMethodInfo(ptd);
 500             ptd->idx = idx;
 501             continue;
 502         }
 503         else
 504         {
 505             /* skip C++ member protection /0 /1 or /2 */
 506             if (*ptd->ptr == '/') ptd->ptr += 2;
 507         }
 508         PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &adt) == -1);
 509
 510         switch (*ptd->ptr++)
 511         {
 512         case ',':
 513             PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &ofs) == -1);
 514             PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 515             PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &sz) == -1);
 516             PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 517
 518             if (doadd) DEBUG_AddStructElement(sdt, ptd->buf + idx, adt, ofs, sz);
 519             break;
 520         case ':':
 521             {
 522                 char* tmp;
 523                 /* method parameters... terminated by ';' */
 524                 PTS_ABORTIF(ptd, !(tmp = strchr(ptd->ptr, ';')));
 525                 ptd->ptr = tmp + 1;
 526             }
 527             break;
 528         default:
 529             PTS_ABORTIF(ptd, TRUE);
 530         }
 531         ptd->idx = idx;
 532     }
 533     PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 534     if (*ptd->ptr == '~')
 535     {
 536         ptd->ptr++;
 537         PTS_ABORTIF(ptd, *ptd->ptr++ != '%');
 538         PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1);
 539         PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 540     }
 541     return 0;
 542 }
 543
 544 static inline int DEBUG_PTS_ReadEnum(struct ParseTypedefData* ptd,
 545                                      struct datatype* edt)
 546 {
 547     int                 ofs;
 548     int                 idx;
 549
 550     while (*ptd->ptr != ';') {
 551         idx = ptd->idx;
 552         PTS_ABORTIF(ptd, DEBUG_PTS_ReadID(ptd) == -1);
 553         PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &ofs) == -1);
 554         PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 555         DEBUG_AddStructElement(edt, ptd->buf + idx, NULL, ofs, 0);
 556         ptd->idx = idx;
 557     }
 558     ptd->ptr++;
 559     return 0;
 560 }
 561
 562 static inline int DEBUG_PTS_ReadArray(struct ParseTypedefData* ptd,
 563                                       struct datatype* adt)
 564 {
 565     int                 lo, hi;
 566     struct datatype*    rdt;
 567
 568     /* ar<typeinfo_nodef>;<int>;<int>;<typeinfo> */
 569
 570     PTS_ABORTIF(ptd, *ptd->ptr++ != 'r');
 571     /* FIXME: range type is lost, always assume int */
 572     PTS_ABORTIF(ptd, DEBUG_PTS_ReadRange(ptd, &rdt, &lo, &hi) == -1);
 573     PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &rdt) == -1);
 574
 575     DEBUG_SetArrayParams(adt, lo, hi, rdt);
 576     return 0;
 577 }
 578
 579 static int DEBUG_PTS_ReadTypedef(struct ParseTypedefData* ptd, const char* typename,
 580                                  struct datatype** ret_dt)
 581 {
 582     int                 idx, lo, hi, sz = -1;
 583     struct datatype*    new_dt = NULL;  /* newly created data type */
 584     struct datatype*    ref_dt;         /* referenced data type (pointer...) */
 585     struct datatype*    dt1;            /* intermediate data type (scope is limited) */
 586     struct datatype*    dt2;            /* intermediate data type: t1=t2=new_dt */
 587     int                 filenr1, subnr1;
 588
 589     /* things are a bit complicated because of the way the typedefs are stored inside
 590      * the file (we cannot keep the struct datatype** around, because address can
 591      * change when realloc is done, so we must call over and over
 592      * DEBUG_FileSubNr2StabEnum to keep the correct values around
 593      * (however, keeping struct datatype* is valid))
 594      */
 595     PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypeReference(ptd, &filenr1, &subnr1) == -1);
 596
 597     while (*ptd->ptr == '=') {
 598         ptd->ptr++;
 599         PTS_ABORTIF(ptd, new_dt != NULL);
 600
 601         /* first handle attribute if any */
 602         switch (*ptd->ptr) {
 603         case '@':
 604             if (*++ptd->ptr == 's') {
 605                 ptd->ptr++;
 606                 if (DEBUG_PTS_ReadNum(ptd, &sz) == -1) {
 607                     DEBUG_Printf(DBG_CHN_MESG, "Not an attribute... NIY\n");
 608                     ptd->ptr -= 2;
 609                     return -1;
 610                 }
 611                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 612             }
 613             break;
 614         }
 615         /* then the real definitions */
 616         switch (*ptd->ptr++) {
 617         case '*':
 618         case '&':
 619             new_dt = DEBUG_NewDataType(DT_POINTER, NULL);
 620             PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &ref_dt) == -1);
 621             DEBUG_SetPointerType(new_dt, ref_dt);
 622            break;
 623         case 'k': /* 'const' modifier */
 624         case 'B': /* 'volatile' modifier */
 625             /* just kinda ignore the modifier, I guess -gmt */
 626             PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, typename, &new_dt) == -1);
 627             break;
 628         case '(':
 629             ptd->ptr--;
 630             PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, typename, &new_dt) == -1);
 631             break;
 632         case 'a':
 633             new_dt = DEBUG_NewDataType(DT_ARRAY, NULL);
 634             PTS_ABORTIF(ptd, DEBUG_PTS_ReadArray(ptd, new_dt) == -1);
 635             break;
 636         case 'r':
 637             new_dt = DEBUG_NewDataType(DT_BASIC, typename);
 638             assert(!*DEBUG_FileSubNr2StabEnum(filenr1, subnr1));
 639             *DEBUG_FileSubNr2StabEnum(filenr1, subnr1) = new_dt;
 640             PTS_ABORTIF(ptd, DEBUG_PTS_ReadRange(ptd, &ref_dt, &lo, &hi) == -1);
 641             /* should perhaps do more here... */
 642             break;
 643         case 'f':
 644             new_dt = DEBUG_NewDataType(DT_FUNC, NULL);
 645             PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &ref_dt) == -1);
 646             DEBUG_SetPointerType(new_dt, ref_dt);
 647             break;
 648         case 'e':
 649             new_dt = DEBUG_NewDataType(DT_ENUM, NULL);
 650             PTS_ABORTIF(ptd, DEBUG_PTS_ReadEnum(ptd, new_dt) == -1);
 651             break;
 652         case 's':
 653         case 'u':
 654             /* dt1 can have been already defined in a forward definition */
 655             dt1 = *DEBUG_FileSubNr2StabEnum(filenr1, subnr1);
 656             dt2 = DEBUG_TypeCast(DT_STRUCT, typename);
 657             if (!dt1) {
 658                 new_dt = DEBUG_NewDataType(DT_STRUCT, typename);
 659                 /* we need to set it here, because a struct can hold a pointer
 660                  * to itself
 661                  */
 662                 *DEBUG_FileSubNr2StabEnum(filenr1, subnr1) = new_dt;
 663             } else {
 664                 if (DEBUG_GetType(dt1) != DT_STRUCT) {
 665                     DEBUG_Printf(DBG_CHN_MESG,
 666                                  "Forward declaration is not an aggregate\n");
 667                     return -1;
 668                 }
 669
 670                 /* should check typename is the same too */
 671                 new_dt = dt1;
 672             }
 673             PTS_ABORTIF(ptd, DEBUG_PTS_ReadAggregate(ptd, new_dt) == -1);
 674             break;
 675         case 'x':
 676             switch (*ptd->ptr++) {
 677             case 'e':                   lo = DT_ENUM;   break;
 678             case 's':   case 'u':       lo = DT_STRUCT; break;
 679             default: return -1;
 680             }
 681
 682             idx = ptd->idx;
 683             PTS_ABORTIF(ptd, DEBUG_PTS_ReadID(ptd) == -1);
 684             new_dt = DEBUG_NewDataType(lo, ptd->buf + idx);
 685             ptd->idx = idx;
 686             break;
 687         case '-':
 688             {
 689                 enum debug_type_basic basic = DT_BASIC_LAST;
 690
 691                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &lo) == -1);
 692
 693                 switch (lo)
 694                 {
 695                 case  1: basic = DT_BASIC_INT; break;
 696                 case  2: basic = DT_BASIC_CHAR; break;
 697                 case  3: basic = DT_BASIC_SHORTINT; break;
 698                 case  4: basic = DT_BASIC_LONGINT; break;
 699                 case  5: basic = DT_BASIC_UCHAR; break;
 700                 case  6: basic = DT_BASIC_SCHAR; break;
 701                 case  7: basic = DT_BASIC_USHORTINT; break;
 702                 case  8: basic = DT_BASIC_UINT; break;
 703 /*              case  9: basic = DT_BASIC_UINT";  */
 704                 case 10: basic = DT_BASIC_ULONGINT; break;
 705                 case 11: basic = DT_BASIC_VOID; break;
 706                 case 12: basic = DT_BASIC_FLOAT; break;
 707                 case 13: basic = DT_BASIC_DOUBLE; break;
 708                 case 14: basic = DT_BASIC_LONGDOUBLE; break;
 709 /*              case 15: basic = DT_BASIC_INT; break; */
 710                 case 16:
 711                     switch (sz) {
 712                     case 32: basic = DT_BASIC_BOOL1; break;
 713                     case 16: basic = DT_BASIC_BOOL2; break;
 714                     case  8: basic = DT_BASIC_BOOL4; break;
 715                     }
 716                     break;
 717 /*              case 17: basic = DT_BASIC_SHORT real; break; */
 718 /*              case 18: basic = DT_BASIC_REAL; break; */
 719                 case 25: basic = DT_BASIC_CMPLX_FLOAT; break;
 720                 case 26: basic = DT_BASIC_CMPLX_DOUBLE; break;
 721 /*              case 30: basic = DT_BASIC_wchar"; break; */
 722                 case 31: basic = DT_BASIC_LONGLONGINT; break;
 723                 case 32: basic = DT_BASIC_ULONGLONGINT; break;
 724                 default:
 725                     PTS_ABORTIF(ptd, 1);
 726                 }
 727                 PTS_ABORTIF(ptd, !(new_dt = DEBUG_GetBasicType(basic)));
 728                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');
 729             }
 730             break;
 731         case '#':
 732             new_dt = DEBUG_NewDataType(DT_FUNC, NULL);
 733             if (*ptd->ptr == '#')
 734             {
 735                 ptd->ptr++;
 736                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &ref_dt) == -1);
 737                 DEBUG_SetPointerType(new_dt, ref_dt);
 738             }
 739             else
 740             {
 741                 struct datatype* cls_dt;
 742                 struct datatype* pmt_dt;
 743
 744                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &cls_dt) == -1);
 745                 PTS_ABORTIF(ptd, *ptd->ptr++ != ',');
 746                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &ref_dt) == -1);
 747                 DEBUG_SetPointerType(new_dt, ref_dt);
 748                 while (*ptd->ptr == ',')
 749                 {
 750                     ptd->ptr++;
 751                     PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &pmt_dt) == -1);
 752                 }
 753             }
 754             break;
 755         case 'R':
 756             {
 757                 enum debug_type_basic basic = DT_BASIC_LAST;
 758                 int type, len, unk;
 759
 760                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &type) == -1);
 761                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');   /* ';' */
 762                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &len) == -1);
 763                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');   /* ';' */
 764                 PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &unk) == -1);
 765                 PTS_ABORTIF(ptd, *ptd->ptr++ != ';');   /* ';' */
 766
 767                 switch (type)
 768                 {
 769                 case 1: basic = DT_BASIC_FLOAT; break;
 770                 case 2: basic = DT_BASIC_DOUBLE; break;
 771                 case 3: basic = DT_BASIC_CMPLX_FLOAT; break;
 772                 case 4: basic = DT_BASIC_CMPLX_DOUBLE; break;
 773                 case 5: basic = DT_BASIC_CMPLX_LONGDOUBLE; break;
 774                 case 6: basic = DT_BASIC_LONGDOUBLE; break;
 775                 default: PTS_ABORTIF(ptd, 1);
 776                 }
 777                 PTS_ABORTIF(ptd, !(new_dt = DEBUG_GetBasicType(basic)));
 778             }
 779             break;
 780         default:
 781             DEBUG_Printf(DBG_CHN_MESG, "Unknown type '%c'\n", ptd->ptr[-1]);
 782             return -1;
 783         }
 784     }
 785
 786     if (!new_dt)
 787     {
 788         /* is it a forward declaration that has been filled ? */
 789         new_dt = *DEBUG_FileSubNr2StabEnum(filenr1, subnr1);
 790         /* if not, this should then be a basic type: define it, or even void */
 791         if (!new_dt)
 792             new_dt = DEBUG_NewDataType(DT_BASIC, typename);
 793     }
 794
 795     *DEBUG_FileSubNr2StabEnum(filenr1, subnr1) = *ret_dt = new_dt;
 796
 797 #if 0
 798     if (typename) {
 799         DEBUG_Printf(DBG_CHN_MESG, "Adding (%d,%d) %s => ", filenr1, subnr1, typename);
 800         DEBUG_PrintTypeCast(new_dt);
 801         DEBUG_Printf(DBG_CHN_MESG, "\n");
 802     }
 803 #endif
 804
 805     return 0;
 806 }
 807
 808 static int DEBUG_ParseTypedefStab(char* ptr, const char* typename)
 809 {
 810     struct ParseTypedefData     ptd;
 811     struct datatype*            dt;
 812     int                         ret = -1;
 813
 814     /* check for already existing definition */
 815
 816     ptd.idx = 0;
 817 #ifdef PTS_DEBUG
 818     ptd.err_idx = 0;
 819 #endif
 820     for (ptd.ptr = ptr - 1; ;)
 821     {
 822         ptd.ptr = strchr(ptd.ptr + 1, ':');
 823         if (ptd.ptr == NULL || *++ptd.ptr != ':') break;
 824     }
 825
 826     if (ptd.ptr)
 827     {
 828         if (*ptd.ptr != '(') ptd.ptr++;
 829         /* most of type definitions take one char, except Tt */
 830         if (*ptd.ptr != '(') ptd.ptr++;
 831         ret = DEBUG_PTS_ReadTypedef(&ptd, typename, &dt);
 832     }
 833
 834     if (ret == -1 || *ptd.ptr) {
 835 #ifdef PTS_DEBUG
 836         int     i;
 837         DEBUG_Printf(DBG_CHN_MESG, "Failure on %s\n", ptr);
 838         if (ret == -1)
 839         {
 840             for (i = 0; i < ptd.err_idx; i++)
 841             {
 842                 DEBUG_Printf(DBG_CHN_MESG, "[%d]: line %d => %s\n",
 843                              i, ptd.errors[i].line, ptd.errors[i].ptr);
 844             }
 845         }
 846         else
 847             DEBUG_Printf(DBG_CHN_MESG, "[0]: => %s\n", ptd.ptr);
 848
 849 #else
 850         DEBUG_Printf(DBG_CHN_MESG, "Failure on %s at %s\n", ptr, ptd.ptr);
 851 #endif
 852         return FALSE;
 853     }
 854
 855     return TRUE;
 856 }
 857
 858 static struct datatype *
 859 DEBUG_ParseStabType(const char * stab)
 860 {
 861     const char* c = stab - 1;
 862
 863     /*
 864      * Look through the stab definition, and figure out what datatype
 865      * this represents.  If we have something we know about, assign the
 866      * type.
 867      * According to "The \"stabs\" debug format" (Rev 2.130) the name may be
 868      * a C++ name and contain double colons e.g. foo::bar::baz:t5=*6.
 869      */
 870     do
 871     {
 872         if ((c = strchr(c + 1, ':')) == NULL) return NULL;
 873     } while (*++c == ':');
 874
 875     /*
 876      * The next characters say more about the type (i.e. data, function, etc)
 877      * of symbol.  Skip them.  (C++ for example may have Tt).
 878      * Actually this is a very weak description; I think Tt is the only
 879      * multiple combination we should see.
 880      */
 881     while (*c && *c != '(' && !isdigit(*c))
 882         c++;
 883     /*
 884      * The next is either an integer or a (integer,integer).
 885      * The DEBUG_ReadTypeEnum takes care that stab_types is large enough.
 886      */
 887     return *DEBUG_ReadTypeEnum((char**)&c);
 888 }
 889
 890 enum DbgInfoLoad DEBUG_ParseStabs(char * addr, void *load_offset,
 891                                   unsigned int staboff, int stablen,
 892                                   unsigned int strtaboff, int strtablen)
 893 {
 894   struct name_hash    * curr_func = NULL;
 895   struct wine_locals  * curr_loc = NULL;
 896   struct name_hash    * curr_sym = NULL;
 897   char                  currpath[PATH_MAX];
 898   int                   i;
 899   int                   in_external_file = FALSE;
 900   int                   last_nso = -1;
 901   unsigned int          len;
 902   DBG_VALUE             new_value;
 903   int                   nstab;
 904   char                * ptr;
 905   char                * stabbuff;
 906   unsigned int          stabbufflen;
 907   struct stab_nlist   * stab_ptr;
 908   char                * strs;
 909   int                   strtabinc;
 910   char                * subpath = NULL;
 911   char                  symname[4096];
 912
 913   nstab = stablen / sizeof(struct stab_nlist);
 914   stab_ptr = (struct stab_nlist *) (addr + staboff);
 915   strs  = (char *) (addr + strtaboff);
 916
 917   memset(currpath, 0, sizeof(currpath));
 918
 919   /*
 920    * Allocate a buffer into which we can build stab strings for cases
 921    * where the stab is continued over multiple lines.
 922    */
 923   stabbufflen = 65536;
 924   stabbuff = (char *) DBG_alloc(stabbufflen);
 925
 926   strtabinc = 0;
 927   stabbuff[0] = '\0';
 928   for (i = 0; i < nstab; i++, stab_ptr++)
 929     {
 930       ptr = strs + (unsigned int) stab_ptr->n_un.n_name;
 931       if( ptr[strlen(ptr) - 1] == '\\' )
 932         {
 933           /*
 934            * Indicates continuation.  Append this to the buffer, and go onto the
 935            * next record.  Repeat the process until we find a stab without the
 936            * '/' character, as this indicates we have the whole thing.
 937            */
 938           len = strlen(ptr);
 939           if( strlen(stabbuff) + len > stabbufflen )
 940             {
 941               stabbufflen += 65536;
 942               stabbuff = (char *) DBG_realloc(stabbuff, stabbufflen);
 943             }
 944           strncat(stabbuff, ptr, len - 1);
 945           continue;
 946         }
 947       else if( stabbuff[0] != '\0' )
 948         {
 949           strcat( stabbuff, ptr);
 950           ptr = stabbuff;
 951         }
 952
 953       if( strchr(ptr, '=') != NULL )
 954         {
 955           /*
 956            * The stabs aren't in writable memory, so copy it over so we are
 957            * sure we can scribble on it.
 958            */
 959           if( ptr != stabbuff )
 960             {
 961               strcpy(stabbuff, ptr);
 962               ptr = stabbuff;
 963             }
 964           stab_strcpy(symname, sizeof(symname), ptr);
 965           if (!DEBUG_ParseTypedefStab(ptr, symname)) {
 966             /* skip this definition */
 967             stabbuff[0] = '\0';
 968             continue;
 969           }
 970         }
 971
 972       switch(stab_ptr->n_type)
 973         {
 974         case N_GSYM:
 975           /*
 976            * These are useless with ELF.  They have no value, and you have to
 977            * read the normal symbol table to get the address.  Thus we
 978            * ignore them, and when we process the normal symbol table
 979            * we should do the right thing.
 980            *
 981            * With a.out or mingw, they actually do make some amount of sense.
 982            */
 983           new_value.addr.seg = 0;
 984           new_value.type = DEBUG_ParseStabType(ptr);
 985           new_value.addr.off = (unsigned long)load_offset + stab_ptr->n_value;
 986           new_value.cookie = DV_TARGET;
 987
 988           stab_strcpy(symname, sizeof(symname), ptr);
 989 #ifdef __ELF__
 990           curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath,
 991                                       SYM_WINE | SYM_DATA | SYM_INVALID );
 992 #else
 993           curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath,
 994                                       SYM_WINE | SYM_DATA );
 995 #endif
 996           break;
 997         case N_RBRAC:
 998         case N_LBRAC:
 999           /*
1000            * We need to keep track of these so we get symbol scoping
1001            * right for local variables.  For now, we just ignore them.
1002            * The hooks are already there for dealing with this however,
1003            * so all we need to do is to keep count of the nesting level,
1004            * and find the RBRAC for each matching LBRAC.
1005            */
1006           break;
1007         case N_LCSYM:
1008         case N_STSYM:
1009           /*
1010            * These are static symbols and BSS symbols.
1011            */
1012           new_value.addr.seg = 0;
1013           new_value.type = DEBUG_ParseStabType(ptr);
1014           new_value.addr.off = (unsigned long)load_offset + stab_ptr->n_value;
1015           new_value.cookie = DV_TARGET;
1016
1017           stab_strcpy(symname, sizeof(symname), ptr);
1018           curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath,
1019                                       SYM_WINE | SYM_DATA );
1020           break;
1021         case N_PSYM:
1022           /*
1023            * These are function parameters.
1024            */
1025           if( curr_func != NULL && !in_external_file )
1026             {
1027               stab_strcpy(symname, sizeof(symname), ptr);
1028               curr_loc = DEBUG_AddLocal( curr_func, 0,
1029                                          stab_ptr->n_value, 0, 0, symname );
1030               DEBUG_SetLocalSymbolType( curr_loc, DEBUG_ParseStabType(ptr) );
1031             }
1032           break;
1033         case N_RSYM:
1034           if( curr_func != NULL && !in_external_file )
1035             {
1036               stab_strcpy(symname, sizeof(symname), ptr);
1037               curr_loc = DEBUG_AddLocal( curr_func, stab_ptr->n_value + 1,
1038                                          0, 0, 0, symname );
1039               DEBUG_SetLocalSymbolType( curr_loc, DEBUG_ParseStabType(ptr) );
1040             }
1041           break;
1042         case N_LSYM:
1043           if( curr_func != NULL && !in_external_file )
1044             {
1045               stab_strcpy(symname, sizeof(symname), ptr);
1046               curr_loc = DEBUG_AddLocal( curr_func, 0,
1047                                          stab_ptr->n_value, 0, 0, symname );
1048               DEBUG_SetLocalSymbolType( curr_loc, DEBUG_ParseStabType(ptr) );
1049             }
1050           break;
1051         case N_SLINE:
1052           /*
1053            * This is a line number.  These are always relative to the start
1054            * of the function (N_FUN), and this makes the lookup easier.
1055            */
1056           if( curr_func != NULL && !in_external_file )
1057             {
1058 #ifdef __ELF__
1059               DEBUG_AddLineNumber(curr_func, stab_ptr->n_desc,
1060                                   stab_ptr->n_value);
1061 #else
1062 #if 0
1063               /*
1064                * This isn't right.  The order of the stabs is different under
1065                * a.out, and as a result we would end up attaching the line
1066                * number to the wrong function.
1067                */
1068               DEBUG_AddLineNumber(curr_func, stab_ptr->n_desc,
1069                                   stab_ptr->n_value - curr_func->addr.off);
1070 #endif
1071 #endif
1072             }
1073           break;
1074         case N_FUN:
1075           /*
1076            * First, clean up the previous function we were working on.
1077            */
1078           DEBUG_Normalize(curr_func);
1079
1080           /*
1081            * For now, just declare the various functions.  Later
1082            * on, we will add the line number information and the
1083            * local symbols.
1084            */
1085           if( !in_external_file)
1086             {
1087               stab_strcpy(symname, sizeof(symname), ptr);
1088               if (*symname)
1089                 {
1090                   new_value.addr.seg = 0;
1091                   new_value.type = DEBUG_ParseStabType(ptr);
1092                   new_value.addr.off = (unsigned long)load_offset + stab_ptr->n_value;
1093                   new_value.cookie = DV_TARGET;
1094                   /*
1095                    * Copy the string to a temp buffer so we
1096                    * can kill everything after the ':'.  We do
1097                    * it this way because otherwise we end up dirtying
1098                    * all of the pages related to the stabs, and that
1099                    * sucks up swap space like crazy.
1100                    */
1101 #ifdef __ELF__
1102                   curr_func = DEBUG_AddSymbol( symname, &new_value, currpath,
1103                                                SYM_WINE | SYM_FUNC | SYM_INVALID );
1104 #else
1105                   curr_func = DEBUG_AddSymbol( symname, &new_value, currpath,
1106                                                SYM_WINE | SYM_FUNC );
1107 #endif
1108                 }
1109               else
1110                 {
1111                   /* some GCC seem to use a N_FUN "" to mark the end of a function */
1112                   curr_func = NULL;
1113                 }
1114             }
1115           else
1116             {
1117               /*
1118                * Don't add line number information for this function
1119                * any more.
1120                */
1121               curr_func = NULL;
1122             }
1123           break;
1124         case N_SO:
1125           /*
1126            * This indicates a new source file.  Append the records
1127            * together, to build the correct path name.
1128            */
1129 #ifndef __ELF__
1130           /*
1131            * With a.out, there is no NULL string N_SO entry at the end of
1132            * the file.  Thus when we find non-consecutive entries,
1133            * we consider that a new file is started.
1134            */
1135           if( last_nso < i-1 )
1136             {
1137               currpath[0] = '\0';
1138               DEBUG_Normalize(curr_func);
1139               curr_func = NULL;
1140             }
1141 #endif
1142
1143           if( *ptr == '\0' ) /* end of N_SO file */
1144             {
1145               /*
1146                * Nuke old path.
1147                */
1148               currpath[0] = '\0';
1149               DEBUG_Normalize(curr_func);
1150               curr_func = NULL;
1151             }
1152           else
1153             {
1154               if (*ptr != '/')
1155                 strcat(currpath, ptr);
1156               else
1157                 strcpy(currpath, ptr);
1158               subpath = ptr;
1159               DEBUG_ResetIncludes();
1160             }
1161           last_nso = i;
1162           break;
1163         case N_SOL:
1164           /*
1165            * This indicates we are including stuff from an include file.
1166            * If this is the main source, enable the debug stuff, otherwise
1167            * ignore it.
1168            */
1169             in_external_file = !(subpath == NULL || strcmp(ptr, subpath) == 0);
1170             in_external_file = FALSE; /* FIXME EPP hack FIXME */;
1171           break;
1172         case N_UNDF:
1173           strs += strtabinc;
1174           strtabinc = stab_ptr->n_value;
1175           DEBUG_Normalize(curr_func);
1176           curr_func = NULL;
1177           break;
1178         case N_OPT:
1179           /*
1180            * Ignore this.  We don't care what it points to.
1181            */
1182           break;
1183         case N_BINCL:
1184            DEBUG_AddInclude(DEBUG_CreateInclude(ptr, stab_ptr->n_value));
1185            break;
1186         case N_EINCL:
1187            break;
1188         case N_EXCL:
1189            DEBUG_AddInclude(DEBUG_FindInclude(ptr, stab_ptr->n_value));
1190            break;
1191         case N_MAIN:
1192           /*
1193            * Always ignore these.  GCC doesn't even generate them.
1194            */
1195           break;
1196         default:
1197           DEBUG_Printf(DBG_CHN_MESG, "Unknown stab type 0x%02x\n", stab_ptr->n_type);
1198           break;
1199         }
1200
1201       stabbuff[0] = '\0';
1202
1203 #if 0
1204       DEBUG_Printf(DBG_CHN_MESG, "0x%02x %x %s\n", stab_ptr->n_type,
1205                    (unsigned int) stab_ptr->n_value,
1206                    strs + (unsigned int) stab_ptr->n_un.n_name);
1207 #endif
1208     }
1209
1210   DEBUG_FreeIncludes();
1211
1212   return DIL_LOADED;
1213 }
1214
1215 #ifdef __ELF__
1216
1217 /*
1218  * Walk through the entire symbol table and add any symbols we find there.
1219  * This can be used in cases where we have stripped ELF shared libraries,
1220  * or it can be used in cases where we have data symbols for which the address
1221  * isn't encoded in the stabs.
1222  *
1223  * This is all really quite easy, since we don't have to worry about line
1224  * numbers or local data variables.
1225  */
1226 static int DEBUG_ProcessElfSymtab(DBG_MODULE* module, char* addr,
1227                                   void *load_addr, Elf32_Shdr* symtab,
1228                                   Elf32_Shdr* strtab)
1229 {
1230   char          * curfile = NULL;
1231   struct name_hash * curr_sym = NULL;
1232   int             flags;
1233   int             i;
1234   DBG_VALUE       new_value;
1235   int             nsym;
1236   char          * strp;
1237   char          * symname;
1238   Elf32_Sym     * symp;
1239
1240   symp = (Elf32_Sym *) (addr + symtab->sh_offset);
1241   nsym = symtab->sh_size / sizeof(*symp);
1242   strp = (char *) (addr + strtab->sh_offset);
1243
1244   for (i = 0; i < nsym; i++, symp++)
1245     {
1246       /*
1247        * Ignore certain types of entries which really aren't of that much
1248        * interest.
1249        */
1250       if( ELF32_ST_TYPE(symp->st_info) == STT_SECTION ||
1251           symp->st_shndx == STN_UNDEF )
1252         {
1253           continue;
1254         }
1255
1256       symname = strp + symp->st_name;
1257
1258       /*
1259        * Save the name of the current file, so we have a way of tracking
1260        * static functions/data.
1261        */
1262       if( ELF32_ST_TYPE(symp->st_info) == STT_FILE )
1263         {
1264           curfile = symname;
1265           continue;
1266         }
1267
1268       new_value.type = NULL;
1269       new_value.addr.seg = 0;
1270       new_value.addr.off = (unsigned long)load_addr + symp->st_value;
1271       new_value.cookie = DV_TARGET;
1272       flags = SYM_WINE | ((ELF32_ST_TYPE(symp->st_info) == STT_FUNC)
1273                           ? SYM_FUNC : SYM_DATA);
1274       if( ELF32_ST_BIND(symp->st_info) == STB_GLOBAL )
1275           curr_sym = DEBUG_AddSymbol( symname, &new_value, NULL, flags );
1276       else
1277           curr_sym = DEBUG_AddSymbol( symname, &new_value, curfile, flags );
1278
1279       /*
1280        * Record the size of the symbol.  This can come in handy in
1281        * some cases.  Not really used yet, however.
1282        */
1283       if( symp->st_size != 0 )
1284           DEBUG_SetSymbolSize(curr_sym, symp->st_size);
1285     }
1286
1287   return TRUE;
1288 }
1289
1290 /*
1291  * Loads the symbolic information from ELF module stored in 'filename'
1292  * the module has been loaded at 'load_offset' address, so symbols' address
1293  * relocation is performed
1294  * returns
1295  *      -1 if the file cannot be found/opened
1296  *      0 if the file doesn't contain symbolic info (or this info cannot be
1297  *      read or parsed)
1298  *      1 on success
1299  */
1300 enum DbgInfoLoad DEBUG_LoadElfStabs(DBG_MODULE* module)
1301 {
1302     enum DbgInfoLoad dil = DIL_ERROR;
1303     char*       addr = (char*)0xffffffff;
1304     int         fd = -1;
1305     struct stat statbuf;
1306     Elf32_Ehdr* ehptr;
1307     Elf32_Shdr* spnt;
1308     char*       shstrtab;
1309     int         i;
1310     int         stabsect;
1311     int         stabstrsect;
1312
1313     if (module->type != DMT_ELF || !module->elf_info) {
1314         DEBUG_Printf(DBG_CHN_ERR, "Bad elf module '%s'\n", module->module_name);
1315         return DIL_ERROR;
1316     }
1317
1318     /* check that the file exists, and that the module hasn't been loaded yet */
1319     if (stat(module->module_name, &statbuf) == -1) goto leave;
1320     if (S_ISDIR(statbuf.st_mode)) goto leave;
1321
1322     /*
1323      * Now open the file, so that we can mmap() it.
1324      */
1325     if ((fd = open(module->module_name, O_RDONLY)) == -1) goto leave;
1326
1327     dil = DIL_NOINFO;
1328     /*
1329      * Now mmap() the file.
1330      */
1331     addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
1332     if (addr == (char*)0xffffffff) goto leave;
1333
1334     /*
1335      * Next, we need to find a few of the internal ELF headers within
1336      * this thing.  We need the main executable header, and the section
1337      * table.
1338      */
1339     ehptr = (Elf32_Ehdr*) addr;
1340     spnt = (Elf32_Shdr*) (addr + ehptr->e_shoff);
1341     shstrtab = (addr + spnt[ehptr->e_shstrndx].sh_offset);
1342
1343     stabsect = stabstrsect = -1;
1344
1345     for (i = 0; i < ehptr->e_shnum; i++) {
1346         if (strcmp(shstrtab + spnt[i].sh_name, ".stab") == 0)
1347             stabsect = i;
1348
1349         if (strcmp(shstrtab + spnt[i].sh_name, ".stabstr") == 0)
1350             stabstrsect = i;
1351     }
1352
1353     if (stabsect == -1 || stabstrsect == -1) {
1354         DEBUG_Printf(DBG_CHN_WARN, "No .stab section\n");
1355         goto leave;
1356     }
1357
1358     /*
1359      * OK, now just parse all of the stabs.
1360      */
1361     if (DEBUG_ParseStabs(addr,
1362                          module->elf_info->elf_addr,
1363                          spnt[stabsect].sh_offset,
1364                          spnt[stabsect].sh_size,
1365                          spnt[stabstrsect].sh_offset,
1366                          spnt[stabstrsect].sh_size)) {
1367         dil = DIL_LOADED;
1368     } else {
1369         dil = DIL_ERROR;
1370         DEBUG_Printf(DBG_CHN_WARN, "Couldn't read correctly read stabs\n");
1371         goto leave;
1372     }
1373
1374     for (i = 0; i < ehptr->e_shnum; i++) {
1375         if (   (strcmp(shstrtab + spnt[i].sh_name, ".symtab") == 0)
1376             && (spnt[i].sh_type == SHT_SYMTAB))
1377             DEBUG_ProcessElfSymtab(module, addr, module->elf_info->elf_addr,
1378                                    spnt + i, spnt + spnt[i].sh_link);
1379
1380         if (   (strcmp(shstrtab + spnt[i].sh_name, ".dynsym") == 0)
1381             && (spnt[i].sh_type == SHT_DYNSYM))
1382             DEBUG_ProcessElfSymtab(module, addr, module->elf_info->elf_addr,
1383                                    spnt + i, spnt + spnt[i].sh_link);
1384     }
1385
1386  leave:
1387     if (addr != (char*)0xffffffff) munmap(addr, statbuf.st_size);
1388     if (fd != -1) close(fd);
1389
1390     return dil;
1391 }
1392
1393 /*
1394  * Loads the information for ELF module stored in 'filename'
1395  * the module has been loaded at 'load_offset' address
1396  * returns
1397  *      -1 if the file cannot be found/opened
1398  *      0 if the file doesn't contain symbolic info (or this info cannot be
1399  *      read or parsed)
1400  *      1 on success
1401  */
1402 static enum DbgInfoLoad DEBUG_ProcessElfFile(const char* filename,
1403                                              void *load_offset,
1404                                              unsigned int* dyn_addr)
1405 {
1406     static const unsigned char elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 };
1407     enum DbgInfoLoad dil = DIL_ERROR;
1408     char*       addr = (char*)0xffffffff;
1409     int         fd = -1;
1410     struct stat statbuf;
1411     Elf32_Ehdr* ehptr;
1412     Elf32_Shdr* spnt;
1413     Elf32_Phdr* ppnt;
1414     char      * shstrtab;
1415     int         i;
1416     DBG_MODULE* module = NULL;
1417     DWORD       size;
1418     DWORD       delta;
1419
1420     DEBUG_Printf(DBG_CHN_TRACE, "Processing elf file '%s'\n", filename);
1421
1422     /* check that the file exists, and that the module hasn't been loaded yet */
1423     if (stat(filename, &statbuf) == -1) goto leave;
1424
1425     /*
1426      * Now open the file, so that we can mmap() it.
1427      */
1428     if ((fd = open(filename, O_RDONLY)) == -1) goto leave;
1429
1430     /*
1431      * Now mmap() the file.
1432      */
1433     addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
1434     if (addr == (char*)-1) goto leave;
1435
1436     dil = DIL_NOINFO;
1437
1438     /*
1439      * Next, we need to find a few of the internal ELF headers within
1440      * this thing.  We need the main executable header, and the section
1441      * table.
1442      */
1443     ehptr = (Elf32_Ehdr*) addr;
1444     if (memcmp( ehptr->e_ident, elf_signature, sizeof(elf_signature) )) goto leave;
1445
1446     spnt = (Elf32_Shdr*) (addr + ehptr->e_shoff);
1447     shstrtab = (addr + spnt[ehptr->e_shstrndx].sh_offset);
1448
1449     /* if non relocatable ELF, then remove fixed address from computation
1450      * otherwise, all addresses are zero based
1451      */
1452     delta = (load_offset == 0) ? ehptr->e_entry : 0;
1453
1454     /* grab size of module once loaded in memory */
1455     ppnt = (Elf32_Phdr*) (addr + ehptr->e_phoff);
1456     size = 0;
1457     for (i = 0; i < ehptr->e_phnum; i++) {
1458         if (ppnt[i].p_type != PT_LOAD) continue;
1459         if (size < ppnt[i].p_vaddr - delta + ppnt[i].p_memsz)
1460             size = ppnt[i].p_vaddr - delta + ppnt[i].p_memsz;
1461     }
1462
1463     for (i = 0; i < ehptr->e_shnum; i++)
1464     {
1465         if (strcmp(shstrtab + spnt[i].sh_name, ".bss") == 0 &&
1466             spnt[i].sh_type == SHT_NOBITS)
1467         {
1468             if (size < spnt[i].sh_addr - delta + spnt[i].sh_size)
1469                 size = spnt[i].sh_addr - delta + spnt[i].sh_size;
1470         }
1471         if (strcmp(shstrtab + spnt[i].sh_name, ".dynamic") == 0 &&
1472             spnt[i].sh_type == SHT_DYNAMIC)
1473         {
1474             if (dyn_addr) *dyn_addr = spnt[i].sh_addr;
1475         }
1476     }
1477
1478     module = DEBUG_RegisterELFModule((load_offset == 0) ? (void *)ehptr->e_entry : load_offset,
1479                                      size, filename);
1480     if (!module) {
1481         dil = DIL_ERROR;
1482         goto leave;
1483     }
1484
1485     if ((module->elf_info = DBG_alloc(sizeof(ELF_DBG_INFO))) == NULL) {
1486         DEBUG_Printf(DBG_CHN_ERR, "OOM\n");
1487         exit(0);
1488     }
1489
1490     module->elf_info->elf_addr = load_offset;
1491     dil = DEBUG_LoadElfStabs(module);
1492
1493  leave:
1494     if (addr != (char*)0xffffffff) munmap(addr, statbuf.st_size);
1495     if (fd != -1) close(fd);
1496     if (module) module->dil = dil;
1497
1498     return dil;
1499 }
1500
1501 static enum DbgInfoLoad DEBUG_ProcessElfFileFromPath(const char * filename,
1502                                                      void *load_offset,
1503                                                      unsigned int* dyn_addr,
1504                                                      const char* path)
1505 {
1506     enum DbgInfoLoad    dil = DIL_ERROR;
1507     char        *s, *t, *fn;
1508     char*       paths = NULL;
1509
1510     if (!path) return -1;
1511
1512     for (s = paths = DBG_strdup(path); s && *s; s = (t) ? (t+1) : NULL) {
1513         t = strchr(s, ':');
1514         if (t) *t = '\0';
1515         fn = (char*)DBG_alloc(strlen(filename) + 1 + strlen(s) + 1);
1516         if (!fn) break;
1517         strcpy(fn, s );
1518         strcat(fn, "/");
1519         strcat(fn, filename);
1520         dil = DEBUG_ProcessElfFile(fn, load_offset, dyn_addr);
1521         DBG_free(fn);
1522         if (dil != DIL_ERROR) break;
1523         s = (t) ? (t+1) : NULL;
1524     }
1525
1526     DBG_free(paths);
1527     return dil;
1528 }
1529
1530 static enum DbgInfoLoad DEBUG_ProcessElfObject(const char* filename,
1531                                                void *load_offset,
1532                                                unsigned int* dyn_addr)
1533 {
1534    enum DbgInfoLoad     dil = DIL_ERROR;
1535
1536    if (filename == NULL) return DIL_ERROR;
1537    if (DEBUG_FindModuleByName(filename, DMT_ELF)) return DIL_LOADED;
1538
1539    if (strstr (filename, "libstdc++")) return DIL_ERROR; /* We know we can't do it */
1540    dil = DEBUG_ProcessElfFile(filename, load_offset, dyn_addr);
1541
1542    /* if relative pathname, try some absolute base dirs */
1543    if (dil == DIL_ERROR && !strchr(filename, '/')) {
1544       dil = DEBUG_ProcessElfFileFromPath(filename, load_offset, dyn_addr, getenv("PATH"));
1545       if (dil == DIL_ERROR)
1546         dil = DEBUG_ProcessElfFileFromPath(filename, load_offset, dyn_addr, getenv("LD_LIBRARY_PATH"));
1547       if (dil == DIL_ERROR)
1548         dil = DEBUG_ProcessElfFileFromPath(filename, load_offset, dyn_addr, getenv("WINEDLLPATH"));
1549    }
1550
1551    DEBUG_ReportDIL(dil, "ELF", filename, load_offset);
1552
1553    return dil;
1554 }
1555
1556 static  BOOL    DEBUG_WalkList(struct r_debug* dbg_hdr)
1557 {
1558     void *lm_addr;
1559     struct link_map     lm;
1560     Elf32_Ehdr          ehdr;
1561     char                bufstr[256];
1562
1563     /*
1564      * Now walk the linked list.  In all known ELF implementations,
1565      * the dynamic loader maintains this linked list for us.  In some
1566      * cases the first entry doesn't appear with a name, in other cases it
1567      * does.
1568      */
1569     for (lm_addr = (void *)dbg_hdr->r_map; lm_addr; lm_addr = (void *)lm.l_next) {
1570         if (!DEBUG_READ_MEM_VERBOSE(lm_addr, &lm, sizeof(lm)))
1571             return FALSE;
1572
1573         if (lm.l_addr != 0 &&
1574             DEBUG_READ_MEM_VERBOSE((void*)lm.l_addr, &ehdr, sizeof(ehdr)) &&
1575             ehdr.e_type == ET_DYN && /* only look at dynamic modules */
1576             lm.l_name != NULL &&
1577             DEBUG_READ_MEM_VERBOSE((void*)lm.l_name, bufstr, sizeof(bufstr))) {
1578             bufstr[sizeof(bufstr) - 1] = '\0';
1579             DEBUG_ProcessElfObject(bufstr, (void *)lm.l_addr, NULL);
1580         }
1581     }
1582
1583     return TRUE;
1584 }
1585
1586 static BOOL DEBUG_RescanElf(void)
1587 {
1588     struct r_debug        dbg_hdr;
1589
1590     if (!DEBUG_CurrProcess ||
1591         !DEBUG_READ_MEM_VERBOSE((void*)DEBUG_CurrProcess->dbg_hdr_addr, &dbg_hdr, sizeof(dbg_hdr)))
1592        return FALSE;
1593
1594     switch (dbg_hdr.r_state) {
1595     case RT_CONSISTENT:
1596        DEBUG_WalkList(&dbg_hdr);
1597        DEBUG_CheckDelayedBP();
1598        break;
1599     case RT_ADD:
1600        break;
1601     case RT_DELETE:
1602        /* FIXME: this is not currently handled, would need some kind of mark&sweep algo */
1603       break;
1604     }
1605     return FALSE;
1606 }
1607
1608 enum DbgInfoLoad        DEBUG_ReadExecutableDbgInfo(const char* exe_name)
1609 {
1610     Elf32_Dyn           dyn;
1611     struct r_debug      dbg_hdr;
1612     enum DbgInfoLoad    dil = DIL_NOINFO;
1613     unsigned int        dyn_addr;
1614
1615     /*
1616      * Make sure we can stat and open this file.
1617      */
1618     if (exe_name == NULL) goto leave;
1619     DEBUG_ProcessElfObject(exe_name, 0, &dyn_addr);
1620
1621     do {
1622         if (!DEBUG_READ_MEM_VERBOSE((void*)dyn_addr, &dyn, sizeof(dyn)))
1623             goto leave;
1624         dyn_addr += sizeof(dyn);
1625     } while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL);
1626     if (dyn.d_tag == DT_NULL) goto leave;
1627
1628     /*
1629      * OK, now dig into the actual tables themselves.
1630      */
1631     if (!DEBUG_READ_MEM_VERBOSE((void*)dyn.d_un.d_ptr, &dbg_hdr, sizeof(dbg_hdr)))
1632         goto leave;
1633
1634     assert(!DEBUG_CurrProcess->dbg_hdr_addr);
1635     DEBUG_CurrProcess->dbg_hdr_addr = (unsigned long)dyn.d_un.d_ptr;
1636
1637     if (dbg_hdr.r_brk) {
1638         DBG_VALUE       value;
1639
1640         DEBUG_Printf(DBG_CHN_TRACE, "Setting up a breakpoint on r_brk(%lx)\n",
1641                      (unsigned long)dbg_hdr.r_brk);
1642
1643         DEBUG_SetBreakpoints(FALSE);
1644         value.type = NULL;
1645         value.cookie = DV_TARGET;
1646         value.addr.seg = 0;
1647         value.addr.off = (DWORD)dbg_hdr.r_brk;
1648         DEBUG_AddBreakpoint(&value, DEBUG_RescanElf, TRUE);
1649         DEBUG_SetBreakpoints(TRUE);
1650     }
1651
1652     dil = DEBUG_WalkList(&dbg_hdr);
1653
1654  leave:
1655     return dil;
1656 }
1657
1658 /* FIXME: merge with some of the routines above */
1659 int read_elf_info(const char* filename, unsigned long tab[])
1660 {
1661     static const unsigned char elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 };
1662     char*       addr;
1663     Elf32_Ehdr* ehptr;
1664     Elf32_Shdr* spnt;
1665     char*       shstrtab;
1666     int         i;
1667     int         ret = 0;
1668     HANDLE      hFile;
1669     HANDLE      hMap = 0;
1670
1671     addr = NULL;
1672     hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
1673                        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1674     if (hFile == INVALID_HANDLE_VALUE) goto leave;
1675     hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
1676     if (hMap == 0) goto leave;
1677     addr = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
1678     if (addr == NULL) goto leave;
1679
1680     ehptr = (Elf32_Ehdr*) addr;
1681     if (memcmp(ehptr->e_ident, elf_signature, sizeof(elf_signature))) goto leave;
1682
1683     spnt = (Elf32_Shdr*) (addr + ehptr->e_shoff);
1684     shstrtab = (addr + spnt[ehptr->e_shstrndx].sh_offset);
1685
1686     tab[0] = tab[1] = tab[2] = 0;
1687     for (i = 0; i < ehptr->e_shnum; i++)
1688     {
1689     }
1690     ret = 1;
1691  leave:
1692     if (addr != NULL) UnmapViewOfFile(addr);
1693     if (hMap != 0) CloseHandle(hMap);
1694     if (hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile);
1695     return ret;
1696 }
1697
1698 #else   /* !__ELF__ */
1699
1700 enum DbgInfoLoad        DEBUG_ReadExecutableDbgInfo(const char* exe_name)
1701 {
1702   return FALSE;
1703 }
1704
1705 #endif  /* __ELF__ */