/* Print values for GNU debugger GDB.
- Copyright (C) 1986-1991 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
This file is part of GDB.
-GDB is free software; you can redistribute it and/or modify
+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 1, or (at your option)
-any later version.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
-GDB is distributed in the hope that it will be useful,
+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 GDB; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
-#include <string.h>
#include "defs.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 struct block *get_current_block ();
-
-static void print_frame_nameless_args ();
+extern int addressprint; /* Whether to print hex addresses in HLL " */
struct format_data
{
int inspect_it = 0;
-static void do_one_display ();
+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 */
+
+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 *));
-void do_displays ();
-void print_scalar_formatted ();
+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));
\f
/* Decode a format specification. *STRING_PTR should point to it.
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;
static void
print_formatted (val, format, size)
register value val;
- register char format;
- char size;
+ register int format;
+ int size;
{
int len = TYPE_LENGTH (VALUE_TYPE (val));
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;
print_scalar_formatted (valaddr, type, format, size, stream)
char *valaddr;
struct type *type;
- char format;
+ int format;
int size;
FILE *stream;
{
{
/* ok, we're going to have to get fancy here. Assumption: a
long is four bytes. FIXME. */
- unsigned long v1, v2, tmp;
+ 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 */
- tmp = v1;
- v1 = v2;
- v2 = tmp;
+ {
+ unsigned long tmp;
+
+ tmp = v1;
+ v1 = v2;
+ v2 = tmp;
+ }
#endif
switch (format)
{
case 'x':
- fprintf_filtered (stream, "0x%08x%08x", v1, v2);
+ fprintf_filtered (stream, local_hex_format_custom("08x%08"), v1, v2);
break;
default:
error ("Output size \"g\" unimplemented for format \"%c\".",
{
/* no size specified, like in print. Print varying # of digits. */
#if defined (LONG_LONG)
- fprintf_filtered (stream, "0x%llx", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("ll"), val_long);
#else /* not LONG_LONG. */
- fprintf_filtered (stream, "0x%lx", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("l"), val_long);
#endif /* not LONG_LONG. */
}
else
switch (size)
{
case 'b':
- fprintf_filtered (stream, "0x%02llx", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("02ll"), val_long);
break;
case 'h':
- fprintf_filtered (stream, "0x%04llx", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("04ll"), val_long);
break;
case 'w':
- fprintf_filtered (stream, "0x%08llx", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("08ll"), val_long);
break;
case 'g':
- fprintf_filtered (stream, "0x%016llx", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("016ll"), val_long);
break;
default:
error ("Undefined output size \"%c\".", size);
switch (size)
{
case 'b':
- fprintf_filtered (stream, "0x%02x", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("02"), val_long);
break;
case 'h':
- fprintf_filtered (stream, "0x%04x", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("04"), val_long);
break;
case 'w':
- fprintf_filtered (stream, "0x%08x", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("08"), val_long);
break;
case 'g':
- fprintf_filtered (stream, "0x%016x", val_long);
+ fprintf_filtered (stream, local_hex_format_custom("016"), val_long);
break;
default:
error ("Undefined output size \"%c\".", size);
case 'o':
if (val_long)
#ifdef LONG_LONG
- fprintf_filtered (stream, "0%llo", val_long);
+ fprintf_filtered (stream, local_octal_format_custom("ll"), val_long);
#else
- fprintf_filtered (stream, "0%o", val_long);
+ fprintf_filtered (stream, local_octal_format(), val_long);
#endif
else
fprintf_filtered (stream, "0");
break;
case 'a':
- print_address ((CORE_ADDR) 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 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, (LONGEST) addr));
+ value_from_longest (lookup_pointer_type (builtin_type_void),
+ (LONGEST) addr));
}
-/* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM.
+/* 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)
+print_address_symbolic (addr, stream, do_demangle, leadin)
CORE_ADDR addr;
FILE *stream;
int do_demangle;
+ char *leadin;
{
int name_location;
- register int i = find_pc_misc_function (addr);
+ register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (addr);
/* If nothing comes out, don't print anything symbolic. */
- if (i < 0)
+ if (msymbol == NULL)
return;
- fputs_filtered (" <", stream);
+ fputs_filtered (leadin, stream);
+ fputs_filtered ("<", stream);
if (do_demangle)
- fputs_demangled (misc_function_vector[i].name, stream, 1);
+ fputs_demangled (msymbol -> name, stream, DMGL_ANSI | DMGL_PARAMS);
else
- fputs_filtered (misc_function_vector[i].name, stream);
- name_location = misc_function_vector[i].address;
+ fputs_filtered (msymbol -> name, stream);
+ name_location = msymbol -> address;
if (addr - name_location)
fprintf_filtered (stream, "+%d>", addr - name_location);
else
CORE_ADDR addr;
FILE *stream;
{
- fprintf_filtered (stream, "0x%x", addr);
- print_address_symbolic (addr, stream, asm_demangle);
+#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, " ");
}
/* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
- controls whether to print the symbolic name "raw" or demangled. */
+ 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)
FILE *stream;
int do_demangle;
{
- fprintf_filtered (stream, "0x%x", addr);
- print_address_symbolic (addr, stream, 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.
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);
inspect_it = 0; /* Reset print routines to normal */
}
+/* ARGSUSED */
static void
print_command (exp, from_tty)
char *exp;
}
/* Same as print, except in epoch, it gets its own window */
+/* ARGSUSED */
static void
inspect_command (exp, from_tty)
char *exp;
}
/* Same as print, except it doesn't print void results. */
+/* ARGSUSED */
static void
call_command (exp, from_tty)
char *exp;
print_command_1 (exp, 0, 0);
}
+/* ARGSUSED */
static void
output_command (exp, from_tty)
char *exp;
{
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, 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, 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'. */
&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", SYMBOL_VALUE_ADDRESS (sym));
+ 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", SYMBOL_VALUE_ADDRESS (sym));
+ printf ("static storage at address %s", local_hex_string(SYMBOL_VALUE_ADDRESS (sym)));
break;
case LOC_REGPARM:
break;
case LOC_ARG:
- printf ("an argument at offset %d", (int)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:
- printf ("an argument at frame offset %d", (int)val);
+ 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", (int)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 %d", (int)val);
+ 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)));
- break;
-
- case LOC_EXTERNAL:
- printf ("an external symbol at address 0x%x",
- SYMBOL_VALUE_ADDRESS (sym));
+ printf ("a function at address %s",
+ local_hex_string(BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
break;
default:
{
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. */
*exp = 0;
old_chain = make_cleanup (free_current_contents, &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'
&& VALUE_LVAL (val) == lval_memory)
next_address = VALUE_ADDRESS (val);
else
- next_address = (CORE_ADDR) value_as_long (val);
+ next_address = value_as_pointer (val);
do_cleanups (old_chain);
}
do_examine (fmt, next_address);
+ /* If the examine succeeds, we remember its size and format for next time. */
+ last_size = fmt.size;
+ last_format = fmt.format;
+
/* Set a couple of internal variables if appropriate. */
if (last_examine_value)
{
- /* Make last address examined available to the user as $_. */
+ /* Make last address examined available to the user as $_. Use
+ the correct pointer type. */
set_internalvar (lookup_internalvar ("_"),
- value_from_long (builtin_type_int,
- (LONGEST) last_examine_address));
+ 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);
if (exp)
{
- expr = parse_c_expression (exp);
+ expr = parse_expression (exp);
old_chain = make_cleanup (free_current_contents, &expr);
val = evaluate_type (expr);
}
do_cleanups (old_chain);
}
+/* ARGSUSED */
static void
whatis_command (exp, from_tty)
char *exp;
whatis_exp (exp, -1);
}
+/* 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;
+}
+
/* 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 char *p = typename;
- register int len;
- register struct block *b
- = target_has_stack ? get_current_block () : 0;
register struct type *type;
+ struct expression *expr;
+ register struct cleanup *old_chain;
- if (typename == 0)
- {
- whatis_exp (typename, 1);
- return;
- }
-
- while (*p && *p != ' ' && *p != '\t') p++;
- len = p - typename;
- while (*p == ' ' || *p == '\t') p++;
-
- 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, 0,
- (struct symtab **)NULL);
- if (sym == 0)
- {
- whatis_exp (typename, 1 /* FIXME: right? */);
- return;
- }
- printf_filtered ("No type named %s, but there is a ",
- typename);
- switch (TYPE_CODE (SYMBOL_TYPE (sym)))
- {
- case TYPE_CODE_STRUCT:
- printf_filtered ("struct");
- break;
-
- case TYPE_CODE_UNION:
- printf_filtered ("union");
- break;
-
- case TYPE_CODE_ENUM:
- printf_filtered ("enum");
- break;
-
- default:
- printf_filtered ("(Internal error in gdb)");
- break;
- }
- printf_filtered (" %s. Type \"help ptype\".\n", typename);
- type = SYMBOL_TYPE (sym);
- }
- }
-
- type_print (type, "", stdout, 1);
- printf_filtered ("\n");
+ whatis_exp (typename, 1);
}
\f
-#if 0
-/* This is not necessary. Instead, decode_line_1 takes any variable,
- so "info line foo" is a close equivalent to "whereis foo". */
-static void
-whereis_command (var, from_tty)
- char *var;
- int from_tty;
-{
- struct symtab *s;
- struct symbol *sym;
-
- if (var == NULL)
- error_no_arg ("Variable name.");
-
- sym = lookup_symbol (var, get_selected_block (), VAR_NAMESPACE,
- NULL, &s);
-
- if (sym != NULL && s != NULL)
- printf_filtered ("Symbol \"%s\" is at line %d of file %s\n",
- var, sym->line, s->filename);
- else
- {
- if (lookup_misc_func (var) >= 0)
- printf_filtered ("Symbol \"%s\" is in a file compiled without -g.",
- var);
- else
- error ("No symbol \"%s\" in current context.", var);
- }
-}
-#endif /* 0 */
-\f
-enum display_status {disabled, enabled};
-
-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 display_status status;
-};
-
-/* 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. */
}
innermost_block = 0;
- expr = parse_c_expression (exp);
+ expr = parse_expression (exp);
new = (struct display *) xmalloc (sizeof (struct display));
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;
else
printf_filtered (" ");
- addr = (CORE_ADDR) value_as_long (evaluate_expression (d->exp));
+ addr = value_as_pointer (evaluate_expression (d->exp));
if (d->format.format == 'i')
addr = ADDR_BITS_REMOVE (addr);
}
static void
-display_info ()
+display_info (ignore, from_tty)
+ char *ignore;
+ int from_tty;
{
register struct display *d;
}
}
-void
-enable_display (args)
+static void
+enable_display (args, from_tty)
char *args;
+ int from_tty;
{
register char *p = args;
register char *p1;
}
}
-void
+/* ARGSUSED */
+static void
disable_display_command (args, from_tty)
char *args;
int from_tty;
/* 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 highest_offset = -1;
+ long highest_offset = -1;
int arg_size;
/* Number of ints of arguments that we have printed so far. */
int args_printed = 0;
QUIT;
sym = BLOCK_SYM (b, i);
- if (SYMBOL_CLASS (sym) != LOC_REGPARM
- && SYMBOL_CLASS (sym) != LOC_ARG
- && SYMBOL_CLASS (sym) != LOC_LOCAL_ARG
- && SYMBOL_CLASS (sym) != LOC_REF_ARG)
- 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... */
- sym = lookup_symbol (SYMBOL_NAME (sym),
- b, VAR_NAMESPACE, (int *)NULL, (struct symtab **)NULL);
+ /* 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)) {
-
- /* Keep track of the highest stack argument offset seen */
case LOC_ARG:
case LOC_REF_ARG:
{
- int current_offset = SYMBOL_VALUE (sym);
+ long current_offset = SYMBOL_VALUE (sym);
arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
}
- /* Other types of symbols don't need to be kept track of. */
- default:
+ /* 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;
+
+ /* 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_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 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, 0, Val_no_prettyprint);
+ stream, 0, 0, 2, Val_no_prettyprint);
else
fputs_filtered ("???", stream);
first = 0;
enough about the stack to find them. */
if (num != -1)
{
- int start;
+ long start;
CORE_ADDR addr;
if (highest_offset == -1)
static void
print_frame_nameless_args (argsaddr, start, num, first, stream)
CORE_ADDR argsaddr;
- int start;
+ long start;
int num;
int first;
FILE *stream;
}
}
\f
+/* ARGSUSED */
static void
printf_command (arg, from_tty)
char *arg;
{
char *s1;
if (nargs == allocated_args)
- val_args = (value *) xrealloc (val_args,
+ val_args = (value *) xrealloc ((char *) val_args,
(allocated_args *= 2)
* sizeof (value));
s1 = s;
if (argclass[i] == string_arg)
{
char *str;
- int tem, j;
- tem = value_as_long (val_args[i]);
+ 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++)
else
#endif
{
- *((int *) &arg_bytes[argindex]) = value_as_long (val_args[i]);
- argindex += sizeof (int);
+ *((long *) &arg_bytes[argindex]) = value_as_long (val_args[i]);
+ argindex += sizeof (long);
}
}
}
Two arguments are interpeted as bounds within which to dump
assembly. */
+/* ARGSUSED */
static void
disassemble_command (arg, from_tty)
char *arg;
printf_filtered ("for function %s:\n", name);
}
else
- printf_filtered ("from 0x%x to 0x%x:\n", low, high);
+ printf_filtered ("from %s ", local_hex_string(low));
+ printf_filtered ("to %s:\n", local_hex_string(high));
/* Dump the specified range. */
for (pc = low; pc < high; )
/* "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 standard C notation.\n\
-The result is printed and saved in the value history, if it is not void.");
+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\
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);
add_com ("inspect", class_vars, inspect_command,
projects / deliverable / binutils-gdb.git / blobdiff