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