2 * File hash.c - generate hash tables for Wine debugger symbols
4 * Copyright (C) 1993, Eric Youngdale.
12 #include <sys/types.h>
16 #include "selectors.h"
21 #define NR_NAME_HASH 16384
23 #define PATH_MAX _MAX_PATH
26 static char * reg_name[] =
28 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"
34 struct name_hash * next; /* Used to look up within name hash */
40 WineLocals * local_vars;
48 unsigned short breakpoint_offset;
49 unsigned int symbol_size;
53 static BOOL32 DEBUG_GetStackSymbolValue( const char * name, DBG_ADDR *addr );
54 static int sortlist_valid = FALSE;
56 static int sorttab_nsym;
57 static struct name_hash ** addr_sorttab = NULL;
59 static struct name_hash * name_hash_table[NR_NAME_HASH];
61 static unsigned int name_hash( const char * name )
63 unsigned int hash = 0;
71 hash = (hash << 4) + *p++;
73 if( (tmp = (hash & 0xf0000000)) )
79 return hash % NR_NAME_HASH;
83 DEBUG_cmp_sym(const void * p1, const void * p2)
85 struct name_hash ** name1 = (struct name_hash **) p1;
86 struct name_hash ** name2 = (struct name_hash **) p2;
88 if( ((*name1)->flags & SYM_INVALID) != 0 )
93 if( ((*name2)->flags & SYM_INVALID) != 0 )
98 if( (*name1)->addr.seg > (*name2)->addr.seg )
103 if( (*name1)->addr.seg < (*name2)->addr.seg )
108 if( (*name1)->addr.off > (*name2)->addr.off )
113 if( (*name1)->addr.off < (*name2)->addr.off )
121 /***********************************************************************
122 * DEBUG_ResortSymbols
124 * Rebuild sorted list of symbols.
128 DEBUG_ResortSymbols()
130 struct name_hash *nh;
134 for(i=0; i<NR_NAME_HASH; i++)
136 for (nh = name_hash_table[i]; nh; nh = nh->next)
148 addr_sorttab = (struct name_hash **) xrealloc(addr_sorttab,
149 nsym * sizeof(struct name_hash *));
152 for(i=0; i<NR_NAME_HASH; i++)
154 for (nh = name_hash_table[i]; nh; nh = nh->next)
156 addr_sorttab[nsym++] = nh;
160 qsort(addr_sorttab, nsym,
161 sizeof(struct name_hash *), DEBUG_cmp_sym);
162 sortlist_valid = TRUE;
166 /***********************************************************************
169 * Add a symbol to the table.
172 DEBUG_AddSymbol( const char * name, const DBG_ADDR *addr, const char * source,
175 struct name_hash * new;
176 struct name_hash *nh;
177 static char prev_source[PATH_MAX] = {'\0', };
178 static char * prev_duped_source = NULL;
182 hash = name_hash(name);
183 for (nh = name_hash_table[hash]; nh; nh = nh->next)
185 if( ((nh->flags & SYM_INVALID) != 0) && strcmp(name, nh->name) == 0 )
187 nh->addr.off = addr->off;
188 nh->addr.seg = addr->seg;
189 if( nh->addr.type == NULL && addr->type != NULL )
191 nh->addr.type = addr->type;
193 nh->flags &= ~SYM_INVALID;
196 if (nh->addr.seg == addr->seg &&
197 nh->addr.off == addr->off &&
198 strcmp(name, nh->name) == 0 )
205 * First see if we already have an entry for this symbol. If so
206 * return it, so we don't end up with duplicates.
209 new = (struct name_hash *) xmalloc(sizeof(struct name_hash));
211 new->name = xstrdup(name);
216 * This is an enhancement to reduce memory consumption. The idea
217 * is that we duplicate a given string only once. This is a big
218 * win if there are lots of symbols defined in a given source file.
220 if( strcmp(source, prev_source) == 0 )
222 new->sourcefile = prev_duped_source;
226 strcpy(prev_source, source);
227 prev_duped_source = new->sourcefile = xstrdup(source);
232 new->sourcefile = NULL;
236 new->lines_alloc = 0;
240 new->locals_alloc = 0;
241 new->local_vars = NULL;
246 /* Now insert into the hash table */
247 new->next = name_hash_table[hash];
248 name_hash_table[hash] = new;
251 * Check some heuristics based upon the file name to see whether
252 * we want to step through this guy or not. These are machine generated
253 * assembly files that are used to translate between the MS way of
254 * calling things and the GCC way of calling things. In general we
255 * always want to step through.
259 c = strrchr(source, '.');
260 if( c != NULL && strcmp(c, ".s") == 0 )
262 c = strrchr(source, '/');
266 if( (strcmp(c, "callfrom16.s") == 0)
267 || (strcmp(c, "callto16.s") == 0)
268 || (strcmp(c, "call32.s") == 0) )
270 new->flags |= SYM_TRAMPOLINE;
276 sortlist_valid = FALSE;
280 BOOL32 DEBUG_Normalize(struct name_hash * nh )
284 * We aren't adding any more locals or linenumbers to this function.
285 * Free any spare memory that we might have allocated.
292 if( nh->n_locals != nh->locals_alloc )
294 nh->locals_alloc = nh->n_locals;
295 nh->local_vars = xrealloc(nh->local_vars,
296 nh->locals_alloc * sizeof(WineLocals));
299 if( nh->n_lines != nh->lines_alloc )
301 nh->lines_alloc = nh->n_lines;
302 nh->linetab = xrealloc(nh->linetab,
303 nh->lines_alloc * sizeof(WineLineNo));
309 /***********************************************************************
310 * DEBUG_GetSymbolValue
312 * Get the address of a named symbol.
314 BOOL32 DEBUG_GetSymbolValue( const char * name, const int lineno,
315 DBG_ADDR *addr, int bp_flag )
318 struct name_hash *nh;
320 for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next)
322 if( (nh->flags & SYM_INVALID) != 0 )
327 if (!strcmp(nh->name, name)) break;
330 if (!nh && (name[0] != '_'))
333 strcpy(buffer+1, name);
334 for(nh = name_hash_table[name_hash(buffer)]; nh; nh = nh->next)
336 if( (nh->flags & SYM_INVALID) != 0 )
340 if (!strcmp(nh->name, buffer)) break;
345 * If we don't have anything here, then try and see if this
346 * is a local symbol to the current stack frame. No matter
347 * what, we have nothing more to do, so we let that function
348 * decide what we ultimately return.
352 return DEBUG_GetStackSymbolValue(name, addr);
355 return DEBUG_GetLineNumberAddr( nh, lineno, addr, bp_flag );
358 /***********************************************************************
359 * DEBUG_GetLineNumberAddr
361 * Get the address of a named symbol.
363 BOOL32 DEBUG_GetLineNumberAddr( struct name_hash * nh, const int lineno,
364 DBG_ADDR *addr, int bp_flag )
373 addr->off += nh->breakpoint_offset;
379 * Search for the specific line number. If we don't find it,
382 if( nh->linetab == NULL )
387 for(i=0; i < nh->n_lines; i++ )
389 if( nh->linetab[i].line_number == lineno )
391 *addr = nh->linetab[i].pc_offset;
397 * This specific line number not found.
406 /***********************************************************************
407 * DEBUG_SetSymbolValue
409 * Set the address of a named symbol.
411 BOOL32 DEBUG_SetSymbolValue( const char * name, const DBG_ADDR *addr )
414 struct name_hash *nh;
416 for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next)
417 if (!strcmp(nh->name, name)) break;
419 if (!nh && (name[0] != '_'))
422 strcpy(buffer+1, name);
423 for(nh = name_hash_table[name_hash(buffer)]; nh; nh = nh->next)
424 if (!strcmp(nh->name, buffer)) break;
427 if (!nh) return FALSE;
429 nh->flags &= SYM_INVALID;
430 DBG_FIX_ADDR_SEG( &nh->addr, DS_reg(&DEBUG_context) );
435 /***********************************************************************
436 * DEBUG_FindNearestSymbol
438 * Find the symbol nearest to a given address.
439 * If ebp is specified as non-zero, it means we should dump the argument
440 * list into the string we return as well.
442 const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag,
443 struct name_hash ** rtn,
445 struct list_id * source)
447 static char name_buffer[MAX_PATH + 256];
448 static char arglist[1024];
449 static char argtmp[256];
450 struct name_hash * nearest = NULL;
454 char * lineinfo, *sourcefile;
465 source->sourcefile = NULL;
469 if( sortlist_valid == FALSE )
471 DEBUG_ResortSymbols();
474 if( sortlist_valid == FALSE )
480 * FIXME - use the binary search that we added to
481 * the function DEBUG_CheckLinenoStatus. Better yet, we should
482 * probably keep some notion of the current function so we don't
483 * have to search every time.
486 * Binary search to find closest symbol.
490 if( addr_sorttab[0]->addr.seg > addr->seg
491 || ( addr_sorttab[0]->addr.seg == addr->seg
492 && addr_sorttab[0]->addr.off > addr->off) )
496 else if( addr_sorttab[high - 1]->addr.seg < addr->seg
497 || ( addr_sorttab[high - 1]->addr.seg == addr->seg
498 && addr_sorttab[high - 1]->addr.off < addr->off) )
500 nearest = addr_sorttab[high - 1];
506 mid = (high + low)/2;
510 * See if there are any other entries that might also
511 * have the same address, and would also have a line
514 if( mid > 0 && addr_sorttab[mid]->linetab == NULL )
516 if( (addr_sorttab[mid - 1]->addr.seg ==
517 addr_sorttab[mid]->addr.seg)
518 && (addr_sorttab[mid - 1]->addr.off ==
519 addr_sorttab[mid]->addr.off)
520 && (addr_sorttab[mid - 1]->linetab != NULL) )
526 if( (mid < sorttab_nsym - 1)
527 && (addr_sorttab[mid]->linetab == NULL) )
529 if( (addr_sorttab[mid + 1]->addr.seg ==
530 addr_sorttab[mid]->addr.seg)
531 && (addr_sorttab[mid + 1]->addr.off ==
532 addr_sorttab[mid]->addr.off)
533 && (addr_sorttab[mid + 1]->linetab != NULL) )
538 nearest = addr_sorttab[mid];
540 fprintf(stderr, "Found %x:%x when looking for %x:%x %x %s\n",
541 addr_sorttab[mid ]->addr.seg,
542 addr_sorttab[mid ]->addr.off,
543 addr->seg, addr->off,
544 addr_sorttab[mid ]->linetab,
545 addr_sorttab[mid ]->name);
549 if( (addr_sorttab[mid]->addr.seg < addr->seg)
550 || ( addr_sorttab[mid]->addr.seg == addr->seg
551 && addr_sorttab[mid]->addr.off <= addr->off) )
562 if (!nearest) return NULL;
570 * Fill in the relevant bits to the structure so that we can
571 * locate the source and line for this bit of code.
575 source->sourcefile = nearest->sourcefile;
576 if( nearest->linetab == NULL )
582 source->line = nearest->linetab[0].line_number;
590 * Prepare to display the argument list. If ebp is specified, it is
591 * the framepointer for the function in question. If not specified,
592 * we don't want the arglist.
594 memset(arglist, '\0', sizeof(arglist));
597 for(i=0; i < nearest->n_locals; i++ )
600 * If this is a register (offset == 0) or a local
601 * variable, we don't want to know about it.
603 if( nearest->local_vars[i].offset <= 0 )
608 ptr = (unsigned int *) (ebp + nearest->local_vars[i].offset);
609 if( arglist[0] == '\0' )
615 strcat(arglist, ", ");
618 sprintf(argtmp, "%s=0x%x", nearest->local_vars[i].name,
620 strcat(arglist, argtmp);
622 if( arglist[0] == '(' )
624 strcat(arglist, ")");
628 if( (nearest->sourcefile != NULL) && (flag == TRUE)
629 && (addr->off - nearest->addr.off < 0x100000) )
633 * Try and find the nearest line number to the current offset.
635 if( nearest->linetab != NULL )
638 * FIXME - this is an inefficient linear search. A binary
639 * search would be better if this gets to be a performance
642 for(i=0; i < nearest->n_lines; i++)
644 if( addr->off < nearest->linetab[i].pc_offset.off )
648 lineno = nearest->linetab[i].line_number;
654 sprintf(linebuff, ":%d", lineno);
658 source->line = lineno;
662 /* Remove the path from the file name */
663 sourcefile = strrchr( nearest->sourcefile, '/' );
664 if (!sourcefile) sourcefile = nearest->sourcefile;
667 if (addr->off == nearest->addr.off)
668 sprintf( name_buffer, "%s%s [%s%s]", nearest->name,
669 arglist, sourcefile, lineinfo);
671 sprintf( name_buffer, "%s+0x%lx%s [%s%s]", nearest->name,
672 addr->off - nearest->addr.off,
673 arglist, sourcefile, lineinfo );
677 if (addr->off == nearest->addr.off)
678 sprintf( name_buffer, "%s%s", nearest->name, arglist);
680 if (addr->seg && (nearest->addr.seg!=addr->seg))
683 sprintf( name_buffer, "%s+0x%lx%s", nearest->name,
684 addr->off - nearest->addr.off, arglist);
691 /***********************************************************************
692 * DEBUG_ReadSymbolTable
694 * Read a symbol file into the hash table.
696 void DEBUG_ReadSymbolTable( const char * filename )
699 DBG_ADDR addr = { 0, 0 };
706 if (!(symbolfile = fopen(filename, "r")))
708 fprintf( stderr, "Unable to open symbol table %s\n", filename );
712 fprintf( stderr, "Reading symbols from file %s\n", filename );
716 fgets( buffer, sizeof(buffer), symbolfile );
717 if (feof(symbolfile)) break;
719 /* Strip any text after a # sign (i.e. comments) */
722 if(*cpnt++ == '#') { *cpnt = 0; break; }
724 /* Quietly ignore any lines that have just whitespace */
728 if(*cpnt != ' ' && *cpnt != '\t') break;
731 if (!(*cpnt) || *cpnt == '\n') continue;
733 nargs = sscanf(buffer, "%lx %c %s", &addr.off, &type, name);
734 DEBUG_AddSymbol( name, &addr, NULL, SYM_WINE );
740 /***********************************************************************
741 * DEBUG_LoadEntryPoints16
743 * Load the entry points of a Win16 module into the hash table.
745 static void DEBUG_LoadEntryPoints16( HMODULE16 hModule, NE_MODULE *pModule,
752 /* First search the resident names */
754 unsigned char *cpnt = (unsigned char *)pModule + pModule->name_table;
757 cpnt += *cpnt + 1 + sizeof(WORD);
758 sprintf( buffer, "%s.%.*s", name, *cpnt, cpnt + 1 );
759 if ((address = MODULE_GetEntryPoint( hModule,
760 *(WORD *)(cpnt + *cpnt + 1) )))
762 addr.seg = HIWORD(address);
763 addr.off = LOWORD(address);
765 DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
769 /* Now search the non-resident names table */
771 if (!pModule->nrname_handle) return; /* No non-resident table */
772 cpnt = (char *)GlobalLock16( pModule->nrname_handle );
775 cpnt += *cpnt + 1 + sizeof(WORD);
776 sprintf( buffer, "%s.%.*s", name, *cpnt, cpnt + 1 );
777 if ((address = MODULE_GetEntryPoint( hModule,
778 *(WORD *)(cpnt + *cpnt + 1) )))
780 addr.seg = HIWORD(address);
781 addr.off = LOWORD(address);
783 DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
789 /***********************************************************************
790 * DEBUG_LoadEntryPoints32
792 * Load the entry points of a Win32 module into the hash table.
794 static void DEBUG_LoadEntryPoints32( PE_MODULE *pe, const char *name )
796 #define RVA(x) (load_addr+(DWORD)(x))
801 IMAGE_EXPORT_DIRECTORY *exports;
807 PE_MODREF *pem = pCurrentProcess->modref_list;
808 while (pem && (pem->pe_module != pe)) pem = pem->next;
810 load_addr = pem->load_addr;
811 exports = pem->pe_export;
816 /* Add start of DLL */
818 addr.off = load_addr;
819 DEBUG_AddSymbol( name, &addr, NULL, SYM_WIN32 | SYM_FUNC );
821 /* Add entry point */
823 sprintf( buffer, "%s.EntryPoint", name );
824 addr.off = RVA( pe->pe_header->OptionalHeader.AddressOfEntryPoint );
825 DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
827 /* Add start of sections */
829 for (i = 0; i < pe->pe_header->FileHeader.NumberOfSections; i++)
831 sprintf( buffer, "%s.%s", name, pe->pe_seg[i].Name );
832 addr.off = RVA( pe->pe_seg[i].VirtualAddress );
833 DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
836 /* Add exported functions */
838 if (!exports) return;
839 ordinals = (WORD *)RVA( exports->AddressOfNameOrdinals );
840 names = (const char **)RVA( exports->AddressOfNames );
841 functions = (void **)RVA( exports->AddressOfFunctions );
843 for (i = 0; i < exports->NumberOfNames; i++)
845 if (!names[i]) continue;
846 sprintf( buffer, "%s.%s", name, (char *)RVA(names[i]) );
847 addr.off = RVA( functions[ordinals[i]] );
848 DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
851 for (i = 0; i < exports->NumberOfFunctions; i++)
853 if (!functions[i]) continue;
854 /* Check if we already added it with a name */
855 for (j = 0; j < exports->NumberOfNames; j++)
856 if ((ordinals[j] == i) && names[j]) break;
857 if (j < exports->NumberOfNames) continue;
858 sprintf( buffer, "%s.%ld", name, i + exports->Base );
859 addr.off = (DWORD)RVA( functions[i] );
860 DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
866 /***********************************************************************
867 * DEBUG_LoadEntryPoints
869 * Load the entry points of all the modules into the hash table.
871 void DEBUG_LoadEntryPoints(void)
877 for (ok = ModuleFirst(&entry); ok; ok = ModuleNext(&entry))
879 if (!(pModule = MODULE_GetPtr( entry.hModule ))) continue;
880 fprintf( stderr, " %s", entry.szModule );
882 if (pModule->flags & NE_FFLAGS_WIN32) /* PE module */
884 if (pModule->flags & NE_FFLAGS_BUILTIN) continue;
885 DEBUG_LoadEntryPoints32( pModule->pe_module, entry.szModule );
888 DEBUG_LoadEntryPoints16( entry.hModule, pModule, entry.szModule );
894 DEBUG_AddLineNumber( struct name_hash * func, int line_num,
895 unsigned long offset )
902 if( func->n_lines + 1 >= func->lines_alloc )
904 func->lines_alloc += 64;
905 func->linetab = xrealloc(func->linetab,
906 func->lines_alloc * sizeof(WineLineNo));
909 func->linetab[func->n_lines].line_number = line_num;
910 func->linetab[func->n_lines].pc_offset.seg = func->addr.seg;
911 func->linetab[func->n_lines].pc_offset.off = func->addr.off + offset;
912 func->linetab[func->n_lines].pc_offset.type = NULL;
918 DEBUG_AddLocal( struct name_hash * func, int regno,
929 if( func->n_locals + 1 >= func->locals_alloc )
931 func->locals_alloc += 32;
932 func->local_vars = xrealloc(func->local_vars,
933 func->locals_alloc * sizeof(WineLocals));
936 func->local_vars[func->n_locals].regno = regno;
937 func->local_vars[func->n_locals].offset = offset;
938 func->local_vars[func->n_locals].pc_start = pc_start;
939 func->local_vars[func->n_locals].pc_end = pc_end;
940 func->local_vars[func->n_locals].name = xstrdup(name);
941 func->local_vars[func->n_locals].type = NULL;
944 return &func->local_vars[func->n_locals - 1];
952 struct name_hash *nh;
955 * Utility function to dump stats about the hash table.
957 for(i=0; i<NR_NAME_HASH; i++)
960 for (nh = name_hash_table[i]; nh; nh = nh->next)
964 fprintf(stderr, "Bucket %d: %d\n", i, depth);
968 /***********************************************************************
969 * DEBUG_CheckLinenoStatus
971 * Find the symbol nearest to a given address.
972 * If ebp is specified as non-zero, it means we should dump the argument
973 * list into the string we return as well.
975 int DEBUG_CheckLinenoStatus( const DBG_ADDR *addr)
977 struct name_hash * nearest = NULL;
981 if( sortlist_valid == FALSE )
983 DEBUG_ResortSymbols();
987 * Binary search to find closest symbol.
991 if( addr_sorttab[0]->addr.seg > addr->seg
992 || ( addr_sorttab[0]->addr.seg == addr->seg
993 && addr_sorttab[0]->addr.off > addr->off) )
997 else if( addr_sorttab[high - 1]->addr.seg < addr->seg
998 || ( addr_sorttab[high - 1]->addr.seg == addr->seg
999 && addr_sorttab[high - 1]->addr.off < addr->off) )
1001 nearest = addr_sorttab[high - 1];
1007 mid = (high + low)/2;
1011 * See if there are any other entries that might also
1012 * have the same address, and would also have a line
1015 if( mid > 0 && addr_sorttab[mid]->linetab == NULL )
1017 if( (addr_sorttab[mid - 1]->addr.seg ==
1018 addr_sorttab[mid]->addr.seg)
1019 && (addr_sorttab[mid - 1]->addr.off ==
1020 addr_sorttab[mid]->addr.off)
1021 && (addr_sorttab[mid - 1]->linetab != NULL) )
1027 if( (mid < sorttab_nsym - 1)
1028 && (addr_sorttab[mid]->linetab == NULL) )
1030 if( (addr_sorttab[mid + 1]->addr.seg ==
1031 addr_sorttab[mid]->addr.seg)
1032 && (addr_sorttab[mid + 1]->addr.off ==
1033 addr_sorttab[mid]->addr.off)
1034 && (addr_sorttab[mid + 1]->linetab != NULL) )
1039 nearest = addr_sorttab[mid];
1041 fprintf(stderr, "Found %x:%x when looking for %x:%x %x %s\n",
1042 addr_sorttab[mid ]->addr.seg,
1043 addr_sorttab[mid ]->addr.off,
1044 addr->seg, addr->off,
1045 addr_sorttab[mid ]->linetab,
1046 addr_sorttab[mid ]->name);
1050 if( (addr_sorttab[mid]->addr.seg < addr->seg)
1051 || ( addr_sorttab[mid]->addr.seg == addr->seg
1052 && addr_sorttab[mid]->addr.off <= addr->off) )
1063 if (!nearest) return FUNC_HAS_NO_LINES;
1065 if( nearest->flags & SYM_STEP_THROUGH )
1068 * This will cause us to keep single stepping until
1069 * we get to the other side somewhere.
1071 return NOT_ON_LINENUMBER;
1074 if( (nearest->flags & SYM_TRAMPOLINE) )
1077 * This will cause us to keep single stepping until
1078 * we get to the other side somewhere.
1080 return FUNC_IS_TRAMPOLINE;
1083 if( nearest->linetab == NULL )
1085 return FUNC_HAS_NO_LINES;
1090 * We never want to stop on the first instruction of a function
1091 * even if it has it's own linenumber. Let the thing keep running
1092 * until it gets past the function prologue. We only do this if there
1093 * is more than one line number for the function, of course.
1095 if( nearest->addr.off == addr->off && nearest->n_lines > 1 )
1097 return NOT_ON_LINENUMBER;
1100 if( (nearest->sourcefile != NULL)
1101 && (addr->off - nearest->addr.off < 0x100000) )
1104 * FIXME - this is an inefficient linear search. A binary
1105 * search would be better if this gets to be a performance
1108 for(i=0; i < nearest->n_lines; i++)
1110 if( addr->off == nearest->linetab[i].pc_offset.off )
1112 return AT_LINENUMBER;
1114 if( addr->off < nearest->linetab[i].pc_offset.off )
1120 return NOT_ON_LINENUMBER;
1123 return FUNC_HAS_NO_LINES;
1126 /***********************************************************************
1129 * Find the symbol nearest to a given address.
1130 * Returns sourcefile name and line number in a format that the listing
1131 * handler can deal with.
1134 DEBUG_GetFuncInfo( struct list_id * ret, const char * filename,
1139 struct name_hash *nh;
1141 for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next)
1143 if( filename != NULL )
1146 if( nh->sourcefile == NULL )
1151 pnt = strrchr(nh->sourcefile, '/');
1152 if( strcmp(nh->sourcefile, filename) != 0
1153 && (pnt == NULL || strcmp(pnt + 1, filename) != 0) )
1158 if (!strcmp(nh->name, name)) break;
1161 if (!nh && (name[0] != '_'))
1164 strcpy(buffer+1, name);
1165 for(nh = name_hash_table[name_hash(buffer)]; nh; nh = nh->next)
1167 if( filename != NULL )
1169 if( nh->sourcefile == NULL )
1174 pnt = strrchr(nh->sourcefile, '/');
1175 if( strcmp(nh->sourcefile, filename) != 0
1176 && (pnt == NULL || strcmp(pnt + 1, filename) != 0) )
1181 if (!strcmp(nh->name, buffer)) break;
1187 if( filename != NULL )
1189 fprintf(stderr, "No such function %s in %s\n", name, filename);
1193 fprintf(stderr, "No such function %s\n", name);
1195 ret->sourcefile = NULL;
1200 ret->sourcefile = nh->sourcefile;
1203 * Search for the specific line number. If we don't find it,
1204 * then return FALSE.
1206 if( nh->linetab == NULL )
1212 ret->line = nh->linetab[0].line_number;
1216 /***********************************************************************
1217 * DEBUG_GetStackSymbolValue
1219 * Get the address of a named symbol from the current stack frame.
1222 BOOL32 DEBUG_GetStackSymbolValue( const char * name, DBG_ADDR *addr )
1224 struct name_hash * curr_func;
1229 if( DEBUG_GetCurrentFrame(&curr_func, &eip, &ebp) == FALSE )
1234 for(i=0; i < curr_func->n_locals; i++ )
1237 * Test the range of validity of the local variable. This
1238 * comes up with RBRAC/LBRAC stabs in particular.
1240 if( (curr_func->local_vars[i].pc_start != 0)
1241 && ((eip - curr_func->addr.off)
1242 < curr_func->local_vars[i].pc_start) )
1247 if( (curr_func->local_vars[i].pc_end != 0)
1248 && ((eip - curr_func->addr.off)
1249 > curr_func->local_vars[i].pc_end) )
1254 if( strcmp(name, curr_func->local_vars[i].name) == 0 )
1257 * OK, we found it. Now figure out what to do with this.
1259 if( curr_func->local_vars[i].regno != 0 )
1262 * Register variable. We don't know how to treat
1269 addr->off = ebp + curr_func->local_vars[i].offset;
1270 addr->type = curr_func->local_vars[i].type;
1281 struct name_hash * curr_func;
1288 if( DEBUG_GetCurrentFrame(&curr_func, &eip, &ebp) == FALSE )
1293 for(i=0; i < curr_func->n_locals; i++ )
1296 * Test the range of validity of the local variable. This
1297 * comes up with RBRAC/LBRAC stabs in particular.
1299 if( (curr_func->local_vars[i].pc_start != 0)
1300 && ((eip - curr_func->addr.off)
1301 < curr_func->local_vars[i].pc_start) )
1306 if( (curr_func->local_vars[i].pc_end != 0)
1307 && ((eip - curr_func->addr.off)
1308 > curr_func->local_vars[i].pc_end) )
1313 if( curr_func->local_vars[i].offset == 0 )
1315 fprintf(stderr, "%s:%s optimized into register $%s \n",
1316 curr_func->name, curr_func->local_vars[i].name,
1317 reg_name[curr_func->local_vars[i].regno]);
1321 ptr = (unsigned int *) (ebp + curr_func->local_vars[i].offset);
1322 fprintf(stderr, "%s:%s == 0x%8.8x\n",
1323 curr_func->name, curr_func->local_vars[i].name,
1334 DEBUG_SetSymbolSize(struct name_hash * sym, unsigned int len)
1336 sym->symbol_size = len;
1342 DEBUG_SetSymbolBPOff(struct name_hash * sym, unsigned int off)
1344 sym->breakpoint_offset = off;
1350 DEBUG_GetSymbolAddr(struct name_hash * sym, DBG_ADDR * addr)
1358 int DEBUG_SetLocalSymbolType(struct wine_locals * sym, struct datatype * type)