/* Print values for GNU debugger GDB.
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
+ 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
Foundation, Inc.
This file is part of GDB.
#include "objfiles.h" /* ditto */
#include "completer.h" /* for completion functions */
#include "ui-out.h"
+#include "gdb_assert.h"
+#include "block.h"
+#include "disasm.h"
extern int asm_demangle; /* Whether to demangle syms in asm printouts */
extern int addressprint; /* Whether to print hex addresses in HLL " */
static void disable_display_command (char *, int);
-static void disassemble_command (char *, int);
-
static void printf_command (char *, int);
-static void print_frame_nameless_args (struct frame_info *, long,
- int, int, struct ui_file *);
-
static void display_info (char *, int);
static void do_one_display (struct display *);
static struct format_data decode_format (char **, int, int);
-static int print_insn (CORE_ADDR, struct ui_file *);
-
static void sym_info (char *, int);
\f
decode_format (char **string_ptr, int oformat, int osize)
{
struct format_data val;
- register char *p = *string_ptr;
+ char *p = *string_ptr;
val.format = '?';
val.size = '?';
/* We often wrap here if there are long symbolic names. */
wrap_here (" ");
next_address = VALUE_ADDRESS (val)
- + print_insn (VALUE_ADDRESS (val), stream);
+ + gdb_print_insn (VALUE_ADDRESS (val), stream);
next_section = VALUE_BFD_SECTION (val);
break;
|| TYPE_CODE (type) == TYPE_CODE_ARRAY
|| TYPE_CODE (type) == TYPE_CODE_STRING
|| TYPE_CODE (type) == TYPE_CODE_STRUCT
- || TYPE_CODE (type) == TYPE_CODE_UNION)
+ || TYPE_CODE (type) == TYPE_CODE_UNION
+ || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
/* If format is 0, use the 'natural' format for
* that type of value. If the type is non-scalar,
* we have to use language rules to print it as
with a format. */
void
-print_scalar_formatted (char *valaddr, struct type *type, int format, int size,
+print_scalar_formatted (void *valaddr, struct type *type, int format, int size,
struct ui_file *stream)
{
LONGEST val_long;
val_long = unpack_long (type, valaddr);
/* If the value is a pointer, and pointers and addresses are not the
- same, then at this point, the value's length is TARGET_ADDR_BIT, not
- TYPE_LENGTH (type). */
+ same, then at this point, the value's length (in target bytes) is
+ TARGET_ADDR_BIT/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
if (TYPE_CODE (type) == TYPE_CODE_PTR)
- len = TARGET_ADDR_BIT;
+ len = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
/* If we are printing it as unsigned, truncate it in case it is actually
a negative signed value (e.g. "print/u (short)-1" should print 65535
strcpy (buf, local_binary_format_prefix ());
strcat (buf, cp);
strcat (buf, local_binary_format_suffix ());
- fprintf_filtered (stream, buf);
+ fputs_filtered (buf, stream);
}
break;
}
}
- /* 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. */
if (symbol)
{
name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
- if (do_demangle)
- name_temp = SYMBOL_SOURCE_NAME (symbol);
+ if (do_demangle || asm_demangle)
+ name_temp = SYMBOL_PRINT_NAME (symbol);
else
- name_temp = SYMBOL_LINKAGE_NAME (symbol);
+ name_temp = DEPRECATED_SYMBOL_NAME (symbol);
}
if (msymbol != NULL)
symbol = 0;
symtab = 0;
name_location = SYMBOL_VALUE_ADDRESS (msymbol);
- if (do_demangle)
- name_temp = SYMBOL_SOURCE_NAME (msymbol);
+ if (do_demangle || asm_demangle)
+ name_temp = SYMBOL_PRINT_NAME (msymbol);
else
- name_temp = SYMBOL_LINKAGE_NAME (msymbol);
+ name_temp = DEPRECATED_SYMBOL_NAME (msymbol);
}
}
if (symbol == NULL && msymbol == NULL)
return 1;
- /* 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
static void
do_examine (struct format_data fmt, CORE_ADDR addr, asection *sect)
{
- register char format = 0;
- register char size;
- register int count = 1;
+ char format = 0;
+ char size;
+ int count = 1;
struct type *val_type = NULL;
- register int i;
- register int maxelts;
+ int i;
+ int maxelts;
format = fmt.format;
size = fmt.size;
print_command_1 (char *exp, int inspect, int voidprint)
{
struct expression *expr;
- register struct cleanup *old_chain = 0;
- register char format = 0;
+ struct cleanup *old_chain = 0;
+ char format = 0;
struct value *val;
struct format_data fmt;
int cleanup = 0;
old_chain = make_cleanup (free_current_contents, &expr);
cleanup = 1;
val = evaluate_expression (expr);
-
- /* C++: figure out what type we actually want to print it as. */
- type = VALUE_TYPE (val);
-
- if (objectprint
- && (TYPE_CODE (type) == TYPE_CODE_PTR
- || TYPE_CODE (type) == TYPE_CODE_REF)
- && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT
- || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_UNION))
- {
- struct value *v;
-
- v = value_from_vtable_info (val, TYPE_TARGET_TYPE (type));
- if (v != 0)
- {
- val = v;
- type = VALUE_TYPE (val);
- }
- }
}
else
val = access_value_history (0);
output_command (char *exp, int from_tty)
{
struct expression *expr;
- register struct cleanup *old_chain;
- register char format = 0;
+ struct cleanup *old_chain;
+ char format = 0;
struct value *val;
struct format_data fmt;
set_command (char *exp, int from_tty)
{
struct expression *expr = parse_expression (exp);
- register struct cleanup *old_chain =
+ struct cleanup *old_chain =
make_cleanup (free_current_contents, &expr);
evaluate_expression (expr);
do_cleanups (old_chain);
offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
if (offset)
printf_filtered ("%s + %u in ",
- SYMBOL_SOURCE_NAME (msymbol), offset);
+ SYMBOL_PRINT_NAME (msymbol), offset);
else
printf_filtered ("%s in ",
- SYMBOL_SOURCE_NAME (msymbol));
+ SYMBOL_PRINT_NAME (msymbol));
if (pc_in_unmapped_range (addr, sect))
printf_filtered ("load address range of ");
if (section_is_overlay (sect))
static void
address_info (char *exp, int from_tty)
{
- register struct symbol *sym;
- register struct minimal_symbol *msymbol;
- register long val;
- register long basereg;
+ struct symbol *sym;
+ struct minimal_symbol *msymbol;
+ long val;
+ long basereg;
asection *section;
CORE_ADDR load_addr;
int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero
if (exp == 0)
error ("Argument required.");
- sym = lookup_symbol (exp, get_selected_block (), VAR_NAMESPACE,
+ sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN,
&is_a_field_of_this, (struct symtab **) NULL);
if (sym == NULL)
{
printf_filtered ("Symbol \"");
fprintf_symbol_filtered (gdb_stdout, exp,
current_language->la_language, DMGL_ANSI);
- printf_filtered ("\" is a field of the local class variable `this'\n");
+ printf_filtered ("\" is a field of the local class variable ");
+ if (current_language->la_language == language_objc)
+ printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
+ else
+ printf_filtered ("`this'\n");
return;
}
}
printf_filtered ("Symbol \"");
- fprintf_symbol_filtered (gdb_stdout, SYMBOL_NAME (sym),
+ fprintf_symbol_filtered (gdb_stdout, DEPRECATED_SYMBOL_NAME (sym),
current_language->la_language, DMGL_ANSI);
printf_filtered ("\" is ");
val = SYMBOL_VALUE (sym);
}
break;
+ case LOC_COMPUTED:
+ case LOC_COMPUTED_ARG:
+ (SYMBOL_LOCATION_FUNCS (sym)->describe_location) (sym, gdb_stdout);
+ break;
+
case LOC_REGISTER:
printf_filtered ("a variable in register %s", REGISTER_NAME (val));
break;
case LOC_BLOCK:
printf_filtered ("a function at address ");
-#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);
{
struct minimal_symbol *msym;
- msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
+ msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, NULL);
if (msym == NULL)
printf_filtered ("unresolved");
else
}
break;
- case LOC_THREAD_LOCAL_STATIC:
+ case LOC_HP_THREAD_LOCAL_STATIC:
printf_filtered (
"a thread-local variable at offset %ld from the thread base register %s",
val, REGISTER_NAME (basereg));
display_command (char *exp, int from_tty)
{
struct format_data fmt;
- register struct expression *expr;
- register struct display *new;
+ struct expression *expr;
+ struct display *new;
int display_it = 1;
#if defined(TUI)
- if (tui_version && *exp == '$')
+ /* NOTE: cagney/2003-02-13 The `tui_active' was previously
+ `tui_version'. */
+ if (tui_active && *exp == '$')
display_it = (tui_set_layout (exp) == TUI_FAILURE);
#endif
void
clear_displays (void)
{
- register struct display *d;
+ struct display *d;
while ((d = display_chain) != NULL)
{
static void
delete_display (int num)
{
- register struct display *d1, *d;
+ struct display *d1, *d;
if (!display_chain)
error ("No display number %d.", num);
static void
undisplay_command (char *args, int from_tty)
{
- register char *p = args;
- register char *p1;
- register int num;
+ char *p = args;
+ char *p1;
+ int num;
if (args == 0)
{
return;
if (d->block)
- within_current_scope = contained_in (get_selected_block (), d->block);
+ within_current_scope = contained_in (get_selected_block (0), d->block);
else
within_current_scope = 1;
if (!within_current_scope)
void
do_displays (void)
{
- register struct display *d;
+ struct display *d;
for (d = display_chain; d; d = d->next)
do_one_display (d);
void
disable_display (int num)
{
- register struct display *d;
+ struct display *d;
for (d = display_chain; d; d = d->next)
if (d->number == num)
static void
display_info (char *ignore, int from_tty)
{
- register struct display *d;
+ struct display *d;
if (!display_chain)
printf_unfiltered ("There are no auto-display expressions now.\n");
else if (d->format.format)
printf_filtered ("/%c ", d->format.format);
print_expression (d->exp, gdb_stdout);
- if (d->block && !contained_in (get_selected_block (), d->block))
+ if (d->block && !contained_in (get_selected_block (0), d->block))
printf_filtered (" (cannot be evaluated in the current context)");
printf_filtered ("\n");
gdb_flush (gdb_stdout);
static void
enable_display (char *args, int from_tty)
{
- register char *p = args;
- register char *p1;
- register int num;
- register struct display *d;
+ char *p = args;
+ char *p1;
+ int num;
+ struct display *d;
if (p == 0)
{
static void
disable_display_command (char *args, int from_tty)
{
- register char *p = args;
- register char *p1;
- register struct display *d;
+ char *p = args;
+ char *p1;
+ struct display *d;
if (p == 0)
{
value_print (val, stream, 0, Val_pretty_default);
}
-/* Print the arguments of a stack frame, given the function FUNC
- running in that frame (as a symbol), the info on the frame,
- and the number of args according to the stack frame (or -1 if unknown). */
-
-/* References here and elsewhere to "number of args according to the
- stack frame" appear in all cases to refer to "number of ints of args
- according to the stack frame". At least for VAX, i386, isi. */
-
-void
-print_frame_args (struct symbol *func, struct frame_info *fi, int num,
- struct ui_file *stream)
-{
- struct block *b = NULL;
- int first = 1;
- register int i;
- register struct symbol *sym;
- struct value *val;
- /* Offset of next stack argument beyond the one we have seen that is
- at the highest offset.
- -1 if we haven't come to a stack argument yet. */
- long highest_offset = -1;
- int arg_size;
- /* Number of ints of arguments that we have printed so far. */
- int args_printed = 0;
- struct cleanup *old_chain, *list_chain;
- struct ui_stream *stb;
-
- stb = ui_out_stream_new (uiout);
- old_chain = make_cleanup_ui_out_stream_delete (stb);
-
- if (func)
- {
- b = SYMBOL_BLOCK_VALUE (func);
- ALL_BLOCK_SYMBOLS (b, i, sym)
- {
- QUIT;
-
- /* Keep track of the highest stack argument offset seen, and
- skip over any kinds of symbols we don't care about. */
-
- switch (SYMBOL_CLASS (sym))
- {
- case LOC_ARG:
- 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
- this argument and rounding to an int boundary. */
- current_offset =
- ((current_offset + arg_size + sizeof (int) - 1)
- & ~(sizeof (int) - 1));
-
- /* If this is the highest offset seen yet, set highest_offset. */
- if (highest_offset == -1
- || (current_offset > highest_offset))
- highest_offset = current_offset;
-
- /* Add the number of ints we're about to print to args_printed. */
- args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
- }
-
- /* We care about types of symbols, but don't need to keep track of
- stack offsets in them. */
- case LOC_REGPARM:
- case LOC_REGPARM_ADDR:
- case LOC_LOCAL_ARG:
- case LOC_BASEREG_ARG:
- break;
-
- /* Other types of symbols we just skip over. */
- default:
- continue;
- }
-
- /* We have to look up the symbol because arguments can have
- two entries (one a parameter, one a local) and the one we
- want is the local, which lookup_symbol will find for us.
- This includes gcc1 (not gcc2) on the sparc when passing a
- small structure and gcc2 when the argument type is float
- and it is passed as a double and converted to float by
- the prologue (in the latter case the type of the LOC_ARG
- symbol is double and the type of the LOC_LOCAL symbol is
- float). */
- /* But if the parameter name is null, don't try it.
- Null parameter names occur on the RS/6000, for traceback tables.
- FIXME, should we even print them? */
-
- if (*SYMBOL_NAME (sym))
- {
- struct symbol *nsym;
- nsym = lookup_symbol
- (SYMBOL_NAME (sym),
- b, VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
- if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
- {
- /* There is a LOC_ARG/LOC_REGISTER pair. This means that
- it was passed on the stack and loaded into a register,
- or passed in a register and stored in a stack slot.
- GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
-
- Reasons for using the LOC_ARG:
- (1) because find_saved_registers may be slow for remote
- debugging,
- (2) because registers are often re-used and stack slots
- rarely (never?) are. Therefore using the stack slot is
- much less likely to print garbage.
-
- Reasons why we might want to use the LOC_REGISTER:
- (1) So that the backtrace prints the same value as
- "print foo". I see no compelling reason why this needs
- to be the case; having the backtrace print the value which
- was passed in, and "print foo" print the value as modified
- within the called function, makes perfect sense to me.
-
- Additional note: It might be nice if "info args" displayed
- both values.
- One more note: There is a case with sparc structure passing
- where we need to use the LOC_REGISTER, but this is dealt with
- by creating a single LOC_REGPARM in symbol reading. */
-
- /* Leave sym (the LOC_ARG) alone. */
- ;
- }
- else
- sym = nsym;
- }
-
- /* Print the current arg. */
- if (!first)
- ui_out_text (uiout, ", ");
- ui_out_wrap_hint (uiout, " ");
-
- annotate_arg_begin ();
-
- list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- fprintf_symbol_filtered (stb->stream, SYMBOL_SOURCE_NAME (sym),
- SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
- ui_out_field_stream (uiout, "name", stb);
- annotate_arg_name_end ();
- ui_out_text (uiout, "=");
-
- /* Avoid value_print because it will deref ref parameters. We just
- want to print their addresses. Print ??? for args whose address
- we do not know. We pass 2 as "recurse" to val_print because our
- standard indentation here is 4 spaces, and val_print indents
- 2 for each recurse. */
- val = read_var_value (sym, fi);
-
- annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val));
-
- if (val)
- {
- val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
- VALUE_ADDRESS (val),
- stb->stream, 0, 0, 2, Val_no_prettyprint);
- ui_out_field_stream (uiout, "value", stb);
- }
- else
- ui_out_text (uiout, "???");
-
- /* Invoke ui_out_tuple_end. */
- do_cleanups (list_chain);
-
- annotate_arg_end ();
-
- first = 0;
- }
- }
-
- /* Don't print nameless args in situations where we don't know
- enough about the stack to find them. */
- if (num != -1)
- {
- long start;
-
- if (highest_offset == -1)
- start = FRAME_ARGS_SKIP;
- else
- start = highest_offset;
-
- print_frame_nameless_args (fi, start, num - args_printed,
- first, stream);
- }
- do_cleanups (old_chain);
-}
-
-/* Print nameless args on STREAM.
- FI is the frameinfo for this frame, START is the offset
- of the first nameless arg, and NUM is the number of nameless args to
- print. FIRST is nonzero if this is the first argument (not just
- the first nameless arg). */
-
-static void
-print_frame_nameless_args (struct frame_info *fi, long start, int num,
- int first, struct ui_file *stream)
-{
- int i;
- CORE_ADDR argsaddr;
- long arg_value;
-
- for (i = 0; i < num; i++)
- {
- QUIT;
-#ifdef NAMELESS_ARG_VALUE
- NAMELESS_ARG_VALUE (fi, start, &arg_value);
-#else
- argsaddr = FRAME_ARGS_ADDRESS (fi);
- if (!argsaddr)
- return;
-
- arg_value = read_memory_integer (argsaddr + start, sizeof (int));
-#endif
-
- if (!first)
- fprintf_filtered (stream, ", ");
-
-#ifdef PRINT_NAMELESS_INTEGER
- PRINT_NAMELESS_INTEGER (stream, arg_value);
-#else
-#ifdef PRINT_TYPELESS_INTEGER
- PRINT_TYPELESS_INTEGER (stream, builtin_type_int, (LONGEST) arg_value);
-#else
- fprintf_filtered (stream, "%ld", arg_value);
-#endif /* PRINT_TYPELESS_INTEGER */
-#endif /* PRINT_NAMELESS_INTEGER */
- first = 0;
- start += sizeof (int);
- }
-}
-\f
/* ARGSUSED */
static void
printf_command (char *arg, int from_tty)
{
- register char *f = NULL;
- register char *s = arg;
+ char *f = NULL;
+ char *s = arg;
char *string = NULL;
struct value **val_args;
char *substrings;
current_substring += strlen (current_substring) + 1;
}
/* Print the portion of the format string after the last argument. */
- printf_filtered (last_arg);
+ puts_filtered (last_arg);
}
do_cleanups (old_cleanups);
}
-\f
-/* Dump a specified section of assembly code. With no command line
- arguments, this command will dump the assembly code for the
- function surrounding the pc value in the selected frame. With one
- argument, it will dump the assembly code surrounding that pc value.
- Two arguments are interpeted as bounds within which to dump
- assembly. */
-
-/* ARGSUSED */
-static void
-disassemble_command (char *arg, int from_tty)
-{
- CORE_ADDR low, high;
- char *name;
- CORE_ADDR pc, pc_masked;
- char *space_index;
-#if 0
- asection *section;
-#endif
-
- name = NULL;
- if (!arg)
- {
- if (!selected_frame)
- error ("No frame selected.\n");
-
- 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");
-#if defined(TUI)
- else if (tui_version)
- low = tuiGetLowDisassemblyAddress (low, pc);
-#endif
- low += FUNCTION_START_OFFSET;
- }
- else if (!(space_index = (char *) strchr (arg, ' ')))
- {
- /* One argument. */
- pc = parse_and_eval_address (arg);
- if (find_pc_partial_function (pc, &name, &low, &high) == 0)
- error ("No function contains specified address.\n");
-#if defined(TUI)
- else if (tui_version)
- low = tuiGetLowDisassemblyAddress (low, pc);
-#endif
- low += FUNCTION_START_OFFSET;
- }
- else
- {
- /* Two arguments. */
- *space_index = '\0';
- low = parse_and_eval_address (arg);
- high = parse_and_eval_address (space_index + 1);
- }
-
-#if defined(TUI)
- if (!tui_is_window_visible (DISASSEM_WIN))
-#endif
- {
- printf_filtered ("Dump of assembler code ");
- if (name != NULL)
- {
- printf_filtered ("for function %s:\n", name);
- }
- else
- {
- printf_filtered ("from ");
- print_address_numeric (low, 1, gdb_stdout);
- printf_filtered (" to ");
- print_address_numeric (high, 1, gdb_stdout);
- printf_filtered (":\n");
- }
-
- /* Dump the specified range. */
- 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_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);
- }
-#if defined(TUI)
- else
- {
- tui_show_assembly (low);
- }
-#endif
-}
-
-/* Print the instruction at address MEMADDR in debugged memory,
- on STREAM. Returns length of the instruction, in bytes. */
-
-static int
-print_insn (CORE_ADDR memaddr, struct ui_file *stream)
-{
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_BIG;
- else
- TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_LITTLE;
-
- if (TARGET_ARCHITECTURE != NULL)
- TARGET_PRINT_INSN_INFO->mach = TARGET_ARCHITECTURE->mach;
- /* else: should set .mach=0 but some disassemblers don't grok this */
-
- TARGET_PRINT_INSN_INFO->stream = stream;
-
- return TARGET_PRINT_INSN (memaddr, TARGET_PRINT_INSN_INFO);
-}
-\f
void
_initialize_printcmd (void)
Default count is 1. Default address is following last thing printed\n\
with this command or \"print\".", NULL));
- c = add_com ("disassemble", class_vars, disassemble_command,
- "Disassemble a specified section of memory.\n\
-Default is the function surrounding the pc of the selected frame.\n\
-With a single argument, the function surrounding that address is dumped.\n\
-Two arguments are taken as a range of memory to dump.");
- set_cmd_completer (c, location_completer);
- if (xdb_commands)
- add_com_alias ("va", "disassemble", class_xdb, 0);
-
#if 0
add_com ("whereis", class_vars, whereis_command,
"Print line number and file of definition of variable.");
projects / deliverable / binutils-gdb.git / blobdiff