git.oblomov.eu Git - wine/blob - debugger/stabs.c

   1 /* -*- tab-width: 8; c-basic-offset: 2 -*- */
   2
   3 /*
   4  * File stabs.c - read stabs information from the wine executable itself.
   5  *
   6  * Copyright (C) 1996, Eric Youngdale.
   7  *               1999, 2000 Eric Pouech
   8  */
   9
  10 #include "config.h"
  11
  12 #include <sys/types.h>
  13 #include <fcntl.h>
  14 #include <sys/stat.h>
  15 #ifdef HAVE_SYS_MMAN_H
  16 #include <sys/mman.h>
  17 #endif
  18 #include <limits.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22 #ifndef PATH_MAX
  23 #define PATH_MAX _MAX_PATH
  24 #endif
  25
  26 #include "debugger.h"
  27
  28 #if defined(__svr4__) || defined(__sun)
  29 #define __ELF__
  30 #endif
  31
  32 #ifdef __ELF__
  33 #ifdef HAVE_ELF_H
  34 # include <elf.h>
  35 #endif
  36 #ifdef HAVE_LINK_H
  37 # include <link.h>
  38 #endif
  39 #elif defined(__EMX__)
  40 #ifdef HAVE_A_OUT_H
  41 # include <a_out.h>
  42 #endif
  43 #else
  44 #ifdef HAVE_A_OUT_H
  45 # include <a.out.h>
  46 #endif
  47 #endif
  48
  49 #ifndef N_UNDF
  50 #define N_UNDF          0x00
  51 #endif
  52
  53 #define N_GSYM          0x20
  54 #define N_FUN           0x24
  55 #define N_STSYM         0x26
  56 #define N_LCSYM         0x28
  57 #define N_MAIN          0x2a
  58 #define N_ROSYM         0x2c
  59 #define N_OPT           0x3c
  60 #define N_RSYM          0x40
  61 #define N_SLINE         0x44
  62 #define N_SO            0x64
  63 #define N_LSYM          0x80
  64 #define N_BINCL         0x82
  65 #define N_SOL           0x84
  66 #define N_PSYM          0xa0
  67 #define N_EINCL         0xa2
  68 #define N_LBRAC         0xc0
  69 #define N_EXCL          0xc2
  70 #define N_RBRAC         0xe0
  71
  72
  73 struct stab_nlist {
  74   union {
  75     char *n_name;
  76     struct stab_nlist *n_next;
  77     long n_strx;
  78   } n_un;
  79   unsigned char n_type;
  80   char n_other;
  81   short n_desc;
  82   unsigned long n_value;
  83 };
  84
  85 /*
  86  * This is used to keep track of known datatypes so that we don't redefine
  87  * them over and over again.  It sucks up lots of memory otherwise.
  88  */
  89 struct known_typedef
  90 {
  91   struct known_typedef * next;
  92   char                 * name;
  93   int                    ndefs;
  94   struct datatype      * types[1];
  95 };
  96
  97 #define NR_STAB_HASH 521
  98
  99 struct known_typedef * ktd_head[NR_STAB_HASH] = {NULL,};
 100
 101 static unsigned int stab_hash( const char * name )
 102 {
 103     unsigned int hash = 0;
 104     unsigned int tmp;
 105     const char * p;
 106
 107     p = name;
 108
 109     while (*p)
 110       {
 111         hash = (hash << 4) + *p++;
 112
 113         if( (tmp = (hash & 0xf0000000)) )
 114           {
 115             hash ^= tmp >> 24;
 116           }
 117         hash &= ~tmp;
 118       }
 119     return hash % NR_STAB_HASH;
 120 }
 121
 122
 123 static void stab_strcpy(char * dest, int sz, const char * source)
 124 {
 125   /*
 126    * A strcpy routine that stops when we hit the ':' character.
 127    * Faster than copying the whole thing, and then nuking the
 128    * ':'.
 129    */
 130   while(*source != '\0' && *source != ':' && sz-- > 0)
 131       *dest++ = *source++;
 132   *dest = '\0';
 133   assert(sz > 0);
 134 }
 135
 136 typedef struct {
 137    char*                name;
 138    unsigned long        value;
 139    int                  idx;
 140    struct datatype**    vector;
 141    int                  nrofentries;
 142 } include_def;
 143
 144 #define MAX_INCLUDES    256
 145
 146 static  include_def*    include_defs = NULL;
 147 static  int             num_include_def = 0;
 148 static  int             num_alloc_include_def = 0;
 149 static  int             cu_include_stack[MAX_INCLUDES];
 150 static  int             cu_include_stk_idx = 0;
 151 static  struct datatype**       cu_vector = NULL;
 152 static  int             cu_nrofentries = 0;
 153
 154 static
 155 int
 156 DEBUG_CreateInclude(const char* file, unsigned long val)
 157 {
 158   if (num_include_def == num_alloc_include_def)
 159     {
 160       num_alloc_include_def += 256;
 161       include_defs = DBG_realloc(include_defs, sizeof(include_defs[0])*num_alloc_include_def);
 162       memset(include_defs+num_include_def, 0, sizeof(include_defs[0])*256);
 163     }
 164   include_defs[num_include_def].name = DBG_strdup(file);
 165   include_defs[num_include_def].value = val;
 166   include_defs[num_include_def].vector = NULL;
 167   include_defs[num_include_def].nrofentries = 0;
 168
 169   return num_include_def++;
 170 }
 171
 172 static
 173 int
 174 DEBUG_FindInclude(const char* file, unsigned long val)
 175 {
 176   int           i;
 177
 178   for (i = 0; i < num_include_def; i++)
 179     {
 180       if (val == include_defs[i].value &&
 181           strcmp(file, include_defs[i].name) == 0)
 182         return i;
 183     }
 184   return -1;
 185 }
 186
 187 static
 188 int
 189 DEBUG_AddInclude(int idx)
 190 {
 191   ++cu_include_stk_idx;
 192
 193   /* is this happen, just bump MAX_INCLUDES */
 194   /* we could also handle this as another dynarray */
 195   assert(cu_include_stk_idx < MAX_INCLUDES);
 196
 197   cu_include_stack[cu_include_stk_idx] = idx;
 198   return cu_include_stk_idx;
 199 }
 200
 201 static
 202 void
 203 DEBUG_ResetIncludes(void)
 204 {
 205   /*
 206    * The datatypes that we would need to use are reset when
 207    * we start a new file. (at least the ones in filenr == 0
 208    */
 209   cu_include_stk_idx = 0;/* keep 0 as index for the .c file itself */
 210   memset(cu_vector, 0, sizeof(cu_vector[0]) * cu_nrofentries);
 211 }
 212
 213 static
 214 void
 215 DEBUG_FreeIncludes(void)
 216 {
 217   int   i;
 218
 219   DEBUG_ResetIncludes();
 220
 221   for (i = 0; i < num_include_def; i++)
 222     {
 223       DBG_free(include_defs[i].name);
 224       DBG_free(include_defs[i].vector);
 225     }
 226   DBG_free(include_defs);
 227   include_defs = NULL;
 228   num_include_def = 0;
 229   num_alloc_include_def = 0;
 230   DBG_free(cu_vector);
 231   cu_vector = NULL;
 232   cu_nrofentries = 0;
 233 }
 234
 235 #define MAX_TD_NESTING  128
 236
 237 static
 238 struct datatype**
 239 DEBUG_FileSubNr2StabEnum(int filenr, int subnr)
 240 {
 241   struct datatype** ret;
 242
 243   /* DEBUG_Printf(DBG_CHN_MESG, "creating type id for (%d,%d)\n", filenr, subnr); */
 244
 245   /* FIXME: I could perhaps create a dummy include_def for each compilation
 246    * unit which would allow not to handle those two cases separately
 247    */
 248   if (filenr == 0)
 249     {
 250       if (cu_nrofentries <= subnr)
 251         {
 252           cu_vector = DBG_realloc(cu_vector, sizeof(cu_vector[0])*(subnr+1));
 253           memset(cu_vector+cu_nrofentries, 0, sizeof(cu_vector[0])*(subnr+1-cu_nrofentries));
 254           cu_nrofentries = subnr + 1;
 255         }
 256       ret = &cu_vector[subnr];
 257     }
 258   else
 259     {
 260       include_def*      idef;
 261
 262       assert(filenr <= cu_include_stk_idx);
 263
 264       idef = &include_defs[cu_include_stack[filenr]];
 265
 266       if (idef->nrofentries <= subnr)
 267         {
 268           idef->vector = DBG_realloc(idef->vector, sizeof(idef->vector[0])*(subnr+1));
 269           memset(idef->vector + idef->nrofentries, 0, sizeof(idef->vector[0])*(subnr+1-idef->nrofentries));
 270           idef->nrofentries = subnr + 1;
 271         }
 272       ret = &idef->vector[subnr];
 273     }
 274   /* DEBUG_Printf(DBG_CHN_MESG,"(%d,%d) is %d\n",filenr,subnr,ret); */
 275   return ret;
 276 }
 277
 278 static
 279 struct datatype**
 280 DEBUG_ReadTypeEnumBackwards(char*x) {
 281     int filenr,subnr;
 282
 283     if (*x==')') {
 284         while (*x!='(')
 285             x--;
 286         x++;                            /* '(' */
 287         filenr=strtol(x,&x,10);         /* <int> */
 288         x++;                            /* ',' */
 289         subnr=strtol(x,&x,10);          /* <int> */
 290         x++;                            /* ')' */
 291     } else {
 292         while ((*x>='0') && (*x<='9'))
 293             x--;
 294         filenr = 0;
 295         subnr = atol(x+1);
 296     }
 297     return DEBUG_FileSubNr2StabEnum(filenr,subnr);
 298 }
 299
 300 static
 301 struct datatype**
 302 DEBUG_ReadTypeEnum(char **x) {
 303     int filenr,subnr;
 304
 305     if (**x=='(') {
 306         (*x)++;                                 /* '(' */
 307         filenr=strtol(*x,x,10);                 /* <int> */
 308         (*x)++;                                 /* ',' */
 309         subnr=strtol(*x,x,10);                  /* <int> */
 310         (*x)++;                                 /* ')' */
 311     } else {
 312         filenr = 0;
 313         subnr = strtol(*x,x,10);                /* <int> */
 314     }
 315     return DEBUG_FileSubNr2StabEnum(filenr,subnr);
 316 }
 317
 318 static
 319 int
 320 DEBUG_RegisterTypedef(const char * name, struct datatype ** types, int ndef)
 321 {
 322   int                    hash;
 323   struct known_typedef * ktd;
 324
 325   if( ndef == 1 )
 326       return TRUE;
 327
 328   ktd = (struct known_typedef *) DBG_alloc(sizeof(struct known_typedef)
 329                                          + (ndef - 1) * sizeof(struct datatype *));
 330
 331   hash = stab_hash(name);
 332
 333   ktd->name = DBG_strdup(name);
 334   ktd->ndefs = ndef;
 335   memcpy(&ktd->types[0], types, ndef * sizeof(struct datatype *));
 336   ktd->next = ktd_head[hash];
 337   ktd_head[hash] = ktd;
 338
 339   return TRUE;
 340 }
 341
 342 static
 343 int
 344 DEBUG_HandlePreviousTypedef(const char * name, const char * stab)
 345 {
 346   int                    count;
 347   enum debug_type        expect;
 348   int                    hash;
 349   struct known_typedef * ktd;
 350   char                 * ptr;
 351
 352   hash = stab_hash(name);
 353
 354   for(ktd = ktd_head[hash]; ktd; ktd = ktd->next)
 355       if ((ktd->name[0] == name[0]) && (strcmp(name, ktd->name) == 0) )
 356           break;
 357
 358   /*
 359    * Didn't find it.  This must be a new one.
 360    */
 361   if( ktd == NULL )
 362       return FALSE;
 363
 364   /*
 365    * Examine the stab to make sure it has the same number of definitions.
 366    */
 367   count = 0;
 368   for(ptr = strchr(stab, '='); ptr; ptr = strchr(ptr+1, '='))
 369     {
 370       if( count >= ktd->ndefs )
 371           return FALSE;
 372
 373       /*
 374        * Make sure the types of all of the objects is consistent with
 375        * what we have already parsed.
 376        */
 377       switch(ptr[1])
 378         {
 379         case '*':
 380           expect = DT_POINTER;
 381           break;
 382         case 's':
 383         case 'u':
 384           expect = DT_STRUCT;
 385           break;
 386         case 'a':
 387           expect = DT_ARRAY;
 388           break;
 389         case '(':       /* it's mainly a ref to another typedef, skip it */
 390           expect = -1;
 391           break;
 392         case '1':
 393         case 'r':
 394           expect = DT_BASIC;
 395           break;
 396         case 'x':
 397           expect = DT_STRUCT;
 398           break;
 399         case 'e':
 400           expect = DT_ENUM;
 401           break;
 402         case 'f':
 403           expect = DT_FUNC;
 404           break;
 405         default:
 406           DEBUG_Printf(DBG_CHN_FIXME, "Unknown type (%c).\n",ptr[1]);
 407           return FALSE;
 408         }
 409       if( expect != -1 && expect != DEBUG_GetType(ktd->types[count]) )
 410           return FALSE;
 411       count++;
 412     }
 413
 414   if( ktd->ndefs != count )
 415       return FALSE;
 416
 417   /*
 418    * Go through, dig out all of the type numbers, and substitute the
 419    * appropriate things.
 420    */
 421   count = 0;
 422   for(ptr = strchr(stab, '='); ptr; ptr = strchr(ptr+1, '='))
 423       *DEBUG_ReadTypeEnumBackwards(ptr-1) = ktd->types[count++];
 424
 425   return TRUE;
 426 }
 427
 428 static int DEBUG_FreeRegisteredTypedefs(void)
 429 {
 430   int                    count;
 431   int                    j;
 432   struct known_typedef * ktd;
 433   struct known_typedef * next;
 434
 435   count = 0;
 436   for(j=0; j < NR_STAB_HASH; j++ )
 437     {
 438       for(ktd = ktd_head[j]; ktd; ktd = next)
 439         {
 440           count++;
 441           next = ktd->next;
 442           DBG_free(ktd->name);
 443           DBG_free(ktd);
 444         }
 445       ktd_head[j] = NULL;
 446     }
 447
 448   return TRUE;
 449
 450 }
 451
 452 static
 453 int
 454 DEBUG_ParseTypedefStab(char * ptr, const char * typename)
 455 {
 456   int               arrmax;
 457   int               arrmin;
 458   char            * c;
 459   struct datatype * curr_type;
 460   struct datatype * datatype;
 461   struct datatype * curr_types[MAX_TD_NESTING];
 462   char              element_name[1024];
 463   int               ntypes = 0, ntp;
 464   int               offset;
 465   const char      * orig_typename;
 466   int               size;
 467   char            * tc;
 468   char            * tc2;
 469   int               failure;
 470
 471   orig_typename = typename;
 472
 473   if( DEBUG_HandlePreviousTypedef(typename, ptr) )
 474     return TRUE;
 475
 476   /*
 477    * Go from back to front.  First we go through and figure out what
 478    * type numbers we need, and register those types.  Then we go in
 479    * and fill the details.
 480    */
 481
 482   for( c = strchr(ptr, '='); c != NULL; c = strchr(c + 1, '=') )
 483     {
 484       /*
 485        * Back up until we get to a non-numeric character, to get datatype
 486        */
 487       struct datatype** dt = DEBUG_ReadTypeEnumBackwards(c-1);
 488
 489       if( ntypes >= MAX_TD_NESTING )
 490         {
 491           /*
 492            * If this ever happens, just bump the counter.
 493            */
 494           DEBUG_Printf(DBG_CHN_MESG, "Typedef nesting overflow\n");
 495           return FALSE;
 496         }
 497
 498       switch(c[1])
 499         {
 500         case '*':
 501           *dt = DEBUG_NewDataType(DT_POINTER, NULL);
 502           curr_types[ntypes++] = *dt;
 503           break;
 504         case 's':
 505         case 'u':
 506           *dt = DEBUG_NewDataType(DT_STRUCT, typename);
 507           curr_types[ntypes++] = *dt;
 508           break;
 509         case 'a':
 510           *dt = DEBUG_NewDataType(DT_ARRAY, NULL);
 511           curr_types[ntypes++] = *dt;
 512           break;
 513         case '(':
 514           /* will be handled in next loop,
 515            * just a ref to another type
 516            */
 517           curr_types[ntypes++] = NULL;
 518           break;
 519         case '1':
 520         case 'r':
 521           *dt = DEBUG_NewDataType(DT_BASIC, typename);
 522           curr_types[ntypes++] = *dt;
 523           break;
 524         case 'x':
 525           stab_strcpy(element_name, sizeof(element_name), c + 3);
 526           *dt = DEBUG_NewDataType(DT_STRUCT, element_name);
 527           curr_types[ntypes++] = *dt;
 528           break;
 529         case 'e':
 530           *dt = DEBUG_NewDataType(DT_ENUM, NULL);
 531           curr_types[ntypes++] = *dt;
 532           break;
 533         case 'f':
 534           *dt = DEBUG_NewDataType(DT_FUNC, NULL);
 535           curr_types[ntypes++] = *dt;
 536           break;
 537         default:
 538           DEBUG_Printf(DBG_CHN_FIXME, "Unknown type (%c).\n",c[1]);
 539           return FALSE;
 540         }
 541       typename = NULL;
 542
 543     }
 544
 545   ntp = ntypes - 1;
 546   /*
 547    * OK, now take a second sweep through.  Now we will be digging
 548    * out the definitions of the various components, and storing
 549    * them in the skeletons that we have already allocated.  We take
 550    * a right-to left search as this is much easier to parse.
 551    */
 552   for( c = strrchr(ptr, '='); c != NULL; c = strrchr(ptr, '=') )
 553     {
 554       struct datatype** dt = DEBUG_ReadTypeEnumBackwards(c-1);
 555       struct datatype** dt2;
 556
 557       curr_type = *dt;
 558
 559       switch(c[1])
 560         {
 561         case 'x':
 562           ntp--;
 563           tc = c + 3;
 564           while( *tc != ':' )
 565             tc++;
 566           tc++;
 567           if( *tc == '\0' )
 568             *c = '\0';
 569           else
 570             strcpy(c, tc);
 571           break;
 572         case '*':
 573         case 'f':
 574           ntp--;
 575           tc = c + 2;
 576           datatype = *DEBUG_ReadTypeEnum(&tc);
 577           DEBUG_SetPointerType(curr_type, datatype);
 578           if( *tc == '\0' )
 579             *c = '\0';
 580           else
 581             strcpy(c, tc);
 582           break;
 583         case '(':
 584           tc = c + 1;
 585           dt2 = DEBUG_ReadTypeEnum(&tc);
 586
 587           if (!*dt && *dt2)
 588             {
 589               *dt = *dt2;
 590             }
 591           else if (!*dt && !*dt2)
 592             {
 593               /* this should be a basic type, define it */
 594               *dt2 = *dt = DEBUG_NewDataType(DT_BASIC, typename);
 595             }
 596           else
 597             {
 598               DEBUG_Printf(DBG_CHN_MESG, "Unknown condition %p %p (%s)\n", *dt, *dt2, ptr);
 599             }
 600           if( *tc == '\0' )
 601             *c = '\0';
 602           else
 603             strcpy(c, tc);
 604           curr_types[ntp--] = *dt;
 605           break;
 606         case '1':
 607         case 'r':
 608           ntp--;
 609           /*
 610            * We have already handled these above.
 611            */
 612           *c = '\0';
 613           break;
 614         case 'a':
 615           ntp--;
 616           /* ar<typeinfo_nodef>;<int>;<int>;<typeinfo>,<int>,<int>;; */
 617
 618           tc  = c + 3;
 619           /* 'r' */
 620           DEBUG_ReadTypeEnum(&tc);
 621           tc++;                                 /* ';' */
 622           arrmin = strtol(tc, &tc, 10);         /* <int> */
 623           tc++;                                 /* ';' */
 624           arrmax = strtol(tc, &tc, 10);         /* <int> */
 625           tc++;                                 /* ';' */
 626           datatype = *DEBUG_ReadTypeEnum(&tc);  /* <typeinfo> */
 627           if( *tc == '\0' )
 628             *c = '\0';
 629           else
 630             strcpy(c, tc);
 631           DEBUG_SetArrayParams(curr_type, arrmin, arrmax, datatype);
 632           break;
 633         case 's':
 634         case 'u':
 635           ntp--;
 636           failure = 0;
 637
 638           tc = c + 2;
 639           if( DEBUG_SetStructSize(curr_type, strtol(tc, &tc, 10)) == FALSE )
 640             {
 641               /*
 642                * We have already filled out this structure.  Nothing to do,
 643                * so just skip forward to the end of the definition.
 644                */
 645               while( tc[0] != ';' && tc[1] != ';' )
 646                 tc++;
 647
 648               tc += 2;
 649
 650               if( *tc == '\0' )
 651                 *c = '\0';
 652               else
 653                 strcpy(c, tc + 1);
 654               continue;
 655             }
 656
 657           /*
 658            * Now parse the individual elements of the structure/union.
 659            */
 660           while(*tc != ';')
 661             {
 662               char *ti;
 663               tc2 = element_name;
 664               while(*tc != ':')
 665                 *tc2++ = *tc++;
 666               tc++;
 667               *tc2++ = '\0';
 668               ti=tc;
 669               datatype = *DEBUG_ReadTypeEnum(&tc);
 670               *tc='\0';
 671               tc++;
 672               offset  = strtol(tc, &tc, 10);
 673               tc++;
 674               size  = strtol(tc, &tc, 10);
 675               tc++;
 676               if (datatype)
 677                 DEBUG_AddStructElement(curr_type, element_name, datatype,
 678                                        offset, size);
 679               else
 680                 {
 681                   failure = 1;
 682                   /* ... but proceed parsing to the end of the stab */
 683                   DEBUG_Printf(DBG_CHN_MESG, "failure on %s %s\n", ptr, ti);
 684                 }
 685             }
 686
 687           if (failure)
 688             {
 689
 690               /* if we had a undeclared value this one is undeclared too.
 691                * remove it from the stab_types.
 692                * I just set it to NULL to detect bugs in my thoughtprocess.
 693                * FIXME: leaks the memory for the structure elements.
 694                * FIXME: such structures should have been optimized away
 695                *        by ld.
 696                */
 697               *dt = NULL;
 698             }
 699           if( *tc == '\0' )
 700             *c = '\0';
 701           else
 702             strcpy(c, tc + 1);
 703           break;
 704         case 'e':
 705           ntp--;
 706           tc = c + 2;
 707           /*
 708            * Now parse the individual elements of the structure/union.
 709            */
 710           while(*tc != ';')
 711             {
 712               tc2 = element_name;
 713               while(*tc != ':')
 714                 *tc2++ = *tc++;
 715               tc++;
 716               *tc2++ = '\0';
 717               offset  = strtol(tc, &tc, 10);
 718               tc++;
 719               DEBUG_AddStructElement(curr_type, element_name, NULL, offset, 0);
 720             }
 721           if( *tc == '\0' )
 722             *c = '\0';
 723           else
 724             strcpy(c, tc + 1);
 725           break;
 726         default:
 727           DEBUG_Printf(DBG_CHN_FIXME, "Unknown type (%c).\n",c[1]);
 728           return FALSE;
 729         }
 730     }
 731   /*
 732    * Now register the type so that if we encounter it again, we will know
 733    * what to do.
 734    */
 735   DEBUG_RegisterTypedef(orig_typename, curr_types, ntypes);
 736
 737   return TRUE;
 738 }
 739
 740 static struct datatype *
 741 DEBUG_ParseStabType(const char * stab)
 742 {
 743   char * c;
 744
 745   /*
 746    * Look through the stab definition, and figure out what datatype
 747    * this represents.  If we have something we know about, assign the
 748    * type.
 749    */
 750   c = strchr(stab, ':');
 751   if( c == NULL )
 752       return NULL;
 753
 754   c++;
 755   /*
 756    * The next character says more about the type (i.e. data, function, etc)
 757    * of symbol.  Skip it.
 758    */
 759   if (*c != '(')
 760     c++;
 761   /*
 762    * The next is either an integer or a (integer,integer).
 763    * The DEBUG_ReadTypeEnum takes care that stab_types is large enough.
 764    */
 765   return *DEBUG_ReadTypeEnum(&c);
 766 }
 767
 768 int
 769 DEBUG_ParseStabs(char * addr, unsigned int load_offset,
 770                  unsigned int staboff, int stablen,
 771                  unsigned int strtaboff, int strtablen)
 772 {
 773   struct name_hash    * curr_func = NULL;
 774   struct wine_locals  * curr_loc = NULL;
 775   struct name_hash    * curr_sym = NULL;
 776   char                  currpath[PATH_MAX];
 777   int                   i;
 778   int                   in_external_file = FALSE;
 779   int                   last_nso = -1;
 780   int                   len;
 781   DBG_VALUE             new_value;
 782   int                   nstab;
 783   char                * ptr;
 784   char                * stabbuff;
 785   int                   stabbufflen;
 786   struct stab_nlist   * stab_ptr;
 787   char                * strs;
 788   int                   strtabinc;
 789   char                * subpath = NULL;
 790   char                  symname[4096];
 791
 792   nstab = stablen / sizeof(struct stab_nlist);
 793   stab_ptr = (struct stab_nlist *) (addr + staboff);
 794   strs  = (char *) (addr + strtaboff);
 795
 796   memset(currpath, 0, sizeof(currpath));
 797
 798   /*
 799    * Allocate a buffer into which we can build stab strings for cases
 800    * where the stab is continued over multiple lines.
 801    */
 802   stabbufflen = 65536;
 803   stabbuff = (char *) DBG_alloc(stabbufflen);
 804
 805   strtabinc = 0;
 806   stabbuff[0] = '\0';
 807   for(i=0; i < nstab; i++, stab_ptr++ )
 808     {
 809       ptr = strs + (unsigned int) stab_ptr->n_un.n_name;
 810       if( ptr[strlen(ptr) - 1] == '\\' )
 811         {
 812           /*
 813            * Indicates continuation.  Append this to the buffer, and go onto the
 814            * next record.  Repeat the process until we find a stab without the
 815            * '/' character, as this indicates we have the whole thing.
 816            */
 817           len = strlen(ptr);
 818           if( strlen(stabbuff) + len > stabbufflen )
 819             {
 820               stabbufflen += 65536;
 821               stabbuff = (char *) DBG_realloc(stabbuff, stabbufflen);
 822             }
 823           strncat(stabbuff, ptr, len - 1);
 824           continue;
 825         }
 826       else if( stabbuff[0] != '\0' )
 827         {
 828           strcat( stabbuff, ptr);
 829           ptr = stabbuff;
 830         }
 831
 832       if( strchr(ptr, '=') != NULL )
 833         {
 834           /*
 835            * The stabs aren't in writable memory, so copy it over so we are
 836            * sure we can scribble on it.
 837            */
 838           if( ptr != stabbuff )
 839             {
 840               strcpy(stabbuff, ptr);
 841               ptr = stabbuff;
 842             }
 843           stab_strcpy(symname, sizeof(symname), ptr);
 844           if (!DEBUG_ParseTypedefStab(ptr, symname)) {
 845             /* skip this definition */
 846             stabbuff[0] = '\0';
 847             continue;
 848           }
 849         }
 850
 851       switch(stab_ptr->n_type)
 852         {
 853         case N_GSYM:
 854           /*
 855            * These are useless with ELF.  They have no value, and you have to
 856            * read the normal symbol table to get the address.  Thus we
 857            * ignore them, and when we process the normal symbol table
 858            * we should do the right thing.
 859            *
 860            * With a.out or mingw, they actually do make some amount of sense.
 861            */
 862           new_value.addr.seg = 0;
 863           new_value.type = DEBUG_ParseStabType(ptr);
 864           new_value.addr.off = load_offset + stab_ptr->n_value;
 865           new_value.cookie = DV_TARGET;
 866
 867           stab_strcpy(symname, sizeof(symname), ptr);
 868 #ifdef __ELF__
 869           curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath,
 870                                       SYM_WINE | SYM_DATA | SYM_INVALID );
 871 #else
 872           curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath,
 873                                       SYM_WINE | SYM_DATA );
 874 #endif
 875           break;
 876         case N_RBRAC:
 877         case N_LBRAC:
 878           /*
 879            * We need to keep track of these so we get symbol scoping
 880            * right for local variables.  For now, we just ignore them.
 881            * The hooks are already there for dealing with this however,
 882            * so all we need to do is to keep count of the nesting level,
 883            * and find the RBRAC for each matching LBRAC.
 884            */
 885           break;
 886         case N_LCSYM:
 887         case N_STSYM:
 888           /*
 889            * These are static symbols and BSS symbols.
 890            */
 891           new_value.addr.seg = 0;
 892           new_value.type = DEBUG_ParseStabType(ptr);
 893           new_value.addr.off = load_offset + stab_ptr->n_value;
 894           new_value.cookie = DV_TARGET;
 895
 896           stab_strcpy(symname, sizeof(symname), ptr);
 897           curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath,
 898                                       SYM_WINE | SYM_DATA );
 899           break;
 900         case N_PSYM:
 901           /*
 902            * These are function parameters.
 903            */
 904           if( curr_func != NULL && !in_external_file )
 905             {
 906               stab_strcpy(symname, sizeof(symname), ptr);
 907               curr_loc = DEBUG_AddLocal( curr_func, 0,
 908                                          stab_ptr->n_value, 0, 0, symname );
 909               DEBUG_SetLocalSymbolType( curr_loc, DEBUG_ParseStabType(ptr) );
 910             }
 911           break;
 912         case N_RSYM:
 913           if( curr_func != NULL && !in_external_file )
 914             {
 915               stab_strcpy(symname, sizeof(symname), ptr);
 916               curr_loc = DEBUG_AddLocal( curr_func, stab_ptr->n_value + 1,
 917                                          0, 0, 0, symname );
 918               DEBUG_SetLocalSymbolType( curr_loc, DEBUG_ParseStabType(ptr) );
 919             }
 920           break;
 921         case N_LSYM:
 922           if( curr_func != NULL && !in_external_file )
 923             {
 924               stab_strcpy(symname, sizeof(symname), ptr);
 925               curr_loc = DEBUG_AddLocal( curr_func, 0,
 926                                          stab_ptr->n_value, 0, 0, symname );
 927               DEBUG_SetLocalSymbolType( curr_loc, DEBUG_ParseStabType(ptr) );
 928             }
 929           break;
 930         case N_SLINE:
 931           /*
 932            * This is a line number.  These are always relative to the start
 933            * of the function (N_FUN), and this makes the lookup easier.
 934            */
 935           if( curr_func != NULL && !in_external_file )
 936             {
 937 #ifdef __ELF__
 938               DEBUG_AddLineNumber(curr_func, stab_ptr->n_desc,
 939                                   stab_ptr->n_value);
 940 #else
 941 #if 0
 942               /*
 943                * This isn't right.  The order of the stabs is different under
 944                * a.out, and as a result we would end up attaching the line
 945                * number to the wrong function.
 946                */
 947               DEBUG_AddLineNumber(curr_func, stab_ptr->n_desc,
 948                                   stab_ptr->n_value - curr_func->addr.off);
 949 #endif
 950 #endif
 951             }
 952           break;
 953         case N_FUN:
 954           /*
 955            * First, clean up the previous function we were working on.
 956            */
 957           DEBUG_Normalize(curr_func);
 958
 959           /*
 960            * For now, just declare the various functions.  Later
 961            * on, we will add the line number information and the
 962            * local symbols.
 963            */
 964           if( !in_external_file)
 965             {
 966               stab_strcpy(symname, sizeof(symname), ptr);
 967               if (*symname)
 968                 {
 969                   new_value.addr.seg = 0;
 970                   new_value.type = DEBUG_ParseStabType(ptr);
 971                   new_value.addr.off = load_offset + stab_ptr->n_value;
 972                   new_value.cookie = DV_TARGET;
 973                   /*
 974                    * Copy the string to a temp buffer so we
 975                    * can kill everything after the ':'.  We do
 976                    * it this way because otherwise we end up dirtying
 977                    * all of the pages related to the stabs, and that
 978                    * sucks up swap space like crazy.
 979                    */
 980                   curr_func = DEBUG_AddSymbol( symname, &new_value, currpath,
 981                                                SYM_WINE | SYM_FUNC);
 982                 }
 983               else
 984                 {
 985                   /* some GCC seem to use a N_FUN "" to mark the end of a function */
 986                   curr_func = NULL;
 987                 }
 988             }
 989           else
 990             {
 991               /*
 992                * Don't add line number information for this function
 993                * any more.
 994                */
 995               curr_func = NULL;
 996             }
 997           break;
 998         case N_SO:
 999           /*
1000            * This indicates a new source file.  Append the records
1001            * together, to build the correct path name.
1002            */
1003 #ifndef __ELF__
1004           /*
1005            * With a.out, there is no NULL string N_SO entry at the end of
1006            * the file.  Thus when we find non-consecutive entries,
1007            * we consider that a new file is started.
1008            */
1009           if( last_nso < i-1 )
1010             {
1011               currpath[0] = '\0';
1012               DEBUG_Normalize(curr_func);
1013               curr_func = NULL;
1014             }
1015 #endif
1016
1017           if( *ptr == '\0' )
1018             {
1019               /*
1020                * Nuke old path.
1021                */
1022               currpath[0] = '\0';
1023               DEBUG_Normalize(curr_func);
1024               curr_func = NULL;
1025             }
1026           else
1027             {
1028               if (*ptr != '/')
1029                 strcat(currpath, ptr);
1030               else
1031                 strcpy(currpath, ptr);
1032               subpath = ptr;
1033               DEBUG_ResetIncludes();
1034             }
1035           last_nso = i;
1036           break;
1037         case N_SOL:
1038           /*
1039            * This indicates we are including stuff from an include file.
1040            * If this is the main source, enable the debug stuff, otherwise
1041            * ignore it.
1042            */
1043           in_external_file = !(subpath == NULL || strcmp(ptr, subpath) == 0);
1044           break;
1045         case N_UNDF:
1046           strs += strtabinc;
1047           strtabinc = stab_ptr->n_value;
1048           DEBUG_Normalize(curr_func);
1049           curr_func = NULL;
1050           break;
1051         case N_OPT:
1052           /*
1053            * Ignore this.  We don't care what it points to.
1054            */
1055           break;
1056         case N_BINCL:
1057            DEBUG_AddInclude(DEBUG_CreateInclude(ptr, stab_ptr->n_value));
1058            break;
1059         case N_EINCL:
1060            break;
1061         case N_EXCL:
1062            DEBUG_AddInclude(DEBUG_FindInclude(ptr, stab_ptr->n_value));
1063            break;
1064         case N_MAIN:
1065           /*
1066            * Always ignore these.  GCC doesn't even generate them.
1067            */
1068           break;
1069         default:
1070           DEBUG_Printf(DBG_CHN_MESG, "Unkown stab type 0x%02x\n", stab_ptr->n_type);
1071           break;
1072         }
1073
1074       stabbuff[0] = '\0';
1075
1076 #if 0
1077       DEBUG_Printf(DBG_CHN_MESG, "%d %x %s\n", stab_ptr->n_type,
1078                    (unsigned int) stab_ptr->n_value,
1079                    strs + (unsigned int) stab_ptr->n_un.n_name);
1080 #endif
1081     }
1082
1083   DEBUG_FreeRegisteredTypedefs();
1084   DEBUG_FreeIncludes();
1085
1086   return TRUE;
1087 }
1088
1089 #ifdef __ELF__
1090
1091 /*
1092  * Walk through the entire symbol table and add any symbols we find there.
1093  * This can be used in cases where we have stripped ELF shared libraries,
1094  * or it can be used in cases where we have data symbols for which the address
1095  * isn't encoded in the stabs.
1096  *
1097  * This is all really quite easy, since we don't have to worry about line
1098  * numbers or local data variables.
1099  */
1100 static
1101 int
1102 DEBUG_ProcessElfSymtab(char * addr, unsigned int load_offset,
1103                        Elf32_Shdr * symtab, Elf32_Shdr * strtab)
1104 {
1105   char          * curfile = NULL;
1106   struct name_hash * curr_sym = NULL;
1107   int             flags;
1108   int             i;
1109   DBG_VALUE       new_value;
1110   int             nsym;
1111   char          * strp;
1112   char          * symname;
1113   Elf32_Sym     * symp;
1114
1115
1116   symp = (Elf32_Sym *) (addr + symtab->sh_offset);
1117   nsym = symtab->sh_size / sizeof(*symp);
1118   strp = (char *) (addr + strtab->sh_offset);
1119
1120   for(i=0; i < nsym; i++, symp++)
1121     {
1122       /*
1123        * Ignore certain types of entries which really aren't of that much
1124        * interest.
1125        */
1126       if( ELF32_ST_TYPE(symp->st_info) == STT_SECTION ||
1127           symp->st_shndx == STN_UNDEF )
1128         {
1129           continue;
1130         }
1131
1132       symname = strp + symp->st_name;
1133
1134       /*
1135        * Save the name of the current file, so we have a way of tracking
1136        * static functions/data.
1137        */
1138       if( ELF32_ST_TYPE(symp->st_info) == STT_FILE )
1139         {
1140           curfile = symname;
1141           continue;
1142         }
1143
1144       /*
1145        * See if we already have something for this symbol.
1146        * If so, ignore this entry, because it would have come from the
1147        * stabs or from a previous symbol.  If the value is different,
1148        * we will have to keep the darned thing, because there can be
1149        * multiple local symbols by the same name.
1150        */
1151       if(    (DEBUG_GetSymbolValue(symname, -1, &new_value, FALSE ) == TRUE)
1152           && (new_value.addr.off == (load_offset + symp->st_value)) )
1153           continue;
1154
1155       new_value.addr.seg = 0;
1156       new_value.type = NULL;
1157       new_value.addr.off = load_offset + symp->st_value;
1158       new_value.cookie = DV_TARGET;
1159       flags = SYM_WINE | (ELF32_ST_BIND(symp->st_info) == STT_FUNC
1160                           ? SYM_FUNC : SYM_DATA);
1161       if( ELF32_ST_BIND(symp->st_info) == STB_GLOBAL )
1162           curr_sym = DEBUG_AddSymbol( symname, &new_value, NULL, flags );
1163       else
1164           curr_sym = DEBUG_AddSymbol( symname, &new_value, curfile, flags );
1165
1166       /*
1167        * Record the size of the symbol.  This can come in handy in
1168        * some cases.  Not really used yet, however.
1169        */
1170       if( symp->st_size != 0 )
1171           DEBUG_SetSymbolSize(curr_sym, symp->st_size);
1172     }
1173
1174   return TRUE;
1175 }
1176
1177 int
1178 DEBUG_ProcessElfObject(const char * filename, unsigned int load_offset)
1179 {
1180   int                   rtn = FALSE;
1181   char                * addr = (char*)0xffffffff;
1182   int                   fd = -1;
1183   struct stat           statbuf;
1184   Elf32_Ehdr          * ehptr;
1185   Elf32_Shdr          * spnt;
1186   char                * shstrtab;
1187   int                   nsect;
1188   int                   i;
1189   int                   stabsect;
1190   int                   stabstrsect;
1191
1192   /*
1193    * Make sure we can stat and open this file.
1194    */
1195   if( filename == NULL )
1196       goto leave;
1197
1198   if (stat(filename, &statbuf) == -1)
1199     {
1200       char *s,*t,*fn,*paths;
1201       if (strchr(filename,'/'))
1202         goto leave;
1203       paths = DBG_strdup(getenv("PATH"));
1204       s = paths;
1205       while (s && *s) {
1206         t = strchr(s,':');
1207         if (t) *t='\0';
1208         fn = (char*)DBG_alloc(strlen(filename)+1+strlen(s)+1);
1209         strcpy(fn,s);
1210         strcat(fn,"/");
1211         strcat(fn,filename);
1212         if ((rtn = DEBUG_ProcessElfObject(fn,load_offset))) {
1213                 DBG_free(fn);
1214                 DBG_free(paths);
1215                 goto leave;
1216         }
1217         DBG_free(fn);
1218         if (t) s = t+1; else break;
1219       }
1220       if (!s || !*s) DEBUG_Printf(DBG_CHN_MESG," not found");
1221       DBG_free(paths);
1222       goto leave;
1223     }
1224
1225   if (DEBUG_FindModuleByName(filename, DM_TYPE_ELF))
1226     goto leave;
1227
1228   DEBUG_Printf(DBG_CHN_MESG, "Loading stabs debug symbols from %s (0x%08lx)\n",
1229                filename, load_offset);
1230
1231   /*
1232    * Now open the file, so that we can mmap() it.
1233    */
1234   if ((fd = open(filename, O_RDONLY)) == -1)
1235       goto leave;
1236
1237   /*
1238    * Now mmap() the file.
1239    */
1240   addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
1241   if (addr == (char*)0xffffffff)
1242       goto leave;
1243
1244   /*
1245    * Next, we need to find a few of the internal ELF headers within
1246    * this thing.  We need the main executable header, and the section
1247    * table.
1248    */
1249   ehptr = (Elf32_Ehdr *) addr;
1250
1251   if( load_offset == 0 )
1252       DEBUG_RegisterELFModule(ehptr->e_entry, filename);
1253   else
1254       DEBUG_RegisterELFModule(load_offset, filename);
1255
1256   spnt = (Elf32_Shdr *) (addr + ehptr->e_shoff);
1257   nsect = ehptr->e_shnum;
1258   shstrtab = (addr + spnt[ehptr->e_shstrndx].sh_offset);
1259
1260   stabsect = stabstrsect = -1;
1261
1262   for(i=0; i < nsect; i++)
1263     {
1264       if( strcmp(shstrtab + spnt[i].sh_name, ".stab") == 0 )
1265           stabsect = i;
1266
1267       if( strcmp(shstrtab + spnt[i].sh_name, ".stabstr") == 0 )
1268           stabstrsect = i;
1269     }
1270
1271   if( stabsect == -1 || stabstrsect == -1 ) {
1272     DEBUG_Printf(DBG_CHN_WARN, "no .stab section\n");
1273     goto leave;
1274   }
1275
1276   /*
1277    * OK, now just parse all of the stabs.
1278    */
1279   if (!(rtn = DEBUG_ParseStabs(addr, load_offset,
1280                                spnt[stabsect].sh_offset,
1281                                spnt[stabsect].sh_size,
1282                                spnt[stabstrsect].sh_offset,
1283                                spnt[stabstrsect].sh_size))) {
1284     DEBUG_Printf(DBG_CHN_WARN, "bad stabs\n");
1285     goto leave;
1286   }
1287
1288   for(i=0; i < nsect; i++)
1289     {
1290       if(    (strcmp(shstrtab + spnt[i].sh_name, ".symtab") == 0)
1291           && (spnt[i].sh_type == SHT_SYMTAB) )
1292           DEBUG_ProcessElfSymtab(addr, load_offset,
1293                                  spnt + i, spnt + spnt[i].sh_link);
1294
1295       if(    (strcmp(shstrtab + spnt[i].sh_name, ".dynsym") == 0)
1296           && (spnt[i].sh_type == SHT_DYNSYM) )
1297           DEBUG_ProcessElfSymtab(addr, load_offset,
1298                                  spnt + i, spnt + spnt[i].sh_link);
1299     }
1300
1301 leave:
1302
1303   if (addr != (char*)0xffffffff)
1304     munmap(addr, statbuf.st_size);
1305
1306   if (fd != -1) close(fd);
1307
1308   return rtn;
1309 }
1310
1311 static  BOOL    DEBUG_WalkList(struct r_debug* dbg_hdr)
1312 {
1313   u_long                lm_addr;
1314   struct link_map       lm;
1315   Elf32_Ehdr            ehdr;
1316   char                  bufstr[256];
1317
1318   /*
1319    * Now walk the linked list.  In all known ELF implementations,
1320    * the dynamic loader maintains this linked list for us.  In some
1321    * cases the first entry doesn't appear with a name, in other cases it
1322    * does.
1323    */
1324   for (lm_addr = (u_long)dbg_hdr->r_map; lm_addr; lm_addr = (u_long)lm.l_next) {
1325     if (!DEBUG_READ_MEM_VERBOSE((void*)lm_addr, &lm, sizeof(lm)))
1326       return FALSE;
1327     if (lm.l_addr != 0 &&
1328         DEBUG_READ_MEM_VERBOSE((void*)lm.l_addr, &ehdr, sizeof(ehdr)) &&
1329         ehdr.e_type == ET_DYN && /* only look at dynamic modules */
1330         lm.l_name != NULL &&
1331         DEBUG_READ_MEM_VERBOSE(lm.l_name, bufstr, sizeof(bufstr))) {
1332       bufstr[sizeof(bufstr) - 1] = '\0';
1333       DEBUG_ProcessElfObject(bufstr, lm.l_addr);
1334     }
1335   }
1336
1337   return TRUE;
1338 }
1339
1340 static BOOL DEBUG_RescanElf(void)
1341 {
1342     struct r_debug        dbg_hdr;
1343
1344     if (!DEBUG_CurrProcess ||
1345         !DEBUG_READ_MEM_VERBOSE((void*)DEBUG_CurrProcess->dbg_hdr_addr, &dbg_hdr, sizeof(dbg_hdr)))
1346        return FALSE;
1347
1348     switch (dbg_hdr.r_state) {
1349     case RT_CONSISTENT:
1350        DEBUG_WalkList(&dbg_hdr);
1351        break;
1352     case RT_ADD:
1353        break;
1354     case RT_DELETE:
1355        /*FIXME: this is not currently handled, would need some kind of mark&sweep algo */
1356       break;
1357     }
1358     return FALSE;
1359 }
1360
1361 int
1362 DEBUG_ReadExecutableDbgInfo(const char* exe_name)
1363 {
1364   Elf32_Dyn             dyn;
1365   struct r_debug        dbg_hdr;
1366   int                   rtn = FALSE;
1367   DBG_VALUE             val;
1368
1369   /*
1370    * Make sure we can stat and open this file.
1371    */
1372   if (exe_name == NULL) goto leave;
1373   DEBUG_ProcessElfObject(exe_name, 0);
1374
1375   /* previous step should have loaded symbol _DYNAMIC if it exists inside
1376    * the main executable
1377    */
1378   if (!DEBUG_GetSymbolValue("_DYNAMIC", -1, &val, FALSE)) {
1379     DEBUG_Printf(DBG_CHN_WARN, "Can't find symbol _DYNAMIC\n");
1380     goto leave;
1381   }
1382
1383   do {
1384     if (!DEBUG_READ_MEM_VERBOSE((void*)val.addr.off, &dyn, sizeof(dyn)))
1385       goto leave;
1386     val.addr.off += sizeof(dyn);
1387   } while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL);
1388   if (dyn.d_tag == DT_NULL) goto leave;
1389
1390   /*
1391    * OK, now dig into the actual tables themselves.
1392    */
1393   if (!DEBUG_READ_MEM_VERBOSE((void*)dyn.d_un.d_ptr, &dbg_hdr, sizeof(dbg_hdr)))
1394     goto leave;
1395
1396   assert(!DEBUG_CurrProcess->dbg_hdr_addr);
1397   DEBUG_CurrProcess->dbg_hdr_addr = (u_long)dyn.d_un.d_ptr;
1398
1399   if (dbg_hdr.r_brk) {
1400     DBG_VALUE   value;
1401
1402     DEBUG_Printf(DBG_CHN_TRACE, "Setting up a breakpoint on r_brk(%lx)\n",
1403                  dbg_hdr.r_brk);
1404
1405     DEBUG_SetBreakpoints(FALSE);
1406     value.type = NULL;
1407     value.cookie = DV_TARGET;
1408     value.addr.seg = 0;
1409     value.addr.off = dbg_hdr.r_brk;
1410     DEBUG_AddBreakpoint(&value, DEBUG_RescanElf);
1411     DEBUG_SetBreakpoints(TRUE);
1412   }
1413
1414   rtn = DEBUG_WalkList(&dbg_hdr);
1415
1416 leave:
1417   return rtn;
1418 }
1419
1420 #else   /* !__ELF__ */
1421
1422 int
1423 DEBUG_ProcessElfObject(const char * filename, unsigned int load_offset)
1424 {
1425   return FALSE;
1426 }
1427
1428 int
1429 DEBUG_ReadExecutableDbgInfo(const char* exe_name)
1430 {
1431   return FALSE;
1432 }
1433
1434 #endif  /* __ELF__ */