#include "defs.h"
#include <string.h>
+#include <varargs.h>
#include "frame.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "breakpoint.h"
#include "demangle.h"
-/* These are just for containing_function_bounds. It might be better
- to move containing_function_bounds to blockframe.c or thereabouts. */
-#include "bfd.h"
-#include "symfile.h"
-#include "objfiles.h"
-
extern int asm_demangle; /* Whether to demangle syms in asm printouts */
extern int addressprint; /* Whether to print hex addresses in HLL " */
static unsigned int max_symbolic_offset = UINT_MAX;
+/* Append the source filename and linenumber of the symbol when
+ printing a symbolic value as `<symbol at filename:linenum>' if set. */
+static int print_symbol_filename = 0;
+
/* Number of auto-display expression currently being displayed.
So that we can disable it if we get an error or a signal within it.
-1 when not doing one. */
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));
{
if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
val.size = *p++;
-#ifdef LONG_LONG
+#ifdef CC_HAS_LONG_LONG
else if (*p == 'l')
{
val.size = 'g';
break;
}
-#ifndef LONG_LONG
+#ifndef CC_HAS_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')
break;
case 'i':
- wrap_here (""); /* Force output out, print_insn not using _filtered */
+ /* The old comment says
+ "Force output out, print_insn not using _filtered".
+ I'm not completely sure what that means, I suspect most print_insn
+ now do use _filtered, so I guess it's obsolete. */
+ /* We often wrap here if there are long symbolic names. */
+ wrap_here (" ");
next_address = VALUE_ADDRESS (val)
+ print_insn (VALUE_ADDRESS (val), stdout);
break;
LONGEST val_long;
int len = TYPE_LENGTH (type);
- if (size == 'g' && sizeof (LONGEST) < 8
- && format == 'x')
+ if (len > sizeof (LONGEST)
+ && (format == 't'
+ || format == 'c'
+ || format == 'o'
+ || format == 'u'
+ || format == 'd'
+ || 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);
- }
+ /* We can't print it normally, but we can print it in hex.
+ Printing it in the wrong radix is more useful than saying
+ "use /x, you dummy". */
+ /* FIXME: we could also do octal or binary if that was the
+ desired format. */
+ /* FIXME: we should be using the size field to give us a minimum
+ field width to print. */
+ val_print_type_code_int (type, valaddr, stream);
return;
}
-
+
val_long = unpack_long (type, valaddr);
/* If value is unsigned, truncate it in case negative. */
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. */
+ print_longest (stream, 'x', 1, val_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':
- fprintf_filtered (stream, local_hex_format_custom("02"), val_long);
- break;
- case 'h':
- fprintf_filtered (stream, local_hex_format_custom("04"), val_long);
- break;
- case 'w':
- fprintf_filtered (stream, local_hex_format_custom("08"), val_long);
- break;
- case 'g':
- fprintf_filtered (stream, local_hex_format_custom("016"), val_long);
- break;
- default:
- error ("Undefined output size \"%c\".", size);
- }
-#endif /* not LONG_LONG */
+ switch (size)
+ {
+ case 'b':
+ case 'h':
+ case 'w':
+ case 'g':
+ print_longest (stream, size, 1, val_long);
+ break;
+ default:
+ error ("Undefined output size \"%c\".", size);
+ }
break;
case 'd':
-#ifdef LONG_LONG
- fprintf_filtered (stream, local_decimal_format_custom("ll"), val_long);
-#else
- fprintf_filtered (stream, local_decimal_format(), val_long);
-#endif
+ print_longest (stream, 'd', 1, val_long);
break;
case 'u':
-#ifdef LONG_LONG
- fprintf_filtered (stream, "%llu", val_long);
-#else
- fprintf_filtered (stream, "%u", val_long);
-#endif
+ print_longest (stream, 'u', 0, val_long);
break;
case 'o':
if (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
+ print_longest (stream, 'o', 1, val_long);
else
fprintf_filtered (stream, "0");
break;
char *leadin;
{
CORE_ADDR name_location;
- register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (addr);
+ register struct symbol *symbol;
+ char *name;
- /* If nothing comes out, don't print anything symbolic. */
+ /* First try to find the address in the symbol tables to find
+ static functions. If that doesn't succeed we try the minimal symbol
+ vector for symbols in non-text space.
+ FIXME: Should find a way to get at the static non-text symbols too. */
- if (msymbol == NULL)
- return;
+ symbol = find_pc_function (addr);
+ if (symbol)
+ {
+ name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
+ if (do_demangle)
+ name = SYMBOL_SOURCE_NAME (symbol);
+ else
+ name = SYMBOL_LINKAGE_NAME (symbol);
+ }
+ else
+ {
+ register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (addr);
- /* If the nearest symbol is too far away, ditto. */
+ /* If nothing comes out, don't print anything symbolic. */
+ if (msymbol == NULL)
+ return;
+ name_location = SYMBOL_VALUE_ADDRESS (msymbol);
+ if (do_demangle)
+ name = SYMBOL_SOURCE_NAME (msymbol);
+ else
+ name = SYMBOL_LINKAGE_NAME (msymbol);
+ }
- name_location = SYMBOL_VALUE_ADDRESS (msymbol);
+ /* If the nearest symbol is too far away, don't print anything symbolic. */
/* For when CORE_ADDR is larger than unsigned int, we do math in
CORE_ADDR. But when we detect unsigned wraparound in the
fputs_filtered (leadin, stream);
fputs_filtered ("<", stream);
- if (do_demangle)
- fputs_filtered (SYMBOL_SOURCE_NAME (msymbol), stream);
- else
- fputs_filtered (SYMBOL_LINKAGE_NAME (msymbol), stream);
+ fputs_filtered (name, stream);
if (addr != name_location)
- fprintf_filtered (stream, "+%d>", (int)(addr - name_location));
- else
- fputs_filtered (">", stream);
+ fprintf_filtered (stream, "+%u", (unsigned int)(addr - name_location));
+
+ /* Append source filename and line number if desired. */
+ if (symbol && print_symbol_filename)
+ {
+ struct symtab_and_line sal;
+
+ sal = find_pc_line (addr, 0);
+ if (sal.symtab)
+ fprintf_filtered (stream, " at %s:%d", sal.symtab->filename, sal.line);
+ }
+ fputs_filtered (">", stream);
}
/* Print address ADDR symbolically on STREAM.
CORE_ADDR addr;
FILE *stream;
{
-#ifdef ADDR_BITS_REMOVE
+#if 0 && defined (ADDR_BITS_REMOVE)
+ /* This is wrong for pointer to char, in which we do want to print
+ the low bits. */
fprintf_filtered (stream, local_hex_format(), ADDR_BITS_REMOVE(addr));
#else
fprintf_filtered (stream, local_hex_format(), addr);
else if (size == 'w')
val_type = builtin_type_long;
else if (size == 'g')
-#ifndef LONG_LONG
+#ifndef CC_HAS_LONG_LONG
val_type = builtin_type_double;
#else
val_type = builtin_type_long_long;
case LOC_REGPARM:
printf ("an argument in register %s", reg_names[val]);
break;
-
+
+ case LOC_REGPARM_ADDR:
+ printf ("address of an argument in register %s", reg_names[val]);
+ break;
+
case LOC_ARG:
- 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);
- }
+ 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);
- }
+ printf ("an argument at frame offset %ld", val);
break;
case LOC_LOCAL:
- 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);
- }
+ 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_BASEREG:
+ printf ("a variable at offset %ld from register %s",
+ val, reg_names[basereg]);
+ break;
+
+ case LOC_BASEREG_ARG:
+ printf ("an argument at offset %ld from register %s",
+ val, reg_names[basereg]);
+ break;
+
case LOC_TYPEDEF:
printf ("a typedef");
break;
/* We care about types of symbols, but don't need to keep track of
stack offsets in them. */
case LOC_REGPARM:
+ case LOC_REGPARM_ADDR:
case LOC_LOCAL_ARG:
+ case LOC_BASEREG_ARG:
break;
/* Other types of symbols we just skip over. */
and it is passed as a double and converted to float by
the prologue (in the latter case the type of the LOC_ARG
symbol is double and the type of the LOC_LOCAL symbol is
- float). It's possible this should be dealt with in
- symbol reading the way it now is for LOC_REGPARM. */
+ float). There are also LOC_ARG/LOC_REGISTER pairs which
+ are not combined in symbol-reading. */
/* But if the parameter name is null, don't try it.
Null parameter names occur on the RS/6000, for traceback tables.
FIXME, should we even print them? */
}
}
\f
+/* This is an interface which allows to us make a va_list. */
+typedef struct {
+ unsigned int nargs;
+ unsigned int max_arg_size;
+
+ /* Current position in bytes. */
+ unsigned int argindex;
+
+#ifdef MAKEVA_EXTRA_INFO
+ /* For host dependent information. */
+ MAKEVA_EXTRA_INFO
+#endif
+
+ /* Some systems (mips, pa) would like this to be aligned, and it never
+ will hurt. */
+ union
+ {
+ char arg_bytes[1];
+ double force_double_align;
+ LONGEST force_long_align;
+ } aligner;
+} makeva_list;
+
+/* Tell the caller how many bytes to allocate for a makeva_list with NARGS
+ arguments and whose largest argument is MAX_ARG_SIZE bytes. This
+ way the caller can use alloca, malloc, or some other allocator. */
+unsigned int
+makeva_size (nargs, max_arg_size)
+ unsigned int nargs;
+ unsigned int max_arg_size;
+{
+ return sizeof (makeva_list) + nargs * max_arg_size;
+}
+
+/* Start working on LIST with NARGS arguments and whose largest
+ argument is MAX_ARG_SIZE bytes. */
+void
+makeva_start (list, nargs, max_arg_size)
+ makeva_list *list;
+ unsigned int nargs;
+ unsigned int max_arg_size;
+{
+ list->nargs = nargs;
+ list->max_arg_size = max_arg_size;
+#if defined (MAKEVA_START)
+ MAKEVA_START (list);
+#else
+ list->argindex = 0;
+#endif
+}
+
+/* Add ARG to LIST. */
+void
+makeva_arg (list, argaddr, argsize)
+ makeva_list *list;
+ PTR argaddr;
+ unsigned int argsize;
+{
+#if defined (MAKEVA_ARG)
+ MAKEVA_ARG (list, argaddr, argsize);
+#else
+ memcpy (&list->aligner.arg_bytes[list->argindex], argaddr, argsize);
+ list->argindex += argsize;
+#endif
+}
+
+/* From LIST, for which makeva_arg has been called for each arg,
+ return a va_list containing the args. */
+va_list
+makeva_end (list)
+ makeva_list *list;
+{
+#if defined (MAKEVA_END)
+ MAKEVA_END (list);
+#else
+ /* This works if a va_list is just a pointer to the arguments. */
+ return (va_list) list->aligner.arg_bytes;
+#endif
+}
+\f
/* ARGSUSED */
static void
printf_command (arg, from_tty)
value *val_args;
int nargs = 0;
int allocated_args = 20;
- char *arg_bytes;
+ va_list args_to_vprintf;
val_args = (value *) xmalloc (allocated_args * sizeof (value));
enum argclass {int_arg, string_arg, double_arg, long_long_arg};
enum argclass *argclass;
int nargs_wanted;
- int argindex;
int lcount;
int i;
-
+ /* We build up a va_list to pass to vprintf. This is unnecessary;
+ instead of calling vprintf ("%d%f", <constructed va_list>) we
+ could just call printf ("%d", arg1); printf ("%f", arg2);. Funny
+ how I thought of that right *after* I got the MAKEVA stuff pretty much
+ working... */
+ makeva_list *args_makeva;
+
argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
nargs_wanted = 0;
f = string;
argclass[nargs_wanted++] = int_arg;
f++;
}
-
+
/* Now, parse all arguments and evaluate them.
Store the VALUEs in VAL_ARGS. */
-
+
while (*s != '\0')
{
char *s1;
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;
+
+ args_makeva = (makeva_list *)
+ alloca (makeva_size (nargs, sizeof (double)));
+ makeva_start (args_makeva, nargs, sizeof (double));
for (i = 0; i < nargs; i++)
{
if (argclass[i] == string_arg)
str[j] = 0;
/* Pass address of internal copy as the arg to vprintf. */
- *((int *) &arg_bytes[argindex]) = (int) str;
- argindex += sizeof (int);
+ makeva_arg (args_makeva, &str, sizeof (str));
}
else if (VALUE_TYPE (val_args[i])->code == TYPE_CODE_FLT)
{
- *((double *) &arg_bytes[argindex]) = value_as_double (val_args[i]);
- argindex += sizeof (double);
+ double val = value_as_double (val_args[i]);
+ makeva_arg (args_makeva, &val, sizeof (val));
}
else
-#ifdef LONG_LONG
+#ifdef CC_HAS_LONG_LONG
if (argclass[i] == long_long_arg)
{
- *(long long *) &arg_bytes[argindex] = value_as_long (val_args[i]);
- argindex += sizeof (long long);
+ long long val = value_as_long (val_args[i]);
+ makeva_arg (args_makeva, &val, sizeof (val));
}
else
#endif
{
- *((long *) &arg_bytes[argindex]) = value_as_long (val_args[i]);
- argindex += sizeof (long);
+ long val = value_as_long (val_args[i]);
+ makeva_arg (args_makeva, &val, sizeof (val));
}
}
+ args_to_vprintf = makeva_end (args_makeva);
}
- /* 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;
+ /* 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.
- 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. */
+ But for now, just force out any pending output, so at least the output
+ appears in the correct order. */
+ wrap_here ((char *)NULL);
+ vprintf (string, args_to_vprintf);
}
\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;
-{
- CORE_ADDR scan;
- CORE_ADDR limit;
- struct obj_section *sec;
-
- if (!find_pc_partial_function (pc, 0, low))
- return 0;
-
- sec = find_pc_section (pc);
- if (sec == NULL)
- return 0;
- limit = sec->endaddr;
-
- scan = *low;
- while (scan < limit)
- {
- ++scan;
- if (!find_pc_partial_function (scan, 0, high))
- return 0;
- if (*low != *high)
- return 1;
- }
- *high = limit;
- return 1;
-}
-
/* 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
int from_tty;
{
CORE_ADDR low, high;
+ char *name;
CORE_ADDR pc;
char *space_index;
+ name = NULL;
if (!arg)
{
if (!selected_frame)
error ("No frame selected.\n");
pc = get_frame_pc (selected_frame);
- if (!containing_function_bounds (pc, &low, &high))
- error ("No function contains pc specified by selected frame.\n");
+ if (find_pc_partial_function (pc, &name, &low, &high) == 0)
+ error ("No function contains program counter for 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");
+ if (find_pc_partial_function (pc, &name, &low, &high) == 0)
+ error ("No function contains specified address.\n");
}
else
{
}
printf_filtered ("Dump of assembler code ");
- if (!space_index)
+ if (name != NULL)
{
- char *name;
- find_pc_partial_function (pc, &name, 0);
printf_filtered ("for function %s:\n", name);
}
else
/* "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\
+ "Call a function in the program.\n\
The argument is the function name and arguments, in the notation of the\n\
current working language. The result is printed and saved in the value\n\
history, if it is not void.");
"Set the largest offset that will be printed in <symbol+1234> form.",
&setprintlist),
&showprintlist);
+ add_show_from_set (
+ add_set_cmd ("symbol-filename", no_class, var_boolean,
+ (char *)&print_symbol_filename,
+ "Set printing of source filename and line number with <symbol>.",
+ &setprintlist),
+ &showprintlist);
}