| /* |
| * File hash.c - generate hash tables for Wine debugger symbols |
| * |
| * Copyright (C) 1993, Eric Youngdale. |
| */ |
| |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <neexe.h> |
| #include "module.h" |
| #include "selectors.h" |
| #include "debugger.h" |
| #include "toolhelp.h" |
| #include "xmalloc.h" |
| |
| struct name_hash |
| { |
| struct name_hash * next; |
| char * name; |
| DBG_ADDR addr; |
| }; |
| |
| #define NR_NAME_HASH 128 |
| |
| static struct name_hash * name_hash_table[NR_NAME_HASH]; |
| |
| static unsigned int name_hash( const char * name ) |
| { |
| unsigned int hash = 0; |
| const char * p; |
| |
| p = name; |
| |
| while (*p) hash = (hash << 15) + (hash << 3) + (hash >> 3) + *p++; |
| return hash % NR_NAME_HASH; |
| } |
| |
| |
| /*********************************************************************** |
| * DEBUG_AddSymbol |
| * |
| * Add a symbol to the table. |
| */ |
| void DEBUG_AddSymbol( const char * name, const DBG_ADDR *addr ) |
| { |
| struct name_hash * new; |
| int hash; |
| |
| new = (struct name_hash *) xmalloc(sizeof(struct name_hash)); |
| new->addr = *addr; |
| new->name = xstrdup(name); |
| new->next = NULL; |
| hash = name_hash(name); |
| |
| /* Now insert into the hash table */ |
| new->next = name_hash_table[hash]; |
| name_hash_table[hash] = new; |
| } |
| |
| |
| /*********************************************************************** |
| * DEBUG_GetSymbolValue |
| * |
| * Get the address of a named symbol. |
| */ |
| BOOL32 DEBUG_GetSymbolValue( const char * name, DBG_ADDR *addr ) |
| { |
| char buffer[256]; |
| struct name_hash *nh; |
| |
| for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next) |
| 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 (!strcmp(nh->name, buffer)) break; |
| } |
| |
| if (!nh) return FALSE; |
| *addr = nh->addr; |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * DEBUG_SetSymbolValue |
| * |
| * Set the address of a named symbol. |
| */ |
| BOOL32 DEBUG_SetSymbolValue( const char * name, const DBG_ADDR *addr ) |
| { |
| char buffer[256]; |
| struct name_hash *nh; |
| |
| for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next) |
| 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 (!strcmp(nh->name, buffer)) break; |
| } |
| |
| if (!nh) return FALSE; |
| nh->addr = *addr; |
| DBG_FIX_ADDR_SEG( &nh->addr, DS_reg(DEBUG_context) ); |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * DEBUG_FindNearestSymbol |
| * |
| * Find the symbol nearest to a given address. |
| */ |
| const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr ) |
| { |
| static char name_buffer[256]; |
| struct name_hash * nearest = NULL; |
| struct name_hash * nh; |
| unsigned int nearest_address = 0; |
| int i; |
| |
| for(i=0; i<NR_NAME_HASH; i++) |
| { |
| for (nh = name_hash_table[i]; nh; nh = nh->next) |
| if (nh->addr.seg == addr->seg && |
| nh->addr.off <= addr->off && |
| nh->addr.off >= nearest_address) |
| { |
| nearest_address = nh->addr.off; |
| nearest = nh; |
| } |
| } |
| if (!nearest) return NULL; |
| |
| if (addr->off == nearest->addr.off) |
| sprintf( name_buffer, "%s", nearest->name ); |
| else |
| sprintf( name_buffer, "%s+0x%lx", nearest->name, |
| addr->off - nearest->addr.off ); |
| return name_buffer; |
| } |
| |
| |
| /*********************************************************************** |
| * DEBUG_ReadSymbolTable |
| * |
| * Read a symbol file into the hash table. |
| */ |
| void DEBUG_ReadSymbolTable( const char * filename ) |
| { |
| FILE * symbolfile; |
| DBG_ADDR addr = { 0, 0 }; |
| int nargs; |
| char type; |
| char * cpnt; |
| char buffer[256]; |
| char name[256]; |
| |
| if (!(symbolfile = fopen(filename, "r"))) |
| { |
| fprintf( stderr, "Unable to open symbol table %s\n", filename ); |
| return; |
| } |
| |
| fprintf( stderr, "Reading symbols from file %s\n", filename ); |
| |
| 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; |
| |
| nargs = sscanf(buffer, "%lx %c %s", &addr.off, &type, name); |
| DEBUG_AddSymbol( name, &addr ); |
| } |
| fclose(symbolfile); |
| } |
| |
| |
| /*********************************************************************** |
| * DEBUG_LoadEntryPoints |
| * |
| * Load the entry points of all the modules into the hash table. |
| */ |
| void DEBUG_LoadEntryPoints(void) |
| { |
| MODULEENTRY entry; |
| NE_MODULE *pModule; |
| DBG_ADDR addr; |
| char buffer[256]; |
| unsigned char *cpnt, *name; |
| FARPROC16 address; |
| BOOL ok; |
| |
| for (ok = ModuleFirst(&entry); ok; ok = ModuleNext(&entry)) |
| { |
| if (!(pModule = MODULE_GetPtr( entry.hModule ))) continue; |
| |
| name = (unsigned char *)pModule + pModule->name_table; |
| |
| /* First search the resident names */ |
| |
| cpnt = (unsigned char *)pModule + pModule->name_table; |
| while (*cpnt) |
| { |
| cpnt += *cpnt + 1 + sizeof(WORD); |
| sprintf( buffer, "%*.*s.%*.*s", *name, *name, name + 1, |
| *cpnt, *cpnt, cpnt + 1 ); |
| if ((address = MODULE_GetEntryPoint( entry.hModule, |
| *(WORD *)(cpnt + *cpnt + 1) ))) |
| { |
| addr.seg = HIWORD(address); |
| addr.off = LOWORD(address); |
| DEBUG_AddSymbol( buffer, &addr ); |
| } |
| } |
| |
| /* Now search the non-resident names table */ |
| |
| if (!pModule->nrname_handle) continue; /* No non-resident table */ |
| cpnt = (char *)GlobalLock16( pModule->nrname_handle ); |
| while (*cpnt) |
| { |
| cpnt += *cpnt + 1 + sizeof(WORD); |
| sprintf( buffer, "%*.*s.%*.*s", *name, *name, name + 1, |
| *cpnt, *cpnt, cpnt + 1 ); |
| if ((address = MODULE_GetEntryPoint( entry.hModule, |
| *(WORD *)(cpnt + *cpnt + 1) ))) |
| { |
| addr.seg = HIWORD(address); |
| addr.off = LOWORD(address); |
| DEBUG_AddSymbol( buffer, &addr ); |
| } |
| } |
| } |
| } |