2 * File hash.c - generate hash tables for Wine debugger symbols
4 * Copyright (C) 1993, Eric Youngdale.
13 #include <sys/types.h>
17 #include "selectors.h"
21 #define NR_NAME_HASH 16384
23 #define PATH_MAX _MAX_PATH
27 static char * reg_name
[] =
29 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"
32 static unsigned reg_ofs
[] =
34 FIELD_OFFSET(CONTEXT
, Eax
), FIELD_OFFSET(CONTEXT
, Ecx
),
35 FIELD_OFFSET(CONTEXT
, Edx
), FIELD_OFFSET(CONTEXT
, Ebx
),
36 FIELD_OFFSET(CONTEXT
, Esp
), FIELD_OFFSET(CONTEXT
, Ebp
),
37 FIELD_OFFSET(CONTEXT
, Esi
), FIELD_OFFSET(CONTEXT
, Edi
)
40 static char * reg_name
[] = { NULL
}; /* FIXME */
41 static unsigned reg_ofs
[] = { 0 };
47 struct name_hash
* next
; /* Used to look up within name hash */
53 WineLocals
* local_vars
;
61 unsigned short breakpoint_offset
;
62 unsigned int symbol_size
;
66 static BOOL
DEBUG_GetStackSymbolValue( const char * name
, DBG_ADDR
*addr
);
67 static int sortlist_valid
= FALSE
;
69 static int sorttab_nsym
;
70 static struct name_hash
** addr_sorttab
= NULL
;
72 static struct name_hash
* name_hash_table
[NR_NAME_HASH
];
74 static unsigned int name_hash( const char * name
)
76 unsigned int hash
= 0;
84 hash
= (hash
<< 4) + *p
++;
86 if( (tmp
= (hash
& 0xf0000000)) )
92 return hash
% NR_NAME_HASH
;
96 DEBUG_cmp_sym(const void * p1
, const void * p2
)
98 struct name_hash
** name1
= (struct name_hash
**) p1
;
99 struct name_hash
** name2
= (struct name_hash
**) p2
;
101 if( ((*name1
)->flags
& SYM_INVALID
) != 0 )
106 if( ((*name2
)->flags
& SYM_INVALID
) != 0 )
111 if( (*name1
)->addr
.seg
> (*name2
)->addr
.seg
)
116 if( (*name1
)->addr
.seg
< (*name2
)->addr
.seg
)
121 if( (*name1
)->addr
.off
> (*name2
)->addr
.off
)
126 if( (*name1
)->addr
.off
< (*name2
)->addr
.off
)
134 /***********************************************************************
135 * DEBUG_ResortSymbols
137 * Rebuild sorted list of symbols.
141 DEBUG_ResortSymbols()
143 struct name_hash
*nh
;
147 for(i
=0; i
<NR_NAME_HASH
; i
++)
149 for (nh
= name_hash_table
[i
]; nh
; nh
= nh
->next
)
151 if( (nh
->flags
& SYM_INVALID
) == 0 )
154 fprintf( stderr
, "Symbol %s is invalid\n", nh
->name
);
164 addr_sorttab
= (struct name_hash
**) DBG_realloc(addr_sorttab
,
165 nsym
* sizeof(struct name_hash
*));
168 for(i
=0; i
<NR_NAME_HASH
; i
++)
170 for (nh
= name_hash_table
[i
]; nh
; nh
= nh
->next
)
172 if( (nh
->flags
& SYM_INVALID
) == 0 )
173 addr_sorttab
[nsym
++] = nh
;
177 qsort(addr_sorttab
, nsym
,
178 sizeof(struct name_hash
*), DEBUG_cmp_sym
);
179 sortlist_valid
= TRUE
;
183 /***********************************************************************
186 * Add a symbol to the table.
189 DEBUG_AddSymbol( const char * name
, const DBG_ADDR
*addr
, const char * source
,
192 struct name_hash
* new;
193 struct name_hash
*nh
;
194 static char prev_source
[PATH_MAX
] = {'\0', };
195 static char * prev_duped_source
= NULL
;
199 hash
= name_hash(name
);
200 for (nh
= name_hash_table
[hash
]; nh
; nh
= nh
->next
)
202 if( ((nh
->flags
& SYM_INVALID
) != 0) && strcmp(name
, nh
->name
) == 0 )
204 nh
->addr
.off
= addr
->off
;
205 nh
->addr
.seg
= addr
->seg
;
206 if( nh
->addr
.type
== NULL
&& addr
->type
!= NULL
)
208 nh
->addr
.type
= addr
->type
;
210 /* it may happen that the same symbol is defined in several compilation
211 * units, but the linker decides to merge it into a single instance.
212 * in that case, we don't clear the invalid flag for all the compilation
213 * units (N_GSYM), and wait to get the symbol from the symtab
215 if ((flags
& SYM_INVALID
) == 0)
216 nh
->flags
&= ~SYM_INVALID
;
219 if (nh
->addr
.seg
== addr
->seg
&&
220 nh
->addr
.off
== addr
->off
&&
221 strcmp(name
, nh
->name
) == 0 )
228 * First see if we already have an entry for this symbol. If so
229 * return it, so we don't end up with duplicates.
232 new = (struct name_hash
*) DBG_alloc(sizeof(struct name_hash
));
234 new->name
= DBG_strdup(name
);
239 * This is an enhancement to reduce memory consumption. The idea
240 * is that we duplicate a given string only once. This is a big
241 * win if there are lots of symbols defined in a given source file.
243 if( strcmp(source
, prev_source
) == 0 )
245 new->sourcefile
= prev_duped_source
;
249 strcpy(prev_source
, source
);
250 prev_duped_source
= new->sourcefile
= DBG_strdup(source
);
255 new->sourcefile
= NULL
;
259 new->lines_alloc
= 0;
263 new->locals_alloc
= 0;
264 new->local_vars
= NULL
;
269 /* Now insert into the hash table */
270 new->next
= name_hash_table
[hash
];
271 name_hash_table
[hash
] = new;
274 * Check some heuristics based upon the file name to see whether
275 * we want to step through this guy or not. These are machine generated
276 * assembly files that are used to translate between the MS way of
277 * calling things and the GCC way of calling things. In general we
278 * always want to step through.
282 c
= strrchr(source
, '.');
283 if( c
!= NULL
&& strcmp(c
, ".s") == 0 )
285 c
= strrchr(source
, '/');
289 if( (strcmp(c
, "callfrom16.s") == 0)
290 || (strcmp(c
, "callto16.s") == 0)
291 || (strcmp(c
, "call32.s") == 0) )
293 new->flags
|= SYM_TRAMPOLINE
;
299 sortlist_valid
= FALSE
;
303 BOOL
DEBUG_Normalize(struct name_hash
* nh
)
307 * We aren't adding any more locals or linenumbers to this function.
308 * Free any spare memory that we might have allocated.
315 if( nh
->n_locals
!= nh
->locals_alloc
)
317 nh
->locals_alloc
= nh
->n_locals
;
318 nh
->local_vars
= DBG_realloc(nh
->local_vars
,
319 nh
->locals_alloc
* sizeof(WineLocals
));
322 if( nh
->n_lines
!= nh
->lines_alloc
)
324 nh
->lines_alloc
= nh
->n_lines
;
325 nh
->linetab
= DBG_realloc(nh
->linetab
,
326 nh
->lines_alloc
* sizeof(WineLineNo
));
332 /***********************************************************************
333 * DEBUG_GetSymbolValue
335 * Get the address of a named symbol.
337 BOOL
DEBUG_GetSymbolValue( const char * name
, const int lineno
,
338 DBG_ADDR
*addr
, int bp_flag
)
341 struct name_hash
*nh
;
343 for(nh
= name_hash_table
[name_hash(name
)]; nh
; nh
= nh
->next
)
345 if( (nh
->flags
& SYM_INVALID
) != 0 )
350 if (!strcmp(nh
->name
, name
)) break;
353 if (!nh
&& (name
[0] != '_'))
356 strcpy(buffer
+1, name
);
357 for(nh
= name_hash_table
[name_hash(buffer
)]; nh
; nh
= nh
->next
)
359 if( (nh
->flags
& SYM_INVALID
) != 0 )
363 if (!strcmp(nh
->name
, buffer
)) break;
368 * If we don't have anything here, then try and see if this
369 * is a local symbol to the current stack frame. No matter
370 * what, we have nothing more to do, so we let that function
371 * decide what we ultimately return.
375 return DEBUG_GetStackSymbolValue(name
, addr
);
378 return DEBUG_GetLineNumberAddr( nh
, lineno
, addr
, bp_flag
);
381 /***********************************************************************
382 * DEBUG_GetLineNumberAddr
384 * Get the address of a named symbol.
386 BOOL
DEBUG_GetLineNumberAddr( struct name_hash
* nh
, const int lineno
,
387 DBG_ADDR
*addr
, int bp_flag
)
396 addr
->off
+= nh
->breakpoint_offset
;
402 * Search for the specific line number. If we don't find it,
405 if( nh
->linetab
== NULL
)
410 for(i
=0; i
< nh
->n_lines
; i
++ )
412 if( nh
->linetab
[i
].line_number
== lineno
)
414 *addr
= nh
->linetab
[i
].pc_offset
;
420 * This specific line number not found.
429 /***********************************************************************
430 * DEBUG_SetSymbolValue
432 * Set the address of a named symbol.
434 BOOL
DEBUG_SetSymbolValue( const char * name
, const DBG_ADDR
*addr
)
437 struct name_hash
*nh
;
439 for(nh
= name_hash_table
[name_hash(name
)]; nh
; nh
= nh
->next
)
440 if (!strcmp(nh
->name
, name
)) break;
442 if (!nh
&& (name
[0] != '_'))
445 strcpy(buffer
+1, name
);
446 for(nh
= name_hash_table
[name_hash(buffer
)]; nh
; nh
= nh
->next
)
447 if (!strcmp(nh
->name
, buffer
)) break;
450 if (!nh
) return FALSE
;
452 nh
->flags
&= SYM_INVALID
;
453 DBG_FIX_ADDR_SEG( &nh
->addr
, DS_reg(&DEBUG_context
) );
458 /***********************************************************************
459 * DEBUG_FindNearestSymbol
461 * Find the symbol nearest to a given address.
462 * If ebp is specified as non-zero, it means we should dump the argument
463 * list into the string we return as well.
465 const char * DEBUG_FindNearestSymbol( const DBG_ADDR
*addr
, int flag
,
466 struct name_hash
** rtn
,
468 struct list_id
* source
)
470 static char name_buffer
[MAX_PATH
+ 256];
471 static char arglist
[1024];
472 static char argtmp
[256];
473 struct name_hash
* nearest
= NULL
;
477 char * lineinfo
, *sourcefile
;
488 source
->sourcefile
= NULL
;
492 if( sortlist_valid
== FALSE
)
494 DEBUG_ResortSymbols();
497 if( sortlist_valid
== FALSE
)
503 * FIXME - use the binary search that we added to
504 * the function DEBUG_CheckLinenoStatus. Better yet, we should
505 * probably keep some notion of the current function so we don't
506 * have to search every time.
509 * Binary search to find closest symbol.
513 if( addr_sorttab
[0]->addr
.seg
> addr
->seg
514 || ( addr_sorttab
[0]->addr
.seg
== addr
->seg
515 && addr_sorttab
[0]->addr
.off
> addr
->off
) )
519 else if( addr_sorttab
[high
- 1]->addr
.seg
< addr
->seg
520 || ( addr_sorttab
[high
- 1]->addr
.seg
== addr
->seg
521 && addr_sorttab
[high
- 1]->addr
.off
< addr
->off
) )
523 nearest
= addr_sorttab
[high
- 1];
529 mid
= (high
+ low
)/2;
533 * See if there are any other entries that might also
534 * have the same address, and would also have a line
537 if( mid
> 0 && addr_sorttab
[mid
]->linetab
== NULL
)
539 if( (addr_sorttab
[mid
- 1]->addr
.seg
==
540 addr_sorttab
[mid
]->addr
.seg
)
541 && (addr_sorttab
[mid
- 1]->addr
.off
==
542 addr_sorttab
[mid
]->addr
.off
)
543 && (addr_sorttab
[mid
- 1]->linetab
!= NULL
) )
549 if( (mid
< sorttab_nsym
- 1)
550 && (addr_sorttab
[mid
]->linetab
== NULL
) )
552 if( (addr_sorttab
[mid
+ 1]->addr
.seg
==
553 addr_sorttab
[mid
]->addr
.seg
)
554 && (addr_sorttab
[mid
+ 1]->addr
.off
==
555 addr_sorttab
[mid
]->addr
.off
)
556 && (addr_sorttab
[mid
+ 1]->linetab
!= NULL
) )
561 nearest
= addr_sorttab
[mid
];
563 fprintf(stderr
, "Found %x:%x when looking for %x:%x %x %s\n",
564 addr_sorttab
[mid
]->addr
.seg
,
565 addr_sorttab
[mid
]->addr
.off
,
566 addr
->seg
, addr
->off
,
567 addr_sorttab
[mid
]->linetab
,
568 addr_sorttab
[mid
]->name
);
572 if( (addr_sorttab
[mid
]->addr
.seg
< addr
->seg
)
573 || ( addr_sorttab
[mid
]->addr
.seg
== addr
->seg
574 && addr_sorttab
[mid
]->addr
.off
<= addr
->off
) )
585 if (!nearest
) return NULL
;
593 * Fill in the relevant bits to the structure so that we can
594 * locate the source and line for this bit of code.
598 source
->sourcefile
= nearest
->sourcefile
;
599 if( nearest
->linetab
== NULL
)
605 source
->line
= nearest
->linetab
[0].line_number
;
613 * Prepare to display the argument list. If ebp is specified, it is
614 * the framepointer for the function in question. If not specified,
615 * we don't want the arglist.
617 memset(arglist
, '\0', sizeof(arglist
));
620 for(i
=0; i
< nearest
->n_locals
; i
++ )
623 * If this is a register (offset == 0) or a local
624 * variable, we don't want to know about it.
626 if( nearest
->local_vars
[i
].offset
<= 0 )
631 ptr
= (unsigned int *) (ebp
+ nearest
->local_vars
[i
].offset
);
632 if( arglist
[0] == '\0' )
638 strcat(arglist
, ", ");
641 sprintf(argtmp
, "%s=0x%x", nearest
->local_vars
[i
].name
,
643 strcat(arglist
, argtmp
);
645 if( arglist
[0] == '(' )
647 strcat(arglist
, ")");
651 if( (nearest
->sourcefile
!= NULL
) && (flag
== TRUE
)
652 && (addr
->off
- nearest
->addr
.off
< 0x100000) )
656 * Try and find the nearest line number to the current offset.
658 if( nearest
->linetab
!= NULL
)
661 high
= nearest
->n_lines
;
662 while ((high
- low
) > 1)
664 mid
= (high
+ low
) / 2;
665 if (addr
->off
< nearest
->linetab
[mid
].pc_offset
.off
)
670 lineno
= nearest
->linetab
[low
].line_number
;
675 sprintf(linebuff
, ":%d", lineno
);
679 source
->line
= lineno
;
683 /* Remove the path from the file name */
684 sourcefile
= strrchr( nearest
->sourcefile
, '/' );
685 if (!sourcefile
) sourcefile
= nearest
->sourcefile
;
688 if (addr
->off
== nearest
->addr
.off
)
689 sprintf( name_buffer
, "%s%s [%s%s]", nearest
->name
,
690 arglist
, sourcefile
, lineinfo
);
692 sprintf( name_buffer
, "%s+0x%lx%s [%s%s]", nearest
->name
,
693 addr
->off
- nearest
->addr
.off
,
694 arglist
, sourcefile
, lineinfo
);
698 if (addr
->off
== nearest
->addr
.off
)
699 sprintf( name_buffer
, "%s%s", nearest
->name
, arglist
);
701 if (addr
->seg
&& (nearest
->addr
.seg
!=addr
->seg
))
704 sprintf( name_buffer
, "%s+0x%lx%s", nearest
->name
,
705 addr
->off
- nearest
->addr
.off
, arglist
);
712 /***********************************************************************
713 * DEBUG_ReadSymbolTable
715 * Read a symbol file into the hash table.
717 void DEBUG_ReadSymbolTable( const char * filename
)
720 DBG_ADDR addr
= { 0, 0 };
727 if (!(symbolfile
= fopen(filename
, "r")))
729 fprintf( stderr
, "Unable to open symbol table %s\n", filename
);
733 fprintf( stderr
, "Reading symbols from file %s\n", filename
);
737 fgets( buffer
, sizeof(buffer
), symbolfile
);
738 if (feof(symbolfile
)) break;
740 /* Strip any text after a # sign (i.e. comments) */
743 if(*cpnt
++ == '#') { *cpnt
= 0; break; }
745 /* Quietly ignore any lines that have just whitespace */
749 if(*cpnt
!= ' ' && *cpnt
!= '\t') break;
752 if (!(*cpnt
) || *cpnt
== '\n') continue;
754 nargs
= sscanf(buffer
, "%lx %c %s", &addr
.off
, &type
, name
);
755 DEBUG_AddSymbol( name
, &addr
, NULL
, SYM_WINE
);
761 /***********************************************************************
762 * DEBUG_LoadEntryPoints16
764 * Load the entry points of a Win16 module into the hash table.
766 static void DEBUG_LoadEntryPoints16( HMODULE16 hModule
, NE_MODULE
*pModule
,
773 /* First search the resident names */
775 unsigned char *cpnt
= (unsigned char *)pModule
+ pModule
->name_table
;
778 cpnt
+= *cpnt
+ 1 + sizeof(WORD
);
779 sprintf( buffer
, "%s.%.*s", name
, *cpnt
, cpnt
+ 1 );
780 if ((address
= NE_GetEntryPoint(hModule
, *(WORD
*)(cpnt
+ *cpnt
+ 1))))
782 addr
.seg
= HIWORD(address
);
783 addr
.off
= LOWORD(address
);
785 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
789 /* Now search the non-resident names table */
791 if (!pModule
->nrname_handle
) return; /* No non-resident table */
792 cpnt
= (char *)GlobalLock16( pModule
->nrname_handle
);
795 cpnt
+= *cpnt
+ 1 + sizeof(WORD
);
796 sprintf( buffer
, "%s.%.*s", name
, *cpnt
, cpnt
+ 1 );
797 if ((address
= NE_GetEntryPoint(hModule
, *(WORD
*)(cpnt
+ *cpnt
+ 1))))
799 addr
.seg
= HIWORD(address
);
800 addr
.off
= LOWORD(address
);
802 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
808 /***********************************************************************
809 * DEBUG_LoadEntryPoints32
811 * Load the entry points of a Win32 module into the hash table.
813 static void DEBUG_LoadEntryPoints32( HMODULE hModule
, const char *name
)
815 #define RVA(x) (hModule+(DWORD)(x))
820 IMAGE_SECTION_HEADER
*pe_seg
;
821 IMAGE_EXPORT_DIRECTORY
*exports
;
822 IMAGE_DATA_DIRECTORY
*dir
;
830 /* Add start of DLL */
833 DEBUG_AddSymbol( name
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
835 /* Add entry point */
837 sprintf( buffer
, "%s.EntryPoint", name
);
838 addr
.off
= (DWORD
)RVA_PTR( hModule
, OptionalHeader
.AddressOfEntryPoint
);
839 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
841 /* Add start of sections */
843 pe_seg
= PE_SECTIONS(hModule
);
844 for (i
= 0; i
< PE_HEADER(hModule
)->FileHeader
.NumberOfSections
; i
++)
846 sprintf( buffer
, "%s.%s", name
, pe_seg
->Name
);
847 addr
.off
= RVA(pe_seg
->VirtualAddress
);
848 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
852 /* Add exported functions */
854 dir
= &PE_HEADER(hModule
)->OptionalHeader
.
855 DataDirectory
[IMAGE_DIRECTORY_ENTRY_EXPORT
];
858 exports
= (IMAGE_EXPORT_DIRECTORY
*)RVA( dir
->VirtualAddress
);
859 ordinals
= (WORD
*)RVA( exports
->AddressOfNameOrdinals
);
860 names
= (const char **)RVA( exports
->AddressOfNames
);
861 functions
= (void **)RVA( exports
->AddressOfFunctions
);
863 for (i
= 0; i
< exports
->NumberOfNames
; i
++)
865 if (!names
[i
]) continue;
866 sprintf( buffer
, "%s.%s", name
, (char *)RVA(names
[i
]) );
867 addr
.off
= RVA( functions
[ordinals
[i
]] );
868 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
871 for (i
= 0; i
< exports
->NumberOfFunctions
; i
++)
873 if (!functions
[i
]) continue;
874 /* Check if we already added it with a name */
875 for (j
= 0; j
< exports
->NumberOfNames
; j
++)
876 if ((ordinals
[j
] == i
) && names
[j
]) break;
877 if (j
< exports
->NumberOfNames
) continue;
878 sprintf( buffer
, "%s.%ld", name
, i
+ exports
->Base
);
879 addr
.off
= (DWORD
)RVA( functions
[i
] );
880 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
883 DEBUG_RegisterDebugInfo(hModule
, name
);
887 typedef struct tag_lmr
{
890 struct tag_lmr
* next
;
891 } DBG_LoadedModuleRef
;
899 static BOOL
DEBUG_LEPHelper(const char* mod_name
, BOOL is16
, DBG_LEPData
* lep
)
901 static DBG_LoadedModuleRef
* lmr
= NULL
;
902 DBG_LoadedModuleRef
* p
;
903 DBG_LoadedModuleRef
** pp1
;
904 DBG_LoadedModuleRef
* p2
;
905 int len
= strlen(mod_name
);
908 for (p
= lmr
; p
; p
= p
->next
) {
909 cmp
= strcasecmp(p
->module_name
, mod_name
);
910 if (cmp
== 0 && p
->is16
== is16
)
917 if (lep
->pfx
) fprintf( stderr
, lep
->pfx
);
918 fprintf( stderr
, " " );
923 if ((lep
->rowcount
+ len
) > 76)
925 fprintf( stderr
, "\n ");
928 fprintf( stderr
, " %s", mod_name
);
929 lep
->rowcount
+= len
+ 1;
931 p
= DBG_alloc(sizeof(*lmr
));
932 p
->module_name
= DBG_strdup(mod_name
);
936 for (pp1
= &lmr
; *pp1
; pp1
= &(*pp1
)->next
) {
937 if (strcasecmp((*pp1
)->module_name
, mod_name
) > 0)
946 else if (*pp1
== NULL
)
960 /***********************************************************************
961 * DEBUG_LoadEntryPoints
963 * Load the entry points of all the modules into the hash table.
965 int DEBUG_LoadEntryPoints(const char* pfx
)
976 /* FIXME: we assume that a module is never removed from memory */
978 for (ok
= ModuleFirst16(&entry
); ok
; ok
= ModuleNext16(&entry
))
980 if (!(pModule
= NE_GetPtr( entry
.hModule
))) continue;
981 if (!(pModule
->flags
& NE_FFLAGS_WIN32
) && /* NE module */
982 DEBUG_LEPHelper( entry
.szModule
, TRUE
, &lep
))
983 DEBUG_LoadEntryPoints16( entry
.hModule
, pModule
, entry
.szModule
);
986 for (wm
=PROCESS_Current()->modref_list
;wm
;wm
=wm
->next
)
988 if ((wm
->flags
& WINE_MODREF_INTERNAL
))
990 if (DEBUG_LEPHelper( wm
->modname
, FALSE
, &lep
))
991 DEBUG_LoadEntryPoints32( wm
->module
, wm
->modname
);
994 if (lep
.first
) fprintf( stderr
, " $");
995 for (wm
=PROCESS_Current()->modref_list
;wm
;wm
=wm
->next
)
997 if (!(wm
->flags
& WINE_MODREF_INTERNAL
))
999 if (DEBUG_LEPHelper( wm
->modname
, FALSE
, &lep
))
1000 DEBUG_LoadEntryPoints32( wm
->module
, wm
->modname
);
1003 if (lep
.first
) fprintf( stderr
, "\n" );
1009 DEBUG_AddLineNumber( struct name_hash
* func
, int line_num
,
1010 unsigned long offset
)
1017 if( func
->n_lines
+ 1 >= func
->lines_alloc
)
1019 func
->lines_alloc
+= 64;
1020 func
->linetab
= DBG_realloc(func
->linetab
,
1021 func
->lines_alloc
* sizeof(WineLineNo
));
1024 func
->linetab
[func
->n_lines
].line_number
= line_num
;
1025 func
->linetab
[func
->n_lines
].pc_offset
.seg
= func
->addr
.seg
;
1026 func
->linetab
[func
->n_lines
].pc_offset
.off
= func
->addr
.off
+ offset
;
1027 func
->linetab
[func
->n_lines
].pc_offset
.type
= NULL
;
1032 struct wine_locals
*
1033 DEBUG_AddLocal( struct name_hash
* func
, int regno
,
1044 if( func
->n_locals
+ 1 >= func
->locals_alloc
)
1046 func
->locals_alloc
+= 32;
1047 func
->local_vars
= DBG_realloc(func
->local_vars
,
1048 func
->locals_alloc
* sizeof(WineLocals
));
1051 func
->local_vars
[func
->n_locals
].regno
= regno
;
1052 func
->local_vars
[func
->n_locals
].offset
= offset
;
1053 func
->local_vars
[func
->n_locals
].pc_start
= pc_start
;
1054 func
->local_vars
[func
->n_locals
].pc_end
= pc_end
;
1055 func
->local_vars
[func
->n_locals
].name
= DBG_strdup(name
);
1056 func
->local_vars
[func
->n_locals
].type
= NULL
;
1059 return &func
->local_vars
[func
->n_locals
- 1];
1063 DEBUG_DumpHashInfo()
1067 struct name_hash
*nh
;
1070 * Utility function to dump stats about the hash table.
1072 for(i
=0; i
<NR_NAME_HASH
; i
++)
1075 for (nh
= name_hash_table
[i
]; nh
; nh
= nh
->next
)
1079 fprintf(stderr
, "Bucket %d: %d\n", i
, depth
);
1083 /***********************************************************************
1084 * DEBUG_CheckLinenoStatus
1086 * Find the symbol nearest to a given address.
1087 * If ebp is specified as non-zero, it means we should dump the argument
1088 * list into the string we return as well.
1090 int DEBUG_CheckLinenoStatus( const DBG_ADDR
*addr
)
1092 struct name_hash
* nearest
= NULL
;
1095 if( sortlist_valid
== FALSE
)
1097 DEBUG_ResortSymbols();
1101 * Binary search to find closest symbol.
1104 high
= sorttab_nsym
;
1105 if( addr_sorttab
[0]->addr
.seg
> addr
->seg
1106 || ( addr_sorttab
[0]->addr
.seg
== addr
->seg
1107 && addr_sorttab
[0]->addr
.off
> addr
->off
) )
1111 else if( addr_sorttab
[high
- 1]->addr
.seg
< addr
->seg
1112 || ( addr_sorttab
[high
- 1]->addr
.seg
== addr
->seg
1113 && addr_sorttab
[high
- 1]->addr
.off
< addr
->off
) )
1115 nearest
= addr_sorttab
[high
- 1];
1121 mid
= (high
+ low
)/2;
1125 * See if there are any other entries that might also
1126 * have the same address, and would also have a line
1129 if( mid
> 0 && addr_sorttab
[mid
]->linetab
== NULL
)
1131 if( (addr_sorttab
[mid
- 1]->addr
.seg
==
1132 addr_sorttab
[mid
]->addr
.seg
)
1133 && (addr_sorttab
[mid
- 1]->addr
.off
==
1134 addr_sorttab
[mid
]->addr
.off
)
1135 && (addr_sorttab
[mid
- 1]->linetab
!= NULL
) )
1141 if( (mid
< sorttab_nsym
- 1)
1142 && (addr_sorttab
[mid
]->linetab
== NULL
) )
1144 if( (addr_sorttab
[mid
+ 1]->addr
.seg
==
1145 addr_sorttab
[mid
]->addr
.seg
)
1146 && (addr_sorttab
[mid
+ 1]->addr
.off
==
1147 addr_sorttab
[mid
]->addr
.off
)
1148 && (addr_sorttab
[mid
+ 1]->linetab
!= NULL
) )
1153 nearest
= addr_sorttab
[mid
];
1155 fprintf(stderr
, "Found %x:%x when looking for %x:%x %x %s\n",
1156 addr_sorttab
[mid
]->addr
.seg
,
1157 addr_sorttab
[mid
]->addr
.off
,
1158 addr
->seg
, addr
->off
,
1159 addr_sorttab
[mid
]->linetab
,
1160 addr_sorttab
[mid
]->name
);
1164 if( (addr_sorttab
[mid
]->addr
.seg
< addr
->seg
)
1165 || ( addr_sorttab
[mid
]->addr
.seg
== addr
->seg
1166 && addr_sorttab
[mid
]->addr
.off
<= addr
->off
) )
1177 if (!nearest
) return FUNC_HAS_NO_LINES
;
1179 if( nearest
->flags
& SYM_STEP_THROUGH
)
1182 * This will cause us to keep single stepping until
1183 * we get to the other side somewhere.
1185 return NOT_ON_LINENUMBER
;
1188 if( (nearest
->flags
& SYM_TRAMPOLINE
) )
1191 * This will cause us to keep single stepping until
1192 * we get to the other side somewhere.
1194 return FUNC_IS_TRAMPOLINE
;
1197 if( nearest
->linetab
== NULL
)
1199 return FUNC_HAS_NO_LINES
;
1204 * We never want to stop on the first instruction of a function
1205 * even if it has it's own linenumber. Let the thing keep running
1206 * until it gets past the function prologue. We only do this if there
1207 * is more than one line number for the function, of course.
1209 if( nearest
->addr
.off
== addr
->off
&& nearest
->n_lines
> 1 )
1211 return NOT_ON_LINENUMBER
;
1214 if( (nearest
->sourcefile
!= NULL
)
1215 && (addr
->off
- nearest
->addr
.off
< 0x100000) )
1218 high
= nearest
->n_lines
;
1219 while ((high
- low
) > 1)
1221 mid
= (high
+ low
) / 2;
1222 if (addr
->off
< nearest
->linetab
[mid
].pc_offset
.off
) high
= mid
;
1225 if (addr
->off
== nearest
->linetab
[low
].pc_offset
.off
)
1226 return AT_LINENUMBER
;
1228 return NOT_ON_LINENUMBER
;
1231 return FUNC_HAS_NO_LINES
;
1234 /***********************************************************************
1237 * Find the symbol nearest to a given address.
1238 * Returns sourcefile name and line number in a format that the listing
1239 * handler can deal with.
1242 DEBUG_GetFuncInfo( struct list_id
* ret
, const char * filename
,
1247 struct name_hash
*nh
;
1249 for(nh
= name_hash_table
[name_hash(name
)]; nh
; nh
= nh
->next
)
1251 if( filename
!= NULL
)
1254 if( nh
->sourcefile
== NULL
)
1259 pnt
= strrchr(nh
->sourcefile
, '/');
1260 if( strcmp(nh
->sourcefile
, filename
) != 0
1261 && (pnt
== NULL
|| strcmp(pnt
+ 1, filename
) != 0) )
1266 if (!strcmp(nh
->name
, name
)) break;
1269 if (!nh
&& (name
[0] != '_'))
1272 strcpy(buffer
+1, name
);
1273 for(nh
= name_hash_table
[name_hash(buffer
)]; nh
; nh
= nh
->next
)
1275 if( filename
!= NULL
)
1277 if( nh
->sourcefile
== NULL
)
1282 pnt
= strrchr(nh
->sourcefile
, '/');
1283 if( strcmp(nh
->sourcefile
, filename
) != 0
1284 && (pnt
== NULL
|| strcmp(pnt
+ 1, filename
) != 0) )
1289 if (!strcmp(nh
->name
, buffer
)) break;
1295 if( filename
!= NULL
)
1297 fprintf(stderr
, "No such function %s in %s\n", name
, filename
);
1301 fprintf(stderr
, "No such function %s\n", name
);
1303 ret
->sourcefile
= NULL
;
1308 ret
->sourcefile
= nh
->sourcefile
;
1311 * Search for the specific line number. If we don't find it,
1312 * then return FALSE.
1314 if( nh
->linetab
== NULL
)
1320 ret
->line
= nh
->linetab
[0].line_number
;
1324 /***********************************************************************
1325 * DEBUG_GetStackSymbolValue
1327 * Get the address of a named symbol from the current stack frame.
1330 BOOL
DEBUG_GetStackSymbolValue( const char * name
, DBG_ADDR
*addr
)
1332 struct name_hash
* curr_func
;
1337 if( DEBUG_GetCurrentFrame(&curr_func
, &eip
, &ebp
) == FALSE
)
1342 for(i
=0; i
< curr_func
->n_locals
; i
++ )
1345 * Test the range of validity of the local variable. This
1346 * comes up with RBRAC/LBRAC stabs in particular.
1348 if( (curr_func
->local_vars
[i
].pc_start
!= 0)
1349 && ((eip
- curr_func
->addr
.off
)
1350 < curr_func
->local_vars
[i
].pc_start
) )
1355 if( (curr_func
->local_vars
[i
].pc_end
!= 0)
1356 && ((eip
- curr_func
->addr
.off
)
1357 > curr_func
->local_vars
[i
].pc_end
) )
1362 if( strcmp(name
, curr_func
->local_vars
[i
].name
) == 0 )
1365 * OK, we found it. Now figure out what to do with this.
1367 /* FIXME: what if regno == 0 ($eax) */
1368 if( curr_func
->local_vars
[i
].regno
!= 0 )
1371 * Register variable. Point to DEBUG_context field.
1374 addr
->off
= ((DWORD
)&DEBUG_context
) + reg_ofs
[curr_func
->local_vars
[i
].regno
];
1375 addr
->type
= curr_func
->local_vars
[i
].type
;
1381 addr
->off
= ebp
+ curr_func
->local_vars
[i
].offset
;
1382 addr
->type
= curr_func
->local_vars
[i
].type
;
1393 struct name_hash
* curr_func
;
1400 if( DEBUG_GetCurrentFrame(&curr_func
, &eip
, &ebp
) == FALSE
)
1405 for(i
=0; i
< curr_func
->n_locals
; i
++ )
1408 * Test the range of validity of the local variable. This
1409 * comes up with RBRAC/LBRAC stabs in particular.
1411 if( (curr_func
->local_vars
[i
].pc_start
!= 0)
1412 && ((eip
- curr_func
->addr
.off
)
1413 < curr_func
->local_vars
[i
].pc_start
) )
1418 if( (curr_func
->local_vars
[i
].pc_end
!= 0)
1419 && ((eip
- curr_func
->addr
.off
)
1420 > curr_func
->local_vars
[i
].pc_end
) )
1425 if( curr_func
->local_vars
[i
].offset
== 0 )
1427 ptr
= (unsigned int *) (((DWORD
)&DEBUG_context
)
1428 + reg_ofs
[curr_func
->local_vars
[i
].regno
]);
1429 fprintf(stderr
, "%s:%s (optimized into register $%s) == 0x%8.8x\n",
1430 curr_func
->name
, curr_func
->local_vars
[i
].name
,
1431 reg_name
[curr_func
->local_vars
[i
].regno
],
1436 ptr
= (unsigned int *) (ebp
+ curr_func
->local_vars
[i
].offset
);
1437 fprintf(stderr
, "%s:%s == 0x%8.8x\n",
1438 curr_func
->name
, curr_func
->local_vars
[i
].name
,
1449 DEBUG_SetSymbolSize(struct name_hash
* sym
, unsigned int len
)
1451 sym
->symbol_size
= len
;
1457 DEBUG_SetSymbolBPOff(struct name_hash
* sym
, unsigned int off
)
1459 sym
->breakpoint_offset
= off
;
1465 DEBUG_GetSymbolAddr(struct name_hash
* sym
, DBG_ADDR
* addr
)
1473 int DEBUG_SetLocalSymbolType(struct wine_locals
* sym
, struct datatype
* type
)