#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;
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));
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:
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
{
/* This assumes a CORE_ADDR can fit in a LONGEST. Probably a safe
assumption. */
- print_longest (stream, 'x', use_local, (unsigned LONGEST) addr);
+ 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. */
/* 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'. */
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);
fprintf_symbol_filtered (gdb_stdout, SYMBOL_NAME (sym),
current_language->la_language, DMGL_ANSI);
printf_filtered ("\" is ");
- val = SYMBOL_VALUE (sym);
+ 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:
printf_filtered ("unresolved");
else
{
+ section = SYMBOL_BFD_SECTION (msym);
printf_filtered ("static storage at address ");
- print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1, gdb_stdout);
+ 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;
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
{
{
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);
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);
}
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_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;