You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "defs.h"
-#include <string.h>
-#include <varargs.h>
+#include "gdb_string.h"
#include "frame.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "demangle.h"
#include "valprint.h"
#include "annotate.h"
+#include "symfile.h" /* for overlay functions */
+#include "objfiles.h" /* ditto */
extern int asm_demangle; /* Whether to demangle syms in asm printouts */
extern int addressprint; /* Whether to print hex addresses in HLL " */
static CORE_ADDR next_address;
+/* Default section to examine next. */
+
+static asection *next_section;
+
/* Last address examined. */
static CORE_ADDR last_examine_address;
/* Pointer to the target-dependent disassembly function. */
int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info *));
+disassemble_info tm_print_insn_info;
/* Prototypes for local functions. */
static void validate_format PARAMS ((struct format_data, char *));
-static void do_examine PARAMS ((struct format_data, CORE_ADDR));
+static void do_examine PARAMS ((struct format_data, CORE_ADDR addr, asection *section));
static void print_formatted PARAMS ((value_ptr, int, int));
register int format;
int size;
{
- int len = TYPE_LENGTH (VALUE_TYPE (val));
+ struct type *type = check_typedef (VALUE_TYPE (val));
+ int len = TYPE_LENGTH (type);
if (VALUE_LVAL (val) == lval_memory)
- next_address = VALUE_ADDRESS (val) + len;
+ {
+ next_address = VALUE_ADDRESS (val) + len;
+ next_section = VALUE_BFD_SECTION (val);
+ }
switch (format)
{
case 's':
next_address = VALUE_ADDRESS (val)
+ val_print_string (VALUE_ADDRESS (val), 0, gdb_stdout);
+ next_section = VALUE_BFD_SECTION (val);
break;
case 'i':
wrap_here (" ");
next_address = VALUE_ADDRESS (val)
+ print_insn (VALUE_ADDRESS (val), gdb_stdout);
+ next_section = VALUE_BFD_SECTION (val);
break;
default:
if (format == 0
- || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_ARRAY
- || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_STRING
- || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_STRUCT
- || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_UNION
- || VALUE_REPEATED (val))
+ || TYPE_CODE (type) == TYPE_CODE_ARRAY
+ || TYPE_CODE (type) == TYPE_CODE_STRING
+ || TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION)
value_print (val, gdb_stdout, format, Val_pretty_default);
else
- print_scalar_formatted (VALUE_CONTENTS (val), VALUE_TYPE (val),
+ print_scalar_formatted (VALUE_CONTENTS (val), type,
format, size, gdb_stdout);
}
}
GDB_FILE *stream;
{
LONGEST val_long;
- int len = TYPE_LENGTH (type);
+ unsigned int len = TYPE_LENGTH (type);
if (len > sizeof (LONGEST)
&& (format == 't'
|| format == 'd'
|| format == 'x'))
{
- /* We can't print it normally, but we can print it in hex.
- Printing it in the wrong radix is more useful than saying
- "use /x, you dummy". */
- /* FIXME: we could also do octal or binary if that was the
- desired format. */
- /* FIXME: we should be using the size field to give us a minimum
- field width to print. */
- val_print_type_code_int (type, valaddr, stream);
- return;
- }
+ if (! TYPE_UNSIGNED (type)
+ || ! extract_long_unsigned_integer (valaddr, len, &val_long))
+ {
+ /* We can't print it normally, but we can print it in hex.
+ Printing it in the wrong radix is more useful than saying
+ "use /x, you dummy". */
+ /* FIXME: we could also do octal or binary if that was the
+ desired format. */
+ /* FIXME: we should be using the size field to give us a
+ minimum field width to print. */
+ val_print_type_code_int (type, valaddr, stream);
+ return;
+ }
- if (format != 'f')
+ /* If we get here, extract_long_unsigned_integer set val_long. */
+ }
+ else if (format != 'f')
val_long = unpack_long (type, valaddr);
/* If we are printing it as unsigned, truncate it in case it is actually
struct symtab *symtab = 0;
CORE_ADDR name_location = 0;
char *name = "";
+ asection *section = 0;
+ int unmapped = 0;
+
+ /* Determine if the address is in an overlay, and whether it is mapped. */
+ if (overlay_debugging)
+ {
+ section = find_pc_overlay (addr);
+ if (pc_in_unmapped_range (addr, section))
+ {
+ unmapped = 1;
+ addr = overlay_mapped_address (addr, section);
+ }
+ }
+
+ /* On some targets, add in extra "flag" bits to PC for
+ disassembly. This should ensure that "rounding errors" in
+ symbol addresses that are masked for disassembly favour the
+ the correct symbol. */
+
+#ifdef GDB_TARGET_UNMASK_DISAS_PC
+ addr = GDB_TARGET_UNMASK_DISAS_PC (addr);
+#endif
/* First try to find the address in the symbol table, then
in the minsyms. Take the closest one. */
save some memory, but for many debug format--ELF/DWARF or
anything/stabs--it would be inconvenient to eliminate those minimal
symbols anyway). */
- symbol = find_pc_function (addr);
- if (symbol)
- name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
+ msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
+ symbol = find_pc_sect_function (addr, section);
if (symbol)
{
+ name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
if (do_demangle)
name = SYMBOL_SOURCE_NAME (symbol);
else
name = SYMBOL_LINKAGE_NAME (symbol);
}
- msymbol = lookup_minimal_symbol_by_pc (addr);
if (msymbol != NULL)
{
if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
if (symbol == NULL && msymbol == NULL)
return;
+ /* On some targets, mask out extra "flag" bits from PC for handsome
+ disassembly. */
+
+#ifdef GDB_TARGET_MASK_DISAS_PC
+ name_location = GDB_TARGET_MASK_DISAS_PC (name_location);
+ addr = GDB_TARGET_MASK_DISAS_PC (addr);
+#endif
+
/* If the nearest symbol is too far away, don't print anything symbolic. */
/* For when CORE_ADDR is larger than unsigned int, we do math in
return;
fputs_filtered (leadin, stream);
- fputs_filtered ("<", stream);
+ if (unmapped)
+ fputs_filtered ("<*", stream);
+ else
+ fputs_filtered ("<", stream);
fputs_filtered (name, stream);
if (addr != name_location)
fprintf_filtered (stream, "+%u", (unsigned int)(addr - name_location));
{
struct symtab_and_line sal;
- sal = find_pc_line (addr, 0);
+ sal = find_pc_sect_line (addr, section, 0);
+
if (sal.symtab)
fprintf_filtered (stream, " at %s:%d", sal.symtab->filename, sal.line);
else if (symtab && symbol && symbol->line)
else if (symtab)
fprintf_filtered (stream, " in %s", symtab->filename);
}
- fputs_filtered (">", stream);
+ if (unmapped)
+ fputs_filtered ("*>", stream);
+ else
+ fputs_filtered (">", stream);
}
/* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
GDB_FILE *stream;
{
/* This assumes a CORE_ADDR can fit in a LONGEST. Probably a safe
- assumption. We pass use_local but I'm not completely sure whether
- that is correct. When (if ever) should we *not* use_local? */
- print_longest (stream, 'x', 1, (unsigned LONGEST) addr);
+ assumption. */
+ print_longest (stream, 'x', use_local, (ULONGEST) addr);
}
/* Print address ADDR symbolically on STREAM.
Fetch it from memory and print on gdb_stdout. */
static void
-do_examine (fmt, addr)
+do_examine (fmt, addr, sect)
struct format_data fmt;
CORE_ADDR addr;
+ asection *sect;
{
register char format = 0;
register char size;
size = fmt.size;
count = fmt.count;
next_address = addr;
+ next_section = sect;
/* String or instruction format implies fetch single bytes
regardless of the specified size. */
while (count > 0)
{
+ QUIT;
print_address (next_address, gdb_stdout);
printf_filtered (":");
for (i = maxelts;
/* Note that print_formatted sets next_address for the next
object. */
last_examine_address = next_address;
- last_examine_value = value_at (val_type, next_address);
+ last_examine_value = value_at (val_type, next_address, sect);
print_formatted (last_examine_value, format, size);
}
printf_filtered ("\n");
do_cleanups (old_chain);
}
+/* ARGSUSED */
+static void
+sym_info (arg, from_tty)
+ char *arg;
+ int from_tty;
+{
+ struct minimal_symbol *msymbol;
+ struct objfile *objfile;
+ struct obj_section *osect;
+ asection *sect;
+ CORE_ADDR addr, sect_addr;
+ int matches = 0;
+ unsigned int offset;
+
+ if (!arg)
+ error_no_arg ("address");
+
+ addr = parse_and_eval_address (arg);
+ ALL_OBJSECTIONS (objfile, osect)
+ {
+ sect = osect->the_bfd_section;
+ sect_addr = overlay_mapped_address (addr, sect);
+
+ if (osect->addr <= sect_addr && sect_addr < osect->endaddr &&
+ (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, sect)))
+ {
+ matches = 1;
+ offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
+ if (offset)
+ printf_filtered ("%s + %u in ",
+ SYMBOL_SOURCE_NAME (msymbol), offset);
+ else
+ printf_filtered ("%s in ",
+ SYMBOL_SOURCE_NAME (msymbol));
+ if (pc_in_unmapped_range (addr, sect))
+ printf_filtered ("load address range of ");
+ if (section_is_overlay (sect))
+ printf_filtered ("%s overlay ",
+ section_is_mapped (sect) ? "mapped" : "unmapped");
+ printf_filtered ("section %s", sect->name);
+ printf_filtered ("\n");
+ }
+ }
+ if (matches == 0)
+ printf_filtered ("No symbol matches %s.\n", arg);
+}
+
/* ARGSUSED */
static void
address_info (exp, from_tty)
register struct minimal_symbol *msymbol;
register long val;
register long basereg;
+ asection *section;
+ CORE_ADDR load_addr;
int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero
if exp is a field of `this'. */
return;
}
- msymbol = lookup_minimal_symbol (exp, (struct objfile *) NULL);
+ msymbol = lookup_minimal_symbol (exp, NULL, NULL);
if (msymbol != NULL)
{
+ load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
+
printf_filtered ("Symbol \"");
fprintf_symbol_filtered (gdb_stdout, exp,
current_language->la_language, DMGL_ANSI);
printf_filtered ("\" is at ");
- print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol), 1,
- gdb_stdout);
- printf_filtered (" in a file compiled without debugging.\n");
+ print_address_numeric (load_addr, 1, gdb_stdout);
+ printf_filtered (" in a file compiled without debugging");
+ section = SYMBOL_BFD_SECTION (msymbol);
+ if (section_is_overlay (section))
+ {
+ load_addr = overlay_unmapped_address (load_addr, section);
+ printf_filtered (",\n -- loaded at ");
+ print_address_numeric (load_addr, 1, gdb_stdout);
+ printf_filtered (" in overlay section %s", section->name);
+ }
+ printf_filtered (".\n");
}
else
error ("No symbol \"%s\" in current context.", exp);
printf_filtered ("Symbol \"");
fprintf_symbol_filtered (gdb_stdout, SYMBOL_NAME (sym),
current_language->la_language, DMGL_ANSI);
- printf_filtered ("\" is ", SYMBOL_NAME (sym));
- val = SYMBOL_VALUE (sym);
+ printf_filtered ("\" is ");
+ val = SYMBOL_VALUE (sym);
basereg = SYMBOL_BASEREG (sym);
+ section = SYMBOL_BFD_SECTION (sym);
switch (SYMBOL_CLASS (sym))
{
case LOC_LABEL:
printf_filtered ("a label at address ");
- print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
+ print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
+ 1, gdb_stdout);
+ if (section_is_overlay (section))
+ {
+ load_addr = overlay_unmapped_address (load_addr, section);
+ printf_filtered (",\n -- loaded at ");
+ print_address_numeric (load_addr, 1, gdb_stdout);
+ printf_filtered (" in overlay section %s", section->name);
+ }
break;
case LOC_REGISTER:
case LOC_STATIC:
printf_filtered ("static storage at address ");
- print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
+ print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
+ 1, gdb_stdout);
+ if (section_is_overlay (section))
+ {
+ load_addr = overlay_unmapped_address (load_addr, section);
+ printf_filtered (",\n -- loaded at ");
+ print_address_numeric (load_addr, 1, gdb_stdout);
+ printf_filtered (" in overlay section %s", section->name);
+ }
break;
case LOC_REGPARM:
case LOC_BLOCK:
printf_filtered ("a function at address ");
- print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
- gdb_stdout);
+#ifdef GDB_TARGET_MASK_DISAS_PC
+ print_address_numeric
+ (load_addr= GDB_TARGET_MASK_DISAS_PC (BLOCK_START (SYMBOL_BLOCK_VALUE (sym))),
+ 1, gdb_stdout);
+#else
+ print_address_numeric (load_addr=BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
+ 1, gdb_stdout);
+#endif
+ if (section_is_overlay (section))
+ {
+ load_addr = overlay_unmapped_address (load_addr, section);
+ printf_filtered (",\n -- loaded at ");
+ print_address_numeric (load_addr, 1, gdb_stdout);
+ printf_filtered (" in overlay section %s", section->name);
+ }
+ break;
+
+ case LOC_UNRESOLVED:
+ {
+ struct minimal_symbol *msym;
+
+ msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
+ if (msym == NULL)
+ printf_filtered ("unresolved");
+ else
+ {
+ section = SYMBOL_BFD_SECTION (msym);
+ printf_filtered ("static storage at address ");
+ print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (msym),
+ 1, gdb_stdout);
+ if (section_is_overlay (section))
+ {
+ load_addr = overlay_unmapped_address (load_addr, section);
+ printf_filtered (",\n -- loaded at ");
+ print_address_numeric (load_addr, 1, gdb_stdout);
+ printf_filtered (" in overlay section %s", section->name);
+ }
+ }
+ }
break;
case LOC_OPTIMIZED_OUT:
next_address = VALUE_ADDRESS (val);
else
next_address = value_as_pointer (val);
+ if (VALUE_BFD_SECTION (val))
+ next_section = VALUE_BFD_SECTION (val);
do_cleanups (old_chain);
}
- do_examine (fmt, next_address);
+ do_examine (fmt, next_address, next_section);
/* If the examine succeeds, we remember its size and format for next time. */
last_size = fmt.size;
if (d->format.size)
{
CORE_ADDR addr;
+ value_ptr val;
annotate_display_format ();
else
printf_filtered (" ");
- addr = value_as_pointer (evaluate_expression (d->exp));
+ val = evaluate_expression (d->exp);
+ addr = value_as_pointer (val);
if (d->format.format == 'i')
addr = ADDR_BITS_REMOVE (addr);
annotate_display_value ();
- do_examine (d->format, addr);
+ do_examine (d->format, addr, VALUE_BFD_SECTION (val));
}
else
{
case LOC_REF_ARG:
{
long current_offset = SYMBOL_VALUE (sym);
-
arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
/* Compute address of next argument by adding the size of
#ifdef PRINT_TYPELESS_INTEGER
PRINT_TYPELESS_INTEGER (stream, builtin_type_int, (LONGEST) arg_value);
#else
- fprintf_filtered (stream, "%d", arg_value);
+ fprintf_filtered (stream, "%ld", arg_value);
#endif /* PRINT_TYPELESS_INTEGER */
#endif /* PRINT_NAMELESS_INTEGER */
first = 0;
if (argclass[nargs] == double_arg)
{
- if (TYPE_LENGTH (VALUE_TYPE (val_args[nargs])) == sizeof (float))
+ struct type *type = VALUE_TYPE (val_args[nargs]);
+ if (TYPE_LENGTH (type) == sizeof (float))
VALUE_TYPE (val_args[nargs]) = builtin_type_float;
- if (TYPE_LENGTH (VALUE_TYPE (val_args[nargs])) == sizeof (double))
+ if (TYPE_LENGTH (type) == sizeof (double))
VALUE_TYPE (val_args[nargs]) = builtin_type_double;
}
nargs++;
{
char c;
QUIT;
- read_memory (tem + j, &c, 1);
+ read_memory_section (tem + j, &c, 1,
+ VALUE_BFD_SECTION (val_args[i]));
if (c == 0)
break;
}
/* Copy the string contents into a string inside GDB. */
str = (char *) alloca (j + 1);
- read_memory (tem, str, j);
+ read_memory_section (tem, str, j, VALUE_BFD_SECTION (val_args[i]));
str[j] = 0;
printf_filtered (current_substring, str);
{
CORE_ADDR low, high;
char *name;
- CORE_ADDR pc;
+ CORE_ADDR pc, pc_masked;
char *space_index;
+ asection *section;
name = NULL;
if (!arg)
pc = get_frame_pc (selected_frame);
if (find_pc_partial_function (pc, &name, &low, &high) == 0)
error ("No function contains program counter for selected frame.\n");
+ low += FUNCTION_START_OFFSET;
}
else if (!(space_index = (char *) strchr (arg, ' ')))
{
pc = parse_and_eval_address (arg);
if (find_pc_partial_function (pc, &name, &low, &high) == 0)
error ("No function contains specified address.\n");
+ if (overlay_debugging)
+ {
+ section = find_pc_overlay (pc);
+ if (pc_in_unmapped_range (pc, section))
+ {
+ /* find_pc_partial_function will have returned low and high
+ relative to the symbolic (mapped) address range. Need to
+ translate them back to the unmapped range where PC is. */
+ low = overlay_unmapped_address (low, section);
+ high = overlay_unmapped_address (high, section);
+ }
+ }
+ low += FUNCTION_START_OFFSET;
}
else
{
}
/* Dump the specified range. */
- for (pc = low; pc < high; )
+ pc = low;
+
+#ifdef GDB_TARGET_MASK_DISAS_PC
+ pc_masked = GDB_TARGET_MASK_DISAS_PC (pc);
+#else
+ pc_masked = pc;
+#endif
+
+ while (pc_masked < high)
{
QUIT;
- print_address (pc, gdb_stdout);
+ print_address (pc_masked, gdb_stdout);
printf_filtered (":\t");
/* We often wrap here if there are long symbolic names. */
wrap_here (" ");
pc += print_insn (pc, gdb_stdout);
printf_filtered ("\n");
+
+#ifdef GDB_TARGET_MASK_DISAS_PC
+ pc_masked = GDB_TARGET_MASK_DISAS_PC (pc);
+#else
+ pc_masked = pc;
+#endif
}
printf_filtered ("End of assembler dump.\n");
gdb_flush (gdb_stdout);
CORE_ADDR memaddr;
GDB_FILE *stream;
{
- disassemble_info info;
-
-#define GDB_INIT_DISASSEMBLE_INFO(INFO, STREAM) \
- (INFO).fprintf_func = (fprintf_ftype)fprintf_filtered, \
- (INFO).stream = (STREAM), \
- (INFO).read_memory_func = dis_asm_read_memory, \
- (INFO).memory_error_func = dis_asm_memory_error, \
- (INFO).print_address_func = dis_asm_print_address, \
- (INFO).insn_info_valid = 0
-
- GDB_INIT_DISASSEMBLE_INFO(info, stream);
-
/* If there's no disassembler, something is very wrong. */
if (tm_print_insn == NULL)
abort ();
- return (*tm_print_insn) (memaddr, &info);
+ if (TARGET_BYTE_ORDER == BIG_ENDIAN)
+ tm_print_insn_info.endian = BFD_ENDIAN_BIG;
+ else
+ tm_print_insn_info.endian = BFD_ENDIAN_LITTLE;
+
+ if (target_architecture != NULL)
+ tm_print_insn_info.mach = target_architecture->mach;
+ /* else: should set .mach=0 but some disassemblers don't grok this */
+
+ return (*tm_print_insn) (memaddr, &tm_print_insn_info);
}
\f
current_display_number = -1;
add_info ("address", address_info,
- "Describe where variable VAR is stored.");
+ "Describe where symbol SYM is stored.");
+
+ add_info ("symbol", sym_info,
+ "Describe what symbol is at location ADDR.\n\
+Only for symbols with fixed locations (global or static scope).");
add_com ("x", class_vars, x_command,
concat ("Examine memory: x/FMT ADDRESS.\n\
examine_h_type = init_type (TYPE_CODE_INT, 2, 0, "examine_h_type", NULL);
examine_w_type = init_type (TYPE_CODE_INT, 4, 0, "examine_w_type", NULL);
examine_g_type = init_type (TYPE_CODE_INT, 8, 0, "examine_g_type", NULL);
+
+ INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
+ tm_print_insn_info.flavour = bfd_target_unknown_flavour;
+ tm_print_insn_info.read_memory_func = dis_asm_read_memory;
+ tm_print_insn_info.memory_error_func = dis_asm_memory_error;
+ tm_print_insn_info.print_address_func = dis_asm_print_address;
}
projects / deliverable / binutils-gdb.git / blobdiff