/* Print values for GNU debugger GDB.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1993, 1994, 1995,
- 1998, 2000 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+ 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
+ Foundation, Inc.
This file is part of GDB.
#include "annotate.h"
#include "symfile.h" /* for overlay functions */
#include "objfiles.h" /* ditto */
-#ifdef UI_OUT
+#include "completer.h" /* for completion functions */
#include "ui-out.h"
-#endif
+#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 " */
/* Contents of last address examined.
This is not valid past the end of the `x' command! */
-static value_ptr last_examine_value;
+static struct value *last_examine_value;
/* Largest offset between a symbolic value and an address, that will be
printed as `0x1234 <symbol+offset>'. */
/* Innermost block required by this expression when evaluated */
struct block *block;
/* Status of this display (enabled or disabled) */
- enum enable status;
+ int enabled_p;
};
/* Chain of expressions whose values should be displayed
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,
static void do_examine (struct format_data, CORE_ADDR addr,
asection * section);
-static void print_formatted (value_ptr, int, int, struct ui_file *);
+static void print_formatted (struct value *, int, int, struct ui_file *);
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
This is used to pad hex numbers so they line up. */
static void
-print_formatted (register value_ptr val, register int format, int size,
+print_formatted (struct value *val, register int format, int size,
struct ui_file *stream)
{
struct type *type = check_typedef (VALUE_TYPE (val));
/* 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;
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;
else if (format != 'f')
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 (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 / 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
(if shorts are 16 bits) instead of 4294967295). */
break;
case 'f':
- if (len == sizeof (float))
- type = builtin_type_float;
- else if (len == sizeof (double))
- type = builtin_type_double;
+ if (len == TYPE_LENGTH (builtin_type_float))
+ type = builtin_type_float;
+ else if (len == TYPE_LENGTH (builtin_type_double))
+ type = builtin_type_double;
+ else if (len == TYPE_LENGTH (builtin_type_long_double))
+ type = builtin_type_long_double;
print_floating (valaddr, type, 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
struct expression *expr;
register struct cleanup *old_chain = 0;
register char format = 0;
- register value_ptr val;
+ 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))
- {
- value_ptr 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);
struct expression *expr;
register struct cleanup *old_chain;
register char format = 0;
- register value_ptr val;
+ struct value *val;
struct format_data fmt;
if (exp && *exp == '/')
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))
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));
break;
+ case LOC_THREAD_LOCAL_STATIC:
+ printf_filtered ("a thread-local variable at offset %ld in the "
+ "thread-local storage for `%s'",
+ val, SYMBOL_OBJFILE (sym)->name);
+ break;
+
case LOC_OPTIMIZED_OUT:
printf_filtered ("optimized out");
break;
&& VALUE_LVAL (val) == lval_memory)
next_address = VALUE_ADDRESS (val);
else
- next_address = value_as_pointer (val);
+ next_address = value_as_address (val);
if (VALUE_BFD_SECTION (val))
next_section = VALUE_BFD_SECTION (val);
do_cleanups (old_chain);
int display_it = 1;
#if defined(TUI)
- if (tui_version && *exp == '$')
- display_it = ((TuiStatus) tuiDo (
- (TuiOpaqueFuncPtr) tui_vSetLayoutTo, exp) == TUI_FAILURE);
+ /* 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
if (display_it)
new->next = display_chain;
new->number = ++display_number;
new->format = fmt;
- new->status = enabled;
+ new->enabled_p = 1;
display_chain = new;
if (from_tty && target_has_execution)
{
int within_current_scope;
- if (d->status == disabled)
+ if (d->enabled_p == 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)
if (d->format.size)
{
CORE_ADDR addr;
- value_ptr val;
+ struct value *val;
annotate_display_format ();
printf_filtered (" ");
val = evaluate_expression (d->exp);
- addr = value_as_pointer (val);
+ addr = value_as_address (val);
if (d->format.format == 'i')
addr = ADDR_BITS_REMOVE (addr);
for (d = display_chain; d; d = d->next)
if (d->number == num)
{
- d->status = disabled;
+ d->enabled_p = 0;
return;
}
printf_unfiltered ("No display number %d.\n", num);
for (d = display_chain; d; d = d->next)
{
- printf_filtered ("%d: %c ", d->number, "ny"[(int) d->status]);
+ printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]);
if (d->format.size)
printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
d->format.format);
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);
if (p == 0)
{
for (d = display_chain; d; d = d->next)
- d->status = enabled;
+ d->enabled_p = 1;
}
else
while (*p)
for (d = display_chain; d; d = d->next)
if (d->number == num)
{
- d->status = enabled;
+ d->enabled_p = 1;
goto win;
}
printf_unfiltered ("No display number %d.\n", num);
if (p == 0)
{
for (d = display_chain; d; d = d->next)
- d->status = disabled;
+ d->enabled_p = 0;
}
else
while (*p)
print_variable_value (struct symbol *var, struct frame_info *frame,
struct ui_file *stream)
{
- value_ptr val = read_var_value (var, frame);
+ struct value *val = read_var_value (var, frame);
value_print (val, stream, 0, Val_pretty_default);
}
struct ui_file *stream)
{
struct block *b = NULL;
- int nsyms = 0;
int first = 1;
register int i;
register struct symbol *sym;
- register value_ptr val;
+ 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. */
int arg_size;
/* Number of ints of arguments that we have printed so far. */
int args_printed = 0;
-#ifdef UI_OUT
- struct cleanup *old_chain;
+ 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);
-#endif /* UI_OUT */
if (func)
{
b = SYMBOL_BLOCK_VALUE (func);
- nsyms = BLOCK_NSYMS (b);
- }
+ /* Function blocks are order sensitive, and thus should not be
+ hashed. */
+ gdb_assert (BLOCK_HASHTABLE (b) == 0);
- for (i = 0; i < nsyms; i++)
- {
- QUIT;
- sym = BLOCK_SYM (b, i);
+ 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. */
+ /* 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);
- }
+ 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;
+ /* 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:
+ case LOC_COMPUTED_ARG:
+ break;
- /* Other types of symbols we just skip over. */
- default:
- continue;
- }
+ /* 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)
+ /* 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 (*DEPRECATED_SYMBOL_NAME (sym))
{
- /* 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. */
- ;
+ struct symbol *nsym;
+ nsym = lookup_symbol
+ (DEPRECATED_SYMBOL_NAME (sym),
+ b, VAR_DOMAIN, (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;
}
- else
- sym = nsym;
- }
-#ifdef UI_OUT
- /* Print the current arg. */
- if (!first)
- ui_out_text (uiout, ", ");
- ui_out_wrap_hint (uiout, " ");
+ /* Print the current arg. */
+ if (!first)
+ ui_out_text (uiout, ", ");
+ ui_out_wrap_hint (uiout, " ");
- annotate_arg_begin ();
+ annotate_arg_begin ();
- ui_out_list_begin (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, "=");
-#else
- /* Print the current arg. */
- if (!first)
- fprintf_filtered (stream, ", ");
- wrap_here (" ");
+ list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+ fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
+ SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
+ ui_out_field_stream (uiout, "name", stb);
+ annotate_arg_name_end ();
+ ui_out_text (uiout, "=");
- annotate_arg_begin ();
+ /* 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);
- fprintf_symbol_filtered (stream, SYMBOL_SOURCE_NAME (sym),
- SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
- annotate_arg_name_end ();
- fputs_filtered ("=", stream);
-#endif
+ annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val));
- /* 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);
+ 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, "???");
- annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val));
+ /* Invoke ui_out_tuple_end. */
+ do_cleanups (list_chain);
- if (val)
- {
- if (GDB_TARGET_IS_D10V
- && SYMBOL_CLASS (sym) == LOC_REGPARM && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR)
- TYPE_LENGTH (VALUE_TYPE (val)) = 2;
-#ifdef UI_OUT
- 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, "???");
+ annotate_arg_end ();
- ui_out_list_end (uiout);
-#else
- val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
- VALUE_ADDRESS (val),
- stream, 0, 0, 2, Val_no_prettyprint);
+ first = 0;
}
- else
- fputs_filtered ("???", stream);
-#endif
-
- annotate_arg_end ();
-
- first = 0;
}
/* Don't print nameless args in situations where we don't know
print_frame_nameless_args (fi, start, num - args_printed,
first, stream);
}
-#ifdef UI_OUT
do_cleanups (old_chain);
-#endif /* no UI_OUT */
}
/* Print nameless args on STREAM.
for (i = 0; i < num; i++)
{
QUIT;
-#ifdef NAMELESS_ARG_VALUE
- NAMELESS_ARG_VALUE (fi, start, &arg_value);
-#else
- argsaddr = FRAME_ARGS_ADDRESS (fi);
+ argsaddr = get_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);
}
register char *f = NULL;
register char *s = arg;
char *string = NULL;
- value_ptr *val_args;
+ struct value **val_args;
char *substrings;
char *current_substring;
int nargs = 0;
int allocated_args = 20;
struct cleanup *old_cleanups;
- val_args = (value_ptr *) xmalloc (allocated_args * sizeof (value_ptr));
+ val_args = (struct value **) xmalloc (allocated_args
+ * sizeof (struct value *));
old_cleanups = make_cleanup (free_current_contents, &val_args);
if (s == 0)
*f++ = '\\';
break;
case 'a':
-#ifdef __STDC__
*f++ = '\a';
-#else
- *f++ = '\007'; /* Bell */
-#endif
break;
case 'b':
*f++ = '\b';
{
char *s1;
if (nargs == allocated_args)
- val_args = (value_ptr *) xrealloc ((char *) val_args,
- (allocated_args *= 2)
- * sizeof (value_ptr));
+ val_args = (struct value **) xrealloc ((char *) val_args,
+ (allocated_args *= 2)
+ * sizeof (struct value *));
s1 = s;
val_args[nargs] = parse_to_comma_and_eval (&s1);
char *str;
CORE_ADDR tem;
int j;
- tem = value_as_pointer (val_args[i]);
+ tem = value_as_address (val_args[i]);
/* This is a %s argument. Find the length of the string. */
for (j = 0;; j++)
}
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 = (CORE_ADDR) tuiDo ((TuiOpaqueFuncPtr) tui_vGetLowDisassemblyAddress,
- (Opaque) low,
- (Opaque) 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 = (CORE_ADDR) tuiDo ((TuiOpaqueFuncPtr) tui_vGetLowDisassemblyAddress,
- (Opaque) low,
- (Opaque) pc);
-#endif
-#if 0
- 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);
- }
- }
-#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_version ||
- m_winPtrIsNull (disassemWin) || !disassemWin->generic.isVisible)
-#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
- {
- tuiDo ((TuiOpaqueFuncPtr) tui_vAddWinToLayout, DISASSEM_WIN);
- tuiDo ((TuiOpaqueFuncPtr) tui_vUpdateSourceWindowsWithAddr, 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 == BIG_ENDIAN)
- 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 */
-
- return TARGET_PRINT_INSN (memaddr, TARGET_PRINT_INSN_INFO);
-}
-\f
void
_initialize_printcmd (void)
{
+ struct cmd_list_element *c;
+
current_display_number = -1;
add_info ("address", address_info,
Default count is 1. Default address is following last thing printed\n\
with this command or \"print\".", NULL));
- 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.");
- 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.");
You can see these environment settings with the \"show\" command.", NULL));
/* "call" is the same as "set", but handy for dbx users to call fns. */
- add_com ("call", class_vars, call_command,
- "Call a function in the program.\n\
+ c = add_com ("call", class_vars, call_command,
+ "Call a function in the program.\n\
The argument is the function name and arguments, in the notation of the\n\
current working language. The result is printed and saved in the value\n\
history, if it is not void.");
+ set_cmd_completer (c, location_completer);
add_cmd ("variable", class_vars, set_command,
"Evaluate expression EXP and assign result to variable VAR, using assignment\n\
This may usually be abbreviated to simply \"set\".",
&setlist);
- add_com ("print", class_vars, print_command,
+ c = add_com ("print", class_vars, print_command,
concat ("Print value of expression EXP.\n\
Variables accessible are those of the lexical environment of the selected\n\
stack frame, plus all those whose scope is global or an entire file.\n\
"\n\
EXP may be preceded with /FMT, where FMT is a format letter\n\
but no count or size letter (see \"x\" command).", NULL));
+ set_cmd_completer (c, location_completer);
add_com_alias ("p", "print", class_vars, 1);
- add_com ("inspect", class_vars, inspect_command,
+ c = add_com ("inspect", class_vars, inspect_command,
"Same as \"print\" command, except that if you are running in the epoch\n\
environment, the value is printed in its own window.");
+ set_cmd_completer (c, location_completer);
add_show_from_set (
add_set_cmd ("max-symbolic-offset", no_class, var_uinteger,