| /* -*- tab-width: 8; c-basic-offset: 4 -*- */ |
| |
| /* |
| * File stabs.c - read stabs information from the wine executable itself. |
| * |
| * Copyright (C) 1996, Eric Youngdale. |
| * 1999-2003 Eric Pouech |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * |
| * Maintenance Information |
| * ----------------------- |
| * |
| * For documentation on the stabs format see for example |
| * The "stabs" debug format |
| * by Julia Menapace, Jim Kingdon, David Mackenzie |
| * of Cygnus Support |
| * available (hopefully) from http:\\sources.redhat.com\gdb\onlinedocs |
| */ |
| |
| #include "config.h" |
| |
| #include <sys/types.h> |
| #include <fcntl.h> |
| #include <sys/stat.h> |
| #ifdef HAVE_SYS_MMAN_H |
| #include <sys/mman.h> |
| #endif |
| #include <limits.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #ifdef HAVE_UNISTD_H |
| # include <unistd.h> |
| #endif |
| #include <stdio.h> |
| #ifndef PATH_MAX |
| #define PATH_MAX MAX_PATH |
| #endif |
| |
| #include "debugger.h" |
| |
| #if defined(__svr4__) || defined(__sun) |
| #define __ELF__ |
| #endif |
| |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(winedbg_stabs); |
| |
| #ifndef N_UNDF |
| #define N_UNDF 0x00 |
| #endif |
| |
| #ifndef STN_UNDEF |
| # define STN_UNDEF 0 |
| #endif |
| |
| #define N_GSYM 0x20 |
| #define N_FUN 0x24 |
| #define N_STSYM 0x26 |
| #define N_LCSYM 0x28 |
| #define N_MAIN 0x2a |
| #define N_ROSYM 0x2c |
| #define N_OPT 0x3c |
| #define N_RSYM 0x40 |
| #define N_SLINE 0x44 |
| #define N_SO 0x64 |
| #define N_LSYM 0x80 |
| #define N_BINCL 0x82 |
| #define N_SOL 0x84 |
| #define N_PSYM 0xa0 |
| #define N_EINCL 0xa2 |
| #define N_LBRAC 0xc0 |
| #define N_EXCL 0xc2 |
| #define N_RBRAC 0xe0 |
| |
| struct stab_nlist { |
| union { |
| char *n_name; |
| struct stab_nlist *n_next; |
| long n_strx; |
| } n_un; |
| unsigned char n_type; |
| char n_other; |
| short n_desc; |
| unsigned long n_value; |
| }; |
| |
| static void stab_strcpy(char * dest, int sz, const char * source) |
| { |
| /* |
| * A strcpy routine that stops when we hit the ':' character. |
| * Faster than copying the whole thing, and then nuking the |
| * ':'. |
| */ |
| while(*source != '\0' && *source != ':' && sz-- > 0) |
| *dest++ = *source++; |
| *dest = '\0'; |
| assert(sz > 0); |
| } |
| |
| typedef struct { |
| char* name; |
| unsigned long value; |
| int idx; |
| struct datatype** vector; |
| int nrofentries; |
| } include_def; |
| |
| #define MAX_INCLUDES 5120 |
| |
| static include_def* include_defs = NULL; |
| static int num_include_def = 0; |
| static int num_alloc_include_def = 0; |
| static int cu_include_stack[MAX_INCLUDES]; |
| static int cu_include_stk_idx = 0; |
| static struct datatype** cu_vector = NULL; |
| static int cu_nrofentries = 0; |
| |
| static |
| int |
| DEBUG_CreateInclude(const char* file, unsigned long val) |
| { |
| if (num_include_def == num_alloc_include_def) |
| { |
| num_alloc_include_def += 256; |
| include_defs = DBG_realloc(include_defs, sizeof(include_defs[0])*num_alloc_include_def); |
| memset(include_defs+num_include_def, 0, sizeof(include_defs[0])*256); |
| } |
| include_defs[num_include_def].name = DBG_strdup(file); |
| include_defs[num_include_def].value = val; |
| include_defs[num_include_def].vector = NULL; |
| include_defs[num_include_def].nrofentries = 0; |
| |
| return num_include_def++; |
| } |
| |
| static |
| int |
| DEBUG_FindInclude(const char* file, unsigned long val) |
| { |
| int i; |
| |
| for (i = 0; i < num_include_def; i++) |
| { |
| if (val == include_defs[i].value && |
| strcmp(file, include_defs[i].name) == 0) |
| return i; |
| } |
| return -1; |
| } |
| |
| static |
| int |
| DEBUG_AddInclude(int idx) |
| { |
| ++cu_include_stk_idx; |
| |
| /* is this happen, just bump MAX_INCLUDES */ |
| /* we could also handle this as another dynarray */ |
| assert(cu_include_stk_idx < MAX_INCLUDES); |
| |
| cu_include_stack[cu_include_stk_idx] = idx; |
| return cu_include_stk_idx; |
| } |
| |
| static |
| void |
| DEBUG_ResetIncludes(void) |
| { |
| /* |
| * The datatypes that we would need to use are reset when |
| * we start a new file. (at least the ones in filenr == 0 |
| */ |
| cu_include_stk_idx = 0;/* keep 0 as index for the .c file itself */ |
| memset(cu_vector, 0, sizeof(cu_vector[0]) * cu_nrofentries); |
| } |
| |
| static |
| void |
| DEBUG_FreeIncludes(void) |
| { |
| int i; |
| |
| DEBUG_ResetIncludes(); |
| |
| for (i = 0; i < num_include_def; i++) |
| { |
| DBG_free(include_defs[i].name); |
| DBG_free(include_defs[i].vector); |
| } |
| DBG_free(include_defs); |
| include_defs = NULL; |
| num_include_def = 0; |
| num_alloc_include_def = 0; |
| DBG_free(cu_vector); |
| cu_vector = NULL; |
| cu_nrofentries = 0; |
| } |
| |
| static |
| struct datatype** |
| DEBUG_FileSubNr2StabEnum(int filenr, int subnr) |
| { |
| struct datatype** ret; |
| |
| WINE_TRACE("creating type id for (%d,%d)\n", filenr, subnr); |
| |
| /* FIXME: I could perhaps create a dummy include_def for each compilation |
| * unit which would allow not to handle those two cases separately |
| */ |
| if (filenr == 0) |
| { |
| if (cu_nrofentries <= subnr) |
| { |
| cu_vector = DBG_realloc(cu_vector, sizeof(cu_vector[0])*(subnr+1)); |
| memset(cu_vector+cu_nrofentries, 0, sizeof(cu_vector[0])*(subnr+1-cu_nrofentries)); |
| cu_nrofentries = subnr + 1; |
| } |
| ret = &cu_vector[subnr]; |
| } |
| else |
| { |
| include_def* idef; |
| |
| assert(filenr <= cu_include_stk_idx); |
| |
| idef = &include_defs[cu_include_stack[filenr]]; |
| |
| if (idef->nrofentries <= subnr) |
| { |
| idef->vector = DBG_realloc(idef->vector, sizeof(idef->vector[0])*(subnr+1)); |
| memset(idef->vector + idef->nrofentries, 0, sizeof(idef->vector[0])*(subnr+1-idef->nrofentries)); |
| idef->nrofentries = subnr + 1; |
| } |
| ret = &idef->vector[subnr]; |
| } |
| WINE_TRACE("(%d,%d) is %p\n",filenr,subnr,ret); |
| return ret; |
| } |
| |
| static |
| struct datatype** |
| DEBUG_ReadTypeEnum(LPCSTR *x) |
| { |
| int filenr,subnr; |
| |
| if (**x=='(') { |
| (*x)++; /* '(' */ |
| filenr=strtol(*x,(char**)x,10); /* <int> */ |
| (*x)++; /* ',' */ |
| subnr=strtol(*x,(char**)x,10); /* <int> */ |
| (*x)++; /* ')' */ |
| } else { |
| filenr = 0; |
| subnr = strtol(*x,(char**)x,10); /* <int> */ |
| } |
| return DEBUG_FileSubNr2StabEnum(filenr,subnr); |
| } |
| |
| /*#define PTS_DEBUG*/ |
| struct ParseTypedefData |
| { |
| const char* ptr; |
| char buf[1024]; |
| int idx; |
| #ifdef PTS_DEBUG |
| struct PTS_Error |
| { |
| char* ptr; |
| unsigned line; |
| } errors[16]; |
| int err_idx; |
| #endif |
| }; |
| |
| #ifdef PTS_DEBUG |
| static void PTS_Push(struct ParseTypedefData* ptd, unsigned line) |
| { |
| assert(ptd->err_idx < sizeof(ptd->errors) / sizeof(ptd->errors[0])); |
| ptd->errors[ptd->err_idx].line = line; |
| ptd->errors[ptd->err_idx].ptr = ptd->ptr; |
| ptd->err_idx++; |
| } |
| #define PTS_ABORTIF(ptd, t) do { if (t) { PTS_Push((ptd), __LINE__); return -1;} } while (0) |
| #else |
| #define PTS_ABORTIF(ptd, t) do { if (t) return -1; } while (0) |
| #endif |
| |
| static int DEBUG_PTS_ReadTypedef(struct ParseTypedefData* ptd, const char* typename, |
| struct datatype** dt); |
| |
| static int DEBUG_PTS_ReadID(struct ParseTypedefData* ptd) |
| { |
| const char* first = ptd->ptr; |
| unsigned int len; |
| |
| PTS_ABORTIF(ptd, (ptd->ptr = strchr(ptd->ptr, ':')) == NULL); |
| len = ptd->ptr - first; |
| PTS_ABORTIF(ptd, len >= sizeof(ptd->buf) - ptd->idx); |
| memcpy(ptd->buf + ptd->idx, first, len); |
| ptd->buf[ptd->idx + len] = '\0'; |
| ptd->idx += len + 1; |
| ptd->ptr++; /* ':' */ |
| return 0; |
| } |
| |
| static int DEBUG_PTS_ReadNum(struct ParseTypedefData* ptd, int* v) |
| { |
| char* last; |
| |
| *v = strtol(ptd->ptr, &last, 10); |
| PTS_ABORTIF(ptd, last == ptd->ptr); |
| ptd->ptr = last; |
| return 0; |
| } |
| |
| static int DEBUG_PTS_ReadTypeReference(struct ParseTypedefData* ptd, |
| int* filenr, int* subnr) |
| { |
| if (*ptd->ptr == '(') { |
| /* '(' <int> ',' <int> ')' */ |
| ptd->ptr++; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, filenr) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ','); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, subnr) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ')'); |
| } else { |
| *filenr = 0; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, subnr) == -1); |
| } |
| return 0; |
| } |
| |
| static int DEBUG_PTS_ReadRange(struct ParseTypedefData* ptd, struct datatype** dt, |
| int* lo, int* hi) |
| { |
| /* type ';' <int> ';' <int> ';' */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, dt) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, lo) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, hi) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ |
| return 0; |
| } |
| |
| static inline int DEBUG_PTS_ReadMethodInfo(struct ParseTypedefData* ptd) |
| { |
| struct datatype* dt; |
| char* tmp; |
| char mthd; |
| |
| do |
| { |
| /* get type of return value */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1); |
| if (*ptd->ptr == ';') ptd->ptr++; |
| |
| /* get types of parameters */ |
| if (*ptd->ptr == ':') |
| { |
| PTS_ABORTIF(ptd, !(tmp = strchr(ptd->ptr + 1, ';'))); |
| ptd->ptr = tmp + 1; |
| } |
| PTS_ABORTIF(ptd, !(*ptd->ptr >= '0' && *ptd->ptr <= '9')); |
| ptd->ptr++; |
| PTS_ABORTIF(ptd, !(ptd->ptr[0] >= 'A' && *ptd->ptr <= 'D')); |
| mthd = *++ptd->ptr; |
| PTS_ABORTIF(ptd, mthd != '.' && mthd != '?' && mthd != '*'); |
| ptd->ptr++; |
| if (mthd == '*') |
| { |
| int ofs; |
| struct datatype* dt; |
| |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &ofs) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| } |
| } while (*ptd->ptr != ';'); |
| ptd->ptr++; |
| |
| return 0; |
| } |
| |
| static inline int DEBUG_PTS_ReadAggregate(struct ParseTypedefData* ptd, |
| struct datatype* sdt) |
| { |
| int sz, ofs; |
| struct datatype* adt; |
| struct datatype* dt = NULL; |
| int idx; |
| int doadd; |
| |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &sz) == -1); |
| |
| doadd = DEBUG_SetStructSize(sdt, sz); |
| if (*ptd->ptr == '!') /* C++ inheritence */ |
| { |
| int num_classes; |
| char tmp[256]; |
| |
| ptd->ptr++; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &num_classes) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ','); |
| while (--num_classes >= 0) |
| { |
| ptd->ptr += 2; /* skip visibility and inheritence */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &ofs) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ','); |
| |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &adt) == -1); |
| |
| snprintf(tmp, sizeof(tmp), "__inherited_class_%s", DEBUG_GetName(adt)); |
| /* FIXME: DEBUG_GetObjectSize will not always work, especially when adt |
| * has just been seen as a forward definition and not the real stuff yet. |
| * As we don't use much the size of members in structs, this may not |
| * be much of a problem |
| */ |
| if (doadd) DEBUG_AddStructElement(sdt, tmp, adt, ofs, DEBUG_GetObjectSize(adt) * 8); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| } |
| |
| } |
| /* if the structure has already been filled, just redo the parsing |
| * but don't store results into the struct |
| * FIXME: there's a quite ugly memory leak in there... |
| */ |
| |
| /* Now parse the individual elements of the structure/union. */ |
| while (*ptd->ptr != ';') |
| { |
| /* agg_name : type ',' <int:offset> ',' <int:size> */ |
| idx = ptd->idx; |
| |
| if (ptd->ptr[0] == '$' && ptd->ptr[1] == 'v') |
| { |
| int x; |
| |
| if (ptd->ptr[2] == 'f') |
| { |
| /* C++ virtual method table */ |
| ptd->ptr += 3; |
| DEBUG_ReadTypeEnum(&ptd->ptr); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ':'); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ','); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &x) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| ptd->idx = idx; |
| continue; |
| } |
| else if (ptd->ptr[2] == 'b') |
| { |
| ptd->ptr += 3; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ':'); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ','); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &x) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| ptd->idx = idx; |
| continue; |
| } |
| } |
| |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadID(ptd) == -1); |
| /* Ref. TSDF R2.130 Section 7.4. When the field name is a method name |
| * it is followed by two colons rather than one. |
| */ |
| if (*ptd->ptr == ':') |
| { |
| ptd->ptr++; |
| DEBUG_PTS_ReadMethodInfo(ptd); |
| ptd->idx = idx; |
| continue; |
| } |
| else |
| { |
| /* skip C++ member protection /0 /1 or /2 */ |
| if (*ptd->ptr == '/') ptd->ptr += 2; |
| } |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &adt) == -1); |
| |
| switch (*ptd->ptr++) |
| { |
| case ',': |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &ofs) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ','); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &sz) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| |
| if (doadd) DEBUG_AddStructElement(sdt, ptd->buf + idx, adt, ofs, sz); |
| break; |
| case ':': |
| { |
| char* tmp; |
| /* method parameters... terminated by ';' */ |
| PTS_ABORTIF(ptd, !(tmp = strchr(ptd->ptr, ';'))); |
| ptd->ptr = tmp + 1; |
| } |
| break; |
| default: |
| PTS_ABORTIF(ptd, TRUE); |
| } |
| ptd->idx = idx; |
| } |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| if (*ptd->ptr == '~') |
| { |
| ptd->ptr++; |
| PTS_ABORTIF(ptd, *ptd->ptr++ != '%'); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &dt) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| } |
| return 0; |
| } |
| |
| static inline int DEBUG_PTS_ReadEnum(struct ParseTypedefData* ptd, |
| struct datatype* edt) |
| { |
| int ofs; |
| int idx; |
| |
| while (*ptd->ptr != ';') { |
| idx = ptd->idx; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadID(ptd) == -1); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &ofs) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ','); |
| DEBUG_AddStructElement(edt, ptd->buf + idx, NULL, ofs, 0); |
| ptd->idx = idx; |
| } |
| ptd->ptr++; |
| return 0; |
| } |
| |
| static inline int DEBUG_PTS_ReadArray(struct ParseTypedefData* ptd, |
| struct datatype* adt) |
| { |
| int lo, hi; |
| struct datatype* rdt; |
| |
| /* ar<typeinfo_nodef>;<int>;<int>;<typeinfo> */ |
| |
| PTS_ABORTIF(ptd, *ptd->ptr++ != 'r'); |
| /* FIXME: range type is lost, always assume int */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadRange(ptd, &rdt, &lo, &hi) == -1); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &rdt) == -1); |
| |
| DEBUG_SetArrayParams(adt, lo, hi, rdt); |
| return 0; |
| } |
| |
| static int DEBUG_PTS_ReadTypedef(struct ParseTypedefData* ptd, const char* typename, |
| struct datatype** ret_dt) |
| { |
| int idx, lo, hi, sz = -1; |
| struct datatype* new_dt = NULL; /* newly created data type */ |
| struct datatype* ref_dt; /* referenced data type (pointer...) */ |
| struct datatype* dt1; /* intermediate data type (scope is limited) */ |
| struct datatype* dt2; /* intermediate data type: t1=t2=new_dt */ |
| int filenr1, subnr1; |
| |
| /* things are a bit complicated because of the way the typedefs are stored inside |
| * the file (we cannot keep the struct datatype** around, because address can |
| * change when realloc is done, so we must call over and over |
| * DEBUG_FileSubNr2StabEnum to keep the correct values around |
| * (however, keeping struct datatype* is valid)) |
| */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypeReference(ptd, &filenr1, &subnr1) == -1); |
| |
| while (*ptd->ptr == '=') { |
| ptd->ptr++; |
| PTS_ABORTIF(ptd, new_dt != NULL); |
| |
| /* first handle attribute if any */ |
| switch (*ptd->ptr) { |
| case '@': |
| if (*++ptd->ptr == 's') { |
| ptd->ptr++; |
| if (DEBUG_PTS_ReadNum(ptd, &sz) == -1) { |
| WINE_ERR("Not an attribute... NIY\n"); |
| ptd->ptr -= 2; |
| return -1; |
| } |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| } |
| break; |
| } |
| /* then the real definitions */ |
| switch (*ptd->ptr++) { |
| case '*': |
| case '&': |
| new_dt = DEBUG_NewDataType(DT_POINTER, NULL); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &ref_dt) == -1); |
| DEBUG_SetPointerType(new_dt, ref_dt); |
| break; |
| case 'k': /* 'const' modifier */ |
| case 'B': /* 'volatile' modifier */ |
| /* just kinda ignore the modifier, I guess -gmt */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, typename, &new_dt) == -1); |
| break; |
| case '(': |
| ptd->ptr--; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, typename, &new_dt) == -1); |
| break; |
| case 'a': |
| new_dt = DEBUG_NewDataType(DT_ARRAY, NULL); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadArray(ptd, new_dt) == -1); |
| break; |
| case 'r': |
| new_dt = DEBUG_NewDataType(DT_BASIC, typename); |
| assert(!*DEBUG_FileSubNr2StabEnum(filenr1, subnr1)); |
| *DEBUG_FileSubNr2StabEnum(filenr1, subnr1) = new_dt; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadRange(ptd, &ref_dt, &lo, &hi) == -1); |
| /* should perhaps do more here... */ |
| break; |
| case 'f': |
| new_dt = DEBUG_NewDataType(DT_FUNC, NULL); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &ref_dt) == -1); |
| DEBUG_SetPointerType(new_dt, ref_dt); |
| break; |
| case 'e': |
| new_dt = DEBUG_NewDataType(DT_ENUM, NULL); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadEnum(ptd, new_dt) == -1); |
| break; |
| case 's': |
| case 'u': |
| /* dt1 can have been already defined in a forward definition */ |
| dt1 = *DEBUG_FileSubNr2StabEnum(filenr1, subnr1); |
| dt2 = DEBUG_TypeCast(DT_STRUCT, typename); |
| if (!dt1) { |
| new_dt = DEBUG_NewDataType(DT_STRUCT, typename); |
| /* we need to set it here, because a struct can hold a pointer |
| * to itself |
| */ |
| *DEBUG_FileSubNr2StabEnum(filenr1, subnr1) = new_dt; |
| } else { |
| if (DEBUG_GetType(dt1) != DT_STRUCT) { |
| WINE_ERR("Forward declaration is not an aggregate\n"); |
| return -1; |
| } |
| |
| /* should check typename is the same too */ |
| new_dt = dt1; |
| } |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadAggregate(ptd, new_dt) == -1); |
| break; |
| case 'x': |
| switch (*ptd->ptr++) { |
| case 'e': lo = DT_ENUM; break; |
| case 's': case 'u': lo = DT_STRUCT; break; |
| default: return -1; |
| } |
| |
| idx = ptd->idx; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadID(ptd) == -1); |
| new_dt = DEBUG_NewDataType(lo, ptd->buf + idx); |
| ptd->idx = idx; |
| break; |
| case '-': |
| { |
| enum debug_type_basic basic = DT_BASIC_LAST; |
| |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &lo) == -1); |
| |
| switch (lo) |
| { |
| case 1: basic = DT_BASIC_INT; break; |
| case 2: basic = DT_BASIC_CHAR; break; |
| case 3: basic = DT_BASIC_SHORTINT; break; |
| case 4: basic = DT_BASIC_LONGINT; break; |
| case 5: basic = DT_BASIC_UCHAR; break; |
| case 6: basic = DT_BASIC_SCHAR; break; |
| case 7: basic = DT_BASIC_USHORTINT; break; |
| case 8: basic = DT_BASIC_UINT; break; |
| /* case 9: basic = DT_BASIC_UINT"; */ |
| case 10: basic = DT_BASIC_ULONGINT; break; |
| case 11: basic = DT_BASIC_VOID; break; |
| case 12: basic = DT_BASIC_FLOAT; break; |
| case 13: basic = DT_BASIC_DOUBLE; break; |
| case 14: basic = DT_BASIC_LONGDOUBLE; break; |
| /* case 15: basic = DT_BASIC_INT; break; */ |
| case 16: |
| switch (sz) { |
| case 32: basic = DT_BASIC_BOOL1; break; |
| case 16: basic = DT_BASIC_BOOL2; break; |
| case 8: basic = DT_BASIC_BOOL4; break; |
| } |
| break; |
| /* case 17: basic = DT_BASIC_SHORT real; break; */ |
| /* case 18: basic = DT_BASIC_REAL; break; */ |
| case 25: basic = DT_BASIC_CMPLX_FLOAT; break; |
| case 26: basic = DT_BASIC_CMPLX_DOUBLE; break; |
| /* case 30: basic = DT_BASIC_wchar"; break; */ |
| case 31: basic = DT_BASIC_LONGLONGINT; break; |
| case 32: basic = DT_BASIC_ULONGLONGINT; break; |
| default: |
| PTS_ABORTIF(ptd, 1); |
| } |
| PTS_ABORTIF(ptd, !(new_dt = DEBUG_GetBasicType(basic))); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); |
| } |
| break; |
| case '#': |
| new_dt = DEBUG_NewDataType(DT_FUNC, NULL); |
| if (*ptd->ptr == '#') |
| { |
| ptd->ptr++; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &ref_dt) == -1); |
| DEBUG_SetPointerType(new_dt, ref_dt); |
| } |
| else |
| { |
| struct datatype* cls_dt; |
| struct datatype* pmt_dt; |
| |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &cls_dt) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ','); |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &ref_dt) == -1); |
| DEBUG_SetPointerType(new_dt, ref_dt); |
| while (*ptd->ptr == ',') |
| { |
| ptd->ptr++; |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadTypedef(ptd, NULL, &pmt_dt) == -1); |
| } |
| } |
| break; |
| case 'R': |
| { |
| enum debug_type_basic basic = DT_BASIC_LAST; |
| int type, len, unk; |
| |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &type) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &len) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ |
| PTS_ABORTIF(ptd, DEBUG_PTS_ReadNum(ptd, &unk) == -1); |
| PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ |
| |
| switch (type) |
| { |
| case 1: basic = DT_BASIC_FLOAT; break; |
| case 2: basic = DT_BASIC_DOUBLE; break; |
| case 3: basic = DT_BASIC_CMPLX_FLOAT; break; |
| case 4: basic = DT_BASIC_CMPLX_DOUBLE; break; |
| case 5: basic = DT_BASIC_CMPLX_LONGDOUBLE; break; |
| case 6: basic = DT_BASIC_LONGDOUBLE; break; |
| default: PTS_ABORTIF(ptd, 1); |
| } |
| PTS_ABORTIF(ptd, !(new_dt = DEBUG_GetBasicType(basic))); |
| } |
| break; |
| default: |
| WINE_ERR("Unknown type '%c'\n", ptd->ptr[-1]); |
| return -1; |
| } |
| } |
| |
| if (!new_dt) |
| { |
| /* is it a forward declaration that has been filled ? */ |
| new_dt = *DEBUG_FileSubNr2StabEnum(filenr1, subnr1); |
| /* if not, this should then be a basic type: define it, or even void */ |
| if (!new_dt) |
| new_dt = DEBUG_NewDataType(DT_BASIC, typename); |
| } |
| |
| *DEBUG_FileSubNr2StabEnum(filenr1, subnr1) = *ret_dt = new_dt; |
| |
| if (typename && WINE_TRACE_ON(winedbg_stabs)) { |
| DEBUG_Printf("Adding (%d,%d) %s => ", filenr1, subnr1, typename); |
| DEBUG_PrintTypeCast(new_dt); |
| DEBUG_Printf("\n"); |
| } |
| |
| return 0; |
| } |
| |
| static int DEBUG_ParseTypedefStab(const char* ptr, const char* typename) |
| { |
| struct ParseTypedefData ptd; |
| struct datatype* dt; |
| int ret = -1; |
| |
| /* check for already existing definition */ |
| |
| ptd.idx = 0; |
| #ifdef PTS_DEBUG |
| ptd.err_idx = 0; |
| #endif |
| for (ptd.ptr = ptr - 1; ;) |
| { |
| ptd.ptr = strchr(ptd.ptr + 1, ':'); |
| if (ptd.ptr == NULL || *++ptd.ptr != ':') break; |
| } |
| |
| if (ptd.ptr) |
| { |
| if (*ptd.ptr != '(') ptd.ptr++; |
| /* most of type definitions take one char, except Tt */ |
| if (*ptd.ptr != '(') ptd.ptr++; |
| ret = DEBUG_PTS_ReadTypedef(&ptd, typename, &dt); |
| } |
| |
| if (ret == -1 || *ptd.ptr) { |
| #ifdef PTS_DEBUG |
| int i; |
| WINE_TRACE("Failure on %s\n", ptr); |
| if (ret == -1) |
| { |
| for (i = 0; i < ptd.err_idx; i++) |
| { |
| WINE_TRACE("[%d]: line %d => %s\n", |
| i, ptd.errors[i].line, ptd.errors[i].ptr); |
| } |
| } |
| else |
| WINE_TRACE("[0]: => %s\n", ptd.ptr); |
| |
| #else |
| WINE_ERR("Failure on %s at %s\n", ptr, ptd.ptr); |
| #endif |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| static struct datatype* |
| DEBUG_ParseStabType(const char* stab) |
| { |
| const char* c = stab - 1; |
| |
| /* |
| * Look through the stab definition, and figure out what datatype |
| * this represents. If we have something we know about, assign the |
| * type. |
| * According to "The \"stabs\" debug format" (Rev 2.130) the name may be |
| * a C++ name and contain double colons e.g. foo::bar::baz:t5=*6. |
| */ |
| do |
| { |
| if ((c = strchr(c + 1, ':')) == NULL) return NULL; |
| } while (*++c == ':'); |
| |
| /* |
| * The next characters say more about the type (i.e. data, function, etc) |
| * of symbol. Skip them. (C++ for example may have Tt). |
| * Actually this is a very weak description; I think Tt is the only |
| * multiple combination we should see. |
| */ |
| while (*c && *c != '(' && !isdigit(*c)) |
| c++; |
| /* |
| * The next is either an integer or a (integer,integer). |
| * The DEBUG_ReadTypeEnum takes care that stab_types is large enough. |
| */ |
| return *DEBUG_ReadTypeEnum(&c); |
| } |
| |
| enum DbgInfoLoad DEBUG_ParseStabs(const char* addr, void* load_offset, |
| unsigned int staboff, int stablen, |
| unsigned int strtaboff, int strtablen) |
| { |
| struct name_hash* curr_func = NULL; |
| struct wine_locals* curr_loc = NULL; |
| struct name_hash* curr_sym = NULL; |
| char currpath[PATH_MAX]; |
| int i; |
| int in_external_file = FALSE; |
| int last_nso = -1; |
| unsigned int len; |
| DBG_VALUE new_value; |
| int nstab; |
| const char* ptr; |
| char* stabbuff; |
| unsigned int stabbufflen; |
| const struct stab_nlist* stab_ptr; |
| const char* strs; |
| int strtabinc; |
| const char* subpath = NULL; |
| char symname[4096]; |
| |
| nstab = stablen / sizeof(struct stab_nlist); |
| stab_ptr = (struct stab_nlist *) (addr + staboff); |
| strs = (char *) (addr + strtaboff); |
| |
| memset(currpath, 0, sizeof(currpath)); |
| |
| /* |
| * Allocate a buffer into which we can build stab strings for cases |
| * where the stab is continued over multiple lines. |
| */ |
| stabbufflen = 65536; |
| stabbuff = (char *) DBG_alloc(stabbufflen); |
| |
| strtabinc = 0; |
| stabbuff[0] = '\0'; |
| for (i = 0; i < nstab; i++, stab_ptr++) |
| { |
| ptr = strs + (unsigned int) stab_ptr->n_un.n_name; |
| if( ptr[strlen(ptr) - 1] == '\\' ) |
| { |
| /* |
| * Indicates continuation. Append this to the buffer, and go onto the |
| * next record. Repeat the process until we find a stab without the |
| * '/' character, as this indicates we have the whole thing. |
| */ |
| len = strlen(ptr); |
| if( strlen(stabbuff) + len > stabbufflen ) |
| { |
| stabbufflen += 65536; |
| stabbuff = (char *) DBG_realloc(stabbuff, stabbufflen); |
| } |
| strncat(stabbuff, ptr, len - 1); |
| continue; |
| } |
| else if( stabbuff[0] != '\0' ) |
| { |
| strcat( stabbuff, ptr); |
| ptr = stabbuff; |
| } |
| |
| if( strchr(ptr, '=') != NULL ) |
| { |
| /* |
| * The stabs aren't in writable memory, so copy it over so we are |
| * sure we can scribble on it. |
| */ |
| if( ptr != stabbuff ) |
| { |
| strcpy(stabbuff, ptr); |
| ptr = stabbuff; |
| } |
| stab_strcpy(symname, sizeof(symname), ptr); |
| if (!DEBUG_ParseTypedefStab(ptr, symname)) { |
| /* skip this definition */ |
| stabbuff[0] = '\0'; |
| continue; |
| } |
| } |
| |
| switch(stab_ptr->n_type) |
| { |
| case N_GSYM: |
| /* |
| * These are useless with ELF. They have no value, and you have to |
| * read the normal symbol table to get the address. Thus we |
| * ignore them, and when we process the normal symbol table |
| * we should do the right thing. |
| * |
| * With a.out or mingw, they actually do make some amount of sense. |
| */ |
| new_value.type = DEBUG_ParseStabType(ptr); |
| new_value.addr.seg = 0; |
| new_value.cookie = DV_TARGET; |
| |
| stab_strcpy(symname, sizeof(symname), ptr); |
| #ifdef __ELF__ |
| /* EPP used to be: new_value.addr.off = 0; */ |
| new_value.addr.off = (unsigned long)load_offset + stab_ptr->n_value; |
| curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath, |
| SYM_WINE | SYM_DATA | SYM_INVALID ); |
| #else |
| new_value.addr.off = (unsigned long)load_offset + stab_ptr->n_value; |
| curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath, |
| SYM_WINE | SYM_DATA ); |
| #endif |
| break; |
| case N_RBRAC: |
| case N_LBRAC: |
| /* |
| * We need to keep track of these so we get symbol scoping |
| * right for local variables. For now, we just ignore them. |
| * The hooks are already there for dealing with this however, |
| * so all we need to do is to keep count of the nesting level, |
| * and find the RBRAC for each matching LBRAC. |
| */ |
| break; |
| case N_LCSYM: |
| case N_STSYM: |
| /* |
| * These are static symbols and BSS symbols. |
| */ |
| new_value.addr.seg = 0; |
| new_value.type = DEBUG_ParseStabType(ptr); |
| new_value.addr.off = (unsigned long)load_offset + stab_ptr->n_value; |
| new_value.cookie = DV_TARGET; |
| |
| stab_strcpy(symname, sizeof(symname), ptr); |
| curr_sym = DEBUG_AddSymbol( symname, &new_value, currpath, |
| SYM_WINE | SYM_DATA ); |
| break; |
| case N_PSYM: |
| /* |
| * These are function parameters. |
| */ |
| if( curr_func != NULL && !in_external_file ) |
| { |
| stab_strcpy(symname, sizeof(symname), ptr); |
| curr_loc = DEBUG_AddLocal( curr_func, 0, |
| stab_ptr->n_value, 0, 0, symname ); |
| DEBUG_SetLocalSymbolType( curr_loc, DEBUG_ParseStabType(ptr) ); |
| } |
| break; |
| case N_RSYM: |
| if( curr_func != NULL && !in_external_file ) |
| { |
| stab_strcpy(symname, sizeof(symname), ptr); |
| curr_loc = DEBUG_AddLocal( curr_func, stab_ptr->n_value + 1, |
| 0, 0, 0, symname ); |
| DEBUG_SetLocalSymbolType( curr_loc, DEBUG_ParseStabType(ptr) ); |
| } |
| break; |
| case N_LSYM: |
| if( curr_func != NULL && !in_external_file ) |
| { |
| stab_strcpy(symname, sizeof(symname), ptr); |
| curr_loc = DEBUG_AddLocal( curr_func, 0, |
| stab_ptr->n_value, 0, 0, symname ); |
| DEBUG_SetLocalSymbolType( curr_loc, DEBUG_ParseStabType(ptr) ); |
| } |
| break; |
| case N_SLINE: |
| /* |
| * This is a line number. These are always relative to the start |
| * of the function (N_FUN), and this makes the lookup easier. |
| */ |
| if( curr_func != NULL && !in_external_file ) |
| { |
| #ifdef __ELF__ |
| DEBUG_AddLineNumber(curr_func, stab_ptr->n_desc, |
| stab_ptr->n_value); |
| #else |
| #if 0 |
| /* |
| * This isn't right. The order of the stabs is different under |
| * a.out, and as a result we would end up attaching the line |
| * number to the wrong function. |
| */ |
| DEBUG_AddLineNumber(curr_func, stab_ptr->n_desc, |
| stab_ptr->n_value - curr_func->addr.off); |
| #endif |
| #endif |
| } |
| break; |
| case N_FUN: |
| /* |
| * First, clean up the previous function we were working on. |
| */ |
| DEBUG_Normalize(curr_func); |
| |
| /* |
| * For now, just declare the various functions. Later |
| * on, we will add the line number information and the |
| * local symbols. |
| */ |
| if( !in_external_file) |
| { |
| stab_strcpy(symname, sizeof(symname), ptr); |
| if (*symname) |
| { |
| new_value.addr.seg = 0; |
| new_value.type = DEBUG_ParseStabType(ptr); |
| new_value.addr.off = (unsigned long)load_offset + stab_ptr->n_value; |
| new_value.cookie = DV_TARGET; |
| /* |
| * Copy the string to a temp buffer so we |
| * can kill everything after the ':'. We do |
| * it this way because otherwise we end up dirtying |
| * all of the pages related to the stabs, and that |
| * sucks up swap space like crazy. |
| */ |
| #ifdef __ELF__ |
| curr_func = DEBUG_AddSymbol( symname, &new_value, currpath, |
| SYM_WINE | SYM_FUNC | SYM_INVALID ); |
| #else |
| curr_func = DEBUG_AddSymbol( symname, &new_value, currpath, |
| SYM_WINE | SYM_FUNC ); |
| #endif |
| } |
| else |
| { |
| /* some GCC seem to use a N_FUN "" to mark the end of a function */ |
| curr_func = NULL; |
| } |
| } |
| else |
| { |
| /* |
| * Don't add line number information for this function |
| * any more. |
| */ |
| curr_func = NULL; |
| } |
| break; |
| case N_SO: |
| /* |
| * This indicates a new source file. Append the records |
| * together, to build the correct path name. |
| */ |
| #ifndef __ELF__ |
| /* |
| * With a.out, there is no NULL string N_SO entry at the end of |
| * the file. Thus when we find non-consecutive entries, |
| * we consider that a new file is started. |
| */ |
| if( last_nso < i-1 ) |
| { |
| currpath[0] = '\0'; |
| DEBUG_Normalize(curr_func); |
| curr_func = NULL; |
| } |
| #endif |
| |
| if( *ptr == '\0' ) /* end of N_SO file */ |
| { |
| /* |
| * Nuke old path. |
| */ |
| currpath[0] = '\0'; |
| DEBUG_Normalize(curr_func); |
| curr_func = NULL; |
| } |
| else |
| { |
| if (*ptr != '/') |
| strcat(currpath, ptr); |
| else |
| strcpy(currpath, ptr); |
| subpath = ptr; |
| DEBUG_ResetIncludes(); |
| } |
| last_nso = i; |
| break; |
| case N_SOL: |
| /* |
| * This indicates we are including stuff from an include file. |
| * If this is the main source, enable the debug stuff, otherwise |
| * ignore it. |
| */ |
| in_external_file = !(subpath == NULL || strcmp(ptr, subpath) == 0); |
| in_external_file = FALSE; /* FIXME EPP hack FIXME */; |
| break; |
| case N_UNDF: |
| strs += strtabinc; |
| strtabinc = stab_ptr->n_value; |
| DEBUG_Normalize(curr_func); |
| curr_func = NULL; |
| break; |
| case N_OPT: |
| /* |
| * Ignore this. We don't care what it points to. |
| */ |
| break; |
| case N_BINCL: |
| DEBUG_AddInclude(DEBUG_CreateInclude(ptr, stab_ptr->n_value)); |
| break; |
| case N_EINCL: |
| break; |
| case N_EXCL: |
| DEBUG_AddInclude(DEBUG_FindInclude(ptr, stab_ptr->n_value)); |
| break; |
| case N_MAIN: |
| /* |
| * Always ignore these. GCC doesn't even generate them. |
| */ |
| break; |
| default: |
| WINE_ERR("Unknown stab type 0x%02x\n", stab_ptr->n_type); |
| break; |
| } |
| |
| stabbuff[0] = '\0'; |
| |
| WINE_TRACE("0x%02x %x %s\n", stab_ptr->n_type, |
| (unsigned int) stab_ptr->n_value, |
| strs + (unsigned int) stab_ptr->n_un.n_name); |
| } |
| |
| DEBUG_FreeIncludes(); |
| |
| return DIL_LOADED; |
| } |
| |
