/* Print values for GNU debugger GDB.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1993, 1994
- Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1993, 1994, 1995
+ Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include <string.h>
-#include <varargs.h>
#include "frame.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "breakpoint.h"
#include "demangle.h"
#include "valprint.h"
+#include "annotate.h"
extern int asm_demangle; /* Whether to demangle syms in asm printouts */
extern int addressprint; /* Whether to print hex addresses in HLL " */
int inspect_it = 0;
-void
-print_value_flags (t)
- struct type *t;
-{
- /* FIXME: Should we be printing * for references as well as pointers? */
- if (t != NULL
- && TYPE_CODE (t) == TYPE_CODE_PTR
- && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID)
- printf_filtered ("*");
- else
- printf_filtered ("-");
-}
-
struct display
{
/* Chain link to next auto-display item. */
static int display_number;
-/* Prototypes for local functions */
+/* Pointer to the target-dependent disassembly function. */
-static void
-delete_display PARAMS ((int));
+int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info *));
-static void
-enable_display PARAMS ((char *, int));
+/* Prototypes for local functions. */
-static void
-disable_display_command PARAMS ((char *, int));
+static void delete_display PARAMS ((int));
-static void
-disassemble_command PARAMS ((char *, int));
+static void enable_display PARAMS ((char *, int));
-static void
-printf_command PARAMS ((char *, int));
+static void disable_display_command PARAMS ((char *, int));
-static void
-print_frame_nameless_args PARAMS ((struct frame_info *, long, int, int,
- GDB_FILE *));
+static void disassemble_command PARAMS ((char *, int));
-static void
-display_info PARAMS ((char *, int));
+static void printf_command PARAMS ((char *, int));
-static void
-do_one_display PARAMS ((struct display *));
+static void print_frame_nameless_args PARAMS ((struct frame_info *, long,
+ int, int, GDB_FILE *));
-static void
-undisplay_command PARAMS ((char *, int));
+static void display_info PARAMS ((char *, int));
-static void
-free_display PARAMS ((struct display *));
+static void do_one_display PARAMS ((struct display *));
-static void
-display_command PARAMS ((char *, int));
+static void undisplay_command PARAMS ((char *, int));
-static void
-x_command PARAMS ((char *, int));
+static void free_display PARAMS ((struct display *));
-static void
-address_info PARAMS ((char *, int));
+static void display_command PARAMS ((char *, int));
-static void
-set_command PARAMS ((char *, int));
+static void x_command PARAMS ((char *, int));
-static void
-output_command PARAMS ((char *, int));
+static void address_info PARAMS ((char *, int));
-static void
-call_command PARAMS ((char *, int));
+static void set_command PARAMS ((char *, int));
-static void
-inspect_command PARAMS ((char *, int));
+static void output_command PARAMS ((char *, int));
-static void
-print_command PARAMS ((char *, int));
+static void call_command PARAMS ((char *, int));
-static void
-print_command_1 PARAMS ((char *, int, int));
+static void inspect_command PARAMS ((char *, int));
-static void
-validate_format PARAMS ((struct format_data, char *));
+static void print_command PARAMS ((char *, int));
-static void
-do_examine PARAMS ((struct format_data, CORE_ADDR));
+static void print_command_1 PARAMS ((char *, int, int));
-static void
-print_formatted PARAMS ((value_ptr, int, int));
+static void validate_format PARAMS ((struct format_data, char *));
-static struct format_data
-decode_format PARAMS ((char **, int, int));
+static void do_examine PARAMS ((struct format_data, CORE_ADDR));
+
+static void print_formatted PARAMS ((value_ptr, int, int));
+
+static struct format_data decode_format PARAMS ((char **, int, int));
+
+static int print_insn PARAMS ((CORE_ADDR, GDB_FILE *));
\f
/* Decode a format specification. *STRING_PTR should point to it.
case 'a':
case 's':
/* Pick the appropriate size for an address. */
-#if TARGET_PTR_BIT == 64
- val.size = osize ? 'g' : osize;
- break;
-#else /* Not 64 */
-#if TARGET_PTR_BIT == 32
- val.size = osize ? 'w' : osize;
- break;
-#else /* Not 32 */
-#if TARGET_PTR_BIT == 16
- val.size = osize ? 'h' : osize;
- break;
-#else /* Not 16 */
- #error Bad value for TARGET_PTR_BIT
-#endif /* Not 16 */
-#endif /* Not 32 */
-#endif /* Not 64 */
+ if (TARGET_PTR_BIT == 64)
+ val.size = osize ? 'g' : osize;
+ else if (TARGET_PTR_BIT == 32)
+ val.size = osize ? 'w' : osize;
+ else if (TARGET_PTR_BIT == 16)
+ val.size = osize ? 'h' : osize;
+ else
+ /* Bad value for TARGET_PTR_BIT */
+ abort ();
break;
case 'f':
/* Floating point has to be word or giantword. */
{
case 's':
next_address = VALUE_ADDRESS (val)
- + value_print (value_addr (val), gdb_stdout, format, Val_pretty_default);
+ + val_print_string (VALUE_ADDRESS (val), 0, gdb_stdout);
break;
case 'i':
fputs_filtered (">", stream);
}
-/* Print address ADDR on STREAM. */
+/* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
+ print_longest. */
void
-print_address_numeric (addr, stream)
+print_address_numeric (addr, use_local, stream)
CORE_ADDR addr;
+ int use_local;
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, (unsigned LONGEST) addr);
}
/* Print address ADDR symbolically on STREAM.
CORE_ADDR addr;
GDB_FILE *stream;
{
- print_address_numeric (addr, stream);
+ print_address_numeric (addr, 1, stream);
print_address_symbolic (addr, stream, asm_demangle, " ");
}
}
else if (addressprint)
{
- print_address_numeric (addr, stream);
+ print_address_numeric (addr, 1, stream);
print_address_symbolic (addr, stream, do_demangle, " ");
}
else
{
int histindex = record_latest_value (val);
- if (annotation_level > 1)
- {
- if (histindex >= 0)
- printf_filtered ("\n\032\032value-history-begin %d ", histindex);
- else
- printf_filtered ("\n\032\032value-begin ");
- print_value_flags (VALUE_TYPE (val));
- printf_filtered ("\n");
- }
+ if (histindex >= 0)
+ annotate_value_history_begin (histindex, VALUE_TYPE (val));
+ else
+ annotate_value_begin (VALUE_TYPE (val));
if (inspect)
printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp, histindex);
else
if (histindex >= 0) printf_filtered ("$%d = ", histindex);
- if (annotation_level > 1 && histindex >= 0)
- printf_filtered ("\n\032\032value-history-value\n");
+ if (histindex >= 0)
+ annotate_value_history_value ();
print_formatted (val, format, fmt.size);
printf_filtered ("\n");
- if (annotation_level > 1)
- {
- if (histindex >= 0)
- printf_filtered ("\n\032\032value-history-end\n");
- else
- printf_filtered ("\n\032\032value-end\n");
- }
+ if (histindex >= 0)
+ annotate_value_history_end ();
+ else
+ annotate_value_end ();
if (inspect)
printf_unfiltered("\") )\030");
val = evaluate_expression (expr);
- if (annotation_level > 1)
- {
- printf_filtered ("\n\032\032value-begin ");
- print_value_flags (VALUE_TYPE (val));
- printf_filtered ("\n");
- }
+ annotate_value_begin (VALUE_TYPE (val));
print_formatted (val, format, fmt.size);
- if (annotation_level > 1)
- printf_filtered ("\n\032\032value-end\n");
+ annotate_value_end ();
do_cleanups (old_chain);
}
return;
}
- msymbol = lookup_minimal_symbol (exp, (struct objfile *) NULL);
+ msymbol = lookup_minimal_symbol (exp, NULL, NULL);
if (msymbol != NULL)
{
fprintf_symbol_filtered (gdb_stdout, exp,
current_language->la_language, DMGL_ANSI);
printf_filtered ("\" is at ");
- print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol), gdb_stdout);
+ print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol), 1,
+ gdb_stdout);
printf_filtered (" in a file compiled without debugging.\n");
}
else
case LOC_LABEL:
printf_filtered ("a label at address ");
- print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), gdb_stdout);
+ print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
break;
case LOC_REGISTER:
case LOC_STATIC:
printf_filtered ("static storage at address ");
- print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), gdb_stdout);
+ print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
break;
case LOC_REGPARM:
case LOC_BLOCK:
printf_filtered ("a function at address ");
- print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
+ print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
gdb_stdout);
break;
current_display_number = d->number;
- printf_filtered ("%d: ", d->number);
+ annotate_display_begin ();
+ printf_filtered ("%d", d->number);
+ annotate_display_number_end ();
+ printf_filtered (": ");
if (d->format.size)
{
CORE_ADDR addr;
-
+
+ annotate_display_format ();
+
printf_filtered ("x/");
if (d->format.count != 1)
printf_filtered ("%d", d->format.count);
if (d->format.format != 'i' && d->format.format != 's')
printf_filtered ("%c", d->format.size);
printf_filtered (" ");
+
+ annotate_display_expression ();
+
print_expression (d->exp, gdb_stdout);
+ annotate_display_expression_end ();
+
if (d->format.count != 1)
printf_filtered ("\n");
else
addr = value_as_pointer (evaluate_expression (d->exp));
if (d->format.format == 'i')
addr = ADDR_BITS_REMOVE (addr);
-
+
+ annotate_display_value ();
+
do_examine (d->format, addr);
}
else
{
+ annotate_display_format ();
+
if (d->format.format)
printf_filtered ("/%c ", d->format.format);
+
+ annotate_display_expression ();
+
print_expression (d->exp, gdb_stdout);
+ annotate_display_expression_end ();
+
printf_filtered (" = ");
+
+ annotate_display_expression ();
+
print_formatted (evaluate_expression (d->exp),
d->format.format, d->format.size);
printf_filtered ("\n");
}
+ annotate_display_end ();
+
gdb_flush (gdb_stdout);
current_display_number = -1;
}
void
print_variable_value (var, frame, stream)
struct symbol *var;
- FRAME frame;
+ struct frame_info *frame;
GDB_FILE *stream;
{
value_ptr val = read_var_value (var, frame);
+
value_print (val, stream, 0, Val_pretty_default);
}
fprintf_filtered (stream, ", ");
wrap_here (" ");
- if (annotation_level > 1)
- printf_filtered ("\n\032\032arg-begin\n");
+ annotate_arg_begin ();
fprintf_symbol_filtered (stream, SYMBOL_SOURCE_NAME (sym),
SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
- if (annotation_level > 1)
- printf_filtered ("\n\032\032arg-name-end\n");
+ annotate_arg_name_end ();
fputs_filtered ("=", stream);
/* Avoid value_print because it will deref ref parameters. We just
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, FRAME_INFO_ID (fi));
+ val = read_var_value (sym, fi);
- if (annotation_level > 1)
- {
- printf_filtered ("\n\032\032arg-value ");
- print_value_flags (val == NULL ? NULL : VALUE_TYPE (val));
- printf_filtered ("\n");
- }
+ annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val));
if (val)
val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), VALUE_ADDRESS (val),
else
fputs_filtered ("???", stream);
- if (annotation_level > 1)
- printf_filtered ("\n\032\032arg-end\n");
+ annotate_arg_end ();
first = 0;
}
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 (fi, start, num, first, stream)
struct frame_info *fi;
{
/* Now scan the string for %-specs and see what kinds of args they want.
- argclass[I] classifies the %-specs so we can give vprintf_unfiltered something
- of the right size. */
+ argclass[I] classifies the %-specs so we can give printf_filtered
+ something of the right size. */
enum argclass {no_arg, int_arg, string_arg, double_arg, long_long_arg};
enum argclass *argclass;
if (nargs != nargs_wanted)
error ("Wrong number of arguments for specified format-string");
- /* FIXME: We should be using vprintf_filtered, but as long as it
- has an arbitrary limit that is unacceptable. Correct fix is
- for vprintf_filtered to scan down the format string so it knows
- how big a buffer it needs (perhaps by putting a vasprintf (see
- GNU C library) in libiberty).
-
- But for now, just force out any pending output, so at least the output
- appears in the correct order. */
- wrap_here ((char *)NULL);
-
/* Now actually print them. */
current_substring = substrings;
for (i = 0; i < nargs; i++)
read_memory (tem, str, j);
str[j] = 0;
- /* Don't use printf_filtered because of arbitrary limit. */
- printf_unfiltered (current_substring, str);
+ printf_filtered (current_substring, str);
}
break;
case double_arg:
{
double val = value_as_double (val_args[i]);
- /* Don't use printf_filtered because of arbitrary limit. */
- printf_unfiltered (current_substring, val);
+ printf_filtered (current_substring, val);
break;
}
case long_long_arg:
#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
{
long long val = value_as_long (val_args[i]);
- /* Don't use printf_filtered because of arbitrary limit. */
- printf_unfiltered (current_substring, val);
+ printf_filtered (current_substring, val);
break;
}
#else
{
/* FIXME: there should be separate int_arg and long_arg. */
long val = value_as_long (val_args[i]);
- /* Don't use printf_filtered because of arbitrary limit. */
- printf_unfiltered (current_substring, val);
+ printf_filtered (current_substring, val);
break;
}
default:
current_substring += strlen (current_substring) + 1;
}
/* Print the portion of the format string after the last argument. */
- /* It would be OK to use printf_filtered here. */
- printf (last_arg);
+ printf_filtered (last_arg);
}
do_cleanups (old_cleanups);
}
else
{
printf_filtered ("from ");
- print_address_numeric (low, gdb_stdout);
+ print_address_numeric (low, 1, gdb_stdout);
printf_filtered (" to ");
- print_address_numeric (high, gdb_stdout);
+ print_address_numeric (high, 1, gdb_stdout);
printf_filtered (":\n");
}
gdb_flush (gdb_stdout);
}
+/* Print the instruction at address MEMADDR in debugged memory,
+ on STREAM. Returns length of the instruction, in bytes. */
+
+static int
+print_insn (memaddr, stream)
+ 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);
+}
+
\f
void
_initialize_printcmd ()
"Describe where variable VAR is stored.");
add_com ("x", class_vars, x_command,
- "Examine memory: x/FMT ADDRESS.\n\
+ concat ("Examine memory: x/FMT ADDRESS.\n\
ADDRESS is an expression for the memory address to examine.\n\
FMT is a repeat count followed by a format letter and a size letter.\n\
Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
- t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
-Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
+ t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
+"Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
The specified number of objects of the specified size are printed\n\
according to the format.\n\n\
Defaults for format and size letters are those previously used.\n\
Default count is 1. Default address is following last thing printed\n\
-with this command or \"print\".");
+with this command or \"print\".", NULL));
add_com ("disassemble", class_vars, disassemble_command,
"Disassemble a specified section of memory.\n\
as in the \"x\" command, and then EXP is used to get the address to examine\n\
and examining is done as in the \"x\" command.\n\n\
With no argument, display all currently requested auto-display expressions.\n\
-Use \"undisplay\" to cancel display requests previously made.");
+Use \"undisplay\" to cancel display requests previously made."
+);
add_cmd ("display", class_vars, enable_display,
"Enable some expressions to be displayed when program stops.\n\
add_com ("printf", class_vars, printf_command,
"printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
This is useful for formatted output in user-defined commands.");
+
add_com ("output", class_vars, output_command,
"Like \"print\" but don't put in value history and don't print newline.\n\
This is useful in user-defined commands.");
add_prefix_cmd ("set", class_vars, set_command,
-"Evaluate expression EXP and assign result to variable VAR, using assignment\n\
+concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
example). VAR may be a debugger \"convenience\" variable (names starting\n\
with $), a register (a few standard names starting with $), or an actual\n\
-variable in the program being debugged. EXP is any valid expression.\n\
-Use \"set variable\" for variables with names identical to set subcommands.\n\
+variable in the program being debugged. EXP is any valid expression.\n",
+"Use \"set variable\" for variables with names identical to set subcommands.\n\
\nWith a subcommand, this command modifies parts of the gdb environment.\n\
-You can see these environment settings with the \"show\" command.",
+You can see these environment settings with the \"show\" command.", NULL),
&setlist, "set ", 1, &cmdlist);
/* "call" is the same as "set", but handy for dbx users to call fns. */
\n\
$NUM gets previous value number NUM. $ and $$ are the last two values.\n\
$$NUM refers to NUM'th value back from the last one.\n\
-Names starting with $ refer to registers (with the values they would have\n\
-if the program were to return to the stack frame now selected, restoring\n\
+Names starting with $ refer to registers (with the values they would have\n",
+"if the program were to return to the stack frame now selected, restoring\n\
all registers saved by frames farther in) or else to debugger\n\
\"convenience\" variables (any such name not a known register).\n\
Use assignment expressions to give values to convenience variables.\n",
&setprintlist),
&showprintlist);
- examine_b_type = init_type (TYPE_CODE_INT, 1, 0, NULL, NULL);
- examine_h_type = init_type (TYPE_CODE_INT, 2, 0, NULL, NULL);
- examine_w_type = init_type (TYPE_CODE_INT, 4, 0, NULL, NULL);
- examine_g_type = init_type (TYPE_CODE_INT, 8, 0, NULL, NULL);
+ examine_b_type = init_type (TYPE_CODE_INT, 1, 0, "examine_b_type", NULL);
+ 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);
}
projects / deliverable / binutils-gdb.git / blobdiff