2 * File hash.c - generate hash tables for Wine debugger symbols
4 * Copyright (C) 1993, Eric Youngdale.
13 #include <sys/types.h>
16 #define NR_NAME_HASH 16384
18 #define PATH_MAX _MAX_PATH
22 static char * reg_name
[] =
24 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"
27 static unsigned reg_ofs
[] =
29 FIELD_OFFSET(CONTEXT
, Eax
), FIELD_OFFSET(CONTEXT
, Ecx
),
30 FIELD_OFFSET(CONTEXT
, Edx
), FIELD_OFFSET(CONTEXT
, Ebx
),
31 FIELD_OFFSET(CONTEXT
, Esp
), FIELD_OFFSET(CONTEXT
, Ebp
),
32 FIELD_OFFSET(CONTEXT
, Esi
), FIELD_OFFSET(CONTEXT
, Edi
)
35 static char * reg_name
[] = { NULL
}; /* FIXME */
36 static unsigned reg_ofs
[] = { 0 };
42 struct name_hash
* next
; /* Used to look up within name hash */
48 WineLocals
* local_vars
;
56 unsigned short breakpoint_offset
;
57 unsigned int symbol_size
;
61 static BOOL
DEBUG_GetStackSymbolValue( const char * name
, DBG_VALUE
*value
);
62 static int sortlist_valid
= FALSE
;
64 static int sorttab_nsym
;
65 static struct name_hash
** addr_sorttab
= NULL
;
67 static struct name_hash
* name_hash_table
[NR_NAME_HASH
];
69 static unsigned int name_hash( const char * name
)
71 unsigned int hash
= 0;
79 hash
= (hash
<< 4) + *p
++;
81 if( (tmp
= (hash
& 0xf0000000)) )
87 return hash
% NR_NAME_HASH
;
91 DEBUG_cmp_sym(const void * p1
, const void * p2
)
93 struct name_hash
** name1
= (struct name_hash
**) p1
;
94 struct name_hash
** name2
= (struct name_hash
**) p2
;
96 if( ((*name1
)->flags
& SYM_INVALID
) != 0 )
101 if( ((*name2
)->flags
& SYM_INVALID
) != 0 )
106 if( (*name1
)->value
.addr
.seg
> (*name2
)->value
.addr
.seg
)
111 if( (*name1
)->value
.addr
.seg
< (*name2
)->value
.addr
.seg
)
116 if( (*name1
)->value
.addr
.off
> (*name2
)->value
.addr
.off
)
121 if( (*name1
)->value
.addr
.off
< (*name2
)->value
.addr
.off
)
129 /***********************************************************************
130 * DEBUG_ResortSymbols
132 * Rebuild sorted list of symbols.
136 DEBUG_ResortSymbols(void)
138 struct name_hash
*nh
;
142 for(i
=0; i
<NR_NAME_HASH
; i
++)
144 for (nh
= name_hash_table
[i
]; nh
; nh
= nh
->next
)
146 if( (nh
->flags
& SYM_INVALID
) == 0 )
149 DEBUG_Printf( DBG_CHN_MESG
, "Symbol %s is invalid\n", nh
->name
);
159 addr_sorttab
= (struct name_hash
**) DBG_realloc(addr_sorttab
,
160 nsym
* sizeof(struct name_hash
*));
163 for(i
=0; i
<NR_NAME_HASH
; i
++)
165 for (nh
= name_hash_table
[i
]; nh
; nh
= nh
->next
)
167 if( (nh
->flags
& SYM_INVALID
) == 0 )
168 addr_sorttab
[nsym
++] = nh
;
172 qsort(addr_sorttab
, nsym
,
173 sizeof(struct name_hash
*), DEBUG_cmp_sym
);
174 sortlist_valid
= TRUE
;
178 /***********************************************************************
181 * Add a symbol to the table.
184 DEBUG_AddSymbol( const char * name
, const DBG_VALUE
*value
,
185 const char * source
, int flags
)
187 struct name_hash
* new;
188 struct name_hash
*nh
;
189 static char prev_source
[PATH_MAX
] = {'\0', };
190 static char * prev_duped_source
= NULL
;
193 assert(value
->cookie
== DV_TARGET
|| value
->cookie
== DV_HOST
);
195 hash
= name_hash(name
);
196 for (nh
= name_hash_table
[hash
]; nh
; nh
= nh
->next
)
198 if( ((nh
->flags
& SYM_INVALID
) != 0) && strcmp(name
, nh
->name
) == 0 )
201 DEBUG_Printf(DBG_CHN_MESG
, "Changing address for symbol %s (%08lx:%08lx => %08lx:%08lx)\n",
202 name
, nh
->value
.addr
.seg
, nh
->value
.addr
.off
, value
->addr
.seg
, value
->addr
.off
);
204 nh
->value
.addr
= value
->addr
;
205 if( nh
->value
.type
== NULL
&& value
->type
!= NULL
)
207 nh
->value
.type
= value
->type
;
208 nh
->value
.cookie
= value
->cookie
;
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
;
220 if (nh
->value
.addr
.seg
== value
->addr
.seg
&&
221 nh
->value
.addr
.off
== value
->addr
.off
&&
222 strcmp(name
, nh
->name
) == 0 )
229 DEBUG_Printf(DBG_CHN_TRACE
, "adding symbol (%s) from file '%s' at 0x%04lx:%08lx\n",
230 name
, source
, value
->addr
.seg
, value
->addr
.off
);
234 * First see if we already have an entry for this symbol. If so
235 * return it, so we don't end up with duplicates.
238 new = (struct name_hash
*) DBG_alloc(sizeof(struct name_hash
));
240 new->name
= DBG_strdup(name
);
245 * This is an enhancement to reduce memory consumption. The idea
246 * is that we duplicate a given string only once. This is a big
247 * win if there are lots of symbols defined in a given source file.
249 if( strcmp(source
, prev_source
) == 0 )
251 new->sourcefile
= prev_duped_source
;
255 strcpy(prev_source
, source
);
256 prev_duped_source
= new->sourcefile
= DBG_strdup(source
);
261 new->sourcefile
= NULL
;
265 new->lines_alloc
= 0;
269 new->locals_alloc
= 0;
270 new->local_vars
= NULL
;
275 /* Now insert into the hash table */
276 new->next
= name_hash_table
[hash
];
277 name_hash_table
[hash
] = new;
280 * Check some heuristics based upon the file name to see whether
281 * we want to step through this guy or not. These are machine generated
282 * assembly files that are used to translate between the MS way of
283 * calling things and the GCC way of calling things. In general we
284 * always want to step through.
286 if ( source
!= NULL
) {
287 int len
= strlen(source
);
289 if (len
> 2 && source
[len
-2] == '.' && source
[len
-1] == 's') {
290 char* c
= strrchr(source
- 2, '/');
292 if (strcmp(c
+ 1, "asmrelay.s") == 0)
293 new->flags
|= SYM_TRAMPOLINE
;
298 sortlist_valid
= FALSE
;
302 BOOL
DEBUG_Normalize(struct name_hash
* nh
)
306 * We aren't adding any more locals or linenumbers to this function.
307 * Free any spare memory that we might have allocated.
314 if( nh
->n_locals
!= nh
->locals_alloc
)
316 nh
->locals_alloc
= nh
->n_locals
;
317 nh
->local_vars
= DBG_realloc(nh
->local_vars
,
318 nh
->locals_alloc
* sizeof(WineLocals
));
321 if( nh
->n_lines
!= nh
->lines_alloc
)
323 nh
->lines_alloc
= nh
->n_lines
;
324 nh
->linetab
= DBG_realloc(nh
->linetab
,
325 nh
->lines_alloc
* sizeof(WineLineNo
));
331 /***********************************************************************
332 * DEBUG_GetSymbolValue
334 * Get the address of a named symbol.
336 static int DEBUG_GSV_Helper(const char* name
, const int lineno
,
337 DBG_VALUE
* value
, int num
, int bp_flag
)
339 struct name_hash
* nh
;
343 for (nh
= name_hash_table
[name_hash(name
)]; nh
; nh
= nh
->next
)
345 if ((nh
->flags
& SYM_INVALID
) != 0) continue;
346 if (!strcmp(nh
->name
, name
) && DEBUG_GetLineNumberAddr( nh
, lineno
, &addr
, bp_flag
))
348 if (i
>= num
) return num
+ 1;
349 value
[i
].addr
= addr
;
350 value
[i
].type
= nh
->value
.type
;
351 value
[i
].cookie
= nh
->value
.cookie
;
358 BOOL
DEBUG_GetSymbolValue( const char * name
, const int lineno
,
359 DBG_VALUE
*rtn
, int bp_flag
)
362 /* FIXME: NUMDBGV should be made variable */
363 DBG_VALUE value
[NUMDBGV
];
365 int num
, i
, local
= -1;
367 num
= DEBUG_GSV_Helper(name
, lineno
, value
, NUMDBGV
, bp_flag
);
368 if (!num
&& (name
[0] != '_'))
372 assert(strlen(name
) < sizeof(buffer
) - 2); /* one for '_', one for '\0' */
374 strcpy(buffer
+ 1, name
);
375 num
= DEBUG_GSV_Helper(buffer
, lineno
, value
, NUMDBGV
, bp_flag
);
378 /* now get the local symbols if any */
379 if (DEBUG_GetStackSymbolValue(name
, &vtmp
) && num
< NUMDBGV
)
388 } else if (!DEBUG_interactiveP
|| num
== 1) {
393 if (num
== NUMDBGV
+1) {
394 DEBUG_Printf(DBG_CHN_MESG
, "Too many addresses for symbol '%s', limiting the first %d\n", name
, NUMDBGV
);
397 DEBUG_Printf(DBG_CHN_MESG
, "Many symbols with name '%s', choose the one you want (<cr> to abort):\n", name
);
398 for (i
= 0; i
< num
; i
++) {
399 DEBUG_Printf(DBG_CHN_MESG
, "[%d]: ", i
+ 1);
401 struct name_hash
*func
;
405 if (DEBUG_GetCurrentFrame(&func
, &eip
, &ebp
))
406 DEBUG_Printf(DBG_CHN_MESG
, "local variable of %s in %s\n", func
->name
, func
->sourcefile
);
408 DEBUG_Printf(DBG_CHN_MESG
, "local variable\n");
410 DEBUG_PrintAddress( &value
[i
].addr
, DEBUG_GetSelectorType(value
[i
].addr
.seg
), TRUE
);
411 DEBUG_Printf(DBG_CHN_MESG
, "\n");
416 if (DEBUG_ReadLine("=> ", buffer
, sizeof(buffer
), FALSE
))
419 if (i
< 1 || i
> num
)
420 DEBUG_Printf(DBG_CHN_MESG
, "Invalid choice %d\n", i
);
422 } while (i
< 1 || i
> num
);
424 /* The array is 0-based, but the choices are 1..n, so we have to subtract one before returning. */
431 /***********************************************************************
432 * DEBUG_GetLineNumberAddr
434 * Get the address of a named symbol.
436 BOOL
DEBUG_GetLineNumberAddr( const struct name_hash
* nh
, const int lineno
,
437 DBG_ADDR
*addr
, int bp_flag
)
443 *addr
= nh
->value
.addr
;
446 addr
->off
+= nh
->breakpoint_offset
;
452 * Search for the specific line number. If we don't find it,
455 if( nh
->linetab
== NULL
)
460 for(i
=0; i
< nh
->n_lines
; i
++ )
462 if( nh
->linetab
[i
].line_number
== lineno
)
464 *addr
= nh
->linetab
[i
].pc_offset
;
470 * This specific line number not found.
479 /***********************************************************************
480 * DEBUG_SetSymbolValue
482 * Set the address of a named symbol.
484 BOOL
DEBUG_SetSymbolValue( const char * name
, const DBG_VALUE
*value
)
487 struct name_hash
*nh
;
489 assert(value
->cookie
== DV_TARGET
|| value
->cookie
== DV_HOST
);
491 for(nh
= name_hash_table
[name_hash(name
)]; nh
; nh
= nh
->next
)
492 if (!strcmp(nh
->name
, name
)) break;
494 if (!nh
&& (name
[0] != '_'))
497 strcpy(buffer
+1, name
);
498 for(nh
= name_hash_table
[name_hash(buffer
)]; nh
; nh
= nh
->next
)
499 if (!strcmp(nh
->name
, buffer
)) break;
502 if (!nh
) return FALSE
;
504 nh
->flags
&= ~SYM_INVALID
;
507 DEBUG_FixAddress( &nh
->value
.addr
, DEBUG_context
.SegDs
);
514 /***********************************************************************
515 * DEBUG_FindNearestSymbol
517 * Find the symbol nearest to a given address.
518 * If ebp is specified as non-zero, it means we should dump the argument
519 * list into the string we return as well.
521 const char * DEBUG_FindNearestSymbol( const DBG_ADDR
*addr
, int flag
,
522 struct name_hash
** rtn
,
524 struct list_id
* source
)
526 static char name_buffer
[MAX_PATH
+ 256];
527 static char arglist
[1024];
528 static char argtmp
[256];
529 struct name_hash
* nearest
= NULL
;
533 char * lineinfo
, *sourcefile
;
547 source
->sourcefile
= NULL
;
551 if( sortlist_valid
== FALSE
)
553 DEBUG_ResortSymbols();
556 if( sortlist_valid
== FALSE
)
562 * FIXME - use the binary search that we added to
563 * the function DEBUG_CheckLinenoStatus. Better yet, we should
564 * probably keep some notion of the current function so we don't
565 * have to search every time.
568 * Binary search to find closest symbol.
572 if( addr_sorttab
[0]->value
.addr
.seg
> addr
->seg
573 || ( addr_sorttab
[0]->value
.addr
.seg
== addr
->seg
574 && addr_sorttab
[0]->value
.addr
.off
> addr
->off
) )
578 else if( addr_sorttab
[high
- 1]->value
.addr
.seg
< addr
->seg
579 || ( addr_sorttab
[high
- 1]->value
.addr
.seg
== addr
->seg
580 && addr_sorttab
[high
- 1]->value
.addr
.off
< addr
->off
) )
582 nearest
= addr_sorttab
[high
- 1];
588 mid
= (high
+ low
)/2;
592 * See if there are any other entries that might also
593 * have the same address, and would also have a line
596 if( mid
> 0 && addr_sorttab
[mid
]->linetab
== NULL
)
598 if( (addr_sorttab
[mid
- 1]->value
.addr
.seg
==
599 addr_sorttab
[mid
]->value
.addr
.seg
)
600 && (addr_sorttab
[mid
- 1]->value
.addr
.off
==
601 addr_sorttab
[mid
]->value
.addr
.off
)
602 && (addr_sorttab
[mid
- 1]->linetab
!= NULL
) )
608 if( (mid
< sorttab_nsym
- 1)
609 && (addr_sorttab
[mid
]->linetab
== NULL
) )
611 if( (addr_sorttab
[mid
+ 1]->value
.addr
.seg
==
612 addr_sorttab
[mid
]->value
.addr
.seg
)
613 && (addr_sorttab
[mid
+ 1]->value
.addr
.off
==
614 addr_sorttab
[mid
]->value
.addr
.off
)
615 && (addr_sorttab
[mid
+ 1]->linetab
!= NULL
) )
620 nearest
= addr_sorttab
[mid
];
622 DEBUG_Printf(DBG_CHN_MESG
, "Found %x:%x when looking for %x:%x %x %s\n",
623 addr_sorttab
[mid
]->value
.addr
.seg
,
624 addr_sorttab
[mid
]->value
.addr
.off
,
625 addr
->seg
, addr
->off
,
626 addr_sorttab
[mid
]->linetab
,
627 addr_sorttab
[mid
]->name
);
631 if( (addr_sorttab
[mid
]->value
.addr
.seg
< addr
->seg
)
632 || ( addr_sorttab
[mid
]->value
.addr
.seg
== addr
->seg
633 && addr_sorttab
[mid
]->value
.addr
.off
<= addr
->off
) )
644 if (!nearest
) return NULL
;
652 * Fill in the relevant bits to the structure so that we can
653 * locate the source and line for this bit of code.
657 source
->sourcefile
= nearest
->sourcefile
;
658 if( nearest
->linetab
== NULL
)
664 source
->line
= nearest
->linetab
[0].line_number
;
672 * Prepare to display the argument list. If ebp is specified, it is
673 * the framepointer for the function in question. If not specified,
674 * we don't want the arglist.
676 memset(arglist
, '\0', sizeof(arglist
));
679 for(i
=0; i
< nearest
->n_locals
; i
++ )
682 * If this is a register (offset == 0) or a local
683 * variable, we don't want to know about it.
685 if( nearest
->local_vars
[i
].offset
<= 0 )
690 ptr
= (unsigned int *) (ebp
+ nearest
->local_vars
[i
].offset
);
691 if( arglist
[0] == '\0' )
697 strcat(arglist
, ", ");
699 DEBUG_READ_MEM_VERBOSE(ptr
, &val
, sizeof(val
));
700 sprintf(argtmp
, "%s=0x%x", nearest
->local_vars
[i
].name
, val
);
702 strcat(arglist
, argtmp
);
704 if( arglist
[0] == '(' )
706 strcat(arglist
, ")");
710 module
= DEBUG_FindModuleByAddr((void*)DEBUG_ToLinear(addr
), DMT_UNKNOWN
);
712 char* ptr
= strrchr(module
->module_name
, '/');
714 if (!ptr
++) ptr
= module
->module_name
;
715 sprintf( modbuf
, " in %s", ptr
);
720 if( (nearest
->sourcefile
!= NULL
) && (flag
== TRUE
)
721 && (addr
->off
- nearest
->value
.addr
.off
< 0x100000) )
725 * Try and find the nearest line number to the current offset.
727 if( nearest
->linetab
!= NULL
)
730 high
= nearest
->n_lines
;
731 while ((high
- low
) > 1)
733 mid
= (high
+ low
) / 2;
734 if (addr
->off
< nearest
->linetab
[mid
].pc_offset
.off
)
739 lineno
= nearest
->linetab
[low
].line_number
;
744 sprintf(linebuff
, ":%d", lineno
);
748 source
->line
= lineno
;
752 /* Remove the path from the file name */
753 sourcefile
= strrchr( nearest
->sourcefile
, '/' );
754 if (!sourcefile
) sourcefile
= nearest
->sourcefile
;
757 if (addr
->off
== nearest
->value
.addr
.off
)
758 sprintf( name_buffer
, "%s%s [%s%s]%s", nearest
->name
,
759 arglist
, sourcefile
, lineinfo
, modbuf
);
761 sprintf( name_buffer
, "%s+0x%lx%s [%s%s]%s", nearest
->name
,
762 addr
->off
- nearest
->value
.addr
.off
,
763 arglist
, sourcefile
, lineinfo
, modbuf
);
767 if (addr
->off
== nearest
->value
.addr
.off
)
768 sprintf( name_buffer
, "%s%s%s", nearest
->name
, arglist
, modbuf
);
770 if (addr
->seg
&& (nearest
->value
.addr
.seg
!=addr
->seg
))
773 sprintf( name_buffer
, "%s+0x%lx%s%s", nearest
->name
,
774 addr
->off
- nearest
->value
.addr
.off
, arglist
, modbuf
);
781 /***********************************************************************
782 * DEBUG_ReadSymbolTable
784 * Read a symbol file into the hash table.
786 void DEBUG_ReadSymbolTable( const char* filename
)
795 if (!(symbolfile
= fopen(filename
, "r")))
797 DEBUG_Printf( DBG_CHN_WARN
, "Unable to open symbol table %s\n", filename
);
801 DEBUG_Printf( DBG_CHN_MESG
, "Reading symbols from file %s\n", filename
);
806 value
.cookie
= DV_TARGET
;
810 fgets( buffer
, sizeof(buffer
), symbolfile
);
811 if (feof(symbolfile
)) break;
813 /* Strip any text after a # sign (i.e. comments) */
816 if(*cpnt
++ == '#') { *cpnt
= 0; break; }
818 /* Quietly ignore any lines that have just whitespace */
822 if(*cpnt
!= ' ' && *cpnt
!= '\t') break;
825 if (!(*cpnt
) || *cpnt
== '\n') continue;
827 if (sscanf(buffer
, "%lx %c %s", &value
.addr
.off
, &type
, name
) == 3)
828 DEBUG_AddSymbol( name
, &value
, NULL
, SYM_WINE
);
835 DEBUG_AddLineNumber( struct name_hash
* func
, int line_num
,
836 unsigned long offset
)
843 if( func
->n_lines
+ 1 >= func
->lines_alloc
)
845 func
->lines_alloc
+= 64;
846 func
->linetab
= DBG_realloc(func
->linetab
,
847 func
->lines_alloc
* sizeof(WineLineNo
));
850 func
->linetab
[func
->n_lines
].line_number
= line_num
;
851 func
->linetab
[func
->n_lines
].pc_offset
.seg
= func
->value
.addr
.seg
;
852 func
->linetab
[func
->n_lines
].pc_offset
.off
= func
->value
.addr
.off
+ offset
;
858 DEBUG_AddLocal( struct name_hash
* func
, int regno
,
869 if( func
->n_locals
+ 1 >= func
->locals_alloc
)
871 func
->locals_alloc
+= 32;
872 func
->local_vars
= DBG_realloc(func
->local_vars
,
873 func
->locals_alloc
* sizeof(WineLocals
));
876 func
->local_vars
[func
->n_locals
].regno
= regno
;
877 func
->local_vars
[func
->n_locals
].offset
= offset
;
878 func
->local_vars
[func
->n_locals
].pc_start
= pc_start
;
879 func
->local_vars
[func
->n_locals
].pc_end
= pc_end
;
880 func
->local_vars
[func
->n_locals
].name
= DBG_strdup(name
);
881 func
->local_vars
[func
->n_locals
].type
= NULL
;
884 return &func
->local_vars
[func
->n_locals
- 1];
888 DEBUG_DumpHashInfo(void)
892 struct name_hash
*nh
;
895 * Utility function to dump stats about the hash table.
897 for(i
=0; i
<NR_NAME_HASH
; i
++)
900 for (nh
= name_hash_table
[i
]; nh
; nh
= nh
->next
)
904 DEBUG_Printf(DBG_CHN_MESG
, "Bucket %d: %d\n", i
, depth
);
908 /***********************************************************************
909 * DEBUG_CheckLinenoStatus
911 * Find the symbol nearest to a given address.
912 * If ebp is specified as non-zero, it means we should dump the argument
913 * list into the string we return as well.
915 int DEBUG_CheckLinenoStatus( const DBG_ADDR
*addr
)
917 struct name_hash
* nearest
= NULL
;
920 if( sortlist_valid
== FALSE
)
922 DEBUG_ResortSymbols();
926 * Binary search to find closest symbol.
930 if( addr_sorttab
[0]->value
.addr
.seg
> addr
->seg
931 || ( addr_sorttab
[0]->value
.addr
.seg
== addr
->seg
932 && addr_sorttab
[0]->value
.addr
.off
> addr
->off
) )
936 else if( addr_sorttab
[high
- 1]->value
.addr
.seg
< addr
->seg
937 || ( addr_sorttab
[high
- 1]->value
.addr
.seg
== addr
->seg
938 && addr_sorttab
[high
- 1]->value
.addr
.off
< addr
->off
) )
940 nearest
= addr_sorttab
[high
- 1];
946 mid
= (high
+ low
)/2;
950 * See if there are any other entries that might also
951 * have the same address, and would also have a line
954 if( mid
> 0 && addr_sorttab
[mid
]->linetab
== NULL
)
956 if( (addr_sorttab
[mid
- 1]->value
.addr
.seg
==
957 addr_sorttab
[mid
]->value
.addr
.seg
)
958 && (addr_sorttab
[mid
- 1]->value
.addr
.off
==
959 addr_sorttab
[mid
]->value
.addr
.off
)
960 && (addr_sorttab
[mid
- 1]->linetab
!= NULL
) )
966 if( (mid
< sorttab_nsym
- 1)
967 && (addr_sorttab
[mid
]->linetab
== NULL
) )
969 if( (addr_sorttab
[mid
+ 1]->value
.addr
.seg
==
970 addr_sorttab
[mid
]->value
.addr
.seg
)
971 && (addr_sorttab
[mid
+ 1]->value
.addr
.off
==
972 addr_sorttab
[mid
]->value
.addr
.off
)
973 && (addr_sorttab
[mid
+ 1]->linetab
!= NULL
) )
978 nearest
= addr_sorttab
[mid
];
980 DEBUG_Printf(DBG_CHN_MESG
, "Found %x:%x when looking for %x:%x %x %s\n",
981 addr_sorttab
[mid
]->value
.addr
.seg
,
982 addr_sorttab
[mid
]->value
.addr
.off
,
983 addr
->seg
, addr
->off
,
984 addr_sorttab
[mid
]->linetab
,
985 addr_sorttab
[mid
]->name
);
989 if( (addr_sorttab
[mid
]->value
.addr
.seg
< addr
->seg
)
990 || ( addr_sorttab
[mid
]->value
.addr
.seg
== addr
->seg
991 && addr_sorttab
[mid
]->value
.addr
.off
<= addr
->off
) )
1002 if (!nearest
) return FUNC_HAS_NO_LINES
;
1004 if( nearest
->flags
& SYM_STEP_THROUGH
)
1007 * This will cause us to keep single stepping until
1008 * we get to the other side somewhere.
1010 return NOT_ON_LINENUMBER
;
1013 if( (nearest
->flags
& SYM_TRAMPOLINE
) )
1016 * This will cause us to keep single stepping until
1017 * we get to the other side somewhere.
1019 return FUNC_IS_TRAMPOLINE
;
1022 if( nearest
->linetab
== NULL
)
1024 return FUNC_HAS_NO_LINES
;
1029 * We never want to stop on the first instruction of a function
1030 * even if it has it's own linenumber. Let the thing keep running
1031 * until it gets past the function prologue. We only do this if there
1032 * is more than one line number for the function, of course.
1034 if( nearest
->value
.addr
.off
== addr
->off
&& nearest
->n_lines
> 1 )
1036 return NOT_ON_LINENUMBER
;
1039 if( (nearest
->sourcefile
!= NULL
)
1040 && (addr
->off
- nearest
->value
.addr
.off
< 0x100000) )
1043 high
= nearest
->n_lines
;
1044 while ((high
- low
) > 1)
1046 mid
= (high
+ low
) / 2;
1047 if (addr
->off
< nearest
->linetab
[mid
].pc_offset
.off
) high
= mid
;
1050 if (addr
->off
== nearest
->linetab
[low
].pc_offset
.off
)
1051 return AT_LINENUMBER
;
1053 return NOT_ON_LINENUMBER
;
1056 return FUNC_HAS_NO_LINES
;
1059 /***********************************************************************
1062 * Find the symbol nearest to a given address.
1063 * Returns sourcefile name and line number in a format that the listing
1064 * handler can deal with.
1067 DEBUG_GetFuncInfo( struct list_id
* ret
, const char * filename
,
1072 struct name_hash
*nh
;
1074 for(nh
= name_hash_table
[name_hash(name
)]; nh
; nh
= nh
->next
)
1076 if( filename
!= NULL
)
1079 if( nh
->sourcefile
== NULL
)
1084 pnt
= strrchr(nh
->sourcefile
, '/');
1085 if( strcmp(nh
->sourcefile
, filename
) != 0
1086 && (pnt
== NULL
|| strcmp(pnt
+ 1, filename
) != 0) )
1091 if (!strcmp(nh
->name
, name
)) break;
1094 if (!nh
&& (name
[0] != '_'))
1097 strcpy(buffer
+1, name
);
1098 for(nh
= name_hash_table
[name_hash(buffer
)]; nh
; nh
= nh
->next
)
1100 if( filename
!= NULL
)
1102 if( nh
->sourcefile
== NULL
)
1107 pnt
= strrchr(nh
->sourcefile
, '/');
1108 if( strcmp(nh
->sourcefile
, filename
) != 0
1109 && (pnt
== NULL
|| strcmp(pnt
+ 1, filename
) != 0) )
1114 if (!strcmp(nh
->name
, buffer
)) break;
1120 if( filename
!= NULL
)
1122 DEBUG_Printf(DBG_CHN_MESG
, "No such function %s in %s\n", name
, filename
);
1126 DEBUG_Printf(DBG_CHN_MESG
, "No such function %s\n", name
);
1128 ret
->sourcefile
= NULL
;
1133 ret
->sourcefile
= nh
->sourcefile
;
1136 * Search for the specific line number. If we don't find it,
1137 * then return FALSE.
1139 if( nh
->linetab
== NULL
)
1145 ret
->line
= nh
->linetab
[0].line_number
;
1149 /***********************************************************************
1150 * DEBUG_GetStackSymbolValue
1152 * Get the address of a named symbol from the current stack frame.
1155 BOOL
DEBUG_GetStackSymbolValue( const char * name
, DBG_VALUE
*value
)
1157 struct name_hash
* curr_func
;
1162 if( DEBUG_GetCurrentFrame(&curr_func
, &eip
, &ebp
) == FALSE
)
1167 for(i
=0; i
< curr_func
->n_locals
; i
++ )
1170 * Test the range of validity of the local variable. This
1171 * comes up with RBRAC/LBRAC stabs in particular.
1173 if( (curr_func
->local_vars
[i
].pc_start
!= 0)
1174 && ((eip
- curr_func
->value
.addr
.off
)
1175 < curr_func
->local_vars
[i
].pc_start
) )
1180 if( (curr_func
->local_vars
[i
].pc_end
!= 0)
1181 && ((eip
- curr_func
->value
.addr
.off
)
1182 > curr_func
->local_vars
[i
].pc_end
) )
1187 if( strcmp(name
, curr_func
->local_vars
[i
].name
) == 0 )
1190 * OK, we found it. Now figure out what to do with this.
1192 if( curr_func
->local_vars
[i
].regno
!= 0 )
1195 * Register variable. Point to DEBUG_context field.
1197 assert(curr_func
->local_vars
[i
].regno
- 1 < sizeof(reg_ofs
)/sizeof(reg_ofs
[0]));
1198 value
->addr
.off
= ((DWORD
)&DEBUG_context
) +
1199 reg_ofs
[curr_func
->local_vars
[i
].regno
- 1];
1200 value
->cookie
= DV_HOST
;
1204 value
->addr
.off
= ebp
+ curr_func
->local_vars
[i
].offset
;
1205 value
->cookie
= DV_TARGET
;
1207 value
->addr
.seg
= 0;
1208 value
->type
= curr_func
->local_vars
[i
].type
;
1218 DEBUG_InfoLocals(void)
1220 struct name_hash
* curr_func
;
1227 if( DEBUG_GetCurrentFrame(&curr_func
, &eip
, &ebp
) == FALSE
)
1232 DEBUG_Printf(DBG_CHN_MESG
, "%s:\n", curr_func
->name
);
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
->value
.addr
.off
)
1242 < curr_func
->local_vars
[i
].pc_start
) )
1247 if( (curr_func
->local_vars
[i
].pc_end
!= 0)
1248 && ((eip
- curr_func
->value
.addr
.off
)
1249 > curr_func
->local_vars
[i
].pc_end
) )
1254 DEBUG_PrintTypeCast(curr_func
->local_vars
[i
].type
);
1256 if( curr_func
->local_vars
[i
].regno
!= 0 )
1258 ptr
= (unsigned int *)(((DWORD
)&DEBUG_context
)
1259 + reg_ofs
[curr_func
->local_vars
[i
].regno
- 1]);
1260 DEBUG_Printf(DBG_CHN_MESG
, " %s (optimized into register $%s) == 0x%8.8x\n",
1261 curr_func
->local_vars
[i
].name
,
1262 reg_name
[curr_func
->local_vars
[i
].regno
- 1],
1267 DEBUG_READ_MEM_VERBOSE((void*)(ebp
+ curr_func
->local_vars
[i
].offset
),
1269 DEBUG_Printf(DBG_CHN_MESG
, " %s == 0x%8.8x\n",
1270 curr_func
->local_vars
[i
].name
, val
);
1278 DEBUG_SetSymbolSize(struct name_hash
* sym
, unsigned int len
)
1280 sym
->symbol_size
= len
;
1286 DEBUG_SetSymbolBPOff(struct name_hash
* sym
, unsigned int off
)
1288 sym
->breakpoint_offset
= off
;
1294 DEBUG_GetSymbolAddr(struct name_hash
* sym
, DBG_ADDR
* addr
)
1297 *addr
= sym
->value
.addr
;
1302 int DEBUG_SetLocalSymbolType(struct wine_locals
* sym
, struct datatype
* type
)