/* Print values for GNU debugger GDB.
- Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
-
-#include <stdio.h>
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+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. */
+
#include "defs.h"
-#include "initialize.h"
-#include "param.h"
+#include <string.h>
+#include "frame.h"
#include "symtab.h"
+#include "gdbtypes.h"
#include "value.h"
+#include "language.h"
#include "expression.h"
+#include "gdbcore.h"
+#include "gdbcmd.h"
+#include "target.h"
+#include "breakpoint.h"
+#include "demangle.h"
+
+extern int asm_demangle; /* Whether to demangle syms in asm printouts */
+extern int addressprint; /* Whether to print hex addresses in HLL " */
struct format_data
{
int current_display_number;
-static void do_one_display ();
+/* Flag to low-level print routines that this value is being printed
+ in an epoch window. We'd like to pass this as a parameter, but
+ every routine would need to take it. Perhaps we can encapsulate
+ this in the I/O stream once we have GNU stdio. */
+
+int inspect_it = 0;
+
+struct display
+{
+ /* Chain link to next auto-display item. */
+ struct display *next;
+ /* Expression to be evaluated and displayed. */
+ struct expression *exp;
+ /* Item number of this auto-display item. */
+ int number;
+ /* Display format specified. */
+ struct format_data format;
+ /* Innermost block required by this expression when evaluated */
+ struct block *block;
+ /* Status of this display (enabled or disabled) */
+ enum enable status;
+};
+
+/* Chain of expressions whose values should be displayed
+ automatically each time the program stops. */
+
+static struct display *display_chain;
+
+static int display_number;
+
+/* Prototypes for local functions */
-void do_displays ();
-void print_address ();
-void print_scalar_formatted ();
+static void
+delete_display PARAMS ((int));
+
+static void
+enable_display PARAMS ((char *, int));
+
+static void
+disable_display_command PARAMS ((char *, int));
+
+static void
+disassemble_command PARAMS ((char *, int));
+
+static int
+containing_function_bounds PARAMS ((CORE_ADDR, CORE_ADDR *, CORE_ADDR *));
+
+static void
+printf_command PARAMS ((char *, int));
+
+static void
+print_frame_nameless_args PARAMS ((CORE_ADDR, long, int, int, FILE *));
+
+static void
+display_info PARAMS ((char *, int));
+
+static void
+do_one_display PARAMS ((struct display *));
+
+static void
+undisplay_command PARAMS ((char *, int));
+
+static void
+free_display PARAMS ((struct display *));
+
+static void
+display_command PARAMS ((char *, int));
+
+static void
+ptype_command PARAMS ((char *, int));
+
+static struct type *
+ptype_eval PARAMS ((struct expression *));
+
+static void
+whatis_command PARAMS ((char *, int));
+
+static void
+whatis_exp PARAMS ((char *, int));
+
+static void
+x_command PARAMS ((char *, int));
+
+static void
+address_info PARAMS ((char *, int));
+
+static void
+set_command PARAMS ((char *, int));
+
+static void
+output_command PARAMS ((char *, int));
+
+static void
+call_command PARAMS ((char *, int));
+
+static void
+inspect_command PARAMS ((char *, int));
+
+static void
+print_command PARAMS ((char *, int));
+
+static void
+print_command_1 PARAMS ((char *, int, int));
+
+static void
+validate_format PARAMS ((struct format_data, char *));
+
+static void
+do_examine PARAMS ((struct format_data, CORE_ADDR));
+
+static void
+print_formatted PARAMS ((value, int, int));
+
+static struct format_data
+decode_format PARAMS ((char **, int, int));
-START_FILE
\f
/* Decode a format specification. *STRING_PTR should point to it.
OFORMAT and OSIZE are used as defaults for the format and size
if none are given in the format specification.
+ If OSIZE is zero, then the size field of the returned value
+ should be set only if a size is explicitly specified by the
+ user.
The structure returned describes all the data
found in the specification. In addition, *STRING_PTR is advanced
past the specification and past all whitespace following it. */
-struct format_data
+static struct format_data
decode_format (string_ptr, oformat, osize)
char **string_ptr;
- char oformat;
- char osize;
+ int oformat;
+ int osize;
{
struct format_data val;
register char *p = *string_ptr;
- val.format = oformat;
- val.size = osize;
+ val.format = '?';
+ val.size = '?';
val.count = 1;
if (*p >= '0' && *p <= '9')
{
if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
val.size = *p++;
+#ifdef LONG_LONG
+ else if (*p == 'l')
+ {
+ val.size = 'g';
+ p++;
+ }
+#endif
else if (*p >= 'a' && *p <= 'z')
val.format = *p++;
else
break;
}
- /* Make sure 'g' size is not used on integer types. */
- if (val.size == 'g' && val.format != 'f')
+#ifndef LONG_LONG
+ /* Make sure 'g' size is not used on integer types.
+ Well, actually, we can handle hex. */
+ if (val.size == 'g' && val.format != 'f' && val.format != 'x')
val.size = 'w';
+#endif
while (*p == ' ' || *p == '\t') p++;
*string_ptr = p;
+ /* Set defaults for format and size if not specified. */
+ if (val.format == '?')
+ {
+ if (val.size == '?')
+ {
+ /* Neither has been specified. */
+ val.format = oformat;
+ val.size = osize;
+ }
+ else
+ /* If a size is specified, any format makes a reasonable
+ default except 'i'. */
+ val.format = oformat == 'i' ? 'x' : oformat;
+ }
+ else if (val.size == '?')
+ switch (val.format)
+ {
+ case 'a':
+ case 's':
+ /* Addresses must be words. */
+ val.size = osize ? 'w' : osize;
+ break;
+ case 'f':
+ /* Floating point has to be word or giantword. */
+ if (osize == 'w' || osize == 'g')
+ val.size = osize;
+ else
+ /* Default it to giantword if the last used size is not
+ appropriate. */
+ val.size = osize ? 'g' : osize;
+ break;
+ case 'c':
+ /* Characters default to one byte. */
+ val.size = osize ? 'b' : osize;
+ break;
+ default:
+ /* The default is the size most recently specified. */
+ val.size = osize;
+ }
+
return val;
}
\f
static void
print_formatted (val, format, size)
register value val;
- register char format;
- char size;
+ register int format;
+ int size;
{
- register CORE_ADDR val_long;
int len = TYPE_LENGTH (VALUE_TYPE (val));
if (VALUE_LVAL (val) == lval_memory)
{
case 's':
next_address = VALUE_ADDRESS (val)
- + value_print (value_addr (val), stdout, 0);
+ + value_print (value_addr (val), stdout, format, Val_pretty_default);
break;
case 'i':
+ wrap_here (""); /* Force output out, print_insn not using _filtered */
next_address = VALUE_ADDRESS (val)
+ print_insn (VALUE_ADDRESS (val), stdout);
break;
if (format == 0
|| TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_ARRAY
|| TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_STRUCT
- || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_UNION)
- value_print (val, stdout, format);
+ || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_UNION
+ || VALUE_REPEATED (val))
+ value_print (val, stdout, format, Val_pretty_default);
else
print_scalar_formatted (VALUE_CONTENTS (val), VALUE_TYPE (val),
format, size, stdout);
print_scalar_formatted (valaddr, type, format, size, stream)
char *valaddr;
struct type *type;
- char format;
+ int format;
int size;
FILE *stream;
{
- long val_long;
+ LONGEST val_long;
int len = TYPE_LENGTH (type);
+ if (size == 'g' && sizeof (LONGEST) < 8
+ && format == 'x')
+ {
+ /* ok, we're going to have to get fancy here. Assumption: a
+ long is four bytes. FIXME. */
+ unsigned long v1, v2;
+
+ v1 = unpack_long (builtin_type_long, valaddr);
+ v2 = unpack_long (builtin_type_long, valaddr + 4);
+
+#if TARGET_BYTE_ORDER == LITTLE_ENDIAN
+ /* Swap the two for printing */
+ {
+ unsigned long tmp;
+
+ tmp = v1;
+ v1 = v2;
+ v2 = tmp;
+ }
+#endif
+
+ switch (format)
+ {
+ case 'x':
+ fprintf_filtered (stream, local_hex_format_custom("08x%08"), v1, v2);
+ break;
+ default:
+ error ("Output size \"g\" unimplemented for format \"%c\".",
+ format);
+ }
+ return;
+ }
+
val_long = unpack_long (type, valaddr);
/* If value is unsigned, truncate it in case negative. */
val_long &= (1 << 8 * sizeof(char)) - 1;
else if (len == sizeof (short))
val_long &= (1 << 8 * sizeof(short)) - 1;
+ else if (len == sizeof (long))
+ val_long &= (unsigned long) - 1;
}
switch (format)
{
case 'x':
+ if (!size)
+ {
+ /* no size specified, like in print. Print varying # of digits. */
+#if defined (LONG_LONG)
+ fprintf_filtered (stream, local_hex_format_custom("ll"), val_long);
+#else /* not LONG_LONG. */
+ fprintf_filtered (stream, local_hex_format_custom("l"), val_long);
+#endif /* not LONG_LONG. */
+ }
+ else
+#if defined (LONG_LONG)
+ switch (size)
+ {
+ case 'b':
+ fprintf_filtered (stream, local_hex_format_custom("02ll"), val_long);
+ break;
+ case 'h':
+ fprintf_filtered (stream, local_hex_format_custom("04ll"), val_long);
+ break;
+ case 'w':
+ fprintf_filtered (stream, local_hex_format_custom("08ll"), val_long);
+ break;
+ case 'g':
+ fprintf_filtered (stream, local_hex_format_custom("016ll"), val_long);
+ break;
+ default:
+ error ("Undefined output size \"%c\".", size);
+ }
+#else /* not LONG_LONG. */
switch (size)
{
case 'b':
- printf ("0x%02x", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("02"), val_long);
break;
case 'h':
- printf ("0x%04x", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("04"), val_long);
break;
- case 0: /* no size specified, like in print */
case 'w':
- printf ("0x%08x", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("08"), val_long);
break;
case 'g':
- printf ("0x%16x", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("016"), val_long);
break;
default:
error ("Undefined output size \"%c\".", size);
}
+#endif /* not LONG_LONG */
break;
case 'd':
- printf ("%d", val_long);
+#ifdef LONG_LONG
+ fprintf_filtered (stream, "%lld", val_long);
+#else
+ fprintf_filtered (stream, "%d", val_long);
+#endif
break;
case 'u':
- printf ("%u", val_long);
+#ifdef LONG_LONG
+ fprintf_filtered (stream, "%llu", val_long);
+#else
+ fprintf_filtered (stream, "%u", val_long);
+#endif
break;
case 'o':
if (val_long)
- printf ("0%o", val_long);
+#ifdef LONG_LONG
+ fprintf_filtered (stream, local_octal_format_custom("ll"), val_long);
+#else
+ fprintf_filtered (stream, local_octal_format(), val_long);
+#endif
else
- printf ("0");
+ fprintf_filtered (stream, "0");
break;
case 'a':
- print_address (val_long, stream);
+ print_address (unpack_pointer (type, valaddr), stream);
break;
case 'c':
- value_print (value_from_long (builtin_type_char, val_long), stream, 0);
+ value_print (value_from_longest (builtin_type_char, val_long), stream, 0,
+ Val_pretty_default);
break;
case 'f':
if (len == sizeof (float))
type = builtin_type_float;
- if (len == sizeof (double))
+ else if (len == sizeof (double))
type = builtin_type_double;
-#ifdef IEEE_FLOAT
- if (is_nan (unpack_double (type, valaddr)))
- {
- printf ("Nan");
- break;
- }
-#endif
- printf ("%g", unpack_double (type, valaddr));
+ print_floating (valaddr, type, stream);
break;
case 0:
abort ();
+ case 't':
+ /* Binary; 't' stands for "two". */
+ {
+ char bits[8*(sizeof val_long) + 1];
+ char *cp = bits;
+ int width;
+
+ if (!size)
+ width = 8*(sizeof val_long);
+ else
+ switch (size)
+ {
+ case 'b':
+ width = 8;
+ break;
+ case 'h':
+ width = 16;
+ break;
+ case 'w':
+ width = 32;
+ break;
+ case 'g':
+ width = 64;
+ break;
+ default:
+ error ("Undefined output size \"%c\".", size);
+ }
+
+ bits[width] = '\0';
+ while (width-- > 0)
+ {
+ bits[width] = (val_long & 1) ? '1' : '0';
+ val_long >>= 1;
+ }
+ if (!size)
+ {
+ while (*cp && *cp == '0')
+ cp++;
+ if (*cp == '\0')
+ cp--;
+ }
+ fprintf_filtered (stream, cp);
+ }
+ break;
+
default:
error ("Undefined output format \"%c\".", format);
}
/* Make address available to the user as $_. */
set_internalvar (lookup_internalvar ("_"),
- value_from_long (builtin_type_int, addr));
+ value_from_longest (lookup_pointer_type (builtin_type_void),
+ (LONGEST) addr));
+}
+
+/* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
+ after LEADIN. Print nothing if no symbolic name is found nearby.
+ DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
+ or to interpret it as a possible C++ name and convert it back to source
+ form. */
+
+void
+print_address_symbolic (addr, stream, do_demangle, leadin)
+ CORE_ADDR addr;
+ FILE *stream;
+ int do_demangle;
+ char *leadin;
+{
+ int name_location;
+ register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (addr);
+
+ /* If nothing comes out, don't print anything symbolic. */
+
+ if (msymbol == NULL)
+ return;
+
+ fputs_filtered (leadin, stream);
+ fputs_filtered ("<", stream);
+ if (do_demangle)
+ fputs_demangled (msymbol -> name, stream, DMGL_ANSI | DMGL_PARAMS);
+ else
+ fputs_filtered (msymbol -> name, stream);
+ name_location = msymbol -> address;
+ if (addr - name_location)
+ fprintf_filtered (stream, "+%d>", addr - name_location);
+ else
+ fputs_filtered (">", stream);
}
/* Print address ADDR symbolically on STREAM.
CORE_ADDR addr;
FILE *stream;
{
- register int i;
-
- fprintf (stream, "0x%x", addr);
+#ifdef ADDR_BITS_REMOVE
+ fprintf_filtered (stream, local_hex_format(), ADDR_BITS_REMOVE(addr));
+#else
+ fprintf_filtered (stream, local_hex_format(), addr);
+#endif
+ print_address_symbolic (addr, stream, asm_demangle, " ");
+}
- i = find_pc_misc_function (addr);
- if (i >= 0)
- if (misc_function_vector[i].address != addr)
- fprintf (stream, " <%s+%d>",
- misc_function_vector[i].name,
- addr - misc_function_vector[i].address);
- else
- fprintf (stream, " <%s>", misc_function_vector[i].name);
+/* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
+ controls whether to print the symbolic name "raw" or demangled.
+ Global setting "addressprint" controls whether to print hex address
+ or not. */
+void
+print_address_demangle (addr, stream, do_demangle)
+ CORE_ADDR addr;
+ FILE *stream;
+ int do_demangle;
+{
+ if (addr == 0) {
+ fprintf_filtered (stream, "0");
+ } else if (addressprint) {
+ fprintf_filtered (stream, local_hex_format(), addr);
+ print_address_symbolic (addr, stream, do_demangle, " ");
+ } else {
+ print_address_symbolic (addr, stream, do_demangle, "");
+ }
}
\f
+
/* Examine data at address ADDR in format FMT.
Fetch it from memory and print on stdout. */
else if (size == 'w')
val_type = builtin_type_long;
else if (size == 'g')
+#ifndef LONG_LONG
val_type = builtin_type_double;
+#else
+ val_type = builtin_type_long_long;
+#endif
maxelts = 8;
if (size == 'w')
while (count > 0)
{
print_address (next_address, stdout);
- fputc (':', stdout);
+ printf_filtered (":");
for (i = maxelts;
i > 0 && count > 0;
i--, count--)
{
- fputc ('\t', stdout);
- /* Note that this sets next_address for the next object. */
+ printf_filtered ("\t");
+ /* 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);
print_formatted (last_examine_value, format, size);
}
- fputc ('\n', stdout);
+ printf_filtered ("\n");
fflush (stdout);
}
}
}
static void
-print_command (exp)
+print_command_1 (exp, inspect, voidprint)
char *exp;
+ int inspect;
+ int voidprint;
{
struct expression *expr;
register struct cleanup *old_chain = 0;
register char format = 0;
register value val;
struct format_data fmt;
- int histindex;
int cleanup = 0;
+ /* Pass inspect flag to the rest of the print routines in a global (sigh). */
+ inspect_it = inspect;
+
if (exp && *exp == '/')
{
exp++;
validate_format (fmt, "print");
last_format = format = fmt.format;
}
+ else
+ {
+ fmt.count = 1;
+ fmt.format = 0;
+ fmt.size = 0;
+ }
if (exp && *exp)
{
- expr = parse_c_expression (exp);
+ extern int objectprint;
+ struct type *type;
+ expr = parse_expression (exp);
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 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);
- histindex = record_latest_value (val);
- printf ("$%d = ", histindex);
+ if (voidprint || (val && VALUE_TYPE (val) &&
+ TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_VOID))
+ {
+ int histindex = record_latest_value (val);
- print_formatted (val, format, fmt.size);
- printf ("\n");
+ if (inspect)
+ printf ("\031(gdb-makebuffer \"%s\" %d '(\"", exp, histindex);
+ else
+ if (histindex >= 0) printf_filtered ("$%d = ", histindex);
+
+ print_formatted (val, format, fmt.size);
+ printf_filtered ("\n");
+ if (inspect)
+ printf("\") )\030");
+ }
if (cleanup)
do_cleanups (old_chain);
+ inspect_it = 0; /* Reset print routines to normal */
+}
+
+/* ARGSUSED */
+static void
+print_command (exp, from_tty)
+ char *exp;
+ int from_tty;
+{
+ print_command_1 (exp, 0, 1);
}
+/* Same as print, except in epoch, it gets its own window */
+/* ARGSUSED */
static void
-output_command (exp)
+inspect_command (exp, from_tty)
char *exp;
+ int from_tty;
+{
+ extern int epoch_interface;
+
+ print_command_1 (exp, epoch_interface, 1);
+}
+
+/* Same as print, except it doesn't print void results. */
+/* ARGSUSED */
+static void
+call_command (exp, from_tty)
+ char *exp;
+ int from_tty;
+{
+ print_command_1 (exp, 0, 0);
+}
+
+/* ARGSUSED */
+static void
+output_command (exp, from_tty)
+ char *exp;
+ int from_tty;
{
struct expression *expr;
register struct cleanup *old_chain;
{
exp++;
fmt = decode_format (&exp, 0, 0);
- validate_format (fmt, "print");
+ validate_format (fmt, "output");
format = fmt.format;
}
- expr = parse_c_expression (exp);
+ expr = parse_expression (exp);
old_chain = make_cleanup (free_current_contents, &expr);
val = evaluate_expression (expr);
do_cleanups (old_chain);
}
+/* ARGSUSED */
static void
-set_command (exp)
+set_command (exp, from_tty)
char *exp;
+ int from_tty;
{
- struct expression *expr = parse_c_expression (exp);
+ struct expression *expr = parse_expression (exp);
register struct cleanup *old_chain
= make_cleanup (free_current_contents, &expr);
evaluate_expression (expr);
do_cleanups (old_chain);
}
+/* ARGSUSED */
static void
-address_info (exp)
+address_info (exp, from_tty)
char *exp;
+ int from_tty;
{
register struct symbol *sym;
- register CORE_ADDR val;
+ register struct minimal_symbol *msymbol;
+ register long val;
+ register long basereg;
+ int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero
+ if exp is a field of `this'. */
if (exp == 0)
error ("Argument required.");
- sym = lookup_symbol (exp, get_selected_block (), VAR_NAMESPACE);
+ sym = lookup_symbol (exp, get_selected_block (), VAR_NAMESPACE,
+ &is_a_field_of_this, (struct symtab **)NULL);
if (sym == 0)
{
- register int i;
+ if (is_a_field_of_this)
+ {
+ printf ("Symbol \"%s\" is a field of the local class variable `this'\n", exp);
+ return;
+ }
- for (i = 0; i < misc_function_count; i++)
- if (!strcmp (misc_function_vector[i].name, exp))
- break;
+ msymbol = lookup_minimal_symbol (exp, (struct objfile *) NULL);
- if (i < misc_function_count)
- printf ("Symbol \"%s\" is at 0x%x in a file compiled without -g.\n",
- exp, misc_function_vector[i].address);
+ if (msymbol != NULL)
+ printf ("Symbol \"%s\" is at %s in a file compiled without debugging.\n",
+ exp, local_hex_string(msymbol -> address));
else
error ("No symbol \"%s\" in current context.", exp);
return;
printf ("Symbol \"%s\" is ", SYMBOL_NAME (sym));
val = SYMBOL_VALUE (sym);
+ basereg = SYMBOL_BASEREG (sym);
switch (SYMBOL_CLASS (sym))
{
break;
case LOC_LABEL:
- printf ("a label at address 0x%x", val);
+ printf ("a label at address %s", local_hex_string(SYMBOL_VALUE_ADDRESS (sym)));
break;
case LOC_REGISTER:
break;
case LOC_STATIC:
- printf ("static at address 0x%x", val);
+ printf ("static storage at address %s", local_hex_string(SYMBOL_VALUE_ADDRESS (sym)));
break;
case LOC_REGPARM:
printf ("an argument in register %s", reg_names[val]);
break;
-
+
case LOC_ARG:
- printf ("an argument at offset %d", val);
+ if (SYMBOL_BASEREG_VALID (sym))
+ {
+ printf ("an argument at offset %ld from register %s",
+ val, reg_names[basereg]);
+ }
+ else
+ {
+ printf ("an argument at offset %ld", val);
+ }
+ break;
+
+ case LOC_LOCAL_ARG:
+ if (SYMBOL_BASEREG_VALID (sym))
+ {
+ printf ("an argument at offset %ld from register %s",
+ val, reg_names[basereg]);
+ }
+ else
+ {
+ printf ("an argument at frame offset %ld", val);
+ }
break;
case LOC_LOCAL:
- printf ("a local variable at frame offset %d", val);
+ if (SYMBOL_BASEREG_VALID (sym))
+ {
+ printf ("a local variable at offset %ld from register %s",
+ val, reg_names[basereg]);
+ }
+ else
+ {
+ printf ("a local variable at frame offset %ld", val);
+ }
+ break;
+
+ case LOC_REF_ARG:
+ printf ("a reference argument at offset %ld", val);
break;
case LOC_TYPEDEF:
break;
case LOC_BLOCK:
- printf ("a function at address 0x%x",
- BLOCK_START (SYMBOL_BLOCK_VALUE (sym)));
+ printf ("a function at address %s",
+ local_hex_string(BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
+ break;
+
+ default:
+ printf ("of unknown (botched) type");
break;
}
printf (".\n");
struct expression *expr;
struct format_data fmt;
struct cleanup *old_chain;
+ struct value *val;
fmt.format = last_format;
fmt.size = last_size;
{
exp++;
fmt = decode_format (&exp, last_format, last_size);
- last_size = fmt.size;
- last_format = fmt.format;
}
/* If we have an expression, evaluate it and use it as the address. */
if (exp != 0 && *exp != 0)
{
- expr = parse_c_expression (exp);
+ expr = parse_expression (exp);
/* Cause expression not to be there any more
if this command is repeated with Newline.
But don't clobber a user-defined command's definition. */
if (from_tty)
*exp = 0;
old_chain = make_cleanup (free_current_contents, &expr);
- next_address = value_as_long (evaluate_expression (expr));
+ val = evaluate_expression (expr);
+ if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_REF)
+ val = value_ind (val);
+ /* In rvalue contexts, such as this, functions are coerced into
+ pointers to functions. This makes "x/i main" work. */
+ if (/* last_format == 'i'
+ && */ TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC
+ && VALUE_LVAL (val) == lval_memory)
+ next_address = VALUE_ADDRESS (val);
+ else
+ next_address = value_as_pointer (val);
do_cleanups (old_chain);
}
do_examine (fmt, next_address);
- /* Make last address examined available to the user as $_. */
- set_internalvar (lookup_internalvar ("_"),
- value_from_long (builtin_type_int, last_examine_address));
+ /* If the examine succeeds, we remember its size and format for next time. */
+ last_size = fmt.size;
+ last_format = fmt.format;
- /* Make contents of last address examined available to the user as $__. */
- set_internalvar (lookup_internalvar ("__"), last_examine_value);
+ /* Set a couple of internal variables if appropriate. */
+ if (last_examine_value)
+ {
+ /* Make last address examined available to the user as $_. Use
+ the correct pointer type. */
+ set_internalvar (lookup_internalvar ("_"),
+ value_from_longest (
+ lookup_pointer_type (VALUE_TYPE (last_examine_value)),
+ (LONGEST) last_examine_address));
+
+ /* Make contents of last address examined available to the user as $__.*/
+ set_internalvar (lookup_internalvar ("__"), last_examine_value);
+ }
}
\f
/* Commands for printing types of things. */
+/* Print type of EXP, or last thing in value history if EXP == NULL.
+ show is passed to type_print. */
static void
-whatis_command (exp)
+whatis_exp (exp, show)
char *exp;
+ int show;
{
struct expression *expr;
register value val;
if (exp)
{
- expr = parse_c_expression (exp);
+ expr = parse_expression (exp);
old_chain = make_cleanup (free_current_contents, &expr);
val = evaluate_type (expr);
}
else
val = access_value_history (0);
- printf ("type = ");
- type_print (VALUE_TYPE (val), "", stdout, 1);
- printf ("\n");
+ printf_filtered ("type = ");
+ type_print (VALUE_TYPE (val), "", stdout, show);
+ printf_filtered ("\n");
if (exp)
do_cleanups (old_chain);
}
+/* ARGSUSED */
static void
-ptype_command (typename)
- char *typename;
+whatis_command (exp, from_tty)
+ char *exp;
+ int from_tty;
{
- register char *p = typename;
- register int len;
- extern struct block *get_current_block ();
- register struct block *b
- = (have_inferior_p () || have_core_file_p ()) ? get_current_block () : 0;
- register struct type *type;
+ /* Most of the time users do not want to see all the fields
+ in a structure. If they do they can use the "ptype" command.
+ Hence the "-1" below. */
+ whatis_exp (exp, -1);
+}
- if (typename == 0)
- error_no_arg ("type name");
+/* Simple subroutine for ptype_command. */
+static
+struct type *
+ptype_eval(exp)
+ struct expression *exp;
+{
+ if(exp->elts[0].opcode==OP_TYPE)
+ return exp->elts[1].type;
+ else
+ return 0;
+}
- while (*p && *p != ' ' && *p != '\t') p++;
- len = p - typename;
- while (*p == ' ' || *p == '\t') p++;
+/* TYPENAME is either the name of a type, or an expression. */
+/* ARGSUSED */
+static void
+ptype_command (typename, from_tty)
+ char *typename;
+ int from_tty;
+{
+ register struct type *type;
+ struct expression *expr;
+ register struct cleanup *old_chain;
- if (len == 6 && !strncmp (typename, "struct", 6))
- type = lookup_struct (p, b);
- else if (len == 5 && !strncmp (typename, "union", 5))
- type = lookup_union (p, b);
- else if (len == 4 && !strncmp (typename, "enum", 4))
- type = lookup_enum (p, b);
+ if (typename)
+ {
+ expr = parse_expression (typename);
+ old_chain = make_cleanup (free_current_contents, &expr);
+ type = ptype_eval (expr);
+
+ if(type)
+ {
+ printf_filtered ("type = ");
+ type_print (type, "", stdout, 1);
+ printf_filtered ("\n");
+ do_cleanups (old_chain);
+ }
+ else
+ {
+ do_cleanups (old_chain);
+ whatis_exp (typename, 1);
+ }
+ }
else
- {
- type = lookup_typename (typename, b, 1);
- if (type == 0)
- {
- register struct symbol *sym
- = lookup_symbol (typename, b, STRUCT_NAMESPACE);
- if (sym == 0)
- error ("No type named %s.", typename);
- printf ("No type named %s, but there is a ",
- typename);
- switch (TYPE_CODE (SYMBOL_TYPE (sym)))
- {
- case TYPE_CODE_STRUCT:
- printf ("struct");
- break;
-
- case TYPE_CODE_UNION:
- printf ("union");
- break;
-
- case TYPE_CODE_ENUM:
- printf ("enum");
- }
- printf (" %s. Type \"help ptype\".\n", typename);
- type = SYMBOL_TYPE (sym);
- }
- }
-
- type_print (type, "", stdout, 1);
- printf ("\n");
+ whatis_exp (typename, 1);
}
\f
-struct display
-{
- /* Chain link to next auto-display item. */
- struct display *next;
- /* Expression to be evaluated and displayed. */
- struct expression *exp;
- /* Item number of this auto-display item. */
- int number;
- /* Display format specified. */
- struct format_data format;
- /* Block in which expression is to be evaluated. */
- struct block *block;
-};
-
-/* Chain of expressions whose values should be displayed
- automatically each time the program stops. */
-
-static struct display *display_chain;
-
-static int display_number;
-
/* Add an expression to the auto-display chain.
Specify the expression. */
fmt.count = 0;
}
- expr = parse_c_expression (exp);
+ innermost_block = 0;
+ expr = parse_expression (exp);
new = (struct display *) xmalloc (sizeof (struct display));
new->exp = expr;
+ new->block = innermost_block;
new->next = display_chain;
new->number = ++display_number;
new->format = fmt;
+ new->status = enabled;
display_chain = new;
- if (from_tty)
+ if (from_tty && target_has_execution)
do_one_display (new);
dont_repeat ();
free_display (d)
struct display *d;
{
- free (d->exp);
- free (d);
+ free ((PTR)d->exp);
+ free ((PTR)d);
}
/* Clear out the display_chain.
while (d = display_chain)
{
- free (d->exp);
+ free ((PTR)d->exp);
display_chain = d->next;
- free (d);
+ free ((PTR)d);
}
}
/* Delete the auto-display number NUM. */
-void
+static void
delete_display (num)
int num;
{
Specify the element numbers. */
static void
-undisplay_command (args)
+undisplay_command (args, from_tty)
char *args;
+ int from_tty;
{
register char *p = args;
register char *p1;
register int num;
- register struct display *d, *d1;
if (args == 0)
{
dont_repeat ();
}
-/* Display a single auto-display. */
+/* Display a single auto-display.
+ Do nothing if the display cannot be printed in the current context,
+ or if the display is disabled. */
static void
do_one_display (d)
struct display *d;
{
+ int within_current_scope;
+
+ if (d->status == disabled)
+ return;
+
+ if (d->block)
+ within_current_scope = contained_in (get_selected_block (), d->block);
+ else
+ within_current_scope = 1;
+ if (!within_current_scope)
+ return;
+
current_display_number = d->number;
- printf ("%d: ", d->number);
+ printf_filtered ("%d: ", d->number);
if (d->format.size)
{
- printf ("x/");
+ CORE_ADDR addr;
+
+ printf_filtered ("x/");
if (d->format.count != 1)
- printf ("%d", d->format.count);
- printf ("%c", d->format.format);
+ printf_filtered ("%d", d->format.count);
+ printf_filtered ("%c", d->format.format);
if (d->format.format != 'i' && d->format.format != 's')
- printf ("%c", d->format.size);
- printf (" ");
+ printf_filtered ("%c", d->format.size);
+ printf_filtered (" ");
print_expression (d->exp, stdout);
if (d->format.count != 1)
- printf ("\n");
+ printf_filtered ("\n");
else
- printf (" ");
- do_examine (d->format,
- value_as_long (evaluate_expression (d->exp)));
+ printf_filtered (" ");
+
+ addr = value_as_pointer (evaluate_expression (d->exp));
+ if (d->format.format == 'i')
+ addr = ADDR_BITS_REMOVE (addr);
+
+ do_examine (d->format, addr);
}
else
{
if (d->format.format)
- printf ("/%c ", d->format.format);
+ printf_filtered ("/%c ", d->format.format);
print_expression (d->exp, stdout);
- printf (" = ");
+ printf_filtered (" = ");
print_formatted (evaluate_expression (d->exp),
d->format.format, d->format.size);
- printf ("\n");
+ printf_filtered ("\n");
}
fflush (stdout);
current_display_number = -1;
}
-/* Display all of the values on the auto-display chain. */
+/* Display all of the values on the auto-display chain which can be
+ evaluated in the current scope. */
void
do_displays ()
This is done when there is an error or a signal. */
void
-delete_current_display ()
+disable_display (num)
+ int num;
+{
+ register struct display *d;
+
+ for (d = display_chain; d; d = d->next)
+ if (d->number == num)
+ {
+ d->status = disabled;
+ return;
+ }
+ printf ("No display number %d.\n", num);
+}
+
+void
+disable_current_display ()
{
if (current_display_number >= 0)
{
- delete_display (current_display_number);
- fprintf (stderr, "Deleting display %d to avoid infinite recursion.\n",
+ disable_display (current_display_number);
+ fprintf (stderr, "Disabling display %d to avoid infinite recursion.\n",
current_display_number);
}
current_display_number = -1;
}
static void
-display_info ()
+display_info (ignore, from_tty)
+ char *ignore;
+ int from_tty;
{
register struct display *d;
if (!display_chain)
printf ("There are no auto-display expressions now.\n");
else
- printf ("Auto-display expressions now in effect:\n");
+ printf_filtered ("Auto-display expressions now in effect:\n\
+Num Enb Expression\n");
+
for (d = display_chain; d; d = d->next)
{
- printf ("%d: ", d->number);
+ printf_filtered ("%d: %c ", d->number, "ny"[(int)d->status]);
if (d->format.size)
- printf ("/%d%c%c ", d->format.count, d->format.size,
+ printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
d->format.format);
else if (d->format.format)
- printf ("/%c ", d->format.format);
+ printf_filtered ("/%c ", d->format.format);
print_expression (d->exp, stdout);
- printf ("\n");
+ if (d->block && !contained_in (get_selected_block (), d->block))
+ printf_filtered (" (cannot be evaluated in the current context)");
+ printf_filtered ("\n");
fflush (stdout);
}
}
+
+static void
+enable_display (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ register char *p = args;
+ register char *p1;
+ register int num;
+ register struct display *d;
+
+ if (p == 0)
+ {
+ for (d = display_chain; d; d = d->next)
+ d->status = enabled;
+ }
+ else
+ while (*p)
+ {
+ p1 = p;
+ while (*p1 >= '0' && *p1 <= '9')
+ p1++;
+ if (*p1 && *p1 != ' ' && *p1 != '\t')
+ error ("Arguments must be display numbers.");
+
+ num = atoi (p);
+
+ for (d = display_chain; d; d = d->next)
+ if (d->number == num)
+ {
+ d->status = enabled;
+ goto win;
+ }
+ printf ("No display number %d.\n", num);
+ win:
+ p = p1;
+ while (*p == ' ' || *p == '\t')
+ p++;
+ }
+}
+
+/* ARGSUSED */
+static void
+disable_display_command (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ register char *p = args;
+ register char *p1;
+ register struct display *d;
+
+ if (p == 0)
+ {
+ for (d = display_chain; d; d = d->next)
+ d->status = disabled;
+ }
+ else
+ while (*p)
+ {
+ p1 = p;
+ while (*p1 >= '0' && *p1 <= '9')
+ p1++;
+ if (*p1 && *p1 != ' ' && *p1 != '\t')
+ error ("Arguments must be display numbers.");
+
+ disable_display (atoi (p));
+
+ p = p1;
+ while (*p == ' ' || *p == '\t')
+ p++;
+ }
+}
+
\f
/* Print the value in stack frame FRAME of a variable
specified by a struct symbol. */
void
print_variable_value (var, frame, stream)
struct symbol *var;
- CORE_ADDR frame;
+ FRAME frame;
FILE *stream;
{
value val = read_var_value (var, frame);
- value_print (val, stream, 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 address of the arglist,
+ 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). */
-static void print_frame_nameless_args ();
+/* 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. */
-print_frame_args (func, addr, num, stream)
+void
+print_frame_args (func, fi, num, stream)
struct symbol *func;
- register CORE_ADDR addr;
+ struct frame_info *fi;
int num;
FILE *stream;
{
int nsyms = 0;
int first = 1;
register int i;
- register int last_offset = FRAME_ARGS_SKIP;
- register int last_regparm = 0;
- register struct symbol *sym, *nextsym;
+ register struct symbol *sym;
register 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;
if (func)
{
nsyms = BLOCK_NSYMS (b);
}
- while (1)
+ for (i = 0; i < nsyms; i++)
{
- /* Find first arg that is not before LAST_OFFSET. */
- nextsym = 0;
- for (i = 0; i < nsyms; i++)
+ QUIT;
+ sym = BLOCK_SYM (b, i);
+
+ /* 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:
{
- QUIT;
- sym = BLOCK_SYM (b, i);
- if (SYMBOL_CLASS (sym) == LOC_ARG)
- {
- if (SYMBOL_VALUE (sym) >= last_offset
- && (nextsym == 0
- || SYMBOL_VALUE (sym) < SYMBOL_VALUE (nextsym)))
- nextsym = sym;
- }
- else if (SYMBOL_CLASS (sym) == LOC_REGPARM)
- {
- if (SYMBOL_VALUE (sym) >= last_regparm
- && (nextsym == 0
- || SYMBOL_VALUE (sym) < SYMBOL_VALUE (nextsym)))
- nextsym = sym;
- }
+ 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);
}
- if (nextsym == 0)
+
+ /* We care about types of symbols, but don't need to keep track of
+ stack offsets in them. */
+ case LOC_REGPARM:
+ case LOC_LOCAL_ARG:
break;
- sym = nextsym;
- /* Print any nameless args between the last arg printed
- and the next arg. */
- if (SYMBOL_CLASS (sym) == LOC_ARG
- && last_offset != (SYMBOL_VALUE (sym) / sizeof (int)) * sizeof (int))
- {
- print_frame_nameless_args (addr, last_offset, SYMBOL_VALUE (sym),
- stream);
- first = 0;
- }
- /* Print the next arg. */
- if (SYMBOL_CLASS (sym) == LOC_REGPARM)
- {
- unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
- unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
-
- read_relative_register_raw_bytes (SYMBOL_VALUE (sym), raw_buffer);
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT)
- val = value_from_double (SYMBOL_TYPE (sym), *(double *)raw_buffer);
- else if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
- || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM)
- val = value_from_long (SYMBOL_TYPE (sym), *(int *)raw_buffer);
- else if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR)
- {
- if (sizeof (char *) == sizeof (int))
- val = value_from_long (builtin_type_int, *(int *)raw_buffer);
- else if (sizeof (char *) == sizeof (long))
- val = value_from_long (builtin_type_long, *(long *)raw_buffer);
- else
- error ("pointer size not sizeof (int) or sizeof (long)");
- VALUE_TYPE (val) = SYMBOL_TYPE (sym);
- }
- else
- error ("can't extract non-scalar from register");
- }
- else
- val = value_at (SYMBOL_TYPE (sym), addr + SYMBOL_VALUE (sym));
+ /* Other types of symbols we just skip over. */
+ default:
+ continue;
+ }
+
+ /* We have to re-look-up the symbol because arguments often have
+ two entries (one a parameter, one a register or local), and the one
+ we want is the non-parm, which lookup_symbol will find for
+ us. After this, sym could be any SYMBOL_CLASS... */
+#ifdef IBM6000_TARGET
+ /* AIX/RS6000 implements a concept of traceback tables, in which case
+ it creates nameless parameters. Looking for those parameter symbols
+ will result in an error. */
+
+ if ( *SYMBOL_NAME (sym))
+#endif
+ sym = lookup_symbol (SYMBOL_NAME (sym),
+ b, VAR_NAMESPACE, (int *)NULL, (struct symtab **)NULL);
+
+ /* Print the current arg. */
if (! first)
- fprintf (stream, ", ");
- fprintf (stream, "%s=", SYMBOL_NAME (sym));
- value_print (val, stream, 0);
+ fprintf_filtered (stream, ", ");
+ wrap_here (" ");
+ fprint_symbol (stream, SYMBOL_NAME (sym));
+ fputs_filtered ("=", stream);
+
+ /* 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, FRAME_INFO_ID (fi));
+ if (val)
+ val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), VALUE_ADDRESS (val),
+ stream, 0, 0, 2, Val_no_prettyprint);
+ else
+ fputs_filtered ("???", stream);
first = 0;
- if (SYMBOL_CLASS (sym) == LOC_ARG)
- last_offset = SYMBOL_VALUE (sym) + TYPE_LENGTH (SYMBOL_TYPE (sym));
+ }
+
+ /* Don't print nameless args in situations where we don't know
+ enough about the stack to find them. */
+ if (num != -1)
+ {
+ long start;
+ CORE_ADDR addr;
+
+ if (highest_offset == -1)
+ start = FRAME_ARGS_SKIP;
else
- {
- last_regparm = SYMBOL_VALUE (sym) + 1;
- last_offset += TYPE_LENGTH (SYMBOL_TYPE (sym));
- }
- /* Round up address of next arg to multiple of size of int. */
- last_offset
- = ((last_offset + sizeof (int) - 1) / sizeof (int)) * sizeof (int);
+ start = highest_offset;
+
+ addr = FRAME_ARGS_ADDRESS (fi);
+ if (addr)
+ print_frame_nameless_args (addr, start, num - args_printed,
+ first, stream);
}
- if (num >= 0 && num * sizeof (int) + FRAME_ARGS_SKIP > last_offset)
- print_frame_nameless_args (addr, last_offset,
- num * sizeof (int) + FRAME_ARGS_SKIP, stream);
}
+/* Print nameless args on STREAM.
+ ARGSADDR is the address of the arglist, 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 (argsaddr, start, end, stream)
+print_frame_nameless_args (argsaddr, start, num, first, stream)
CORE_ADDR argsaddr;
- int start;
- int end;
+ long start;
+ int num;
+ int first;
FILE *stream;
{
- while (start < end)
+ int i;
+ for (i = 0; i < num; i++)
{
QUIT;
- if (start != FRAME_ARGS_SKIP)
- fprintf (stream, ", ");
- fprintf (stream, "%d",
+ if (!first)
+ fprintf_filtered (stream, ", ");
+#ifndef PRINT_TYPELESS_INTEGER
+ fprintf_filtered (stream, "%d",
read_memory_integer (argsaddr + start, sizeof (int)));
+#else
+ PRINT_TYPELESS_INTEGER (stream, builtin_type_int,
+ (LONGEST)
+ read_memory_integer (argsaddr + start,
+ sizeof (int)));
+#endif
+ first = 0;
start += sizeof (int);
}
}
\f
+/* ARGSUSED */
static void
-printf_command (arg)
+printf_command (arg, from_tty)
char *arg;
+ int from_tty;
{
register char *f;
register char *s = arg;
int nargs = 0;
int allocated_args = 20;
char *arg_bytes;
- char *argclass;
- int i;
- int argindex;
- int nargs_wanted;
val_args = (value *) xmalloc (allocated_args * sizeof (value));
if (*s == ',') s++;
while (*s == ' ' || *s == '\t') s++;
- /* Now scan the string for %-specs and see what kinds of args they want.
- argclass[I] is set to 1 if the Ith arg should be a string. */
-
- argclass = (char *) alloca (strlen (s));
- nargs_wanted = 0;
- f = string;
- while (*f)
- if (*f++ == '%')
+ {
+ /* Now scan the string for %-specs and see what kinds of args they want.
+ argclass[I] classifies the %-specs so we can give vprintf something
+ of the right size. */
+
+ enum argclass {int_arg, string_arg, double_arg, long_long_arg};
+ enum argclass *argclass;
+ int nargs_wanted;
+ int argindex;
+ int lcount;
+ int i;
+
+ argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
+ nargs_wanted = 0;
+ f = string;
+ while (*f)
+ if (*f++ == '%')
+ {
+ lcount = 0;
+ while (strchr ("0123456789.hlL-+ #", *f))
+ {
+ if (*f == 'l' || *f == 'L')
+ lcount++;
+ f++;
+ }
+ if (*f == 's')
+ argclass[nargs_wanted++] = string_arg;
+ else if (*f == 'e' || *f == 'f' || *f == 'g')
+ argclass[nargs_wanted++] = double_arg;
+ else if (lcount > 1)
+ argclass[nargs_wanted++] = long_long_arg;
+ else if (*f != '%')
+ argclass[nargs_wanted++] = int_arg;
+ f++;
+ }
+
+ /* Now, parse all arguments and evaluate them.
+ Store the VALUEs in VAL_ARGS. */
+
+ while (*s != '\0')
{
- while (index ("0123456789.hlL-+ #", *f)) f++;
- if (*f == 's')
- argclass[nargs_wanted++] = 1;
- else if (*f != '%')
- argclass[nargs_wanted++] = 0;
- f++;
+ char *s1;
+ if (nargs == allocated_args)
+ val_args = (value *) xrealloc ((char *) val_args,
+ (allocated_args *= 2)
+ * sizeof (value));
+ s1 = s;
+ val_args[nargs] = parse_to_comma_and_eval (&s1);
+
+ /* If format string wants a float, unchecked-convert the value to
+ floating point of the same size */
+
+ if (argclass[nargs] == double_arg)
+ {
+ if (TYPE_LENGTH (VALUE_TYPE (val_args[nargs])) == sizeof (float))
+ VALUE_TYPE (val_args[nargs]) = builtin_type_float;
+ if (TYPE_LENGTH (VALUE_TYPE (val_args[nargs])) == sizeof (double))
+ VALUE_TYPE (val_args[nargs]) = builtin_type_double;
+ }
+ nargs++;
+ s = s1;
+ if (*s == ',')
+ s++;
}
+
+ if (nargs != nargs_wanted)
+ error ("Wrong number of arguments for specified format-string");
+
+ /* Now lay out an argument-list containing the arguments
+ as doubles, integers and C pointers. */
+
+ arg_bytes = (char *) alloca (sizeof (double) * nargs);
+ argindex = 0;
+ for (i = 0; i < nargs; i++)
+ {
+ if (argclass[i] == string_arg)
+ {
+ char *str;
+ CORE_ADDR tem;
+ int j;
+ tem = value_as_pointer (val_args[i]);
+
+ /* This is a %s argument. Find the length of the string. */
+ for (j = 0; ; j++)
+ {
+ char c;
+ QUIT;
+ read_memory (tem + j, &c, 1);
+ if (c == 0)
+ break;
+ }
+
+ /* Copy the string contents into a string inside GDB. */
+ str = (char *) alloca (j + 1);
+ read_memory (tem, str, j);
+ str[j] = 0;
+
+ /* Pass address of internal copy as the arg to vprintf. */
+ *((int *) &arg_bytes[argindex]) = (int) str;
+ argindex += sizeof (int);
+ }
+ else if (VALUE_TYPE (val_args[i])->code == TYPE_CODE_FLT)
+ {
+ *((double *) &arg_bytes[argindex]) = value_as_double (val_args[i]);
+ argindex += sizeof (double);
+ }
+ else
+#ifdef LONG_LONG
+ if (argclass[i] == long_long_arg)
+ {
+ *(long long *) &arg_bytes[argindex] = value_as_long (val_args[i]);
+ argindex += sizeof (long long);
+ }
+ else
+#endif
+ {
+ *((long *) &arg_bytes[argindex]) = value_as_long (val_args[i]);
+ argindex += sizeof (long);
+ }
+ }
+ }
+
+ /* There is not a standard way to make a va_list, so we need
+ to do various things for different systems. */
+#if defined (__INT_VARARGS_H)
+ {
+ va_list list;
+
+ list.__va_arg = 0;
+ list.__va_stk = (int *) arg_bytes;
+ list.__va_reg = (int *) arg_bytes;
+ vprintf (string, list);
+ }
+#else /* No __INT_VARARGS_H. */
+ vprintf (string, arg_bytes);
+#endif /* No __INT_VARARGS_H. */
+}
+\f
+/* Helper function for asdump_command. Finds the bounds of a function
+ for a specified section of text. PC is an address within the
+ function which you want bounds for; *LOW and *HIGH are set to the
+ beginning (inclusive) and end (exclusive) of the function. This
+ function returns 1 on success and 0 on failure. */
+
+static int
+containing_function_bounds (pc, low, high)
+ CORE_ADDR pc, *low, *high;
+{
+ int scan;
- /* Now, parse all arguments and evaluate them.
- Store the VALUEs in VAL_ARGS. */
+ if (!find_pc_partial_function (pc, 0, low))
+ return 0;
- while (*s != '\0')
- {
- char *s1;
- if (nargs == allocated_args)
- val_args = (value *) xrealloc (val_args,
- (allocated_args *= 2)
- * sizeof (value));
- s1 = s;
- val_args[nargs++] = parse_to_comma_and_eval (&s1);
- s = s1;
- if (*s == ',')
- s++;
- }
+ scan = *low;
+ do {
+ scan++;
+ if (!find_pc_partial_function (scan, 0, high))
+ return 0;
+ } while (*low == *high);
- if (nargs != nargs_wanted)
- error ("Wrong number of arguments for specified format-string");
+ return 1;
+}
- /* Now lay out an argument-list containing the arguments
- as doubles, integers and C pointers. */
+/* 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. */
- arg_bytes = (char *) alloca (sizeof (double) * nargs);
- argindex = 0;
- for (i = 0; i < nargs; i++)
- {
- if (argclass[i])
- {
- char *str;
- int tem, j;
- tem = value_as_long (val_args[i]);
+/* ARGSUSED */
+static void
+disassemble_command (arg, from_tty)
+ char *arg;
+ int from_tty;
+{
+ CORE_ADDR low, high;
+ CORE_ADDR pc;
+ char *space_index;
- /* This is a %s argument. Find the length of the string. */
- for (j = 0; ; j++)
- {
- char c;
- QUIT;
- read_memory (tem + j, &c, 1);
- if (c == 0)
- break;
- }
+ if (!arg)
+ {
+ if (!selected_frame)
+ error ("No frame selected.\n");
- /* Copy the string contents into a string inside GDB. */
- str = (char *) alloca (j + 1);
- read_memory (tem, str, j);
- str[j] = 0;
+ pc = get_frame_pc (selected_frame);
+ if (!containing_function_bounds (pc, &low, &high))
+ error ("No function contains pc specified by selected frame.\n");
+ }
+ else if (!(space_index = (char *) strchr (arg, ' ')))
+ {
+ /* One argument. */
+ pc = parse_and_eval_address (arg);
+ if (!containing_function_bounds (pc, &low, &high))
+ error ("No function contains specified pc.\n");
+ }
+ else
+ {
+ /* Two arguments. */
+ *space_index = '\0';
+ low = parse_and_eval_address (arg);
+ high = parse_and_eval_address (space_index + 1);
+ }
- /* Pass address of internal copy as the arg to vprintf. */
- *((int *) &arg_bytes[argindex]) = (int) str;
- argindex += sizeof (int);
- }
- else if (VALUE_TYPE (val_args[i])->code == TYPE_CODE_FLT)
- {
- *((double *) &arg_bytes[argindex]) = value_as_double (val_args[i]);
- argindex += sizeof (double);
- }
- else
- {
- *((int *) &arg_bytes[argindex]) = value_as_long (val_args[i]);
- argindex += sizeof (int);
- }
+ printf_filtered ("Dump of assembler code ");
+ if (!space_index)
+ {
+ char *name;
+ find_pc_partial_function (pc, &name, 0);
+ printf_filtered ("for function %s:\n", name);
}
+ else
+ printf_filtered ("from %s ", local_hex_string(low));
+ printf_filtered ("to %s:\n", local_hex_string(high));
- vprintf (string, arg_bytes);
+ /* Dump the specified range. */
+ for (pc = low; pc < high; )
+ {
+ QUIT;
+ print_address (pc, stdout);
+ printf_filtered (":\t");
+ pc += print_insn (pc, stdout);
+ printf_filtered ("\n");
+ }
+ printf_filtered ("End of assembler dump.\n");
+ fflush (stdout);
}
+
\f
-static
-initialize ()
+void
+_initialize_printcmd ()
{
current_display_number = -1;
Default count is 1. Default address is following last thing printed\n\
with this command or \"print\".");
+ 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.");
+
add_com ("ptype", class_vars, ptype_command,
"Print definition of type TYPE.\n\
Argument may be a type name defined by typedef, or \"struct STRUCTNAME\"\n\
add_com ("whatis", class_vars, whatis_command,
"Print data type of expression EXP.");
+#if 0
+ add_com ("whereis", class_vars, whereis_command,
+ "Print line number and file of definition of variable.");
+#endif
+
add_info ("display", display_info,
"Expressions to display when program stops, with code numbers.");
- add_com ("undisplay", class_vars, undisplay_command,
- "Cancel some expressions to be displayed whenever program stops.\n\
+
+ add_cmd ("undisplay", class_vars, undisplay_command,
+ "Cancel some expressions to be displayed when program stops.\n\
Arguments are the code numbers of the expressions to stop displaying.\n\
No argument means cancel all automatic-display expressions.\n\
-Do \"info display\" to see current list of code numbers.");
+\"delete display\" has the same effect as this command.\n\
+Do \"info display\" to see current list of code numbers.",
+ &cmdlist);
+
add_com ("display", class_vars, display_command,
"Print value of expression EXP each time the program stops.\n\
/FMT may be used before EXP as in the \"print\" command.\n\
With no argument, display all currently requested auto-display expressions.\n\
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\
+Arguments are the code numbers of the expressions to resume displaying.\n\
+No argument means enable all automatic-display expressions.\n\
+Do \"info display\" to see current list of code numbers.", &enablelist);
+
+ add_cmd ("display", class_vars, disable_display_command,
+ "Disable some expressions to be displayed when program stops.\n\
+Arguments are the code numbers of the expressions to stop displaying.\n\
+No argument means disable all automatic-display expressions.\n\
+Do \"info display\" to see current list of code numbers.", &disablelist);
+
+ add_cmd ("display", class_vars, undisplay_command,
+ "Cancel some expressions to be displayed when program stops.\n\
+Arguments are the code numbers of the expressions to stop displaying.\n\
+No argument means cancel all automatic-display expressions.\n\
+Do \"info display\" to see current list of code numbers.", &deletelist);
+
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.");
"Like \"print\" but don't put in value history and don't print newline.\n\
This is useful in user-defined commands.");
- add_com ("set", class_vars, set_command,
- "Perform an assignment VAR = EXP. You must type the \"=\".\n\
-VAR may be a debugger \"convenience\" variables (names starting with $),\n\
-a register (a few standard names starting with $), or an actual variable\n\
-in the program being debugger. EXP is any expression.");
+ add_prefix_cmd ("set", class_vars, set_command,
+"Perform an assignment VAR = EXP.\n\
+You must type the \"=\". VAR may be a debugger \"convenience\" variable\n\
+(names starting with $), a register (a few standard names starting with $),\n\
+or an actual variable in the program being debugged. EXP is any 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.",
+ &setlist, "set ", 1, &cmdlist);
+
+ /* "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 inferior process.\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.");
+
+ add_cmd ("variable", class_vars, set_command,
+ "Perform an assignment VAR = EXP.\n\
+You must type the \"=\". VAR may be a debugger \"convenience\" variable\n\
+(names starting with $), a register (a few standard names starting with $),\n\
+or an actual variable in the program being debugged. EXP is any expression.\n\
+This may usually be abbreviated to simply \"set\".",
+ &setlist);
add_com ("print", class_vars, print_command,
concat ("Print value of expression EXP.\n\
\"convenience\" variables (any such name not a known register).\n\
Use assignment expressions to give values to convenience variables.\n",
"\n\
-\{TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
+{TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
@ is a binary operator for treating consecutive data objects\n\
anywhere in memory as an array. FOO@NUM gives an array whose first\n\
element is FOO, whose second element is stored in the space following\n\
resides in memory.\n",
"\n\
EXP may be preceded with /FMT, where FMT is a format letter\n\
-but no count or size letter (see \"x\" command)."));
+but no count or size letter (see \"x\" command).", NULL));
add_com_alias ("p", "print", class_vars, 1);
-}
-END_FILE
+ 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.");
+}
projects / binutils-gdb.git / blobdiff