/* * File hash.c - generate hash tables for Wine debugger symbols * * Copyright (C) 1993, Eric Youngdale. * * 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 */ #include "config.h" #include #include #include #include #include #include "debugger.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(winedbg); WINE_DECLARE_DEBUG_CHANNEL(winedbg_sym); #define NR_NAME_HASH 16384 #ifndef PATH_MAX #define PATH_MAX MAX_PATH #endif #ifdef __i386__ static const char * reg_name[] = { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi" }; static unsigned reg_ofs[] = { FIELD_OFFSET(CONTEXT, Eax), FIELD_OFFSET(CONTEXT, Ecx), FIELD_OFFSET(CONTEXT, Edx), FIELD_OFFSET(CONTEXT, Ebx), FIELD_OFFSET(CONTEXT, Esp), FIELD_OFFSET(CONTEXT, Ebp), FIELD_OFFSET(CONTEXT, Esi), FIELD_OFFSET(CONTEXT, Edi) }; #else static char * reg_name[] = { NULL }; /* FIXME */ static unsigned reg_ofs[] = { 0 }; #endif struct name_hash { struct name_hash * next; /* Used to look up within name hash */ char * name; char * sourcefile; int n_locals; int locals_alloc; WineLocals * local_vars; int n_lines; int lines_alloc; WineLineNo * linetab; DBG_VALUE value; unsigned short flags; unsigned short breakpoint_offset; unsigned int symbol_size; }; static BOOL DEBUG_GetStackSymbolValue( const char * name, DBG_VALUE *value ); static int sortlist_valid = FALSE; static int sorttab_nsym; static struct name_hash ** addr_sorttab = NULL; static struct name_hash * name_hash_table[NR_NAME_HASH]; static unsigned int name_hash( const char * name ) { unsigned int hash = 0; unsigned int tmp; const char * p; p = name; while (*p) { hash = (hash << 4) + *p++; if( (tmp = (hash & 0xf0000000)) ) { hash ^= tmp >> 24; } hash &= ~tmp; } return hash % NR_NAME_HASH; } int DEBUG_cmp_sym(const void * p1, const void * p2) { struct name_hash * name1 = *(struct name_hash **) p1; struct name_hash * name2 = *(struct name_hash **) p2; if( (name1->flags & SYM_INVALID) != 0 ) return -1; if( (name2->flags & SYM_INVALID) != 0 ) return 1; if( name1->value.addr.seg > name2->value.addr.seg ) return 1; if( name1->value.addr.seg < name2->value.addr.seg ) return -1; if( name1->value.addr.off > name2->value.addr.off ) return 1; if( name1->value.addr.off < name2->value.addr.off ) return -1; return 0; } /*********************************************************************** * DEBUG_ResortSymbols * * Rebuild sorted list of symbols. */ static void DEBUG_ResortSymbols(void) { struct name_hash *nh; int nsym = 0; int i; for(i=0; inext) { if( (nh->flags & SYM_INVALID) == 0 ) nsym++; else DEBUG_Printf("Symbol %s (%04lx:%08lx) is invalid\n", nh->name, nh->value.addr.seg, nh->value.addr.off ); } } sorttab_nsym = nsym; if( nsym == 0 ) { return; } addr_sorttab = (struct name_hash **) DBG_realloc(addr_sorttab, nsym * sizeof(struct name_hash *)); nsym = 0; for(i=0; inext) { if( (nh->flags & SYM_INVALID) == 0 ) addr_sorttab[nsym++] = nh; } } qsort(addr_sorttab, nsym, sizeof(struct name_hash *), DEBUG_cmp_sym); sortlist_valid = TRUE; } /*********************************************************************** * DEBUG_AddSymbol * * Add a symbol to the table. */ struct name_hash * DEBUG_AddSymbol( const char * name, const DBG_VALUE *value, const char * source, int flags) { struct name_hash * new; struct name_hash *nh; static char prev_source[PATH_MAX] = {'\0', }; static char * prev_duped_source = NULL; int hash; assert(value->cookie == DV_TARGET || value->cookie == DV_HOST); hash = name_hash(name); for (nh = name_hash_table[hash]; nh; nh = nh->next) { if (name[0] == nh->name[0] && strcmp(name, nh->name) == 0) { int c = memcmp(&nh->value.addr, &value->addr, sizeof(value->addr)); if ((nh->flags & SYM_INVALID) != 0) { /* this case happens in ELF files, where we don't get the * address of a symbol for the stabs part, but rather from * the ELF sections. in this case, we'll call this function * twice: * - a first time while parsing the stabs, with a NULL * address * - a second time with the correct address * SYM_INVALID is set for the first pass, and cleared in the second * the code below gets most of information for both passes * * some GCC versions may provide the correct address in the first pass * but it does not seem to be sensible to rely on that. */ if (nh->value.addr.seg == 0 && nh->value.addr.off == 0 && c != 0) { WINE_TRACE_(winedbg_sym)( "Changing address for symbol %s (%04lx:%08lx => %04lx:%08lx)\n", name, nh->value.addr.seg, nh->value.addr.off, value->addr.seg, value->addr.off); nh->value.addr = value->addr; } if (nh->value.type == NULL && value->type != NULL) { nh->value.type = value->type; nh->value.cookie = value->cookie; } /* it may happen that the same symbol is defined in several compilation * units, but the linker decides to merge it into a single instance. * in that case, we don't clear the invalid flag for all the compilation * units (N_GSYM), and wait to get the symbol from the symtab */ if ((flags & SYM_INVALID) == 0) nh->flags &= ~SYM_INVALID; return nh; } /* don't define a symbol twice */ if (c == 0 && (flags & SYM_INVALID) == 0) return nh; } } WINE_TRACE_(winedbg_sym)( "adding %s symbol (%s) from file '%s' at %04lx:%08lx\n", (flags & SYM_INVALID) ? "invalid" : " valid", name, source, value->addr.seg, value->addr.off); /* * First see if we already have an entry for this symbol. If so * return it, so we don't end up with duplicates. */ new = (struct name_hash *) DBG_alloc(sizeof(struct name_hash)); new->value = *value; new->name = DBG_strdup(name); if( source != NULL ) { /* * This is an enhancement to reduce memory consumption. The idea * is that we duplicate a given string only once. This is a big * win if there are lots of symbols defined in a given source file. */ if( strcmp(source, prev_source) == 0 ) { new->sourcefile = prev_duped_source; } else { strcpy(prev_source, source); prev_duped_source = new->sourcefile = DBG_strdup(source); } } else { new->sourcefile = NULL; } new->n_lines = 0; new->lines_alloc = 0; new->linetab = NULL; new->n_locals = 0; new->locals_alloc = 0; new->local_vars = NULL; new->flags = flags; new->next = NULL; /* Now insert into the hash table */ new->next = name_hash_table[hash]; name_hash_table[hash] = new; /* * Check some heuristics based upon the file name to see whether * we want to step through this guy or not. These are machine generated * assembly files that are used to translate between the MS way of * calling things and the GCC way of calling things. In general we * always want to step through. */ if ( source != NULL ) { int len = strlen(source); if (len > 2 && source[len-2] == '.' && source[len-1] == 's') { char* c = strrchr(source - 2, '/'); if (c != NULL) { if (strcmp(c + 1, "asmrelay.s") == 0) new->flags |= SYM_TRAMPOLINE; } } } sortlist_valid = FALSE; return new; } BOOL DEBUG_Normalize(struct name_hash * nh ) { /* * We aren't adding any more locals or linenumbers to this function. * Free any spare memory that we might have allocated. */ if( nh == NULL ) { return TRUE; } if( nh->n_locals != nh->locals_alloc ) { nh->locals_alloc = nh->n_locals; nh->local_vars = DBG_realloc(nh->local_vars, nh->locals_alloc * sizeof(WineLocals)); } if( nh->n_lines != nh->lines_alloc ) { nh->lines_alloc = nh->n_lines; nh->linetab = DBG_realloc(nh->linetab, nh->lines_alloc * sizeof(WineLineNo)); } return TRUE; } /*********************************************************************** * DEBUG_GetSymbolValue * * Get the address of a named symbol. * Return values: * gsv_found: if the symbol is found * gsv_unknown: if the symbol isn't found * gsv_aborted: some error occurred (likely, many symbols of same name exist, * and user didn't pick one of them) */ static int DEBUG_GSV_Helper(const char* name, const int lineno, DBG_VALUE* value, int num, int bp_flag) { struct name_hash* nh; int i = 0; DBG_ADDR addr; for (nh = name_hash_table[name_hash(name)]; nh; nh = nh->next) { if ((nh->flags & SYM_INVALID) != 0) continue; if (!strcmp(nh->name, name) && DEBUG_GetLineNumberAddr( nh, lineno, &addr, bp_flag )) { if (i >= num) return num + 1; value[i].addr = addr; value[i].type = nh->value.type; value[i].cookie = nh->value.cookie; i++; } } return i; } enum get_sym_val DEBUG_GetSymbolValue( const char * name, const int lineno, DBG_VALUE *rtn, int bp_flag ) { #define NUMDBGV 100 /* FIXME: NUMDBGV should be made variable */ DBG_VALUE value[NUMDBGV]; DBG_VALUE vtmp; int num, i, local = -1; num = DEBUG_GSV_Helper(name, lineno, value, NUMDBGV, bp_flag); if (!num && (name[0] != '_')) { char buffer[512]; if (strlen(name) < sizeof(buffer) - 2) /* one for '_', one for '\0' */ { buffer[0] = '_'; strcpy(buffer + 1, name); num = DEBUG_GSV_Helper(buffer, lineno, value, NUMDBGV, bp_flag); } else WINE_WARN("Way too long symbol (%s)\n", name); } /* now get the local symbols if any */ if (DEBUG_GetStackSymbolValue(name, &vtmp) && num < NUMDBGV) { value[num] = vtmp; local = num; num++; } if (num == 0) { return gsv_unknown; } else if (!DEBUG_InteractiveP || num == 1) { i = 0; } else { char buffer[256]; if (num == NUMDBGV+1) { DEBUG_Printf("Too many addresses for symbol '%s', limiting the first %d\n", name, NUMDBGV); num = NUMDBGV; } DEBUG_Printf("Many symbols with name '%s', choose the one you want ( to abort):\n", name); for (i = 0; i < num; i++) { DEBUG_Printf("[%d]: ", i + 1); if (i == local) { struct name_hash*func; unsigned int ebp; unsigned int eip; if (DEBUG_GetCurrentFrame(&func, &eip, &ebp)) DEBUG_Printf("local variable of %s in %s\n", func->name, func->sourcefile); else DEBUG_Printf("local variable\n"); } else { DEBUG_PrintAddress( &value[i].addr, DEBUG_GetSelectorType(value[i].addr.seg), TRUE); DEBUG_Printf("\n"); } } do { i = 0; if (DEBUG_ReadLine("=> ", buffer, sizeof(buffer))) { if (buffer[0] == '\0') return gsv_aborted; i = atoi(buffer); if (i < 1 || i > num) DEBUG_Printf("Invalid choice %d\n", i); } } while (i < 1 || i > num); /* The array is 0-based, but the choices are 1..n, so we have to subtract one before returning. */ i--; } *rtn = value[i]; return gsv_found; } /*********************************************************************** * DEBUG_GetLineNumberAddr * * Get the address of a named symbol. */ BOOL DEBUG_GetLineNumberAddr( const struct name_hash * nh, const int lineno, DBG_ADDR *addr, int bp_flag ) { int i; if( lineno == -1 ) { *addr = nh->value.addr; if( bp_flag ) { addr->off += nh->breakpoint_offset; } } else { /* * Search for the specific line number. If we don't find it, * then return FALSE. */ if( nh->linetab == NULL ) { return FALSE; } for(i=0; i < nh->n_lines; i++ ) { if( nh->linetab[i].line_number == lineno ) { *addr = nh->linetab[i].pc_offset; return TRUE; } } /* * This specific line number not found. */ return FALSE; } return TRUE; } /*********************************************************************** * DEBUG_FindNearestSymbol * * Find the symbol nearest to a given address. * If ebp is specified as non-zero, it means we should dump the argument * list into the string we return as well. */ const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag, struct name_hash ** rtn, unsigned int ebp, struct list_id * source) { static char name_buffer[MAX_PATH + 256]; static char arglist[1024]; static char argtmp[256]; struct name_hash * nearest = NULL; int mid, high, low; unsigned int * ptr; int lineno; const char * lineinfo; char *sourcefile; int i; char linebuff[16]; unsigned val; DBG_MODULE* module; char modbuf[256]; if( rtn != NULL ) { *rtn = NULL; } if( source != NULL ) { source->sourcefile = NULL; source->line = -1; } if( sortlist_valid == FALSE ) { DEBUG_ResortSymbols(); } if( sortlist_valid == FALSE ) { return NULL; } /* * FIXME - use the binary search that we added to * the function DEBUG_CheckLinenoStatus. Better yet, we should * probably keep some notion of the current function so we don't * have to search every time. */ /* * Binary search to find closest symbol. */ low = 0; high = sorttab_nsym; if( addr_sorttab[0]->value.addr.seg > addr->seg || ( addr_sorttab[0]->value.addr.seg == addr->seg && addr_sorttab[0]->value.addr.off > addr->off) ) { nearest = NULL; } else if( addr_sorttab[high - 1]->value.addr.seg < addr->seg || ( addr_sorttab[high - 1]->value.addr.seg == addr->seg && addr_sorttab[high - 1]->value.addr.off < addr->off) ) { nearest = addr_sorttab[high - 1]; } else { while(1==1) { mid = (high + low)/2; if( mid == low ) { /* * See if there are any other entries that might also * have the same address, and would also have a line * number table. */ if( mid > 0 && addr_sorttab[mid]->linetab == NULL ) { if( (addr_sorttab[mid - 1]->value.addr.seg == addr_sorttab[mid]->value.addr.seg) && (addr_sorttab[mid - 1]->value.addr.off == addr_sorttab[mid]->value.addr.off) && (addr_sorttab[mid - 1]->linetab != NULL) ) { mid--; } } if( (mid < sorttab_nsym - 1) && (addr_sorttab[mid]->linetab == NULL) ) { if( (addr_sorttab[mid + 1]->value.addr.seg == addr_sorttab[mid]->value.addr.seg) && (addr_sorttab[mid + 1]->value.addr.off == addr_sorttab[mid]->value.addr.off) && (addr_sorttab[mid + 1]->linetab != NULL) ) { mid++; } } nearest = addr_sorttab[mid]; WINE_TRACE_(winedbg_sym)( "Found %lx:%lx when looking for %lx:%lx %p %s\n", addr_sorttab[mid ]->value.addr.seg, addr_sorttab[mid ]->value.addr.off, addr->seg, addr->off, addr_sorttab[mid ]->linetab, addr_sorttab[mid ]->name); break; } if( (addr_sorttab[mid]->value.addr.seg < addr->seg) || ( addr_sorttab[mid]->value.addr.seg == addr->seg && addr_sorttab[mid]->value.addr.off <= addr->off) ) { low = mid; } else { high = mid; } } } if (!nearest) return NULL; if( rtn != NULL ) { *rtn = nearest; } /* * Fill in the relevant bits to the structure so that we can * locate the source and line for this bit of code. */ if( source != NULL ) { source->sourcefile = nearest->sourcefile; if( nearest->linetab == NULL ) { source->line = -1; } else { source->line = nearest->linetab[0].line_number; } } lineinfo = ""; lineno = -1; /* * Prepare to display the argument list. If ebp is specified, it is * the framepointer for the function in question. If not specified, * we don't want the arglist. */ memset(arglist, '\0', sizeof(arglist)); if( ebp != 0 ) { for(i=0; i < nearest->n_locals; i++ ) { /* * If this is a register (offset == 0) or a local * variable, we don't want to know about it. */ if( nearest->local_vars[i].offset <= 0 ) { continue; } ptr = (unsigned int *) (ebp + nearest->local_vars[i].offset); if( arglist[0] == '\0' ) { arglist[0] = '('; } else { strcat(arglist, ", "); } DEBUG_READ_MEM_VERBOSE(ptr, &val, sizeof(val)); snprintf(argtmp, sizeof(argtmp), "%s=0x%x", nearest->local_vars[i].name, val); strcat(arglist, argtmp); } if( arglist[0] == '(' ) { strcat(arglist, ")"); } } module = DEBUG_FindModuleByAddr((void*)DEBUG_ToLinear(addr), DMT_UNKNOWN); if (module) { char *p, *name = module->module_name; if ((p = strrchr(name, '/'))) name = p + 1; if ((p = strrchr(name, '\\'))) name = p + 1; snprintf( modbuf, sizeof(modbuf), " in %s", name); } else modbuf[0] = '\0'; if( (nearest->sourcefile != NULL) && (flag == TRUE) && (addr->off - nearest->value.addr.off < 0x100000) ) { /* * Try and find the nearest line number to the current offset. */ if( nearest->linetab != NULL ) { low = 0; high = nearest->n_lines; while ((high - low) > 1) { mid = (high + low) / 2; if (addr->off < nearest->linetab[mid].pc_offset.off) high = mid; else low = mid; } lineno = nearest->linetab[low].line_number; } if( lineno != -1 ) { snprintf(linebuff, sizeof(linebuff), ":%d", lineno); lineinfo = linebuff; if( source != NULL ) { source->line = lineno; } } /* Remove the path from the file name */ sourcefile = strrchr( nearest->sourcefile, '/' ); if (!sourcefile) sourcefile = nearest->sourcefile; else sourcefile++; if (addr->off == nearest->value.addr.off) snprintf( name_buffer, sizeof(name_buffer), "%s%s [%s%s]%s", nearest->name, arglist, sourcefile, lineinfo, modbuf); else snprintf( name_buffer, sizeof(name_buffer), "%s+0x%lx%s [%s%s]%s", nearest->name, addr->off - nearest->value.addr.off, arglist, sourcefile, lineinfo, modbuf ); } else { if (addr->off == nearest->value.addr.off) snprintf( name_buffer, sizeof(name_buffer), "%s%s%s", nearest->name, arglist, modbuf); else { if (addr->seg && (nearest->value.addr.seg!=addr->seg)) return NULL; else snprintf( name_buffer, sizeof(name_buffer), "%s+0x%lx%s%s", nearest->name, addr->off - nearest->value.addr.off, arglist, modbuf); } } return name_buffer; } /*********************************************************************** * DEBUG_ReadSymbolTable * * Read a symbol file into the hash table. */ void DEBUG_ReadSymbolTable( const char* filename, unsigned long offset ) { FILE * symbolfile; DBG_VALUE value; char type; char * cpnt; char buffer[256]; char name[256]; if (!(symbolfile = fopen(filename, "r"))) { WINE_WARN("Unable to open symbol table %s\n", filename); return; } DEBUG_Printf("Reading symbols from file %s\n", filename); value.type = NULL; value.addr.seg = 0; value.addr.off = 0; value.cookie = DV_TARGET; while (1) { fgets( buffer, sizeof(buffer), symbolfile ); if (feof(symbolfile)) break; /* Strip any text after a # sign (i.e. comments) */ cpnt = buffer; while (*cpnt) if(*cpnt++ == '#') { *cpnt = 0; break; } /* Quietly ignore any lines that have just whitespace */ cpnt = buffer; while(*cpnt) { if(*cpnt != ' ' && *cpnt != '\t') break; cpnt++; } if (!(*cpnt) || *cpnt == '\n') continue; if (sscanf(buffer, "%lx %c %s", &value.addr.off, &type, name) == 3) { if (value.addr.off + offset < value.addr.off) WINE_WARN("Address wrap around\n"); value.addr.off += offset; DEBUG_AddSymbol( name, &value, NULL, SYM_WINE ); } } fclose(symbolfile); } void DEBUG_AddLineNumber( struct name_hash * func, int line_num, unsigned long offset ) { if( func == NULL ) { return; } if( func->n_lines + 1 >= func->lines_alloc ) { func->lines_alloc += 64; func->linetab = DBG_realloc(func->linetab, func->lines_alloc * sizeof(WineLineNo)); } func->linetab[func->n_lines].line_number = line_num; func->linetab[func->n_lines].pc_offset.seg = func->value.addr.seg; func->linetab[func->n_lines].pc_offset.off = func->value.addr.off + offset; func->n_lines++; } struct wine_locals * DEBUG_AddLocal( struct name_hash * func, int regno, int offset, int pc_start, int pc_end, char * name) { if( func == NULL ) { return NULL; } if( func->n_locals + 1 >= func->locals_alloc ) { func->locals_alloc += 32; func->local_vars = DBG_realloc(func->local_vars, func->locals_alloc * sizeof(WineLocals)); } func->local_vars[func->n_locals].regno = regno; func->local_vars[func->n_locals].offset = offset; func->local_vars[func->n_locals].pc_start = pc_start; func->local_vars[func->n_locals].pc_end = pc_end; func->local_vars[func->n_locals].name = DBG_strdup(name); func->local_vars[func->n_locals].type = NULL; func->n_locals++; return &func->local_vars[func->n_locals - 1]; } void DEBUG_DumpHashInfo(void) { int i; int depth; struct name_hash *nh; /* * Utility function to dump stats about the hash table. */ for(i=0; inext) { depth++; } DEBUG_Printf("Bucket %d: %d\n", i, depth); } } /*********************************************************************** * DEBUG_CheckLinenoStatus * * Find the symbol nearest to a given address. * If ebp is specified as non-zero, it means we should dump the argument * list into the string we return as well. */ int DEBUG_CheckLinenoStatus( const DBG_ADDR *addr) { struct name_hash * nearest = NULL; int mid, high, low; if( sortlist_valid == FALSE ) { DEBUG_ResortSymbols(); } /* * Binary search to find closest symbol. */ low = 0; high = sorttab_nsym; if( addr_sorttab[0]->value.addr.seg > addr->seg || ( addr_sorttab[0]->value.addr.seg == addr->seg && addr_sorttab[0]->value.addr.off > addr->off) ) { nearest = NULL; } else if( addr_sorttab[high - 1]->value.addr.seg < addr->seg || ( addr_sorttab[high - 1]->value.addr.seg == addr->seg && addr_sorttab[high - 1]->value.addr.off < addr->off) ) { nearest = addr_sorttab[high - 1]; } else { while(1==1) { mid = (high + low)/2; if( mid == low ) { /* * See if there are any other entries that might also * have the same address, and would also have a line * number table. */ if( mid > 0 && addr_sorttab[mid]->linetab == NULL ) { if( (addr_sorttab[mid - 1]->value.addr.seg == addr_sorttab[mid]->value.addr.seg) && (addr_sorttab[mid - 1]->value.addr.off == addr_sorttab[mid]->value.addr.off) && (addr_sorttab[mid - 1]->linetab != NULL) ) { mid--; } } if( (mid < sorttab_nsym - 1) && (addr_sorttab[mid]->linetab == NULL) ) { if( (addr_sorttab[mid + 1]->value.addr.seg == addr_sorttab[mid]->value.addr.seg) && (addr_sorttab[mid + 1]->value.addr.off == addr_sorttab[mid]->value.addr.off) && (addr_sorttab[mid + 1]->linetab != NULL) ) { mid++; } } nearest = addr_sorttab[mid]; WINE_TRACE_(winedbg_sym)( "Found %lx:%lx when looking for %lx:%lx %p %s\n", addr_sorttab[mid ]->value.addr.seg, addr_sorttab[mid ]->value.addr.off, addr->seg, addr->off, addr_sorttab[mid ]->linetab, addr_sorttab[mid ]->name); break; } if( (addr_sorttab[mid]->value.addr.seg < addr->seg) || ( addr_sorttab[mid]->value.addr.seg == addr->seg && addr_sorttab[mid]->value.addr.off <= addr->off) ) { low = mid; } else { high = mid; } } } if (!nearest) return FUNC_HAS_NO_LINES; if( nearest->flags & SYM_STEP_THROUGH ) { /* * This will cause us to keep single stepping until * we get to the other side somewhere. */ return NOT_ON_LINENUMBER; } if( (nearest->flags & SYM_TRAMPOLINE) ) { /* * This will cause us to keep single stepping until * we get to the other side somewhere. */ return FUNC_IS_TRAMPOLINE; } if( nearest->linetab == NULL ) { return FUNC_HAS_NO_LINES; } /* * We never want to stop on the first instruction of a function * even if it has it's own linenumber. Let the thing keep running * until it gets past the function prologue. We only do this if there * is more than one line number for the function, of course. */ if( nearest->value.addr.off == addr->off && nearest->n_lines > 1 ) { return NOT_ON_LINENUMBER; } if( (nearest->sourcefile != NULL) && (addr->off - nearest->value.addr.off < 0x100000) ) { low = 0; high = nearest->n_lines; while ((high - low) > 1) { mid = (high + low) / 2; if (addr->off < nearest->linetab[mid].pc_offset.off) high = mid; else low = mid; } if (addr->off == nearest->linetab[low].pc_offset.off) return AT_LINENUMBER; else return NOT_ON_LINENUMBER; } return FUNC_HAS_NO_LINES; } /*********************************************************************** * DEBUG_GetFuncInfo * * Find the symbol nearest to a given address. * Returns sourcefile name and line number in a format that the listing * handler can deal with. */ void DEBUG_GetFuncInfo( struct list_id * ret, const char * filename, const char * name) { char buffer[256]; char * pnt; struct name_hash *nh; for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next) { if( filename != NULL ) { if( nh->sourcefile == NULL ) { continue; } pnt = strrchr(nh->sourcefile, '/'); if( strcmp(nh->sourcefile, filename) != 0 && (pnt == NULL || strcmp(pnt + 1, filename) != 0) ) { continue; } } if (!strcmp(nh->name, name)) break; } if (!nh && (name[0] != '_')) { buffer[0] = '_'; strcpy(buffer+1, name); for(nh = name_hash_table[name_hash(buffer)]; nh; nh = nh->next) { if( filename != NULL ) { if( nh->sourcefile == NULL ) { continue; } pnt = strrchr(nh->sourcefile, '/'); if( strcmp(nh->sourcefile, filename) != 0 && (pnt == NULL || strcmp(pnt + 1, filename) != 0) ) { continue; } } if (!strcmp(nh->name, buffer)) break; } } if( !nh ) { if( filename != NULL ) { DEBUG_Printf("No such function %s in %s\n", name, filename); } else { DEBUG_Printf("No such function %s\n", name); } ret->sourcefile = NULL; ret->line = -1; return; } ret->sourcefile = nh->sourcefile; /* * Search for the specific line number. If we don't find it, * then return FALSE. */ if( nh->linetab == NULL ) { ret->line = -1; } else { ret->line = nh->linetab[0].line_number; } } /*********************************************************************** * DEBUG_GetStackSymbolValue * * Get the address of a named symbol from the current stack frame. */ static BOOL DEBUG_GetStackSymbolValue( const char * name, DBG_VALUE *value ) { struct name_hash * curr_func; unsigned int ebp; unsigned int eip; int i; if( DEBUG_GetCurrentFrame(&curr_func, &eip, &ebp) == FALSE ) { return FALSE; } for(i=0; i < curr_func->n_locals; i++ ) { /* * Test the range of validity of the local variable. This * comes up with RBRAC/LBRAC stabs in particular. */ if( (curr_func->local_vars[i].pc_start != 0) && ((eip - curr_func->value.addr.off) < curr_func->local_vars[i].pc_start) ) { continue; } if( (curr_func->local_vars[i].pc_end != 0) && ((eip - curr_func->value.addr.off) > curr_func->local_vars[i].pc_end) ) { continue; } if( strcmp(name, curr_func->local_vars[i].name) == 0 ) { /* * OK, we found it. Now figure out what to do with this. */ if( curr_func->local_vars[i].regno != 0 ) { /* * Register variable. Point to DEBUG_context field. */ assert(curr_func->local_vars[i].regno - 1 < sizeof(reg_ofs)/sizeof(reg_ofs[0])); value->addr.off = ((DWORD)&DEBUG_context) + reg_ofs[curr_func->local_vars[i].regno - 1]; value->cookie = DV_HOST; } else { value->addr.off = ebp + curr_func->local_vars[i].offset; value->cookie = DV_TARGET; } value->addr.seg = 0; value->type = curr_func->local_vars[i].type; return TRUE; } } return FALSE; } int DEBUG_InfoLocals(void) { struct name_hash * curr_func; unsigned int ebp; unsigned int eip; int i; unsigned int * ptr; unsigned int val; if( DEBUG_GetCurrentFrame(&curr_func, &eip, &ebp) == FALSE ) { return FALSE; } DEBUG_Printf("%s:\n", curr_func->name); for(i=0; i < curr_func->n_locals; i++ ) { /* * Test the range of validity of the local variable. This * comes up with RBRAC/LBRAC stabs in particular. */ if( (curr_func->local_vars[i].pc_start != 0) && ((eip - curr_func->value.addr.off) < curr_func->local_vars[i].pc_start) ) { continue; } if( (curr_func->local_vars[i].pc_end != 0) && ((eip - curr_func->value.addr.off) > curr_func->local_vars[i].pc_end) ) { continue; } DEBUG_PrintTypeCast(curr_func->local_vars[i].type); if( curr_func->local_vars[i].regno != 0 ) { ptr = (unsigned int *)(((DWORD)&DEBUG_context) + reg_ofs[curr_func->local_vars[i].regno - 1]); DEBUG_Printf(" %s (optimized into register $%s) == 0x%8.8x\n", curr_func->local_vars[i].name, reg_name[curr_func->local_vars[i].regno - 1], *ptr); } else { DEBUG_READ_MEM_VERBOSE((void*)(ebp + curr_func->local_vars[i].offset), &val, sizeof(val)); DEBUG_Printf(" %s == 0x%8.8x\n", curr_func->local_vars[i].name, val); } } return TRUE; } int DEBUG_SetSymbolSize(struct name_hash * sym, unsigned int len) { sym->symbol_size = len; return TRUE; } int DEBUG_SetSymbolBPOff(struct name_hash * sym, unsigned int off) { sym->breakpoint_offset = off; return TRUE; } int DEBUG_GetSymbolAddr(struct name_hash * sym, DBG_ADDR * addr) { *addr = sym->value.addr; return TRUE; } int DEBUG_SetLocalSymbolType(struct wine_locals * sym, struct datatype * type) { sym->type = type; return TRUE; } const char *DEBUG_GetSymbolName(const struct name_hash * sym) { return sym->name; } #ifdef HAVE_REGEX_H static int cmp_sym_by_name(const void * p1, const void * p2) { struct name_hash ** name1 = (struct name_hash **) p1; struct name_hash ** name2 = (struct name_hash **) p2; return strcmp( (*name1)->name, (*name2)->name ); } #include void DEBUG_InfoSymbols(const char* str) { int i; struct name_hash* nh; struct name_hash** array = NULL; unsigned num_used_array = 0; unsigned num_alloc_array = 0; const char* name; enum dbg_mode mode; regex_t preg; regcomp(&preg, str, REG_NOSUB); /* grab all symbols */ for (i = 0; i < NR_NAME_HASH; i++) { for (nh = name_hash_table[i]; nh; nh = nh->next) { if (regexec(&preg, nh->name, 0, NULL, 0) == 0) { if (num_used_array == num_alloc_array) { int size = sizeof(*array) * (num_alloc_array += 32); if (!array) array = HeapAlloc(GetProcessHeap(), 0, size); else array = HeapReAlloc(GetProcessHeap(), 0, array, size); if (!array) return; } array[num_used_array++] = nh; } } } regfree(&preg); /* now sort them by alphabetical order */ qsort(array, num_used_array, sizeof(*array), cmp_sym_by_name); /* and display them */ for (i = 0; i < num_used_array; i++) { mode = DEBUG_GetSelectorType(array[i]->value.addr.seg); name = DEBUG_FindNearestSymbol( &array[i]->value.addr, TRUE, NULL, 0, NULL ); if (mode != MODE_32) DEBUG_Printf("%04lx:%04lx :", array[i]->value.addr.seg & 0xFFFF, array[i]->value.addr.off); else DEBUG_Printf("%08lx :", array[i]->value.addr.off); if (array[i]->value.type) { DEBUG_Printf(" ("); DEBUG_PrintTypeCast(array[i]->value.type); DEBUG_Printf(")"); } if (name) DEBUG_Printf(" %s\n", name); } HeapFree(GetProcessHeap(), 0, array); } #else /* HAVE_REGEX_H */ void DEBUG_InfoSymbols(const char* str) { WINE_FIXME("Requires regex support\n"); } #endif /* HAVE_REGEX_H */