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 high
= nearest
->n_lines
;
639 while ((high
- low
) > 1)
641 mid
= (high
+ low
) / 2;
642 if (addr
->off
< nearest
->linetab
[mid
].pc_offset
.off
)
647 lineno
= nearest
->linetab
[low
].line_number
;
652 sprintf(linebuff
, ":%d", lineno
);
656 source
->line
= lineno
;
660 /* Remove the path from the file name */
661 sourcefile
= strrchr( nearest
->sourcefile
, '/' );
662 if (!sourcefile
) sourcefile
= nearest
->sourcefile
;
665 if (addr
->off
== nearest
->addr
.off
)
666 sprintf( name_buffer
, "%s%s [%s%s]", nearest
->name
,
667 arglist
, sourcefile
, lineinfo
);
669 sprintf( name_buffer
, "%s+0x%lx%s [%s%s]", nearest
->name
,
670 addr
->off
- nearest
->addr
.off
,
671 arglist
, sourcefile
, lineinfo
);
675 if (addr
->off
== nearest
->addr
.off
)
676 sprintf( name_buffer
, "%s%s", nearest
->name
, arglist
);
678 if (addr
->seg
&& (nearest
->addr
.seg
!=addr
->seg
))
681 sprintf( name_buffer
, "%s+0x%lx%s", nearest
->name
,
682 addr
->off
- nearest
->addr
.off
, arglist
);
689 /***********************************************************************
690 * DEBUG_ReadSymbolTable
692 * Read a symbol file into the hash table.
694 void DEBUG_ReadSymbolTable( const char * filename
)
697 DBG_ADDR addr
= { 0, 0 };
704 if (!(symbolfile
= fopen(filename
, "r")))
706 fprintf( stderr
, "Unable to open symbol table %s\n", filename
);
710 fprintf( stderr
, "Reading symbols from file %s\n", filename
);
714 fgets( buffer
, sizeof(buffer
), symbolfile
);
715 if (feof(symbolfile
)) break;
717 /* Strip any text after a # sign (i.e. comments) */
720 if(*cpnt
++ == '#') { *cpnt
= 0; break; }
722 /* Quietly ignore any lines that have just whitespace */
726 if(*cpnt
!= ' ' && *cpnt
!= '\t') break;
729 if (!(*cpnt
) || *cpnt
== '\n') continue;
731 nargs
= sscanf(buffer
, "%lx %c %s", &addr
.off
, &type
, name
);
732 DEBUG_AddSymbol( name
, &addr
, NULL
, SYM_WINE
);
738 /***********************************************************************
739 * DEBUG_LoadEntryPoints16
741 * Load the entry points of a Win16 module into the hash table.
743 static void DEBUG_LoadEntryPoints16( HMODULE16 hModule
, NE_MODULE
*pModule
,
750 /* First search the resident names */
752 unsigned char *cpnt
= (unsigned char *)pModule
+ pModule
->name_table
;
755 cpnt
+= *cpnt
+ 1 + sizeof(WORD
);
756 sprintf( buffer
, "%s.%.*s", name
, *cpnt
, cpnt
+ 1 );
757 if ((address
= NE_GetEntryPoint(hModule
, *(WORD
*)(cpnt
+ *cpnt
+ 1))))
759 addr
.seg
= HIWORD(address
);
760 addr
.off
= LOWORD(address
);
762 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
766 /* Now search the non-resident names table */
768 if (!pModule
->nrname_handle
) return; /* No non-resident table */
769 cpnt
= (char *)GlobalLock16( pModule
->nrname_handle
);
772 cpnt
+= *cpnt
+ 1 + sizeof(WORD
);
773 sprintf( buffer
, "%s.%.*s", name
, *cpnt
, cpnt
+ 1 );
774 if ((address
= NE_GetEntryPoint(hModule
, *(WORD
*)(cpnt
+ *cpnt
+ 1))))
776 addr
.seg
= HIWORD(address
);
777 addr
.off
= LOWORD(address
);
779 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
785 /***********************************************************************
786 * DEBUG_LoadEntryPoints32
788 * Load the entry points of a Win32 module into the hash table.
790 static void DEBUG_LoadEntryPoints32( HMODULE32 hModule
, const char *name
)
792 #define RVA(x) (hModule+(DWORD)(x))
797 IMAGE_SECTION_HEADER
*pe_seg
;
798 IMAGE_EXPORT_DIRECTORY
*exports
;
799 IMAGE_DATA_DIRECTORY
*dir
;
807 /* Add start of DLL */
810 DEBUG_AddSymbol( name
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
812 /* Add entry point */
814 sprintf( buffer
, "%s.EntryPoint", name
);
815 addr
.off
= (DWORD
)RVA_PTR( hModule
, OptionalHeader
.AddressOfEntryPoint
);
816 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
818 /* Add start of sections */
820 pe_seg
= PE_SECTIONS(hModule
);
821 for (i
= 0; i
< PE_HEADER(hModule
)->FileHeader
.NumberOfSections
; i
++)
823 sprintf( buffer
, "%s.%s", name
, pe_seg
->Name
);
824 addr
.off
= RVA(pe_seg
->VirtualAddress
);
825 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
829 /* Add exported functions */
831 dir
= &PE_HEADER(hModule
)->OptionalHeader
.
832 DataDirectory
[IMAGE_DIRECTORY_ENTRY_EXPORT
];
833 if (!dir
->Size
) return;
834 exports
= (IMAGE_EXPORT_DIRECTORY
*)RVA( dir
->VirtualAddress
);
835 ordinals
= (WORD
*)RVA( exports
->AddressOfNameOrdinals
);
836 names
= (const char **)RVA( exports
->AddressOfNames
);
837 functions
= (void **)RVA( exports
->AddressOfFunctions
);
839 for (i
= 0; i
< exports
->NumberOfNames
; i
++)
841 if (!names
[i
]) continue;
842 sprintf( buffer
, "%s.%s", name
, (char *)RVA(names
[i
]) );
843 addr
.off
= RVA( functions
[ordinals
[i
]] );
844 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
847 for (i
= 0; i
< exports
->NumberOfFunctions
; i
++)
849 if (!functions
[i
]) continue;
850 /* Check if we already added it with a name */
851 for (j
= 0; j
< exports
->NumberOfNames
; j
++)
852 if ((ordinals
[j
] == i
) && names
[j
]) break;
853 if (j
< exports
->NumberOfNames
) continue;
854 sprintf( buffer
, "%s.%ld", name
, i
+ exports
->Base
);
855 addr
.off
= (DWORD
)RVA( functions
[i
] );
856 DEBUG_AddSymbol( buffer
, &addr
, NULL
, SYM_WIN32
| SYM_FUNC
);
859 dir
= &PE_HEADER(hModule
)->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_DEBUG
];
861 DEBUG_RegisterDebugInfo(hModule
, name
, dir
->VirtualAddress
, dir
->Size
);
866 /***********************************************************************
867 * DEBUG_LoadEntryPoints
869 * Load the entry points of all the modules into the hash table.
871 void DEBUG_LoadEntryPoints(void)
878 for (ok
= ModuleFirst(&entry
); ok
; ok
= ModuleNext(&entry
))
880 if (!(pModule
= NE_GetPtr( entry
.hModule
))) continue;
881 fprintf( stderr
, " %s", entry
.szModule
);
883 if (!(pModule
->flags
& NE_FFLAGS_WIN32
)) /* NE module */
884 DEBUG_LoadEntryPoints16( entry
.hModule
, pModule
, entry
.szModule
);
886 for (wm
=PROCESS_Current()->modref_list
;wm
;wm
=wm
->next
) {
887 fprintf( stderr
, " %s", wm
->modname
);
888 DEBUG_LoadEntryPoints32( wm
->module
, wm
->modname
);
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
;
980 if( sortlist_valid
== FALSE
)
982 DEBUG_ResortSymbols();
986 * Binary search to find closest symbol.
990 if( addr_sorttab
[0]->addr
.seg
> addr
->seg
991 || ( addr_sorttab
[0]->addr
.seg
== addr
->seg
992 && addr_sorttab
[0]->addr
.off
> addr
->off
) )
996 else if( addr_sorttab
[high
- 1]->addr
.seg
< addr
->seg
997 || ( addr_sorttab
[high
- 1]->addr
.seg
== addr
->seg
998 && addr_sorttab
[high
- 1]->addr
.off
< addr
->off
) )
1000 nearest
= addr_sorttab
[high
- 1];
1006 mid
= (high
+ low
)/2;
1010 * See if there are any other entries that might also
1011 * have the same address, and would also have a line
1014 if( mid
> 0 && addr_sorttab
[mid
]->linetab
== NULL
)
1016 if( (addr_sorttab
[mid
- 1]->addr
.seg
==
1017 addr_sorttab
[mid
]->addr
.seg
)
1018 && (addr_sorttab
[mid
- 1]->addr
.off
==
1019 addr_sorttab
[mid
]->addr
.off
)
1020 && (addr_sorttab
[mid
- 1]->linetab
!= NULL
) )
1026 if( (mid
< sorttab_nsym
- 1)
1027 && (addr_sorttab
[mid
]->linetab
== NULL
) )
1029 if( (addr_sorttab
[mid
+ 1]->addr
.seg
==
1030 addr_sorttab
[mid
]->addr
.seg
)
1031 && (addr_sorttab
[mid
+ 1]->addr
.off
==
1032 addr_sorttab
[mid
]->addr
.off
)
1033 && (addr_sorttab
[mid
+ 1]->linetab
!= NULL
) )
1038 nearest
= addr_sorttab
[mid
];
1040 fprintf(stderr
, "Found %x:%x when looking for %x:%x %x %s\n",
1041 addr_sorttab
[mid
]->addr
.seg
,
1042 addr_sorttab
[mid
]->addr
.off
,
1043 addr
->seg
, addr
->off
,
1044 addr_sorttab
[mid
]->linetab
,
1045 addr_sorttab
[mid
]->name
);
1049 if( (addr_sorttab
[mid
]->addr
.seg
< addr
->seg
)
1050 || ( addr_sorttab
[mid
]->addr
.seg
== addr
->seg
1051 && addr_sorttab
[mid
]->addr
.off
<= addr
->off
) )
1062 if (!nearest
) return FUNC_HAS_NO_LINES
;
1064 if( nearest
->flags
& SYM_STEP_THROUGH
)
1067 * This will cause us to keep single stepping until
1068 * we get to the other side somewhere.
1070 return NOT_ON_LINENUMBER
;
1073 if( (nearest
->flags
& SYM_TRAMPOLINE
) )
1076 * This will cause us to keep single stepping until
1077 * we get to the other side somewhere.
1079 return FUNC_IS_TRAMPOLINE
;
1082 if( nearest
->linetab
== NULL
)
1084 return FUNC_HAS_NO_LINES
;
1089 * We never want to stop on the first instruction of a function
1090 * even if it has it's own linenumber. Let the thing keep running
1091 * until it gets past the function prologue. We only do this if there
1092 * is more than one line number for the function, of course.
1094 if( nearest
->addr
.off
== addr
->off
&& nearest
->n_lines
> 1 )
1096 return NOT_ON_LINENUMBER
;
1099 if( (nearest
->sourcefile
!= NULL
)
1100 && (addr
->off
- nearest
->addr
.off
< 0x100000) )
1103 high
= nearest
->n_lines
;
1104 while ((high
- low
) > 1)
1106 mid
= (high
+ low
) / 2;
1107 if (addr
->off
< nearest
->linetab
[mid
].pc_offset
.off
) high
= mid
;
1110 if (addr
->off
== nearest
->linetab
[low
].pc_offset
.off
)
1111 return AT_LINENUMBER
;
1113 return NOT_ON_LINENUMBER
;
1116 return FUNC_HAS_NO_LINES
;
1119 /***********************************************************************
1122 * Find the symbol nearest to a given address.
1123 * Returns sourcefile name and line number in a format that the listing
1124 * handler can deal with.
1127 DEBUG_GetFuncInfo( struct list_id
* ret
, const char * filename
,
1132 struct name_hash
*nh
;
1134 for(nh
= name_hash_table
[name_hash(name
)]; nh
; nh
= nh
->next
)
1136 if( filename
!= NULL
)
1139 if( nh
->sourcefile
== NULL
)
1144 pnt
= strrchr(nh
->sourcefile
, '/');
1145 if( strcmp(nh
->sourcefile
, filename
) != 0
1146 && (pnt
== NULL
|| strcmp(pnt
+ 1, filename
) != 0) )
1151 if (!strcmp(nh
->name
, name
)) break;
1154 if (!nh
&& (name
[0] != '_'))
1157 strcpy(buffer
+1, name
);
1158 for(nh
= name_hash_table
[name_hash(buffer
)]; nh
; nh
= nh
->next
)
1160 if( filename
!= NULL
)
1162 if( nh
->sourcefile
== NULL
)
1167 pnt
= strrchr(nh
->sourcefile
, '/');
1168 if( strcmp(nh
->sourcefile
, filename
) != 0
1169 && (pnt
== NULL
|| strcmp(pnt
+ 1, filename
) != 0) )
1174 if (!strcmp(nh
->name
, buffer
)) break;
1180 if( filename
!= NULL
)
1182 fprintf(stderr
, "No such function %s in %s\n", name
, filename
);
1186 fprintf(stderr
, "No such function %s\n", name
);
1188 ret
->sourcefile
= NULL
;
1193 ret
->sourcefile
= nh
->sourcefile
;
1196 * Search for the specific line number. If we don't find it,
1197 * then return FALSE.
1199 if( nh
->linetab
== NULL
)
1205 ret
->line
= nh
->linetab
[0].line_number
;
1209 /***********************************************************************
1210 * DEBUG_GetStackSymbolValue
1212 * Get the address of a named symbol from the current stack frame.
1215 BOOL32
DEBUG_GetStackSymbolValue( const char * name
, DBG_ADDR
*addr
)
1217 struct name_hash
* curr_func
;
1222 if( DEBUG_GetCurrentFrame(&curr_func
, &eip
, &ebp
) == FALSE
)
1227 for(i
=0; i
< curr_func
->n_locals
; i
++ )
1230 * Test the range of validity of the local variable. This
1231 * comes up with RBRAC/LBRAC stabs in particular.
1233 if( (curr_func
->local_vars
[i
].pc_start
!= 0)
1234 && ((eip
- curr_func
->addr
.off
)
1235 < curr_func
->local_vars
[i
].pc_start
) )
1240 if( (curr_func
->local_vars
[i
].pc_end
!= 0)
1241 && ((eip
- curr_func
->addr
.off
)
1242 > curr_func
->local_vars
[i
].pc_end
) )
1247 if( strcmp(name
, curr_func
->local_vars
[i
].name
) == 0 )
1250 * OK, we found it. Now figure out what to do with this.
1252 if( curr_func
->local_vars
[i
].regno
!= 0 )
1255 * Register variable. We don't know how to treat
1262 addr
->off
= ebp
+ curr_func
->local_vars
[i
].offset
;
1263 addr
->type
= curr_func
->local_vars
[i
].type
;
1274 struct name_hash
* curr_func
;
1281 if( DEBUG_GetCurrentFrame(&curr_func
, &eip
, &ebp
) == FALSE
)
1286 for(i
=0; i
< curr_func
->n_locals
; i
++ )
1289 * Test the range of validity of the local variable. This
1290 * comes up with RBRAC/LBRAC stabs in particular.
1292 if( (curr_func
->local_vars
[i
].pc_start
!= 0)
1293 && ((eip
- curr_func
->addr
.off
)
1294 < curr_func
->local_vars
[i
].pc_start
) )
1299 if( (curr_func
->local_vars
[i
].pc_end
!= 0)
1300 && ((eip
- curr_func
->addr
.off
)
1301 > curr_func
->local_vars
[i
].pc_end
) )
1306 if( curr_func
->local_vars
[i
].offset
== 0 )
1308 fprintf(stderr
, "%s:%s optimized into register $%s \n",
1309 curr_func
->name
, curr_func
->local_vars
[i
].name
,
1310 reg_name
[curr_func
->local_vars
[i
].regno
]);
1314 ptr
= (unsigned int *) (ebp
+ curr_func
->local_vars
[i
].offset
);
1315 fprintf(stderr
, "%s:%s == 0x%8.8x\n",
1316 curr_func
->name
, curr_func
->local_vars
[i
].name
,
1327 DEBUG_SetSymbolSize(struct name_hash
* sym
, unsigned int len
)
1329 sym
->symbol_size
= len
;
1335 DEBUG_SetSymbolBPOff(struct name_hash
* sym
, unsigned int off
)
1337 sym
->breakpoint_offset
= off
;
1343 DEBUG_GetSymbolAddr(struct name_hash
* sym
, DBG_ADDR
* addr
)
1351 int DEBUG_SetLocalSymbolType(struct wine_locals
* sym
, struct datatype
* type
)