/* Print values for GNU debugger GDB.
|
/* Print values for GNU debugger GDB.
|
|
|
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
|
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
|
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
|
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
|
2008, 2009, 2010 Free Software Foundation, Inc.
|
2008, 2009, 2010 Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program 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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program 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
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
#include "frame.h"
|
#include "frame.h"
|
#include "symtab.h"
|
#include "symtab.h"
|
#include "gdbtypes.h"
|
#include "gdbtypes.h"
|
#include "value.h"
|
#include "value.h"
|
#include "language.h"
|
#include "language.h"
|
#include "expression.h"
|
#include "expression.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "target.h"
|
#include "target.h"
|
#include "breakpoint.h"
|
#include "breakpoint.h"
|
#include "demangle.h"
|
#include "demangle.h"
|
#include "valprint.h"
|
#include "valprint.h"
|
#include "annotate.h"
|
#include "annotate.h"
|
#include "symfile.h" /* for overlay functions */
|
#include "symfile.h" /* for overlay functions */
|
#include "objfiles.h" /* ditto */
|
#include "objfiles.h" /* ditto */
|
#include "completer.h" /* for completion functions */
|
#include "completer.h" /* for completion functions */
|
#include "ui-out.h"
|
#include "ui-out.h"
|
#include "gdb_assert.h"
|
#include "gdb_assert.h"
|
#include "block.h"
|
#include "block.h"
|
#include "disasm.h"
|
#include "disasm.h"
|
#include "dfp.h"
|
#include "dfp.h"
|
#include "valprint.h"
|
#include "valprint.h"
|
#include "exceptions.h"
|
#include "exceptions.h"
|
#include "observer.h"
|
#include "observer.h"
|
#include "solist.h"
|
#include "solist.h"
|
#include "solib.h"
|
#include "solib.h"
|
#include "parser-defs.h"
|
#include "parser-defs.h"
|
#include "charset.h"
|
#include "charset.h"
|
#include "arch-utils.h"
|
#include "arch-utils.h"
|
|
|
#ifdef TUI
|
#ifdef TUI
|
#include "tui/tui.h" /* For tui_active et.al. */
|
#include "tui/tui.h" /* For tui_active et.al. */
|
#endif
|
#endif
|
|
|
#if defined(__MINGW32__) && !defined(PRINTF_HAS_LONG_LONG)
|
#if defined(__MINGW32__) && !defined(PRINTF_HAS_LONG_LONG)
|
# define USE_PRINTF_I64 1
|
# define USE_PRINTF_I64 1
|
# define PRINTF_HAS_LONG_LONG
|
# define PRINTF_HAS_LONG_LONG
|
#else
|
#else
|
# define USE_PRINTF_I64 0
|
# define USE_PRINTF_I64 0
|
#endif
|
#endif
|
|
|
extern int asm_demangle; /* Whether to demangle syms in asm printouts */
|
extern int asm_demangle; /* Whether to demangle syms in asm printouts */
|
|
|
struct format_data
|
struct format_data
|
{
|
{
|
int count;
|
int count;
|
char format;
|
char format;
|
char size;
|
char size;
|
|
|
/* True if the value should be printed raw -- that is, bypassing
|
/* True if the value should be printed raw -- that is, bypassing
|
python-based formatters. */
|
python-based formatters. */
|
unsigned char raw;
|
unsigned char raw;
|
};
|
};
|
|
|
/* Last specified output format. */
|
/* Last specified output format. */
|
|
|
static char last_format = 0;
|
static char last_format = 0;
|
|
|
/* Last specified examination size. 'b', 'h', 'w' or `q'. */
|
/* Last specified examination size. 'b', 'h', 'w' or `q'. */
|
|
|
static char last_size = 'w';
|
static char last_size = 'w';
|
|
|
/* Default address to examine next, and associated architecture. */
|
/* Default address to examine next, and associated architecture. */
|
|
|
static struct gdbarch *next_gdbarch;
|
static struct gdbarch *next_gdbarch;
|
static CORE_ADDR next_address;
|
static CORE_ADDR next_address;
|
|
|
/* Number of delay instructions following current disassembled insn. */
|
/* Number of delay instructions following current disassembled insn. */
|
|
|
static int branch_delay_insns;
|
static int branch_delay_insns;
|
|
|
/* Last address examined. */
|
/* Last address examined. */
|
|
|
static CORE_ADDR last_examine_address;
|
static CORE_ADDR last_examine_address;
|
|
|
/* Contents of last address examined.
|
/* Contents of last address examined.
|
This is not valid past the end of the `x' command! */
|
This is not valid past the end of the `x' command! */
|
|
|
static struct value *last_examine_value;
|
static struct value *last_examine_value;
|
|
|
/* Largest offset between a symbolic value and an address, that will be
|
/* Largest offset between a symbolic value and an address, that will be
|
printed as `0x1234 <symbol+offset>'. */
|
printed as `0x1234 <symbol+offset>'. */
|
|
|
static unsigned int max_symbolic_offset = UINT_MAX;
|
static unsigned int max_symbolic_offset = UINT_MAX;
|
static void
|
static void
|
show_max_symbolic_offset (struct ui_file *file, int from_tty,
|
show_max_symbolic_offset (struct ui_file *file, int from_tty,
|
struct cmd_list_element *c, const char *value)
|
struct cmd_list_element *c, const char *value)
|
{
|
{
|
fprintf_filtered (file, _("\
|
fprintf_filtered (file, _("\
|
The largest offset that will be printed in <symbol+1234> form is %s.\n"),
|
The largest offset that will be printed in <symbol+1234> form is %s.\n"),
|
value);
|
value);
|
}
|
}
|
|
|
/* Append the source filename and linenumber of the symbol when
|
/* Append the source filename and linenumber of the symbol when
|
printing a symbolic value as `<symbol at filename:linenum>' if set. */
|
printing a symbolic value as `<symbol at filename:linenum>' if set. */
|
static int print_symbol_filename = 0;
|
static int print_symbol_filename = 0;
|
static void
|
static void
|
show_print_symbol_filename (struct ui_file *file, int from_tty,
|
show_print_symbol_filename (struct ui_file *file, int from_tty,
|
struct cmd_list_element *c, const char *value)
|
struct cmd_list_element *c, const char *value)
|
{
|
{
|
fprintf_filtered (file, _("\
|
fprintf_filtered (file, _("\
|
Printing of source filename and line number with <symbol> is %s.\n"),
|
Printing of source filename and line number with <symbol> is %s.\n"),
|
value);
|
value);
|
}
|
}
|
|
|
/* Number of auto-display expression currently being displayed.
|
/* Number of auto-display expression currently being displayed.
|
So that we can disable it if we get an error or a signal within it.
|
So that we can disable it if we get an error or a signal within it.
|
-1 when not doing one. */
|
-1 when not doing one. */
|
|
|
int current_display_number;
|
int current_display_number;
|
|
|
struct display
|
struct display
|
{
|
{
|
/* Chain link to next auto-display item. */
|
/* Chain link to next auto-display item. */
|
struct display *next;
|
struct display *next;
|
|
|
/* The expression as the user typed it. */
|
/* The expression as the user typed it. */
|
char *exp_string;
|
char *exp_string;
|
|
|
/* Expression to be evaluated and displayed. */
|
/* Expression to be evaluated and displayed. */
|
struct expression *exp;
|
struct expression *exp;
|
|
|
/* Item number of this auto-display item. */
|
/* Item number of this auto-display item. */
|
int number;
|
int number;
|
|
|
/* Display format specified. */
|
/* Display format specified. */
|
struct format_data format;
|
struct format_data format;
|
|
|
/* Program space associated with `block'. */
|
/* Program space associated with `block'. */
|
struct program_space *pspace;
|
struct program_space *pspace;
|
|
|
/* Innermost block required by this expression when evaluated */
|
/* Innermost block required by this expression when evaluated */
|
struct block *block;
|
struct block *block;
|
|
|
/* Status of this display (enabled or disabled) */
|
/* Status of this display (enabled or disabled) */
|
int enabled_p;
|
int enabled_p;
|
};
|
};
|
|
|
/* Chain of expressions whose values should be displayed
|
/* Chain of expressions whose values should be displayed
|
automatically each time the program stops. */
|
automatically each time the program stops. */
|
|
|
static struct display *display_chain;
|
static struct display *display_chain;
|
|
|
static int display_number;
|
static int display_number;
|
|
|
/* Prototypes for exported functions. */
|
/* Prototypes for exported functions. */
|
|
|
void output_command (char *, int);
|
void output_command (char *, int);
|
|
|
void _initialize_printcmd (void);
|
void _initialize_printcmd (void);
|
|
|
/* Prototypes for local functions. */
|
/* Prototypes for local functions. */
|
|
|
static void do_one_display (struct display *);
|
static void do_one_display (struct display *);
|
|
|
|
|
/* Decode a format specification. *STRING_PTR should point to it.
|
/* Decode a format specification. *STRING_PTR should point to it.
|
OFORMAT and OSIZE are used as defaults for the format and size
|
OFORMAT and OSIZE are used as defaults for the format and size
|
if none are given in the format specification.
|
if none are given in the format specification.
|
If OSIZE is zero, then the size field of the returned value
|
If OSIZE is zero, then the size field of the returned value
|
should be set only if a size is explicitly specified by the
|
should be set only if a size is explicitly specified by the
|
user.
|
user.
|
The structure returned describes all the data
|
The structure returned describes all the data
|
found in the specification. In addition, *STRING_PTR is advanced
|
found in the specification. In addition, *STRING_PTR is advanced
|
past the specification and past all whitespace following it. */
|
past the specification and past all whitespace following it. */
|
|
|
static struct format_data
|
static struct format_data
|
decode_format (char **string_ptr, int oformat, int osize)
|
decode_format (char **string_ptr, int oformat, int osize)
|
{
|
{
|
struct format_data val;
|
struct format_data val;
|
char *p = *string_ptr;
|
char *p = *string_ptr;
|
|
|
val.format = '?';
|
val.format = '?';
|
val.size = '?';
|
val.size = '?';
|
val.count = 1;
|
val.count = 1;
|
val.raw = 0;
|
val.raw = 0;
|
|
|
if (*p >= '0' && *p <= '9')
|
if (*p >= '0' && *p <= '9')
|
val.count = atoi (p);
|
val.count = atoi (p);
|
while (*p >= '0' && *p <= '9')
|
while (*p >= '0' && *p <= '9')
|
p++;
|
p++;
|
|
|
/* Now process size or format letters that follow. */
|
/* Now process size or format letters that follow. */
|
|
|
while (1)
|
while (1)
|
{
|
{
|
if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
|
if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
|
val.size = *p++;
|
val.size = *p++;
|
else if (*p == 'r')
|
else if (*p == 'r')
|
{
|
{
|
val.raw = 1;
|
val.raw = 1;
|
p++;
|
p++;
|
}
|
}
|
else if (*p >= 'a' && *p <= 'z')
|
else if (*p >= 'a' && *p <= 'z')
|
val.format = *p++;
|
val.format = *p++;
|
else
|
else
|
break;
|
break;
|
}
|
}
|
|
|
while (*p == ' ' || *p == '\t')
|
while (*p == ' ' || *p == '\t')
|
p++;
|
p++;
|
*string_ptr = p;
|
*string_ptr = p;
|
|
|
/* Set defaults for format and size if not specified. */
|
/* Set defaults for format and size if not specified. */
|
if (val.format == '?')
|
if (val.format == '?')
|
{
|
{
|
if (val.size == '?')
|
if (val.size == '?')
|
{
|
{
|
/* Neither has been specified. */
|
/* Neither has been specified. */
|
val.format = oformat;
|
val.format = oformat;
|
val.size = osize;
|
val.size = osize;
|
}
|
}
|
else
|
else
|
/* If a size is specified, any format makes a reasonable
|
/* If a size is specified, any format makes a reasonable
|
default except 'i'. */
|
default except 'i'. */
|
val.format = oformat == 'i' ? 'x' : oformat;
|
val.format = oformat == 'i' ? 'x' : oformat;
|
}
|
}
|
else if (val.size == '?')
|
else if (val.size == '?')
|
switch (val.format)
|
switch (val.format)
|
{
|
{
|
case 'a':
|
case 'a':
|
/* Pick the appropriate size for an address. This is deferred
|
/* Pick the appropriate size for an address. This is deferred
|
until do_examine when we know the actual architecture to use.
|
until do_examine when we know the actual architecture to use.
|
A special size value of 'a' is used to indicate this case. */
|
A special size value of 'a' is used to indicate this case. */
|
val.size = osize ? 'a' : osize;
|
val.size = osize ? 'a' : osize;
|
break;
|
break;
|
case 'f':
|
case 'f':
|
/* Floating point has to be word or giantword. */
|
/* Floating point has to be word or giantword. */
|
if (osize == 'w' || osize == 'g')
|
if (osize == 'w' || osize == 'g')
|
val.size = osize;
|
val.size = osize;
|
else
|
else
|
/* Default it to giantword if the last used size is not
|
/* Default it to giantword if the last used size is not
|
appropriate. */
|
appropriate. */
|
val.size = osize ? 'g' : osize;
|
val.size = osize ? 'g' : osize;
|
break;
|
break;
|
case 'c':
|
case 'c':
|
/* Characters default to one byte. */
|
/* Characters default to one byte. */
|
val.size = osize ? 'b' : osize;
|
val.size = osize ? 'b' : osize;
|
break;
|
break;
|
default:
|
default:
|
/* The default is the size most recently specified. */
|
/* The default is the size most recently specified. */
|
val.size = osize;
|
val.size = osize;
|
}
|
}
|
|
|
return val;
|
return val;
|
}
|
}
|
|
|
/* Print value VAL on stream according to OPTIONS.
|
/* Print value VAL on stream according to OPTIONS.
|
Do not end with a newline.
|
Do not end with a newline.
|
SIZE is the letter for the size of datum being printed.
|
SIZE is the letter for the size of datum being printed.
|
This is used to pad hex numbers so they line up. SIZE is 0
|
This is used to pad hex numbers so they line up. SIZE is 0
|
for print / output and set for examine. */
|
for print / output and set for examine. */
|
|
|
static void
|
static void
|
print_formatted (struct value *val, int size,
|
print_formatted (struct value *val, int size,
|
const struct value_print_options *options,
|
const struct value_print_options *options,
|
struct ui_file *stream)
|
struct ui_file *stream)
|
{
|
{
|
struct type *type = check_typedef (value_type (val));
|
struct type *type = check_typedef (value_type (val));
|
int len = TYPE_LENGTH (type);
|
int len = TYPE_LENGTH (type);
|
|
|
if (VALUE_LVAL (val) == lval_memory)
|
if (VALUE_LVAL (val) == lval_memory)
|
next_address = value_address (val) + len;
|
next_address = value_address (val) + len;
|
|
|
if (size)
|
if (size)
|
{
|
{
|
switch (options->format)
|
switch (options->format)
|
{
|
{
|
case 's':
|
case 's':
|
{
|
{
|
struct type *elttype = value_type (val);
|
struct type *elttype = value_type (val);
|
next_address = (value_address (val)
|
next_address = (value_address (val)
|
+ val_print_string (elttype,
|
+ val_print_string (elttype,
|
value_address (val), -1,
|
value_address (val), -1,
|
stream, options));
|
stream, options));
|
}
|
}
|
return;
|
return;
|
|
|
case 'i':
|
case 'i':
|
/* We often wrap here if there are long symbolic names. */
|
/* We often wrap here if there are long symbolic names. */
|
wrap_here (" ");
|
wrap_here (" ");
|
next_address = (value_address (val)
|
next_address = (value_address (val)
|
+ gdb_print_insn (get_type_arch (type),
|
+ gdb_print_insn (get_type_arch (type),
|
value_address (val), stream,
|
value_address (val), stream,
|
&branch_delay_insns));
|
&branch_delay_insns));
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
if (options->format == 0 || options->format == 's'
|
if (options->format == 0 || options->format == 's'
|
|| TYPE_CODE (type) == TYPE_CODE_REF
|
|| TYPE_CODE (type) == TYPE_CODE_REF
|
|| TYPE_CODE (type) == TYPE_CODE_ARRAY
|
|| TYPE_CODE (type) == TYPE_CODE_ARRAY
|
|| TYPE_CODE (type) == TYPE_CODE_STRING
|
|| TYPE_CODE (type) == TYPE_CODE_STRING
|
|| TYPE_CODE (type) == TYPE_CODE_STRUCT
|
|| TYPE_CODE (type) == TYPE_CODE_STRUCT
|
|| TYPE_CODE (type) == TYPE_CODE_UNION
|
|| TYPE_CODE (type) == TYPE_CODE_UNION
|
|| TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
|
|| TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
|
value_print (val, stream, options);
|
value_print (val, stream, options);
|
else
|
else
|
/* User specified format, so don't look to the the type to
|
/* User specified format, so don't look to the the type to
|
tell us what to do. */
|
tell us what to do. */
|
print_scalar_formatted (value_contents (val), type,
|
print_scalar_formatted (value_contents (val), type,
|
options, size, stream);
|
options, size, stream);
|
}
|
}
|
|
|
/* Return builtin floating point type of same length as TYPE.
|
/* Return builtin floating point type of same length as TYPE.
|
If no such type is found, return TYPE itself. */
|
If no such type is found, return TYPE itself. */
|
static struct type *
|
static struct type *
|
float_type_from_length (struct type *type)
|
float_type_from_length (struct type *type)
|
{
|
{
|
struct gdbarch *gdbarch = get_type_arch (type);
|
struct gdbarch *gdbarch = get_type_arch (type);
|
const struct builtin_type *builtin = builtin_type (gdbarch);
|
const struct builtin_type *builtin = builtin_type (gdbarch);
|
unsigned int len = TYPE_LENGTH (type);
|
unsigned int len = TYPE_LENGTH (type);
|
|
|
if (len == TYPE_LENGTH (builtin->builtin_float))
|
if (len == TYPE_LENGTH (builtin->builtin_float))
|
type = builtin->builtin_float;
|
type = builtin->builtin_float;
|
else if (len == TYPE_LENGTH (builtin->builtin_double))
|
else if (len == TYPE_LENGTH (builtin->builtin_double))
|
type = builtin->builtin_double;
|
type = builtin->builtin_double;
|
else if (len == TYPE_LENGTH (builtin->builtin_long_double))
|
else if (len == TYPE_LENGTH (builtin->builtin_long_double))
|
type = builtin->builtin_long_double;
|
type = builtin->builtin_long_double;
|
|
|
return type;
|
return type;
|
}
|
}
|
|
|
/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
|
/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
|
according to OPTIONS and SIZE on STREAM.
|
according to OPTIONS and SIZE on STREAM.
|
Formats s and i are not supported at this level.
|
Formats s and i are not supported at this level.
|
|
|
This is how the elements of an array or structure are printed
|
This is how the elements of an array or structure are printed
|
with a format. */
|
with a format. */
|
|
|
void
|
void
|
print_scalar_formatted (const void *valaddr, struct type *type,
|
print_scalar_formatted (const void *valaddr, struct type *type,
|
const struct value_print_options *options,
|
const struct value_print_options *options,
|
int size, struct ui_file *stream)
|
int size, struct ui_file *stream)
|
{
|
{
|
struct gdbarch *gdbarch = get_type_arch (type);
|
struct gdbarch *gdbarch = get_type_arch (type);
|
LONGEST val_long = 0;
|
LONGEST val_long = 0;
|
unsigned int len = TYPE_LENGTH (type);
|
unsigned int len = TYPE_LENGTH (type);
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
/* If we get here with a string format, try again without it. Go
|
/* If we get here with a string format, try again without it. Go
|
all the way back to the language printers, which may call us
|
all the way back to the language printers, which may call us
|
again. */
|
again. */
|
if (options->format == 's')
|
if (options->format == 's')
|
{
|
{
|
struct value_print_options opts = *options;
|
struct value_print_options opts = *options;
|
opts.format = 0;
|
opts.format = 0;
|
opts.deref_ref = 0;
|
opts.deref_ref = 0;
|
val_print (type, valaddr, 0, 0, stream, 0, &opts,
|
val_print (type, valaddr, 0, 0, stream, 0, &opts,
|
current_language);
|
current_language);
|
return;
|
return;
|
}
|
}
|
|
|
if (len > sizeof(LONGEST) &&
|
if (len > sizeof(LONGEST) &&
|
(TYPE_CODE (type) == TYPE_CODE_INT
|
(TYPE_CODE (type) == TYPE_CODE_INT
|
|| TYPE_CODE (type) == TYPE_CODE_ENUM))
|
|| TYPE_CODE (type) == TYPE_CODE_ENUM))
|
{
|
{
|
switch (options->format)
|
switch (options->format)
|
{
|
{
|
case 'o':
|
case 'o':
|
print_octal_chars (stream, valaddr, len, byte_order);
|
print_octal_chars (stream, valaddr, len, byte_order);
|
return;
|
return;
|
case 'u':
|
case 'u':
|
case 'd':
|
case 'd':
|
print_decimal_chars (stream, valaddr, len, byte_order);
|
print_decimal_chars (stream, valaddr, len, byte_order);
|
return;
|
return;
|
case 't':
|
case 't':
|
print_binary_chars (stream, valaddr, len, byte_order);
|
print_binary_chars (stream, valaddr, len, byte_order);
|
return;
|
return;
|
case 'x':
|
case 'x':
|
print_hex_chars (stream, valaddr, len, byte_order);
|
print_hex_chars (stream, valaddr, len, byte_order);
|
return;
|
return;
|
case 'c':
|
case 'c':
|
print_char_chars (stream, type, valaddr, len, byte_order);
|
print_char_chars (stream, type, valaddr, len, byte_order);
|
return;
|
return;
|
default:
|
default:
|
break;
|
break;
|
};
|
};
|
}
|
}
|
|
|
if (options->format != 'f')
|
if (options->format != 'f')
|
val_long = unpack_long (type, valaddr);
|
val_long = unpack_long (type, valaddr);
|
|
|
/* If the value is a pointer, and pointers and addresses are not the
|
/* If the value is a pointer, and pointers and addresses are not the
|
same, then at this point, the value's length (in target bytes) is
|
same, then at this point, the value's length (in target bytes) is
|
gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
|
gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
|
if (TYPE_CODE (type) == TYPE_CODE_PTR)
|
if (TYPE_CODE (type) == TYPE_CODE_PTR)
|
len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;
|
len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;
|
|
|
/* If we are printing it as unsigned, truncate it in case it is actually
|
/* If we are printing it as unsigned, truncate it in case it is actually
|
a negative signed value (e.g. "print/u (short)-1" should print 65535
|
a negative signed value (e.g. "print/u (short)-1" should print 65535
|
(if shorts are 16 bits) instead of 4294967295). */
|
(if shorts are 16 bits) instead of 4294967295). */
|
if (options->format != 'd' || TYPE_UNSIGNED (type))
|
if (options->format != 'd' || TYPE_UNSIGNED (type))
|
{
|
{
|
if (len < sizeof (LONGEST))
|
if (len < sizeof (LONGEST))
|
val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
|
val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
|
}
|
}
|
|
|
switch (options->format)
|
switch (options->format)
|
{
|
{
|
case 'x':
|
case 'x':
|
if (!size)
|
if (!size)
|
{
|
{
|
/* No size specified, like in print. Print varying # of digits. */
|
/* No size specified, like in print. Print varying # of digits. */
|
print_longest (stream, 'x', 1, val_long);
|
print_longest (stream, 'x', 1, val_long);
|
}
|
}
|
else
|
else
|
switch (size)
|
switch (size)
|
{
|
{
|
case 'b':
|
case 'b':
|
case 'h':
|
case 'h':
|
case 'w':
|
case 'w':
|
case 'g':
|
case 'g':
|
print_longest (stream, size, 1, val_long);
|
print_longest (stream, size, 1, val_long);
|
break;
|
break;
|
default:
|
default:
|
error (_("Undefined output size \"%c\"."), size);
|
error (_("Undefined output size \"%c\"."), size);
|
}
|
}
|
break;
|
break;
|
|
|
case 'd':
|
case 'd':
|
print_longest (stream, 'd', 1, val_long);
|
print_longest (stream, 'd', 1, val_long);
|
break;
|
break;
|
|
|
case 'u':
|
case 'u':
|
print_longest (stream, 'u', 0, val_long);
|
print_longest (stream, 'u', 0, val_long);
|
break;
|
break;
|
|
|
case 'o':
|
case 'o':
|
if (val_long)
|
if (val_long)
|
print_longest (stream, 'o', 1, val_long);
|
print_longest (stream, 'o', 1, val_long);
|
else
|
else
|
fprintf_filtered (stream, "0");
|
fprintf_filtered (stream, "0");
|
break;
|
break;
|
|
|
case 'a':
|
case 'a':
|
{
|
{
|
CORE_ADDR addr = unpack_pointer (type, valaddr);
|
CORE_ADDR addr = unpack_pointer (type, valaddr);
|
print_address (gdbarch, addr, stream);
|
print_address (gdbarch, addr, stream);
|
}
|
}
|
break;
|
break;
|
|
|
case 'c':
|
case 'c':
|
{
|
{
|
struct value_print_options opts = *options;
|
struct value_print_options opts = *options;
|
opts.format = 0;
|
opts.format = 0;
|
|
|
if (TYPE_UNSIGNED (type))
|
if (TYPE_UNSIGNED (type))
|
type = builtin_type (gdbarch)->builtin_true_unsigned_char;
|
type = builtin_type (gdbarch)->builtin_true_unsigned_char;
|
else
|
else
|
type = builtin_type (gdbarch)->builtin_true_char;
|
type = builtin_type (gdbarch)->builtin_true_char;
|
|
|
value_print (value_from_longest (type, val_long), stream, &opts);
|
value_print (value_from_longest (type, val_long), stream, &opts);
|
}
|
}
|
break;
|
break;
|
|
|
case 'f':
|
case 'f':
|
type = float_type_from_length (type);
|
type = float_type_from_length (type);
|
print_floating (valaddr, type, stream);
|
print_floating (valaddr, type, stream);
|
break;
|
break;
|
|
|
case 0:
|
case 0:
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("failed internal consistency check"));
|
_("failed internal consistency check"));
|
|
|
case 't':
|
case 't':
|
/* Binary; 't' stands for "two". */
|
/* Binary; 't' stands for "two". */
|
{
|
{
|
char bits[8 * (sizeof val_long) + 1];
|
char bits[8 * (sizeof val_long) + 1];
|
char buf[8 * (sizeof val_long) + 32];
|
char buf[8 * (sizeof val_long) + 32];
|
char *cp = bits;
|
char *cp = bits;
|
int width;
|
int width;
|
|
|
if (!size)
|
if (!size)
|
width = 8 * (sizeof val_long);
|
width = 8 * (sizeof val_long);
|
else
|
else
|
switch (size)
|
switch (size)
|
{
|
{
|
case 'b':
|
case 'b':
|
width = 8;
|
width = 8;
|
break;
|
break;
|
case 'h':
|
case 'h':
|
width = 16;
|
width = 16;
|
break;
|
break;
|
case 'w':
|
case 'w':
|
width = 32;
|
width = 32;
|
break;
|
break;
|
case 'g':
|
case 'g':
|
width = 64;
|
width = 64;
|
break;
|
break;
|
default:
|
default:
|
error (_("Undefined output size \"%c\"."), size);
|
error (_("Undefined output size \"%c\"."), size);
|
}
|
}
|
|
|
bits[width] = '\0';
|
bits[width] = '\0';
|
while (width-- > 0)
|
while (width-- > 0)
|
{
|
{
|
bits[width] = (val_long & 1) ? '1' : '0';
|
bits[width] = (val_long & 1) ? '1' : '0';
|
val_long >>= 1;
|
val_long >>= 1;
|
}
|
}
|
if (!size)
|
if (!size)
|
{
|
{
|
while (*cp && *cp == '0')
|
while (*cp && *cp == '0')
|
cp++;
|
cp++;
|
if (*cp == '\0')
|
if (*cp == '\0')
|
cp--;
|
cp--;
|
}
|
}
|
strcpy (buf, cp);
|
strcpy (buf, cp);
|
fputs_filtered (buf, stream);
|
fputs_filtered (buf, stream);
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
error (_("Undefined output format \"%c\"."), options->format);
|
error (_("Undefined output format \"%c\"."), options->format);
|
}
|
}
|
}
|
}
|
|
|
/* Specify default address for `x' command.
|
/* Specify default address for `x' command.
|
The `info lines' command uses this. */
|
The `info lines' command uses this. */
|
|
|
void
|
void
|
set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
|
set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
|
{
|
{
|
struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
|
struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
|
|
|
next_gdbarch = gdbarch;
|
next_gdbarch = gdbarch;
|
next_address = addr;
|
next_address = addr;
|
|
|
/* Make address available to the user as $_. */
|
/* Make address available to the user as $_. */
|
set_internalvar (lookup_internalvar ("_"),
|
set_internalvar (lookup_internalvar ("_"),
|
value_from_pointer (ptr_type, addr));
|
value_from_pointer (ptr_type, 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.
|
after LEADIN. Print nothing if no symbolic name is found nearby.
|
Optionally also print source file and line number, if available.
|
Optionally also print source file and line number, if available.
|
DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
|
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
|
or to interpret it as a possible C++ name and convert it back to source
|
form. However note that DO_DEMANGLE can be overridden by the specific
|
form. However note that DO_DEMANGLE can be overridden by the specific
|
settings of the demangle and asm_demangle variables. */
|
settings of the demangle and asm_demangle variables. */
|
|
|
void
|
void
|
print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
|
print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
|
struct ui_file *stream,
|
struct ui_file *stream,
|
int do_demangle, char *leadin)
|
int do_demangle, char *leadin)
|
{
|
{
|
char *name = NULL;
|
char *name = NULL;
|
char *filename = NULL;
|
char *filename = NULL;
|
int unmapped = 0;
|
int unmapped = 0;
|
int offset = 0;
|
int offset = 0;
|
int line = 0;
|
int line = 0;
|
|
|
/* Throw away both name and filename. */
|
/* Throw away both name and filename. */
|
struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
|
struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
|
make_cleanup (free_current_contents, &filename);
|
make_cleanup (free_current_contents, &filename);
|
|
|
if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
|
if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
|
&filename, &line, &unmapped))
|
&filename, &line, &unmapped))
|
{
|
{
|
do_cleanups (cleanup_chain);
|
do_cleanups (cleanup_chain);
|
return;
|
return;
|
}
|
}
|
|
|
fputs_filtered (leadin, stream);
|
fputs_filtered (leadin, stream);
|
if (unmapped)
|
if (unmapped)
|
fputs_filtered ("<*", stream);
|
fputs_filtered ("<*", stream);
|
else
|
else
|
fputs_filtered ("<", stream);
|
fputs_filtered ("<", stream);
|
fputs_filtered (name, stream);
|
fputs_filtered (name, stream);
|
if (offset != 0)
|
if (offset != 0)
|
fprintf_filtered (stream, "+%u", (unsigned int) offset);
|
fprintf_filtered (stream, "+%u", (unsigned int) offset);
|
|
|
/* Append source filename and line number if desired. Give specific
|
/* Append source filename and line number if desired. Give specific
|
line # of this addr, if we have it; else line # of the nearest symbol. */
|
line # of this addr, if we have it; else line # of the nearest symbol. */
|
if (print_symbol_filename && filename != NULL)
|
if (print_symbol_filename && filename != NULL)
|
{
|
{
|
if (line != -1)
|
if (line != -1)
|
fprintf_filtered (stream, " at %s:%d", filename, line);
|
fprintf_filtered (stream, " at %s:%d", filename, line);
|
else
|
else
|
fprintf_filtered (stream, " in %s", filename);
|
fprintf_filtered (stream, " in %s", filename);
|
}
|
}
|
if (unmapped)
|
if (unmapped)
|
fputs_filtered ("*>", stream);
|
fputs_filtered ("*>", stream);
|
else
|
else
|
fputs_filtered (">", stream);
|
fputs_filtered (">", stream);
|
|
|
do_cleanups (cleanup_chain);
|
do_cleanups (cleanup_chain);
|
}
|
}
|
|
|
/* Given an address ADDR return all the elements needed to print the
|
/* Given an address ADDR return all the elements needed to print the
|
address in a symbolic form. NAME can be mangled or not depending
|
address in a symbolic form. NAME can be mangled or not depending
|
on DO_DEMANGLE (and also on the asm_demangle global variable,
|
on DO_DEMANGLE (and also on the asm_demangle global variable,
|
manipulated via ''set print asm-demangle''). Return 0 in case of
|
manipulated via ''set print asm-demangle''). Return 0 in case of
|
success, when all the info in the OUT paramters is valid. Return 1
|
success, when all the info in the OUT paramters is valid. Return 1
|
otherwise. */
|
otherwise. */
|
int
|
int
|
build_address_symbolic (struct gdbarch *gdbarch,
|
build_address_symbolic (struct gdbarch *gdbarch,
|
CORE_ADDR addr, /* IN */
|
CORE_ADDR addr, /* IN */
|
int do_demangle, /* IN */
|
int do_demangle, /* IN */
|
char **name, /* OUT */
|
char **name, /* OUT */
|
int *offset, /* OUT */
|
int *offset, /* OUT */
|
char **filename, /* OUT */
|
char **filename, /* OUT */
|
int *line, /* OUT */
|
int *line, /* OUT */
|
int *unmapped) /* OUT */
|
int *unmapped) /* OUT */
|
{
|
{
|
struct minimal_symbol *msymbol;
|
struct minimal_symbol *msymbol;
|
struct symbol *symbol;
|
struct symbol *symbol;
|
CORE_ADDR name_location = 0;
|
CORE_ADDR name_location = 0;
|
struct obj_section *section = NULL;
|
struct obj_section *section = NULL;
|
char *name_temp = "";
|
char *name_temp = "";
|
|
|
/* Let's say it is mapped (not unmapped). */
|
/* Let's say it is mapped (not unmapped). */
|
*unmapped = 0;
|
*unmapped = 0;
|
|
|
/* Determine if the address is in an overlay, and whether it is
|
/* Determine if the address is in an overlay, and whether it is
|
mapped. */
|
mapped. */
|
if (overlay_debugging)
|
if (overlay_debugging)
|
{
|
{
|
section = find_pc_overlay (addr);
|
section = find_pc_overlay (addr);
|
if (pc_in_unmapped_range (addr, section))
|
if (pc_in_unmapped_range (addr, section))
|
{
|
{
|
*unmapped = 1;
|
*unmapped = 1;
|
addr = overlay_mapped_address (addr, section);
|
addr = overlay_mapped_address (addr, section);
|
}
|
}
|
}
|
}
|
|
|
/* First try to find the address in the symbol table, then
|
/* First try to find the address in the symbol table, then
|
in the minsyms. Take the closest one. */
|
in the minsyms. Take the closest one. */
|
|
|
/* This is defective in the sense that it only finds text symbols. So
|
/* This is defective in the sense that it only finds text symbols. So
|
really this is kind of pointless--we should make sure that the
|
really this is kind of pointless--we should make sure that the
|
minimal symbols have everything we need (by changing that we could
|
minimal symbols have everything we need (by changing that we could
|
save some memory, but for many debug format--ELF/DWARF or
|
save some memory, but for many debug format--ELF/DWARF or
|
anything/stabs--it would be inconvenient to eliminate those minimal
|
anything/stabs--it would be inconvenient to eliminate those minimal
|
symbols anyway). */
|
symbols anyway). */
|
msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
|
msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
|
symbol = find_pc_sect_function (addr, section);
|
symbol = find_pc_sect_function (addr, section);
|
|
|
if (symbol)
|
if (symbol)
|
{
|
{
|
/* If this is a function (i.e. a code address), strip out any
|
/* If this is a function (i.e. a code address), strip out any
|
non-address bits. For instance, display a pointer to the
|
non-address bits. For instance, display a pointer to the
|
first instruction of a Thumb function as <function>; the
|
first instruction of a Thumb function as <function>; the
|
second instruction will be <function+2>, even though the
|
second instruction will be <function+2>, even though the
|
pointer is <function+3>. This matches the ISA behavior. */
|
pointer is <function+3>. This matches the ISA behavior. */
|
addr = gdbarch_addr_bits_remove (gdbarch, addr);
|
addr = gdbarch_addr_bits_remove (gdbarch, addr);
|
|
|
name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
|
name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
|
if (do_demangle || asm_demangle)
|
if (do_demangle || asm_demangle)
|
name_temp = SYMBOL_PRINT_NAME (symbol);
|
name_temp = SYMBOL_PRINT_NAME (symbol);
|
else
|
else
|
name_temp = SYMBOL_LINKAGE_NAME (symbol);
|
name_temp = SYMBOL_LINKAGE_NAME (symbol);
|
}
|
}
|
|
|
if (msymbol != NULL)
|
if (msymbol != NULL)
|
{
|
{
|
if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
|
if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
|
{
|
{
|
/* The msymbol is closer to the address than the symbol;
|
/* The msymbol is closer to the address than the symbol;
|
use the msymbol instead. */
|
use the msymbol instead. */
|
symbol = 0;
|
symbol = 0;
|
name_location = SYMBOL_VALUE_ADDRESS (msymbol);
|
name_location = SYMBOL_VALUE_ADDRESS (msymbol);
|
if (do_demangle || asm_demangle)
|
if (do_demangle || asm_demangle)
|
name_temp = SYMBOL_PRINT_NAME (msymbol);
|
name_temp = SYMBOL_PRINT_NAME (msymbol);
|
else
|
else
|
name_temp = SYMBOL_LINKAGE_NAME (msymbol);
|
name_temp = SYMBOL_LINKAGE_NAME (msymbol);
|
}
|
}
|
}
|
}
|
if (symbol == NULL && msymbol == NULL)
|
if (symbol == NULL && msymbol == NULL)
|
return 1;
|
return 1;
|
|
|
/* If the nearest symbol is too far away, don't print anything symbolic. */
|
/* 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
|
/* For when CORE_ADDR is larger than unsigned int, we do math in
|
CORE_ADDR. But when we detect unsigned wraparound in the
|
CORE_ADDR. But when we detect unsigned wraparound in the
|
CORE_ADDR math, we ignore this test and print the offset,
|
CORE_ADDR math, we ignore this test and print the offset,
|
because addr+max_symbolic_offset has wrapped through the end
|
because addr+max_symbolic_offset has wrapped through the end
|
of the address space back to the beginning, giving bogus comparison. */
|
of the address space back to the beginning, giving bogus comparison. */
|
if (addr > name_location + max_symbolic_offset
|
if (addr > name_location + max_symbolic_offset
|
&& name_location + max_symbolic_offset > name_location)
|
&& name_location + max_symbolic_offset > name_location)
|
return 1;
|
return 1;
|
|
|
*offset = addr - name_location;
|
*offset = addr - name_location;
|
|
|
*name = xstrdup (name_temp);
|
*name = xstrdup (name_temp);
|
|
|
if (print_symbol_filename)
|
if (print_symbol_filename)
|
{
|
{
|
struct symtab_and_line sal;
|
struct symtab_and_line sal;
|
|
|
sal = find_pc_sect_line (addr, section, 0);
|
sal = find_pc_sect_line (addr, section, 0);
|
|
|
if (sal.symtab)
|
if (sal.symtab)
|
{
|
{
|
*filename = xstrdup (sal.symtab->filename);
|
*filename = xstrdup (sal.symtab->filename);
|
*line = sal.line;
|
*line = sal.line;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
/* Print address ADDR symbolically on STREAM.
|
/* Print address ADDR symbolically on STREAM.
|
First print it as a number. Then perhaps print
|
First print it as a number. Then perhaps print
|
<SYMBOL + OFFSET> after the number. */
|
<SYMBOL + OFFSET> after the number. */
|
|
|
void
|
void
|
print_address (struct gdbarch *gdbarch,
|
print_address (struct gdbarch *gdbarch,
|
CORE_ADDR addr, struct ui_file *stream)
|
CORE_ADDR addr, struct ui_file *stream)
|
{
|
{
|
fputs_filtered (paddress (gdbarch, addr), stream);
|
fputs_filtered (paddress (gdbarch, addr), stream);
|
print_address_symbolic (gdbarch, addr, stream, asm_demangle, " ");
|
print_address_symbolic (gdbarch, addr, stream, asm_demangle, " ");
|
}
|
}
|
|
|
/* Return a prefix for instruction address:
|
/* Return a prefix for instruction address:
|
"=> " for current instruction, else " ". */
|
"=> " for current instruction, else " ". */
|
|
|
const char *
|
const char *
|
pc_prefix (CORE_ADDR addr)
|
pc_prefix (CORE_ADDR addr)
|
{
|
{
|
if (has_stack_frames ())
|
if (has_stack_frames ())
|
{
|
{
|
struct frame_info *frame;
|
struct frame_info *frame;
|
CORE_ADDR pc;
|
CORE_ADDR pc;
|
|
|
frame = get_selected_frame (NULL);
|
frame = get_selected_frame (NULL);
|
pc = get_frame_pc (frame);
|
pc = get_frame_pc (frame);
|
|
|
if (pc == addr)
|
if (pc == addr)
|
return "=> ";
|
return "=> ";
|
}
|
}
|
return " ";
|
return " ";
|
}
|
}
|
|
|
/* Print address ADDR symbolically on STREAM. Parameter 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
|
Global setting "addressprint" controls whether to print hex address
|
or not. */
|
or not. */
|
|
|
void
|
void
|
print_address_demangle (struct gdbarch *gdbarch, CORE_ADDR addr,
|
print_address_demangle (struct gdbarch *gdbarch, CORE_ADDR addr,
|
struct ui_file *stream, int do_demangle)
|
struct ui_file *stream, int do_demangle)
|
{
|
{
|
struct value_print_options opts;
|
struct value_print_options opts;
|
get_user_print_options (&opts);
|
get_user_print_options (&opts);
|
if (addr == 0)
|
if (addr == 0)
|
{
|
{
|
fprintf_filtered (stream, "0");
|
fprintf_filtered (stream, "0");
|
}
|
}
|
else if (opts.addressprint)
|
else if (opts.addressprint)
|
{
|
{
|
fputs_filtered (paddress (gdbarch, addr), stream);
|
fputs_filtered (paddress (gdbarch, addr), stream);
|
print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");
|
print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");
|
}
|
}
|
else
|
else
|
{
|
{
|
print_address_symbolic (gdbarch, addr, stream, do_demangle, "");
|
print_address_symbolic (gdbarch, addr, stream, do_demangle, "");
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Examine data at address ADDR in format FMT.
|
/* Examine data at address ADDR in format FMT.
|
Fetch it from memory and print on gdb_stdout. */
|
Fetch it from memory and print on gdb_stdout. */
|
|
|
static void
|
static void
|
do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
|
do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
|
{
|
{
|
char format = 0;
|
char format = 0;
|
char size;
|
char size;
|
int count = 1;
|
int count = 1;
|
struct type *val_type = NULL;
|
struct type *val_type = NULL;
|
int i;
|
int i;
|
int maxelts;
|
int maxelts;
|
struct value_print_options opts;
|
struct value_print_options opts;
|
|
|
format = fmt.format;
|
format = fmt.format;
|
size = fmt.size;
|
size = fmt.size;
|
count = fmt.count;
|
count = fmt.count;
|
next_gdbarch = gdbarch;
|
next_gdbarch = gdbarch;
|
next_address = addr;
|
next_address = addr;
|
|
|
/* String or instruction format implies fetch single bytes
|
/* String or instruction format implies fetch single bytes
|
regardless of the specified size. */
|
regardless of the specified size. */
|
if (format == 's' || format == 'i')
|
if (format == 's' || format == 'i')
|
size = 'b';
|
size = 'b';
|
|
|
if (size == 'a')
|
if (size == 'a')
|
{
|
{
|
/* Pick the appropriate size for an address. */
|
/* Pick the appropriate size for an address. */
|
if (gdbarch_ptr_bit (next_gdbarch) == 64)
|
if (gdbarch_ptr_bit (next_gdbarch) == 64)
|
size = 'g';
|
size = 'g';
|
else if (gdbarch_ptr_bit (next_gdbarch) == 32)
|
else if (gdbarch_ptr_bit (next_gdbarch) == 32)
|
size = 'w';
|
size = 'w';
|
else if (gdbarch_ptr_bit (next_gdbarch) == 16)
|
else if (gdbarch_ptr_bit (next_gdbarch) == 16)
|
size = 'h';
|
size = 'h';
|
else
|
else
|
/* Bad value for gdbarch_ptr_bit. */
|
/* Bad value for gdbarch_ptr_bit. */
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("failed internal consistency check"));
|
_("failed internal consistency check"));
|
}
|
}
|
|
|
if (size == 'b')
|
if (size == 'b')
|
val_type = builtin_type (next_gdbarch)->builtin_int8;
|
val_type = builtin_type (next_gdbarch)->builtin_int8;
|
else if (size == 'h')
|
else if (size == 'h')
|
val_type = builtin_type (next_gdbarch)->builtin_int16;
|
val_type = builtin_type (next_gdbarch)->builtin_int16;
|
else if (size == 'w')
|
else if (size == 'w')
|
val_type = builtin_type (next_gdbarch)->builtin_int32;
|
val_type = builtin_type (next_gdbarch)->builtin_int32;
|
else if (size == 'g')
|
else if (size == 'g')
|
val_type = builtin_type (next_gdbarch)->builtin_int64;
|
val_type = builtin_type (next_gdbarch)->builtin_int64;
|
|
|
maxelts = 8;
|
maxelts = 8;
|
if (size == 'w')
|
if (size == 'w')
|
maxelts = 4;
|
maxelts = 4;
|
if (size == 'g')
|
if (size == 'g')
|
maxelts = 2;
|
maxelts = 2;
|
if (format == 's' || format == 'i')
|
if (format == 's' || format == 'i')
|
maxelts = 1;
|
maxelts = 1;
|
|
|
get_formatted_print_options (&opts, format);
|
get_formatted_print_options (&opts, format);
|
|
|
/* Print as many objects as specified in COUNT, at most maxelts per line,
|
/* Print as many objects as specified in COUNT, at most maxelts per line,
|
with the address of the next one at the start of each line. */
|
with the address of the next one at the start of each line. */
|
|
|
while (count > 0)
|
while (count > 0)
|
{
|
{
|
QUIT;
|
QUIT;
|
if (format == 'i')
|
if (format == 'i')
|
fputs_filtered (pc_prefix (next_address), gdb_stdout);
|
fputs_filtered (pc_prefix (next_address), gdb_stdout);
|
print_address (next_gdbarch, next_address, gdb_stdout);
|
print_address (next_gdbarch, next_address, gdb_stdout);
|
printf_filtered (":");
|
printf_filtered (":");
|
for (i = maxelts;
|
for (i = maxelts;
|
i > 0 && count > 0;
|
i > 0 && count > 0;
|
i--, count--)
|
i--, count--)
|
{
|
{
|
printf_filtered ("\t");
|
printf_filtered ("\t");
|
/* Note that print_formatted sets next_address for the next
|
/* Note that print_formatted sets next_address for the next
|
object. */
|
object. */
|
last_examine_address = next_address;
|
last_examine_address = next_address;
|
|
|
if (last_examine_value)
|
if (last_examine_value)
|
value_free (last_examine_value);
|
value_free (last_examine_value);
|
|
|
/* The value to be displayed is not fetched greedily.
|
/* The value to be displayed is not fetched greedily.
|
Instead, to avoid the possibility of a fetched value not
|
Instead, to avoid the possibility of a fetched value not
|
being used, its retrieval is delayed until the print code
|
being used, its retrieval is delayed until the print code
|
uses it. When examining an instruction stream, the
|
uses it. When examining an instruction stream, the
|
disassembler will perform its own memory fetch using just
|
disassembler will perform its own memory fetch using just
|
the address stored in LAST_EXAMINE_VALUE. FIXME: Should
|
the address stored in LAST_EXAMINE_VALUE. FIXME: Should
|
the disassembler be modified so that LAST_EXAMINE_VALUE
|
the disassembler be modified so that LAST_EXAMINE_VALUE
|
is left with the byte sequence from the last complete
|
is left with the byte sequence from the last complete
|
instruction fetched from memory? */
|
instruction fetched from memory? */
|
last_examine_value = value_at_lazy (val_type, next_address);
|
last_examine_value = value_at_lazy (val_type, next_address);
|
|
|
if (last_examine_value)
|
if (last_examine_value)
|
release_value (last_examine_value);
|
release_value (last_examine_value);
|
|
|
print_formatted (last_examine_value, size, &opts, gdb_stdout);
|
print_formatted (last_examine_value, size, &opts, gdb_stdout);
|
|
|
/* Display any branch delay slots following the final insn. */
|
/* Display any branch delay slots following the final insn. */
|
if (format == 'i' && count == 1)
|
if (format == 'i' && count == 1)
|
count += branch_delay_insns;
|
count += branch_delay_insns;
|
}
|
}
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
validate_format (struct format_data fmt, char *cmdname)
|
validate_format (struct format_data fmt, char *cmdname)
|
{
|
{
|
if (fmt.size != 0)
|
if (fmt.size != 0)
|
error (_("Size letters are meaningless in \"%s\" command."), cmdname);
|
error (_("Size letters are meaningless in \"%s\" command."), cmdname);
|
if (fmt.count != 1)
|
if (fmt.count != 1)
|
error (_("Item count other than 1 is meaningless in \"%s\" command."),
|
error (_("Item count other than 1 is meaningless in \"%s\" command."),
|
cmdname);
|
cmdname);
|
if (fmt.format == 'i')
|
if (fmt.format == 'i')
|
error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
|
error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
|
fmt.format, cmdname);
|
fmt.format, cmdname);
|
}
|
}
|
|
|
/* Evaluate string EXP as an expression in the current language and
|
/* Evaluate string EXP as an expression in the current language and
|
print the resulting value. EXP may contain a format specifier as the
|
print the resulting value. EXP may contain a format specifier as the
|
first argument ("/x myvar" for example, to print myvar in hex). */
|
first argument ("/x myvar" for example, to print myvar in hex). */
|
|
|
static void
|
static void
|
print_command_1 (char *exp, int inspect, int voidprint)
|
print_command_1 (char *exp, int inspect, int voidprint)
|
{
|
{
|
struct expression *expr;
|
struct expression *expr;
|
struct cleanup *old_chain = 0;
|
struct cleanup *old_chain = 0;
|
char format = 0;
|
char format = 0;
|
struct value *val;
|
struct value *val;
|
struct format_data fmt;
|
struct format_data fmt;
|
int cleanup = 0;
|
int cleanup = 0;
|
|
|
if (exp && *exp == '/')
|
if (exp && *exp == '/')
|
{
|
{
|
exp++;
|
exp++;
|
fmt = decode_format (&exp, last_format, 0);
|
fmt = decode_format (&exp, last_format, 0);
|
validate_format (fmt, "print");
|
validate_format (fmt, "print");
|
last_format = format = fmt.format;
|
last_format = format = fmt.format;
|
}
|
}
|
else
|
else
|
{
|
{
|
fmt.count = 1;
|
fmt.count = 1;
|
fmt.format = 0;
|
fmt.format = 0;
|
fmt.size = 0;
|
fmt.size = 0;
|
fmt.raw = 0;
|
fmt.raw = 0;
|
}
|
}
|
|
|
if (exp && *exp)
|
if (exp && *exp)
|
{
|
{
|
struct type *type;
|
struct type *type;
|
expr = parse_expression (exp);
|
expr = parse_expression (exp);
|
old_chain = make_cleanup (free_current_contents, &expr);
|
old_chain = make_cleanup (free_current_contents, &expr);
|
cleanup = 1;
|
cleanup = 1;
|
val = evaluate_expression (expr);
|
val = evaluate_expression (expr);
|
}
|
}
|
else
|
else
|
val = access_value_history (0);
|
val = access_value_history (0);
|
|
|
if (voidprint || (val && value_type (val) &&
|
if (voidprint || (val && value_type (val) &&
|
TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
|
TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
|
{
|
{
|
struct value_print_options opts;
|
struct value_print_options opts;
|
int histindex = record_latest_value (val);
|
int histindex = record_latest_value (val);
|
|
|
if (histindex >= 0)
|
if (histindex >= 0)
|
annotate_value_history_begin (histindex, value_type (val));
|
annotate_value_history_begin (histindex, value_type (val));
|
else
|
else
|
annotate_value_begin (value_type (val));
|
annotate_value_begin (value_type (val));
|
|
|
if (inspect)
|
if (inspect)
|
printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"",
|
printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"",
|
exp, histindex);
|
exp, histindex);
|
else if (histindex >= 0)
|
else if (histindex >= 0)
|
printf_filtered ("$%d = ", histindex);
|
printf_filtered ("$%d = ", histindex);
|
|
|
if (histindex >= 0)
|
if (histindex >= 0)
|
annotate_value_history_value ();
|
annotate_value_history_value ();
|
|
|
get_formatted_print_options (&opts, format);
|
get_formatted_print_options (&opts, format);
|
opts.inspect_it = inspect;
|
opts.inspect_it = inspect;
|
opts.raw = fmt.raw;
|
opts.raw = fmt.raw;
|
|
|
print_formatted (val, fmt.size, &opts, gdb_stdout);
|
print_formatted (val, fmt.size, &opts, gdb_stdout);
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
|
|
if (histindex >= 0)
|
if (histindex >= 0)
|
annotate_value_history_end ();
|
annotate_value_history_end ();
|
else
|
else
|
annotate_value_end ();
|
annotate_value_end ();
|
|
|
if (inspect)
|
if (inspect)
|
printf_unfiltered ("\") )\030");
|
printf_unfiltered ("\") )\030");
|
}
|
}
|
|
|
if (cleanup)
|
if (cleanup)
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
static void
|
static void
|
print_command (char *exp, int from_tty)
|
print_command (char *exp, int from_tty)
|
{
|
{
|
print_command_1 (exp, 0, 1);
|
print_command_1 (exp, 0, 1);
|
}
|
}
|
|
|
/* Same as print, except in epoch, it gets its own window. */
|
/* Same as print, except in epoch, it gets its own window. */
|
static void
|
static void
|
inspect_command (char *exp, int from_tty)
|
inspect_command (char *exp, int from_tty)
|
{
|
{
|
extern int epoch_interface;
|
extern int epoch_interface;
|
|
|
print_command_1 (exp, epoch_interface, 1);
|
print_command_1 (exp, epoch_interface, 1);
|
}
|
}
|
|
|
/* Same as print, except it doesn't print void results. */
|
/* Same as print, except it doesn't print void results. */
|
static void
|
static void
|
call_command (char *exp, int from_tty)
|
call_command (char *exp, int from_tty)
|
{
|
{
|
print_command_1 (exp, 0, 0);
|
print_command_1 (exp, 0, 0);
|
}
|
}
|
|
|
void
|
void
|
output_command (char *exp, int from_tty)
|
output_command (char *exp, int from_tty)
|
{
|
{
|
struct expression *expr;
|
struct expression *expr;
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
char format = 0;
|
char format = 0;
|
struct value *val;
|
struct value *val;
|
struct format_data fmt;
|
struct format_data fmt;
|
struct value_print_options opts;
|
struct value_print_options opts;
|
|
|
fmt.size = 0;
|
fmt.size = 0;
|
fmt.raw = 0;
|
fmt.raw = 0;
|
|
|
if (exp && *exp == '/')
|
if (exp && *exp == '/')
|
{
|
{
|
exp++;
|
exp++;
|
fmt = decode_format (&exp, 0, 0);
|
fmt = decode_format (&exp, 0, 0);
|
validate_format (fmt, "output");
|
validate_format (fmt, "output");
|
format = fmt.format;
|
format = fmt.format;
|
}
|
}
|
|
|
expr = parse_expression (exp);
|
expr = parse_expression (exp);
|
old_chain = make_cleanup (free_current_contents, &expr);
|
old_chain = make_cleanup (free_current_contents, &expr);
|
|
|
val = evaluate_expression (expr);
|
val = evaluate_expression (expr);
|
|
|
annotate_value_begin (value_type (val));
|
annotate_value_begin (value_type (val));
|
|
|
get_formatted_print_options (&opts, format);
|
get_formatted_print_options (&opts, format);
|
opts.raw = fmt.raw;
|
opts.raw = fmt.raw;
|
print_formatted (val, fmt.size, &opts, gdb_stdout);
|
print_formatted (val, fmt.size, &opts, gdb_stdout);
|
|
|
annotate_value_end ();
|
annotate_value_end ();
|
|
|
wrap_here ("");
|
wrap_here ("");
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
|
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
static void
|
static void
|
set_command (char *exp, int from_tty)
|
set_command (char *exp, int from_tty)
|
{
|
{
|
struct expression *expr = parse_expression (exp);
|
struct expression *expr = parse_expression (exp);
|
struct cleanup *old_chain =
|
struct cleanup *old_chain =
|
make_cleanup (free_current_contents, &expr);
|
make_cleanup (free_current_contents, &expr);
|
evaluate_expression (expr);
|
evaluate_expression (expr);
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
static void
|
static void
|
sym_info (char *arg, int from_tty)
|
sym_info (char *arg, int from_tty)
|
{
|
{
|
struct minimal_symbol *msymbol;
|
struct minimal_symbol *msymbol;
|
struct objfile *objfile;
|
struct objfile *objfile;
|
struct obj_section *osect;
|
struct obj_section *osect;
|
CORE_ADDR addr, sect_addr;
|
CORE_ADDR addr, sect_addr;
|
int matches = 0;
|
int matches = 0;
|
unsigned int offset;
|
unsigned int offset;
|
|
|
if (!arg)
|
if (!arg)
|
error_no_arg (_("address"));
|
error_no_arg (_("address"));
|
|
|
addr = parse_and_eval_address (arg);
|
addr = parse_and_eval_address (arg);
|
ALL_OBJSECTIONS (objfile, osect)
|
ALL_OBJSECTIONS (objfile, osect)
|
{
|
{
|
/* Only process each object file once, even if there's a separate
|
/* Only process each object file once, even if there's a separate
|
debug file. */
|
debug file. */
|
if (objfile->separate_debug_objfile_backlink)
|
if (objfile->separate_debug_objfile_backlink)
|
continue;
|
continue;
|
|
|
sect_addr = overlay_mapped_address (addr, osect);
|
sect_addr = overlay_mapped_address (addr, osect);
|
|
|
if (obj_section_addr (osect) <= sect_addr
|
if (obj_section_addr (osect) <= sect_addr
|
&& sect_addr < obj_section_endaddr (osect)
|
&& sect_addr < obj_section_endaddr (osect)
|
&& (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, osect)))
|
&& (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, osect)))
|
{
|
{
|
const char *obj_name, *mapped, *sec_name, *msym_name;
|
const char *obj_name, *mapped, *sec_name, *msym_name;
|
char *loc_string;
|
char *loc_string;
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
|
|
matches = 1;
|
matches = 1;
|
offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
|
offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
|
mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped");
|
mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped");
|
sec_name = osect->the_bfd_section->name;
|
sec_name = osect->the_bfd_section->name;
|
msym_name = SYMBOL_PRINT_NAME (msymbol);
|
msym_name = SYMBOL_PRINT_NAME (msymbol);
|
|
|
/* Don't print the offset if it is zero.
|
/* Don't print the offset if it is zero.
|
We assume there's no need to handle i18n of "sym + offset". */
|
We assume there's no need to handle i18n of "sym + offset". */
|
if (offset)
|
if (offset)
|
loc_string = xstrprintf ("%s + %u", msym_name, offset);
|
loc_string = xstrprintf ("%s + %u", msym_name, offset);
|
else
|
else
|
loc_string = xstrprintf ("%s", msym_name);
|
loc_string = xstrprintf ("%s", msym_name);
|
|
|
/* Use a cleanup to free loc_string in case the user quits
|
/* Use a cleanup to free loc_string in case the user quits
|
a pagination request inside printf_filtered. */
|
a pagination request inside printf_filtered. */
|
old_chain = make_cleanup (xfree, loc_string);
|
old_chain = make_cleanup (xfree, loc_string);
|
|
|
gdb_assert (osect->objfile && osect->objfile->name);
|
gdb_assert (osect->objfile && osect->objfile->name);
|
obj_name = osect->objfile->name;
|
obj_name = osect->objfile->name;
|
|
|
if (MULTI_OBJFILE_P ())
|
if (MULTI_OBJFILE_P ())
|
if (pc_in_unmapped_range (addr, osect))
|
if (pc_in_unmapped_range (addr, osect))
|
if (section_is_overlay (osect))
|
if (section_is_overlay (osect))
|
printf_filtered (_("%s in load address range of "
|
printf_filtered (_("%s in load address range of "
|
"%s overlay section %s of %s\n"),
|
"%s overlay section %s of %s\n"),
|
loc_string, mapped, sec_name, obj_name);
|
loc_string, mapped, sec_name, obj_name);
|
else
|
else
|
printf_filtered (_("%s in load address range of "
|
printf_filtered (_("%s in load address range of "
|
"section %s of %s\n"),
|
"section %s of %s\n"),
|
loc_string, sec_name, obj_name);
|
loc_string, sec_name, obj_name);
|
else
|
else
|
if (section_is_overlay (osect))
|
if (section_is_overlay (osect))
|
printf_filtered (_("%s in %s overlay section %s of %s\n"),
|
printf_filtered (_("%s in %s overlay section %s of %s\n"),
|
loc_string, mapped, sec_name, obj_name);
|
loc_string, mapped, sec_name, obj_name);
|
else
|
else
|
printf_filtered (_("%s in section %s of %s\n"),
|
printf_filtered (_("%s in section %s of %s\n"),
|
loc_string, sec_name, obj_name);
|
loc_string, sec_name, obj_name);
|
else
|
else
|
if (pc_in_unmapped_range (addr, osect))
|
if (pc_in_unmapped_range (addr, osect))
|
if (section_is_overlay (osect))
|
if (section_is_overlay (osect))
|
printf_filtered (_("%s in load address range of %s overlay "
|
printf_filtered (_("%s in load address range of %s overlay "
|
"section %s\n"),
|
"section %s\n"),
|
loc_string, mapped, sec_name);
|
loc_string, mapped, sec_name);
|
else
|
else
|
printf_filtered (_("%s in load address range of section %s\n"),
|
printf_filtered (_("%s in load address range of section %s\n"),
|
loc_string, sec_name);
|
loc_string, sec_name);
|
else
|
else
|
if (section_is_overlay (osect))
|
if (section_is_overlay (osect))
|
printf_filtered (_("%s in %s overlay section %s\n"),
|
printf_filtered (_("%s in %s overlay section %s\n"),
|
loc_string, mapped, sec_name);
|
loc_string, mapped, sec_name);
|
else
|
else
|
printf_filtered (_("%s in section %s\n"),
|
printf_filtered (_("%s in section %s\n"),
|
loc_string, sec_name);
|
loc_string, sec_name);
|
|
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
}
|
}
|
if (matches == 0)
|
if (matches == 0)
|
printf_filtered (_("No symbol matches %s.\n"), arg);
|
printf_filtered (_("No symbol matches %s.\n"), arg);
|
}
|
}
|
|
|
static void
|
static void
|
address_info (char *exp, int from_tty)
|
address_info (char *exp, int from_tty)
|
{
|
{
|
struct gdbarch *gdbarch;
|
struct gdbarch *gdbarch;
|
int regno;
|
int regno;
|
struct symbol *sym;
|
struct symbol *sym;
|
struct minimal_symbol *msymbol;
|
struct minimal_symbol *msymbol;
|
long val;
|
long val;
|
struct obj_section *section;
|
struct obj_section *section;
|
CORE_ADDR load_addr;
|
CORE_ADDR load_addr;
|
int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero
|
int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero
|
if exp is a field of `this'. */
|
if exp is a field of `this'. */
|
|
|
if (exp == 0)
|
if (exp == 0)
|
error (_("Argument required."));
|
error (_("Argument required."));
|
|
|
sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN,
|
sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN,
|
&is_a_field_of_this);
|
&is_a_field_of_this);
|
if (sym == NULL)
|
if (sym == NULL)
|
{
|
{
|
if (is_a_field_of_this)
|
if (is_a_field_of_this)
|
{
|
{
|
printf_filtered ("Symbol \"");
|
printf_filtered ("Symbol \"");
|
fprintf_symbol_filtered (gdb_stdout, exp,
|
fprintf_symbol_filtered (gdb_stdout, exp,
|
current_language->la_language, DMGL_ANSI);
|
current_language->la_language, DMGL_ANSI);
|
printf_filtered ("\" is a field of the local class variable ");
|
printf_filtered ("\" is a field of the local class variable ");
|
if (current_language->la_language == language_objc)
|
if (current_language->la_language == language_objc)
|
printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
|
printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
|
else
|
else
|
printf_filtered ("`this'\n");
|
printf_filtered ("`this'\n");
|
return;
|
return;
|
}
|
}
|
|
|
msymbol = lookup_minimal_symbol (exp, NULL, NULL);
|
msymbol = lookup_minimal_symbol (exp, NULL, NULL);
|
|
|
if (msymbol != NULL)
|
if (msymbol != NULL)
|
{
|
{
|
gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
|
gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
|
load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
|
load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
|
|
|
printf_filtered ("Symbol \"");
|
printf_filtered ("Symbol \"");
|
fprintf_symbol_filtered (gdb_stdout, exp,
|
fprintf_symbol_filtered (gdb_stdout, exp,
|
current_language->la_language, DMGL_ANSI);
|
current_language->la_language, DMGL_ANSI);
|
printf_filtered ("\" is at ");
|
printf_filtered ("\" is at ");
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
printf_filtered (" in a file compiled without debugging");
|
printf_filtered (" in a file compiled without debugging");
|
section = SYMBOL_OBJ_SECTION (msymbol);
|
section = SYMBOL_OBJ_SECTION (msymbol);
|
if (section_is_overlay (section))
|
if (section_is_overlay (section))
|
{
|
{
|
load_addr = overlay_unmapped_address (load_addr, section);
|
load_addr = overlay_unmapped_address (load_addr, section);
|
printf_filtered (",\n -- loaded at ");
|
printf_filtered (",\n -- loaded at ");
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
printf_filtered (" in overlay section %s",
|
printf_filtered (" in overlay section %s",
|
section->the_bfd_section->name);
|
section->the_bfd_section->name);
|
}
|
}
|
printf_filtered (".\n");
|
printf_filtered (".\n");
|
}
|
}
|
else
|
else
|
error (_("No symbol \"%s\" in current context."), exp);
|
error (_("No symbol \"%s\" in current context."), exp);
|
return;
|
return;
|
}
|
}
|
|
|
printf_filtered ("Symbol \"");
|
printf_filtered ("Symbol \"");
|
fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym),
|
fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym),
|
current_language->la_language, DMGL_ANSI);
|
current_language->la_language, DMGL_ANSI);
|
printf_filtered ("\" is ");
|
printf_filtered ("\" is ");
|
val = SYMBOL_VALUE (sym);
|
val = SYMBOL_VALUE (sym);
|
section = SYMBOL_OBJ_SECTION (sym);
|
section = SYMBOL_OBJ_SECTION (sym);
|
gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
|
gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
|
|
|
switch (SYMBOL_CLASS (sym))
|
switch (SYMBOL_CLASS (sym))
|
{
|
{
|
case LOC_CONST:
|
case LOC_CONST:
|
case LOC_CONST_BYTES:
|
case LOC_CONST_BYTES:
|
printf_filtered ("constant");
|
printf_filtered ("constant");
|
break;
|
break;
|
|
|
case LOC_LABEL:
|
case LOC_LABEL:
|
printf_filtered ("a label at address ");
|
printf_filtered ("a label at address ");
|
load_addr = SYMBOL_VALUE_ADDRESS (sym);
|
load_addr = SYMBOL_VALUE_ADDRESS (sym);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
if (section_is_overlay (section))
|
if (section_is_overlay (section))
|
{
|
{
|
load_addr = overlay_unmapped_address (load_addr, section);
|
load_addr = overlay_unmapped_address (load_addr, section);
|
printf_filtered (",\n -- loaded at ");
|
printf_filtered (",\n -- loaded at ");
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
printf_filtered (" in overlay section %s",
|
printf_filtered (" in overlay section %s",
|
section->the_bfd_section->name);
|
section->the_bfd_section->name);
|
}
|
}
|
break;
|
break;
|
|
|
case LOC_COMPUTED:
|
case LOC_COMPUTED:
|
/* FIXME: cagney/2004-01-26: It should be possible to
|
/* FIXME: cagney/2004-01-26: It should be possible to
|
unconditionally call the SYMBOL_COMPUTED_OPS method when available.
|
unconditionally call the SYMBOL_COMPUTED_OPS method when available.
|
Unfortunately DWARF 2 stores the frame-base (instead of the
|
Unfortunately DWARF 2 stores the frame-base (instead of the
|
function) location in a function's symbol. Oops! For the
|
function) location in a function's symbol. Oops! For the
|
moment enable this when/where applicable. */
|
moment enable this when/where applicable. */
|
SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout);
|
SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout);
|
break;
|
break;
|
|
|
case LOC_REGISTER:
|
case LOC_REGISTER:
|
/* GDBARCH is the architecture associated with the objfile the symbol
|
/* GDBARCH is the architecture associated with the objfile the symbol
|
is defined in; the target architecture may be different, and may
|
is defined in; the target architecture may be different, and may
|
provide additional registers. However, we do not know the target
|
provide additional registers. However, we do not know the target
|
architecture at this point. We assume the objfile architecture
|
architecture at this point. We assume the objfile architecture
|
will contain all the standard registers that occur in debug info
|
will contain all the standard registers that occur in debug info
|
in that objfile. */
|
in that objfile. */
|
regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
|
regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
|
|
|
if (SYMBOL_IS_ARGUMENT (sym))
|
if (SYMBOL_IS_ARGUMENT (sym))
|
printf_filtered (_("an argument in register %s"),
|
printf_filtered (_("an argument in register %s"),
|
gdbarch_register_name (gdbarch, regno));
|
gdbarch_register_name (gdbarch, regno));
|
else
|
else
|
printf_filtered (_("a variable in register %s"),
|
printf_filtered (_("a variable in register %s"),
|
gdbarch_register_name (gdbarch, regno));
|
gdbarch_register_name (gdbarch, regno));
|
break;
|
break;
|
|
|
case LOC_STATIC:
|
case LOC_STATIC:
|
printf_filtered (_("static storage at address "));
|
printf_filtered (_("static storage at address "));
|
load_addr = SYMBOL_VALUE_ADDRESS (sym);
|
load_addr = SYMBOL_VALUE_ADDRESS (sym);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
if (section_is_overlay (section))
|
if (section_is_overlay (section))
|
{
|
{
|
load_addr = overlay_unmapped_address (load_addr, section);
|
load_addr = overlay_unmapped_address (load_addr, section);
|
printf_filtered (_(",\n -- loaded at "));
|
printf_filtered (_(",\n -- loaded at "));
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
printf_filtered (_(" in overlay section %s"),
|
printf_filtered (_(" in overlay section %s"),
|
section->the_bfd_section->name);
|
section->the_bfd_section->name);
|
}
|
}
|
break;
|
break;
|
|
|
case LOC_REGPARM_ADDR:
|
case LOC_REGPARM_ADDR:
|
/* Note comment at LOC_REGISTER. */
|
/* Note comment at LOC_REGISTER. */
|
regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
|
regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
|
printf_filtered (_("address of an argument in register %s"),
|
printf_filtered (_("address of an argument in register %s"),
|
gdbarch_register_name (gdbarch, regno));
|
gdbarch_register_name (gdbarch, regno));
|
break;
|
break;
|
|
|
case LOC_ARG:
|
case LOC_ARG:
|
printf_filtered (_("an argument at offset %ld"), val);
|
printf_filtered (_("an argument at offset %ld"), val);
|
break;
|
break;
|
|
|
case LOC_LOCAL:
|
case LOC_LOCAL:
|
printf_filtered (_("a local variable at frame offset %ld"), val);
|
printf_filtered (_("a local variable at frame offset %ld"), val);
|
break;
|
break;
|
|
|
case LOC_REF_ARG:
|
case LOC_REF_ARG:
|
printf_filtered (_("a reference argument at offset %ld"), val);
|
printf_filtered (_("a reference argument at offset %ld"), val);
|
break;
|
break;
|
|
|
case LOC_TYPEDEF:
|
case LOC_TYPEDEF:
|
printf_filtered (_("a typedef"));
|
printf_filtered (_("a typedef"));
|
break;
|
break;
|
|
|
case LOC_BLOCK:
|
case LOC_BLOCK:
|
printf_filtered (_("a function at address "));
|
printf_filtered (_("a function at address "));
|
load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
|
load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
if (section_is_overlay (section))
|
if (section_is_overlay (section))
|
{
|
{
|
load_addr = overlay_unmapped_address (load_addr, section);
|
load_addr = overlay_unmapped_address (load_addr, section);
|
printf_filtered (_(",\n -- loaded at "));
|
printf_filtered (_(",\n -- loaded at "));
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
printf_filtered (_(" in overlay section %s"),
|
printf_filtered (_(" in overlay section %s"),
|
section->the_bfd_section->name);
|
section->the_bfd_section->name);
|
}
|
}
|
break;
|
break;
|
|
|
case LOC_UNRESOLVED:
|
case LOC_UNRESOLVED:
|
{
|
{
|
struct minimal_symbol *msym;
|
struct minimal_symbol *msym;
|
|
|
msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), NULL, NULL);
|
msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), NULL, NULL);
|
if (msym == NULL)
|
if (msym == NULL)
|
printf_filtered ("unresolved");
|
printf_filtered ("unresolved");
|
else
|
else
|
{
|
{
|
section = SYMBOL_OBJ_SECTION (msym);
|
section = SYMBOL_OBJ_SECTION (msym);
|
load_addr = SYMBOL_VALUE_ADDRESS (msym);
|
load_addr = SYMBOL_VALUE_ADDRESS (msym);
|
|
|
if (section
|
if (section
|
&& (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
|
&& (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
|
printf_filtered (_("a thread-local variable at offset %s "
|
printf_filtered (_("a thread-local variable at offset %s "
|
"in the thread-local storage for `%s'"),
|
"in the thread-local storage for `%s'"),
|
paddress (gdbarch, load_addr),
|
paddress (gdbarch, load_addr),
|
section->objfile->name);
|
section->objfile->name);
|
else
|
else
|
{
|
{
|
printf_filtered (_("static storage at address "));
|
printf_filtered (_("static storage at address "));
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
if (section_is_overlay (section))
|
if (section_is_overlay (section))
|
{
|
{
|
load_addr = overlay_unmapped_address (load_addr, section);
|
load_addr = overlay_unmapped_address (load_addr, section);
|
printf_filtered (_(",\n -- loaded at "));
|
printf_filtered (_(",\n -- loaded at "));
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
|
printf_filtered (_(" in overlay section %s"),
|
printf_filtered (_(" in overlay section %s"),
|
section->the_bfd_section->name);
|
section->the_bfd_section->name);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case LOC_OPTIMIZED_OUT:
|
case LOC_OPTIMIZED_OUT:
|
printf_filtered (_("optimized out"));
|
printf_filtered (_("optimized out"));
|
break;
|
break;
|
|
|
default:
|
default:
|
printf_filtered (_("of unknown (botched) type"));
|
printf_filtered (_("of unknown (botched) type"));
|
break;
|
break;
|
}
|
}
|
printf_filtered (".\n");
|
printf_filtered (".\n");
|
}
|
}
|
|
|
|
|
static void
|
static void
|
x_command (char *exp, int from_tty)
|
x_command (char *exp, int from_tty)
|
{
|
{
|
struct expression *expr;
|
struct expression *expr;
|
struct format_data fmt;
|
struct format_data fmt;
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
struct value *val;
|
struct value *val;
|
|
|
fmt.format = last_format ? last_format : 'x';
|
fmt.format = last_format ? last_format : 'x';
|
fmt.size = last_size;
|
fmt.size = last_size;
|
fmt.count = 1;
|
fmt.count = 1;
|
fmt.raw = 0;
|
fmt.raw = 0;
|
|
|
if (exp && *exp == '/')
|
if (exp && *exp == '/')
|
{
|
{
|
exp++;
|
exp++;
|
fmt = decode_format (&exp, last_format, last_size);
|
fmt = decode_format (&exp, last_format, last_size);
|
}
|
}
|
|
|
/* If we have an expression, evaluate it and use it as the address. */
|
/* If we have an expression, evaluate it and use it as the address. */
|
|
|
if (exp != 0 && *exp != 0)
|
if (exp != 0 && *exp != 0)
|
{
|
{
|
expr = parse_expression (exp);
|
expr = parse_expression (exp);
|
/* Cause expression not to be there any more if this command is
|
/* Cause expression not to be there any more if this command is
|
repeated with Newline. But don't clobber a user-defined
|
repeated with Newline. But don't clobber a user-defined
|
command's definition. */
|
command's definition. */
|
if (from_tty)
|
if (from_tty)
|
*exp = 0;
|
*exp = 0;
|
old_chain = make_cleanup (free_current_contents, &expr);
|
old_chain = make_cleanup (free_current_contents, &expr);
|
val = evaluate_expression (expr);
|
val = evaluate_expression (expr);
|
if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
|
if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
|
val = value_ind (val);
|
val = value_ind (val);
|
/* In rvalue contexts, such as this, functions are coerced into
|
/* In rvalue contexts, such as this, functions are coerced into
|
pointers to functions. This makes "x/i main" work. */
|
pointers to functions. This makes "x/i main" work. */
|
if (/* last_format == 'i' && */
|
if (/* last_format == 'i' && */
|
TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
|
TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
|
&& VALUE_LVAL (val) == lval_memory)
|
&& VALUE_LVAL (val) == lval_memory)
|
next_address = value_address (val);
|
next_address = value_address (val);
|
else
|
else
|
next_address = value_as_address (val);
|
next_address = value_as_address (val);
|
|
|
next_gdbarch = expr->gdbarch;
|
next_gdbarch = expr->gdbarch;
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
if (!next_gdbarch)
|
if (!next_gdbarch)
|
error_no_arg (_("starting display address"));
|
error_no_arg (_("starting display address"));
|
|
|
do_examine (fmt, next_gdbarch, next_address);
|
do_examine (fmt, next_gdbarch, next_address);
|
|
|
/* If the examine succeeds, we remember its size and format for next
|
/* If the examine succeeds, we remember its size and format for next
|
time. */
|
time. */
|
last_size = fmt.size;
|
last_size = fmt.size;
|
last_format = fmt.format;
|
last_format = fmt.format;
|
|
|
/* Set a couple of internal variables if appropriate. */
|
/* Set a couple of internal variables if appropriate. */
|
if (last_examine_value)
|
if (last_examine_value)
|
{
|
{
|
/* Make last address examined available to the user as $_. Use
|
/* Make last address examined available to the user as $_. Use
|
the correct pointer type. */
|
the correct pointer type. */
|
struct type *pointer_type
|
struct type *pointer_type
|
= lookup_pointer_type (value_type (last_examine_value));
|
= lookup_pointer_type (value_type (last_examine_value));
|
set_internalvar (lookup_internalvar ("_"),
|
set_internalvar (lookup_internalvar ("_"),
|
value_from_pointer (pointer_type,
|
value_from_pointer (pointer_type,
|
last_examine_address));
|
last_examine_address));
|
|
|
/* Make contents of last address examined available to the user
|
/* Make contents of last address examined available to the user
|
as $__. If the last value has not been fetched from memory
|
as $__. If the last value has not been fetched from memory
|
then don't fetch it now; instead mark it by voiding the $__
|
then don't fetch it now; instead mark it by voiding the $__
|
variable. */
|
variable. */
|
if (value_lazy (last_examine_value))
|
if (value_lazy (last_examine_value))
|
clear_internalvar (lookup_internalvar ("__"));
|
clear_internalvar (lookup_internalvar ("__"));
|
else
|
else
|
set_internalvar (lookup_internalvar ("__"), last_examine_value);
|
set_internalvar (lookup_internalvar ("__"), last_examine_value);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Add an expression to the auto-display chain.
|
/* Add an expression to the auto-display chain.
|
Specify the expression. */
|
Specify the expression. */
|
|
|
static void
|
static void
|
display_command (char *exp, int from_tty)
|
display_command (char *exp, int from_tty)
|
{
|
{
|
struct format_data fmt;
|
struct format_data fmt;
|
struct expression *expr;
|
struct expression *expr;
|
struct display *new;
|
struct display *new;
|
int display_it = 1;
|
int display_it = 1;
|
|
|
#if defined(TUI)
|
#if defined(TUI)
|
/* NOTE: cagney/2003-02-13 The `tui_active' was previously
|
/* NOTE: cagney/2003-02-13 The `tui_active' was previously
|
`tui_version'. */
|
`tui_version'. */
|
if (tui_active && exp != NULL && *exp == '$')
|
if (tui_active && exp != NULL && *exp == '$')
|
display_it = (tui_set_layout_for_display_command (exp) == TUI_FAILURE);
|
display_it = (tui_set_layout_for_display_command (exp) == TUI_FAILURE);
|
#endif
|
#endif
|
|
|
if (display_it)
|
if (display_it)
|
{
|
{
|
if (exp == 0)
|
if (exp == 0)
|
{
|
{
|
do_displays ();
|
do_displays ();
|
return;
|
return;
|
}
|
}
|
|
|
if (*exp == '/')
|
if (*exp == '/')
|
{
|
{
|
exp++;
|
exp++;
|
fmt = decode_format (&exp, 0, 0);
|
fmt = decode_format (&exp, 0, 0);
|
if (fmt.size && fmt.format == 0)
|
if (fmt.size && fmt.format == 0)
|
fmt.format = 'x';
|
fmt.format = 'x';
|
if (fmt.format == 'i' || fmt.format == 's')
|
if (fmt.format == 'i' || fmt.format == 's')
|
fmt.size = 'b';
|
fmt.size = 'b';
|
}
|
}
|
else
|
else
|
{
|
{
|
fmt.format = 0;
|
fmt.format = 0;
|
fmt.size = 0;
|
fmt.size = 0;
|
fmt.count = 0;
|
fmt.count = 0;
|
fmt.raw = 0;
|
fmt.raw = 0;
|
}
|
}
|
|
|
innermost_block = NULL;
|
innermost_block = NULL;
|
expr = parse_expression (exp);
|
expr = parse_expression (exp);
|
|
|
new = (struct display *) xmalloc (sizeof (struct display));
|
new = (struct display *) xmalloc (sizeof (struct display));
|
|
|
new->exp_string = xstrdup (exp);
|
new->exp_string = xstrdup (exp);
|
new->exp = expr;
|
new->exp = expr;
|
new->block = innermost_block;
|
new->block = innermost_block;
|
new->pspace = current_program_space;
|
new->pspace = current_program_space;
|
new->next = display_chain;
|
new->next = display_chain;
|
new->number = ++display_number;
|
new->number = ++display_number;
|
new->format = fmt;
|
new->format = fmt;
|
new->enabled_p = 1;
|
new->enabled_p = 1;
|
display_chain = new;
|
display_chain = new;
|
|
|
if (from_tty && target_has_execution)
|
if (from_tty && target_has_execution)
|
do_one_display (new);
|
do_one_display (new);
|
|
|
dont_repeat ();
|
dont_repeat ();
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
free_display (struct display *d)
|
free_display (struct display *d)
|
{
|
{
|
xfree (d->exp_string);
|
xfree (d->exp_string);
|
xfree (d->exp);
|
xfree (d->exp);
|
xfree (d);
|
xfree (d);
|
}
|
}
|
|
|
/* Clear out the display_chain. Done when new symtabs are loaded,
|
/* Clear out the display_chain. Done when new symtabs are loaded,
|
since this invalidates the types stored in many expressions. */
|
since this invalidates the types stored in many expressions. */
|
|
|
void
|
void
|
clear_displays (void)
|
clear_displays (void)
|
{
|
{
|
struct display *d;
|
struct display *d;
|
|
|
while ((d = display_chain) != NULL)
|
while ((d = display_chain) != NULL)
|
{
|
{
|
display_chain = d->next;
|
display_chain = d->next;
|
free_display (d);
|
free_display (d);
|
}
|
}
|
}
|
}
|
|
|
/* Delete the auto-display number NUM. */
|
/* Delete the auto-display number NUM. */
|
|
|
static void
|
static void
|
delete_display (int num)
|
delete_display (int num)
|
{
|
{
|
struct display *d1, *d;
|
struct display *d1, *d;
|
|
|
if (!display_chain)
|
if (!display_chain)
|
error (_("No display number %d."), num);
|
error (_("No display number %d."), num);
|
|
|
if (display_chain->number == num)
|
if (display_chain->number == num)
|
{
|
{
|
d1 = display_chain;
|
d1 = display_chain;
|
display_chain = d1->next;
|
display_chain = d1->next;
|
free_display (d1);
|
free_display (d1);
|
}
|
}
|
else
|
else
|
for (d = display_chain;; d = d->next)
|
for (d = display_chain;; d = d->next)
|
{
|
{
|
if (d->next == 0)
|
if (d->next == 0)
|
error (_("No display number %d."), num);
|
error (_("No display number %d."), num);
|
if (d->next->number == num)
|
if (d->next->number == num)
|
{
|
{
|
d1 = d->next;
|
d1 = d->next;
|
d->next = d1->next;
|
d->next = d1->next;
|
free_display (d1);
|
free_display (d1);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Delete some values from the auto-display chain.
|
/* Delete some values from the auto-display chain.
|
Specify the element numbers. */
|
Specify the element numbers. */
|
|
|
static void
|
static void
|
undisplay_command (char *args, int from_tty)
|
undisplay_command (char *args, int from_tty)
|
{
|
{
|
char *p = args;
|
char *p = args;
|
char *p1;
|
char *p1;
|
int num;
|
int num;
|
|
|
if (args == 0)
|
if (args == 0)
|
{
|
{
|
if (query (_("Delete all auto-display expressions? ")))
|
if (query (_("Delete all auto-display expressions? ")))
|
clear_displays ();
|
clear_displays ();
|
dont_repeat ();
|
dont_repeat ();
|
return;
|
return;
|
}
|
}
|
|
|
while (*p)
|
while (*p)
|
{
|
{
|
p1 = p;
|
p1 = p;
|
while (*p1 >= '0' && *p1 <= '9')
|
while (*p1 >= '0' && *p1 <= '9')
|
p1++;
|
p1++;
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
error (_("Arguments must be display numbers."));
|
error (_("Arguments must be display numbers."));
|
|
|
num = atoi (p);
|
num = atoi (p);
|
|
|
delete_display (num);
|
delete_display (num);
|
|
|
p = p1;
|
p = p1;
|
while (*p == ' ' || *p == '\t')
|
while (*p == ' ' || *p == '\t')
|
p++;
|
p++;
|
}
|
}
|
dont_repeat ();
|
dont_repeat ();
|
}
|
}
|
|
|
/* Display a single auto-display.
|
/* Display a single auto-display.
|
Do nothing if the display cannot be printed in the current context,
|
Do nothing if the display cannot be printed in the current context,
|
or if the display is disabled. */
|
or if the display is disabled. */
|
|
|
static void
|
static void
|
do_one_display (struct display *d)
|
do_one_display (struct display *d)
|
{
|
{
|
int within_current_scope;
|
int within_current_scope;
|
|
|
if (d->enabled_p == 0)
|
if (d->enabled_p == 0)
|
return;
|
return;
|
|
|
/* The expression carries the architecture that was used at parse time.
|
/* The expression carries the architecture that was used at parse time.
|
This is a problem if the expression depends on architecture features
|
This is a problem if the expression depends on architecture features
|
(e.g. register numbers), and the current architecture is now different.
|
(e.g. register numbers), and the current architecture is now different.
|
For example, a display statement like "display/i $pc" is expected to
|
For example, a display statement like "display/i $pc" is expected to
|
display the PC register of the current architecture, not the arch at
|
display the PC register of the current architecture, not the arch at
|
the time the display command was given. Therefore, we re-parse the
|
the time the display command was given. Therefore, we re-parse the
|
expression if the current architecture has changed. */
|
expression if the current architecture has changed. */
|
if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
|
if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
|
{
|
{
|
xfree (d->exp);
|
xfree (d->exp);
|
d->exp = NULL;
|
d->exp = NULL;
|
d->block = NULL;
|
d->block = NULL;
|
}
|
}
|
|
|
if (d->exp == NULL)
|
if (d->exp == NULL)
|
{
|
{
|
volatile struct gdb_exception ex;
|
volatile struct gdb_exception ex;
|
TRY_CATCH (ex, RETURN_MASK_ALL)
|
TRY_CATCH (ex, RETURN_MASK_ALL)
|
{
|
{
|
innermost_block = NULL;
|
innermost_block = NULL;
|
d->exp = parse_expression (d->exp_string);
|
d->exp = parse_expression (d->exp_string);
|
d->block = innermost_block;
|
d->block = innermost_block;
|
}
|
}
|
if (ex.reason < 0)
|
if (ex.reason < 0)
|
{
|
{
|
/* Can't re-parse the expression. Disable this display item. */
|
/* Can't re-parse the expression. Disable this display item. */
|
d->enabled_p = 0;
|
d->enabled_p = 0;
|
warning (_("Unable to display \"%s\": %s"),
|
warning (_("Unable to display \"%s\": %s"),
|
d->exp_string, ex.message);
|
d->exp_string, ex.message);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
if (d->block)
|
if (d->block)
|
{
|
{
|
if (d->pspace == current_program_space)
|
if (d->pspace == current_program_space)
|
within_current_scope = contained_in (get_selected_block (0), d->block);
|
within_current_scope = contained_in (get_selected_block (0), d->block);
|
else
|
else
|
within_current_scope = 0;
|
within_current_scope = 0;
|
}
|
}
|
else
|
else
|
within_current_scope = 1;
|
within_current_scope = 1;
|
if (!within_current_scope)
|
if (!within_current_scope)
|
return;
|
return;
|
|
|
current_display_number = d->number;
|
current_display_number = d->number;
|
|
|
annotate_display_begin ();
|
annotate_display_begin ();
|
printf_filtered ("%d", d->number);
|
printf_filtered ("%d", d->number);
|
annotate_display_number_end ();
|
annotate_display_number_end ();
|
printf_filtered (": ");
|
printf_filtered (": ");
|
if (d->format.size)
|
if (d->format.size)
|
{
|
{
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
struct value *val;
|
struct value *val;
|
|
|
annotate_display_format ();
|
annotate_display_format ();
|
|
|
printf_filtered ("x/");
|
printf_filtered ("x/");
|
if (d->format.count != 1)
|
if (d->format.count != 1)
|
printf_filtered ("%d", d->format.count);
|
printf_filtered ("%d", d->format.count);
|
printf_filtered ("%c", d->format.format);
|
printf_filtered ("%c", d->format.format);
|
if (d->format.format != 'i' && d->format.format != 's')
|
if (d->format.format != 'i' && d->format.format != 's')
|
printf_filtered ("%c", d->format.size);
|
printf_filtered ("%c", d->format.size);
|
printf_filtered (" ");
|
printf_filtered (" ");
|
|
|
annotate_display_expression ();
|
annotate_display_expression ();
|
|
|
puts_filtered (d->exp_string);
|
puts_filtered (d->exp_string);
|
annotate_display_expression_end ();
|
annotate_display_expression_end ();
|
|
|
if (d->format.count != 1 || d->format.format == 'i')
|
if (d->format.count != 1 || d->format.format == 'i')
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
else
|
else
|
printf_filtered (" ");
|
printf_filtered (" ");
|
|
|
val = evaluate_expression (d->exp);
|
val = evaluate_expression (d->exp);
|
addr = value_as_address (val);
|
addr = value_as_address (val);
|
if (d->format.format == 'i')
|
if (d->format.format == 'i')
|
addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
|
addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
|
|
|
annotate_display_value ();
|
annotate_display_value ();
|
|
|
do_examine (d->format, d->exp->gdbarch, addr);
|
do_examine (d->format, d->exp->gdbarch, addr);
|
}
|
}
|
else
|
else
|
{
|
{
|
struct value_print_options opts;
|
struct value_print_options opts;
|
|
|
annotate_display_format ();
|
annotate_display_format ();
|
|
|
if (d->format.format)
|
if (d->format.format)
|
printf_filtered ("/%c ", d->format.format);
|
printf_filtered ("/%c ", d->format.format);
|
|
|
annotate_display_expression ();
|
annotate_display_expression ();
|
|
|
puts_filtered (d->exp_string);
|
puts_filtered (d->exp_string);
|
annotate_display_expression_end ();
|
annotate_display_expression_end ();
|
|
|
printf_filtered (" = ");
|
printf_filtered (" = ");
|
|
|
annotate_display_expression ();
|
annotate_display_expression ();
|
|
|
get_formatted_print_options (&opts, d->format.format);
|
get_formatted_print_options (&opts, d->format.format);
|
opts.raw = d->format.raw;
|
opts.raw = d->format.raw;
|
print_formatted (evaluate_expression (d->exp),
|
print_formatted (evaluate_expression (d->exp),
|
d->format.size, &opts, gdb_stdout);
|
d->format.size, &opts, gdb_stdout);
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
}
|
}
|
|
|
annotate_display_end ();
|
annotate_display_end ();
|
|
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
current_display_number = -1;
|
current_display_number = -1;
|
}
|
}
|
|
|
/* Display all of the values on the auto-display chain which can be
|
/* Display all of the values on the auto-display chain which can be
|
evaluated in the current scope. */
|
evaluated in the current scope. */
|
|
|
void
|
void
|
do_displays (void)
|
do_displays (void)
|
{
|
{
|
struct display *d;
|
struct display *d;
|
|
|
for (d = display_chain; d; d = d->next)
|
for (d = display_chain; d; d = d->next)
|
do_one_display (d);
|
do_one_display (d);
|
}
|
}
|
|
|
/* Delete the auto-display which we were in the process of displaying.
|
/* Delete the auto-display which we were in the process of displaying.
|
This is done when there is an error or a signal. */
|
This is done when there is an error or a signal. */
|
|
|
void
|
void
|
disable_display (int num)
|
disable_display (int num)
|
{
|
{
|
struct display *d;
|
struct display *d;
|
|
|
for (d = display_chain; d; d = d->next)
|
for (d = display_chain; d; d = d->next)
|
if (d->number == num)
|
if (d->number == num)
|
{
|
{
|
d->enabled_p = 0;
|
d->enabled_p = 0;
|
return;
|
return;
|
}
|
}
|
printf_unfiltered (_("No display number %d.\n"), num);
|
printf_unfiltered (_("No display number %d.\n"), num);
|
}
|
}
|
|
|
void
|
void
|
disable_current_display (void)
|
disable_current_display (void)
|
{
|
{
|
if (current_display_number >= 0)
|
if (current_display_number >= 0)
|
{
|
{
|
disable_display (current_display_number);
|
disable_display (current_display_number);
|
fprintf_unfiltered (gdb_stderr, _("\
|
fprintf_unfiltered (gdb_stderr, _("\
|
Disabling display %d to avoid infinite recursion.\n"),
|
Disabling display %d to avoid infinite recursion.\n"),
|
current_display_number);
|
current_display_number);
|
}
|
}
|
current_display_number = -1;
|
current_display_number = -1;
|
}
|
}
|
|
|
static void
|
static void
|
display_info (char *ignore, int from_tty)
|
display_info (char *ignore, int from_tty)
|
{
|
{
|
struct display *d;
|
struct display *d;
|
|
|
if (!display_chain)
|
if (!display_chain)
|
printf_unfiltered (_("There are no auto-display expressions now.\n"));
|
printf_unfiltered (_("There are no auto-display expressions now.\n"));
|
else
|
else
|
printf_filtered (_("Auto-display expressions now in effect:\n\
|
printf_filtered (_("Auto-display expressions now in effect:\n\
|
Num Enb Expression\n"));
|
Num Enb Expression\n"));
|
|
|
for (d = display_chain; d; d = d->next)
|
for (d = display_chain; d; d = d->next)
|
{
|
{
|
printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]);
|
printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]);
|
if (d->format.size)
|
if (d->format.size)
|
printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
|
printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
|
d->format.format);
|
d->format.format);
|
else if (d->format.format)
|
else if (d->format.format)
|
printf_filtered ("/%c ", d->format.format);
|
printf_filtered ("/%c ", d->format.format);
|
puts_filtered (d->exp_string);
|
puts_filtered (d->exp_string);
|
if (d->block && !contained_in (get_selected_block (0), d->block))
|
if (d->block && !contained_in (get_selected_block (0), d->block))
|
printf_filtered (_(" (cannot be evaluated in the current context)"));
|
printf_filtered (_(" (cannot be evaluated in the current context)"));
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
enable_display (char *args, int from_tty)
|
enable_display (char *args, int from_tty)
|
{
|
{
|
char *p = args;
|
char *p = args;
|
char *p1;
|
char *p1;
|
int num;
|
int num;
|
struct display *d;
|
struct display *d;
|
|
|
if (p == 0)
|
if (p == 0)
|
{
|
{
|
for (d = display_chain; d; d = d->next)
|
for (d = display_chain; d; d = d->next)
|
d->enabled_p = 1;
|
d->enabled_p = 1;
|
}
|
}
|
else
|
else
|
while (*p)
|
while (*p)
|
{
|
{
|
p1 = p;
|
p1 = p;
|
while (*p1 >= '0' && *p1 <= '9')
|
while (*p1 >= '0' && *p1 <= '9')
|
p1++;
|
p1++;
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
error (_("Arguments must be display numbers."));
|
error (_("Arguments must be display numbers."));
|
|
|
num = atoi (p);
|
num = atoi (p);
|
|
|
for (d = display_chain; d; d = d->next)
|
for (d = display_chain; d; d = d->next)
|
if (d->number == num)
|
if (d->number == num)
|
{
|
{
|
d->enabled_p = 1;
|
d->enabled_p = 1;
|
goto win;
|
goto win;
|
}
|
}
|
printf_unfiltered (_("No display number %d.\n"), num);
|
printf_unfiltered (_("No display number %d.\n"), num);
|
win:
|
win:
|
p = p1;
|
p = p1;
|
while (*p == ' ' || *p == '\t')
|
while (*p == ' ' || *p == '\t')
|
p++;
|
p++;
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
disable_display_command (char *args, int from_tty)
|
disable_display_command (char *args, int from_tty)
|
{
|
{
|
char *p = args;
|
char *p = args;
|
char *p1;
|
char *p1;
|
struct display *d;
|
struct display *d;
|
|
|
if (p == 0)
|
if (p == 0)
|
{
|
{
|
for (d = display_chain; d; d = d->next)
|
for (d = display_chain; d; d = d->next)
|
d->enabled_p = 0;
|
d->enabled_p = 0;
|
}
|
}
|
else
|
else
|
while (*p)
|
while (*p)
|
{
|
{
|
p1 = p;
|
p1 = p;
|
while (*p1 >= '0' && *p1 <= '9')
|
while (*p1 >= '0' && *p1 <= '9')
|
p1++;
|
p1++;
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
error (_("Arguments must be display numbers."));
|
error (_("Arguments must be display numbers."));
|
|
|
disable_display (atoi (p));
|
disable_display (atoi (p));
|
|
|
p = p1;
|
p = p1;
|
while (*p == ' ' || *p == '\t')
|
while (*p == ' ' || *p == '\t')
|
p++;
|
p++;
|
}
|
}
|
}
|
}
|
|
|
/* Return 1 if D uses SOLIB (and will become dangling when SOLIB
|
/* Return 1 if D uses SOLIB (and will become dangling when SOLIB
|
is unloaded), otherwise return 0. */
|
is unloaded), otherwise return 0. */
|
|
|
static int
|
static int
|
display_uses_solib_p (const struct display *d,
|
display_uses_solib_p (const struct display *d,
|
const struct so_list *solib)
|
const struct so_list *solib)
|
{
|
{
|
int endpos;
|
int endpos;
|
struct expression *const exp = d->exp;
|
struct expression *const exp = d->exp;
|
const union exp_element *const elts = exp->elts;
|
const union exp_element *const elts = exp->elts;
|
|
|
if (d->block != NULL
|
if (d->block != NULL
|
&& d->pspace == solib->pspace
|
&& d->pspace == solib->pspace
|
&& solib_contains_address_p (solib, d->block->startaddr))
|
&& solib_contains_address_p (solib, d->block->startaddr))
|
return 1;
|
return 1;
|
|
|
for (endpos = exp->nelts; endpos > 0; )
|
for (endpos = exp->nelts; endpos > 0; )
|
{
|
{
|
int i, args, oplen = 0;
|
int i, args, oplen = 0;
|
|
|
exp->language_defn->la_exp_desc->operator_length (exp, endpos,
|
exp->language_defn->la_exp_desc->operator_length (exp, endpos,
|
&oplen, &args);
|
&oplen, &args);
|
gdb_assert (oplen > 0);
|
gdb_assert (oplen > 0);
|
|
|
i = endpos - oplen;
|
i = endpos - oplen;
|
if (elts[i].opcode == OP_VAR_VALUE)
|
if (elts[i].opcode == OP_VAR_VALUE)
|
{
|
{
|
const struct block *const block = elts[i + 1].block;
|
const struct block *const block = elts[i + 1].block;
|
const struct symbol *const symbol = elts[i + 2].symbol;
|
const struct symbol *const symbol = elts[i + 2].symbol;
|
|
|
if (block != NULL
|
if (block != NULL
|
&& solib_contains_address_p (solib,
|
&& solib_contains_address_p (solib,
|
block->startaddr))
|
block->startaddr))
|
return 1;
|
return 1;
|
|
|
/* SYMBOL_OBJ_SECTION (symbol) may be NULL. */
|
/* SYMBOL_OBJ_SECTION (symbol) may be NULL. */
|
if (SYMBOL_SYMTAB (symbol)->objfile == solib->objfile)
|
if (SYMBOL_SYMTAB (symbol)->objfile == solib->objfile)
|
return 1;
|
return 1;
|
}
|
}
|
endpos -= oplen;
|
endpos -= oplen;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* display_chain items point to blocks and expressions. Some expressions in
|
/* display_chain items point to blocks and expressions. Some expressions in
|
turn may point to symbols.
|
turn may point to symbols.
|
Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
|
Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
|
obstack_free'd when a shared library is unloaded.
|
obstack_free'd when a shared library is unloaded.
|
Clear pointers that are about to become dangling.
|
Clear pointers that are about to become dangling.
|
Both .exp and .block fields will be restored next time we need to display
|
Both .exp and .block fields will be restored next time we need to display
|
an item by re-parsing .exp_string field in the new execution context. */
|
an item by re-parsing .exp_string field in the new execution context. */
|
|
|
static void
|
static void
|
clear_dangling_display_expressions (struct so_list *solib)
|
clear_dangling_display_expressions (struct so_list *solib)
|
{
|
{
|
struct display *d;
|
struct display *d;
|
struct objfile *objfile = NULL;
|
struct objfile *objfile = NULL;
|
|
|
for (d = display_chain; d; d = d->next)
|
for (d = display_chain; d; d = d->next)
|
{
|
{
|
if (d->exp && display_uses_solib_p (d, solib))
|
if (d->exp && display_uses_solib_p (d, solib))
|
{
|
{
|
xfree (d->exp);
|
xfree (d->exp);
|
d->exp = NULL;
|
d->exp = NULL;
|
d->block = NULL;
|
d->block = NULL;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Print the value in stack frame FRAME of a variable specified by a
|
/* Print the value in stack frame FRAME of a variable specified by a
|
struct symbol. NAME is the name to print; if NULL then VAR's print
|
struct symbol. NAME is the name to print; if NULL then VAR's print
|
name will be used. STREAM is the ui_file on which to print the
|
name will be used. STREAM is the ui_file on which to print the
|
value. INDENT specifies the number of indent levels to print
|
value. INDENT specifies the number of indent levels to print
|
before printing the variable name. */
|
before printing the variable name. */
|
|
|
void
|
void
|
print_variable_and_value (const char *name, struct symbol *var,
|
print_variable_and_value (const char *name, struct symbol *var,
|
struct frame_info *frame,
|
struct frame_info *frame,
|
struct ui_file *stream, int indent)
|
struct ui_file *stream, int indent)
|
{
|
{
|
struct value *val;
|
struct value *val;
|
struct value_print_options opts;
|
struct value_print_options opts;
|
|
|
if (!name)
|
if (!name)
|
name = SYMBOL_PRINT_NAME (var);
|
name = SYMBOL_PRINT_NAME (var);
|
|
|
fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
|
fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
|
|
|
val = read_var_value (var, frame);
|
val = read_var_value (var, frame);
|
get_user_print_options (&opts);
|
get_user_print_options (&opts);
|
common_val_print (val, stream, indent, &opts, current_language);
|
common_val_print (val, stream, indent, &opts, current_language);
|
fprintf_filtered (stream, "\n");
|
fprintf_filtered (stream, "\n");
|
}
|
}
|
|
|
static void
|
static void
|
printf_command (char *arg, int from_tty)
|
printf_command (char *arg, int from_tty)
|
{
|
{
|
char *f = NULL;
|
char *f = NULL;
|
char *s = arg;
|
char *s = arg;
|
char *string = NULL;
|
char *string = NULL;
|
struct value **val_args;
|
struct value **val_args;
|
char *substrings;
|
char *substrings;
|
char *current_substring;
|
char *current_substring;
|
int nargs = 0;
|
int nargs = 0;
|
int allocated_args = 20;
|
int allocated_args = 20;
|
struct cleanup *old_cleanups;
|
struct cleanup *old_cleanups;
|
|
|
val_args = xmalloc (allocated_args * sizeof (struct value *));
|
val_args = xmalloc (allocated_args * sizeof (struct value *));
|
old_cleanups = make_cleanup (free_current_contents, &val_args);
|
old_cleanups = make_cleanup (free_current_contents, &val_args);
|
|
|
if (s == 0)
|
if (s == 0)
|
error_no_arg (_("format-control string and values to print"));
|
error_no_arg (_("format-control string and values to print"));
|
|
|
/* Skip white space before format string */
|
/* Skip white space before format string */
|
while (*s == ' ' || *s == '\t')
|
while (*s == ' ' || *s == '\t')
|
s++;
|
s++;
|
|
|
/* A format string should follow, enveloped in double quotes. */
|
/* A format string should follow, enveloped in double quotes. */
|
if (*s++ != '"')
|
if (*s++ != '"')
|
error (_("Bad format string, missing '\"'."));
|
error (_("Bad format string, missing '\"'."));
|
|
|
/* Parse the format-control string and copy it into the string STRING,
|
/* Parse the format-control string and copy it into the string STRING,
|
processing some kinds of escape sequence. */
|
processing some kinds of escape sequence. */
|
|
|
f = string = (char *) alloca (strlen (s) + 1);
|
f = string = (char *) alloca (strlen (s) + 1);
|
|
|
while (*s != '"')
|
while (*s != '"')
|
{
|
{
|
int c = *s++;
|
int c = *s++;
|
switch (c)
|
switch (c)
|
{
|
{
|
case '\0':
|
case '\0':
|
error (_("Bad format string, non-terminated '\"'."));
|
error (_("Bad format string, non-terminated '\"'."));
|
|
|
case '\\':
|
case '\\':
|
switch (c = *s++)
|
switch (c = *s++)
|
{
|
{
|
case '\\':
|
case '\\':
|
*f++ = '\\';
|
*f++ = '\\';
|
break;
|
break;
|
case 'a':
|
case 'a':
|
*f++ = '\a';
|
*f++ = '\a';
|
break;
|
break;
|
case 'b':
|
case 'b':
|
*f++ = '\b';
|
*f++ = '\b';
|
break;
|
break;
|
case 'f':
|
case 'f':
|
*f++ = '\f';
|
*f++ = '\f';
|
break;
|
break;
|
case 'n':
|
case 'n':
|
*f++ = '\n';
|
*f++ = '\n';
|
break;
|
break;
|
case 'r':
|
case 'r':
|
*f++ = '\r';
|
*f++ = '\r';
|
break;
|
break;
|
case 't':
|
case 't':
|
*f++ = '\t';
|
*f++ = '\t';
|
break;
|
break;
|
case 'v':
|
case 'v':
|
*f++ = '\v';
|
*f++ = '\v';
|
break;
|
break;
|
case '"':
|
case '"':
|
*f++ = '"';
|
*f++ = '"';
|
break;
|
break;
|
default:
|
default:
|
/* ??? TODO: handle other escape sequences */
|
/* ??? TODO: handle other escape sequences */
|
error (_("Unrecognized escape character \\%c in format string."),
|
error (_("Unrecognized escape character \\%c in format string."),
|
c);
|
c);
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
*f++ = c;
|
*f++ = c;
|
}
|
}
|
}
|
}
|
|
|
/* Skip over " and following space and comma. */
|
/* Skip over " and following space and comma. */
|
s++;
|
s++;
|
*f++ = '\0';
|
*f++ = '\0';
|
while (*s == ' ' || *s == '\t')
|
while (*s == ' ' || *s == '\t')
|
s++;
|
s++;
|
|
|
if (*s != ',' && *s != 0)
|
if (*s != ',' && *s != 0)
|
error (_("Invalid argument syntax"));
|
error (_("Invalid argument syntax"));
|
|
|
if (*s == ',')
|
if (*s == ',')
|
s++;
|
s++;
|
while (*s == ' ' || *s == '\t')
|
while (*s == ' ' || *s == '\t')
|
s++;
|
s++;
|
|
|
/* Need extra space for the '\0's. Doubling the size is sufficient. */
|
/* Need extra space for the '\0's. Doubling the size is sufficient. */
|
substrings = alloca (strlen (string) * 2);
|
substrings = alloca (strlen (string) * 2);
|
current_substring = substrings;
|
current_substring = substrings;
|
|
|
{
|
{
|
/* Now scan the string for %-specs and see what kinds of args they want.
|
/* Now scan the string for %-specs and see what kinds of args they want.
|
argclass[I] classifies the %-specs so we can give printf_filtered
|
argclass[I] classifies the %-specs so we can give printf_filtered
|
something of the right size. */
|
something of the right size. */
|
|
|
enum argclass
|
enum argclass
|
{
|
{
|
int_arg, long_arg, long_long_arg, ptr_arg,
|
int_arg, long_arg, long_long_arg, ptr_arg,
|
string_arg, wide_string_arg, wide_char_arg,
|
string_arg, wide_string_arg, wide_char_arg,
|
double_arg, long_double_arg, decfloat_arg
|
double_arg, long_double_arg, decfloat_arg
|
};
|
};
|
enum argclass *argclass;
|
enum argclass *argclass;
|
enum argclass this_argclass;
|
enum argclass this_argclass;
|
char *last_arg;
|
char *last_arg;
|
int nargs_wanted;
|
int nargs_wanted;
|
int i;
|
int i;
|
|
|
argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
|
argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
|
nargs_wanted = 0;
|
nargs_wanted = 0;
|
f = string;
|
f = string;
|
last_arg = string;
|
last_arg = string;
|
while (*f)
|
while (*f)
|
if (*f++ == '%')
|
if (*f++ == '%')
|
{
|
{
|
int seen_hash = 0, seen_zero = 0, lcount = 0, seen_prec = 0;
|
int seen_hash = 0, seen_zero = 0, lcount = 0, seen_prec = 0;
|
int seen_space = 0, seen_plus = 0;
|
int seen_space = 0, seen_plus = 0;
|
int seen_big_l = 0, seen_h = 0, seen_big_h = 0;
|
int seen_big_l = 0, seen_h = 0, seen_big_h = 0;
|
int seen_big_d = 0, seen_double_big_d = 0;
|
int seen_big_d = 0, seen_double_big_d = 0;
|
int bad = 0;
|
int bad = 0;
|
|
|
/* Check the validity of the format specifier, and work
|
/* Check the validity of the format specifier, and work
|
out what argument it expects. We only accept C89
|
out what argument it expects. We only accept C89
|
format strings, with the exception of long long (which
|
format strings, with the exception of long long (which
|
we autoconf for). */
|
we autoconf for). */
|
|
|
/* Skip over "%%". */
|
/* Skip over "%%". */
|
if (*f == '%')
|
if (*f == '%')
|
{
|
{
|
f++;
|
f++;
|
continue;
|
continue;
|
}
|
}
|
|
|
/* The first part of a format specifier is a set of flag
|
/* The first part of a format specifier is a set of flag
|
characters. */
|
characters. */
|
while (strchr ("0-+ #", *f))
|
while (strchr ("0-+ #", *f))
|
{
|
{
|
if (*f == '#')
|
if (*f == '#')
|
seen_hash = 1;
|
seen_hash = 1;
|
else if (*f == '0')
|
else if (*f == '0')
|
seen_zero = 1;
|
seen_zero = 1;
|
else if (*f == ' ')
|
else if (*f == ' ')
|
seen_space = 1;
|
seen_space = 1;
|
else if (*f == '+')
|
else if (*f == '+')
|
seen_plus = 1;
|
seen_plus = 1;
|
f++;
|
f++;
|
}
|
}
|
|
|
/* The next part of a format specifier is a width. */
|
/* The next part of a format specifier is a width. */
|
while (strchr ("0123456789", *f))
|
while (strchr ("0123456789", *f))
|
f++;
|
f++;
|
|
|
/* The next part of a format specifier is a precision. */
|
/* The next part of a format specifier is a precision. */
|
if (*f == '.')
|
if (*f == '.')
|
{
|
{
|
seen_prec = 1;
|
seen_prec = 1;
|
f++;
|
f++;
|
while (strchr ("0123456789", *f))
|
while (strchr ("0123456789", *f))
|
f++;
|
f++;
|
}
|
}
|
|
|
/* The next part of a format specifier is a length modifier. */
|
/* The next part of a format specifier is a length modifier. */
|
if (*f == 'h')
|
if (*f == 'h')
|
{
|
{
|
seen_h = 1;
|
seen_h = 1;
|
f++;
|
f++;
|
}
|
}
|
else if (*f == 'l')
|
else if (*f == 'l')
|
{
|
{
|
f++;
|
f++;
|
lcount++;
|
lcount++;
|
if (*f == 'l')
|
if (*f == 'l')
|
{
|
{
|
f++;
|
f++;
|
lcount++;
|
lcount++;
|
}
|
}
|
}
|
}
|
else if (*f == 'L')
|
else if (*f == 'L')
|
{
|
{
|
seen_big_l = 1;
|
seen_big_l = 1;
|
f++;
|
f++;
|
}
|
}
|
/* Decimal32 modifier. */
|
/* Decimal32 modifier. */
|
else if (*f == 'H')
|
else if (*f == 'H')
|
{
|
{
|
seen_big_h = 1;
|
seen_big_h = 1;
|
f++;
|
f++;
|
}
|
}
|
/* Decimal64 and Decimal128 modifiers. */
|
/* Decimal64 and Decimal128 modifiers. */
|
else if (*f == 'D')
|
else if (*f == 'D')
|
{
|
{
|
f++;
|
f++;
|
|
|
/* Check for a Decimal128. */
|
/* Check for a Decimal128. */
|
if (*f == 'D')
|
if (*f == 'D')
|
{
|
{
|
f++;
|
f++;
|
seen_double_big_d = 1;
|
seen_double_big_d = 1;
|
}
|
}
|
else
|
else
|
seen_big_d = 1;
|
seen_big_d = 1;
|
}
|
}
|
|
|
switch (*f)
|
switch (*f)
|
{
|
{
|
case 'u':
|
case 'u':
|
if (seen_hash)
|
if (seen_hash)
|
bad = 1;
|
bad = 1;
|
/* FALLTHROUGH */
|
/* FALLTHROUGH */
|
|
|
case 'o':
|
case 'o':
|
case 'x':
|
case 'x':
|
case 'X':
|
case 'X':
|
if (seen_space || seen_plus)
|
if (seen_space || seen_plus)
|
bad = 1;
|
bad = 1;
|
/* FALLTHROUGH */
|
/* FALLTHROUGH */
|
|
|
case 'd':
|
case 'd':
|
case 'i':
|
case 'i':
|
if (lcount == 0)
|
if (lcount == 0)
|
this_argclass = int_arg;
|
this_argclass = int_arg;
|
else if (lcount == 1)
|
else if (lcount == 1)
|
this_argclass = long_arg;
|
this_argclass = long_arg;
|
else
|
else
|
this_argclass = long_long_arg;
|
this_argclass = long_long_arg;
|
|
|
if (seen_big_l)
|
if (seen_big_l)
|
bad = 1;
|
bad = 1;
|
break;
|
break;
|
|
|
case 'c':
|
case 'c':
|
this_argclass = lcount == 0 ? int_arg : wide_char_arg;
|
this_argclass = lcount == 0 ? int_arg : wide_char_arg;
|
if (lcount > 1 || seen_h || seen_big_l)
|
if (lcount > 1 || seen_h || seen_big_l)
|
bad = 1;
|
bad = 1;
|
if (seen_prec || seen_zero || seen_space || seen_plus)
|
if (seen_prec || seen_zero || seen_space || seen_plus)
|
bad = 1;
|
bad = 1;
|
break;
|
break;
|
|
|
case 'p':
|
case 'p':
|
this_argclass = ptr_arg;
|
this_argclass = ptr_arg;
|
if (lcount || seen_h || seen_big_l)
|
if (lcount || seen_h || seen_big_l)
|
bad = 1;
|
bad = 1;
|
if (seen_prec || seen_zero || seen_space || seen_plus)
|
if (seen_prec || seen_zero || seen_space || seen_plus)
|
bad = 1;
|
bad = 1;
|
break;
|
break;
|
|
|
case 's':
|
case 's':
|
this_argclass = lcount == 0 ? string_arg : wide_string_arg;
|
this_argclass = lcount == 0 ? string_arg : wide_string_arg;
|
if (lcount > 1 || seen_h || seen_big_l)
|
if (lcount > 1 || seen_h || seen_big_l)
|
bad = 1;
|
bad = 1;
|
if (seen_zero || seen_space || seen_plus)
|
if (seen_zero || seen_space || seen_plus)
|
bad = 1;
|
bad = 1;
|
break;
|
break;
|
|
|
case 'e':
|
case 'e':
|
case 'f':
|
case 'f':
|
case 'g':
|
case 'g':
|
case 'E':
|
case 'E':
|
case 'G':
|
case 'G':
|
if (seen_big_h || seen_big_d || seen_double_big_d)
|
if (seen_big_h || seen_big_d || seen_double_big_d)
|
this_argclass = decfloat_arg;
|
this_argclass = decfloat_arg;
|
else if (seen_big_l)
|
else if (seen_big_l)
|
this_argclass = long_double_arg;
|
this_argclass = long_double_arg;
|
else
|
else
|
this_argclass = double_arg;
|
this_argclass = double_arg;
|
|
|
if (lcount || seen_h)
|
if (lcount || seen_h)
|
bad = 1;
|
bad = 1;
|
break;
|
break;
|
|
|
case '*':
|
case '*':
|
error (_("`*' not supported for precision or width in printf"));
|
error (_("`*' not supported for precision or width in printf"));
|
|
|
case 'n':
|
case 'n':
|
error (_("Format specifier `n' not supported in printf"));
|
error (_("Format specifier `n' not supported in printf"));
|
|
|
case '\0':
|
case '\0':
|
error (_("Incomplete format specifier at end of format string"));
|
error (_("Incomplete format specifier at end of format string"));
|
|
|
default:
|
default:
|
error (_("Unrecognized format specifier '%c' in printf"), *f);
|
error (_("Unrecognized format specifier '%c' in printf"), *f);
|
}
|
}
|
|
|
if (bad)
|
if (bad)
|
error (_("Inappropriate modifiers to format specifier '%c' in printf"),
|
error (_("Inappropriate modifiers to format specifier '%c' in printf"),
|
*f);
|
*f);
|
|
|
f++;
|
f++;
|
|
|
if (lcount > 1 && USE_PRINTF_I64)
|
if (lcount > 1 && USE_PRINTF_I64)
|
{
|
{
|
/* Windows' printf does support long long, but not the usual way.
|
/* Windows' printf does support long long, but not the usual way.
|
Convert %lld to %I64d. */
|
Convert %lld to %I64d. */
|
int length_before_ll = f - last_arg - 1 - lcount;
|
int length_before_ll = f - last_arg - 1 - lcount;
|
strncpy (current_substring, last_arg, length_before_ll);
|
strncpy (current_substring, last_arg, length_before_ll);
|
strcpy (current_substring + length_before_ll, "I64");
|
strcpy (current_substring + length_before_ll, "I64");
|
current_substring[length_before_ll + 3] =
|
current_substring[length_before_ll + 3] =
|
last_arg[length_before_ll + lcount];
|
last_arg[length_before_ll + lcount];
|
current_substring += length_before_ll + 4;
|
current_substring += length_before_ll + 4;
|
}
|
}
|
else if (this_argclass == wide_string_arg
|
else if (this_argclass == wide_string_arg
|
|| this_argclass == wide_char_arg)
|
|| this_argclass == wide_char_arg)
|
{
|
{
|
/* Convert %ls or %lc to %s. */
|
/* Convert %ls or %lc to %s. */
|
int length_before_ls = f - last_arg - 2;
|
int length_before_ls = f - last_arg - 2;
|
strncpy (current_substring, last_arg, length_before_ls);
|
strncpy (current_substring, last_arg, length_before_ls);
|
strcpy (current_substring + length_before_ls, "s");
|
strcpy (current_substring + length_before_ls, "s");
|
current_substring += length_before_ls + 2;
|
current_substring += length_before_ls + 2;
|
}
|
}
|
else
|
else
|
{
|
{
|
strncpy (current_substring, last_arg, f - last_arg);
|
strncpy (current_substring, last_arg, f - last_arg);
|
current_substring += f - last_arg;
|
current_substring += f - last_arg;
|
}
|
}
|
*current_substring++ = '\0';
|
*current_substring++ = '\0';
|
last_arg = f;
|
last_arg = f;
|
argclass[nargs_wanted++] = this_argclass;
|
argclass[nargs_wanted++] = this_argclass;
|
}
|
}
|
|
|
/* Now, parse all arguments and evaluate them.
|
/* Now, parse all arguments and evaluate them.
|
Store the VALUEs in VAL_ARGS. */
|
Store the VALUEs in VAL_ARGS. */
|
|
|
while (*s != '\0')
|
while (*s != '\0')
|
{
|
{
|
char *s1;
|
char *s1;
|
if (nargs == allocated_args)
|
if (nargs == allocated_args)
|
val_args = (struct value **) xrealloc ((char *) val_args,
|
val_args = (struct value **) xrealloc ((char *) val_args,
|
(allocated_args *= 2)
|
(allocated_args *= 2)
|
* sizeof (struct value *));
|
* sizeof (struct value *));
|
s1 = s;
|
s1 = s;
|
val_args[nargs] = parse_to_comma_and_eval (&s1);
|
val_args[nargs] = parse_to_comma_and_eval (&s1);
|
|
|
nargs++;
|
nargs++;
|
s = s1;
|
s = s1;
|
if (*s == ',')
|
if (*s == ',')
|
s++;
|
s++;
|
}
|
}
|
|
|
if (nargs != nargs_wanted)
|
if (nargs != nargs_wanted)
|
error (_("Wrong number of arguments for specified format-string"));
|
error (_("Wrong number of arguments for specified format-string"));
|
|
|
/* Now actually print them. */
|
/* Now actually print them. */
|
current_substring = substrings;
|
current_substring = substrings;
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
{
|
{
|
switch (argclass[i])
|
switch (argclass[i])
|
{
|
{
|
case string_arg:
|
case string_arg:
|
{
|
{
|
gdb_byte *str;
|
gdb_byte *str;
|
CORE_ADDR tem;
|
CORE_ADDR tem;
|
int j;
|
int j;
|
tem = value_as_address (val_args[i]);
|
tem = value_as_address (val_args[i]);
|
|
|
/* This is a %s argument. Find the length of the string. */
|
/* This is a %s argument. Find the length of the string. */
|
for (j = 0;; j++)
|
for (j = 0;; j++)
|
{
|
{
|
gdb_byte c;
|
gdb_byte c;
|
QUIT;
|
QUIT;
|
read_memory (tem + j, &c, 1);
|
read_memory (tem + j, &c, 1);
|
if (c == 0)
|
if (c == 0)
|
break;
|
break;
|
}
|
}
|
|
|
/* Copy the string contents into a string inside GDB. */
|
/* Copy the string contents into a string inside GDB. */
|
str = (gdb_byte *) alloca (j + 1);
|
str = (gdb_byte *) alloca (j + 1);
|
if (j != 0)
|
if (j != 0)
|
read_memory (tem, str, j);
|
read_memory (tem, str, j);
|
str[j] = 0;
|
str[j] = 0;
|
|
|
printf_filtered (current_substring, (char *) str);
|
printf_filtered (current_substring, (char *) str);
|
}
|
}
|
break;
|
break;
|
case wide_string_arg:
|
case wide_string_arg:
|
{
|
{
|
gdb_byte *str;
|
gdb_byte *str;
|
CORE_ADDR tem;
|
CORE_ADDR tem;
|
int j;
|
int j;
|
struct gdbarch *gdbarch
|
struct gdbarch *gdbarch
|
= get_type_arch (value_type (val_args[i]));
|
= get_type_arch (value_type (val_args[i]));
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
struct type *wctype = lookup_typename (current_language, gdbarch,
|
struct type *wctype = lookup_typename (current_language, gdbarch,
|
"wchar_t", NULL, 0);
|
"wchar_t", NULL, 0);
|
int wcwidth = TYPE_LENGTH (wctype);
|
int wcwidth = TYPE_LENGTH (wctype);
|
gdb_byte *buf = alloca (wcwidth);
|
gdb_byte *buf = alloca (wcwidth);
|
struct obstack output;
|
struct obstack output;
|
struct cleanup *inner_cleanup;
|
struct cleanup *inner_cleanup;
|
|
|
tem = value_as_address (val_args[i]);
|
tem = value_as_address (val_args[i]);
|
|
|
/* This is a %s argument. Find the length of the string. */
|
/* This is a %s argument. Find the length of the string. */
|
for (j = 0;; j += wcwidth)
|
for (j = 0;; j += wcwidth)
|
{
|
{
|
QUIT;
|
QUIT;
|
read_memory (tem + j, buf, wcwidth);
|
read_memory (tem + j, buf, wcwidth);
|
if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
|
if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
|
break;
|
break;
|
}
|
}
|
|
|
/* Copy the string contents into a string inside GDB. */
|
/* Copy the string contents into a string inside GDB. */
|
str = (gdb_byte *) alloca (j + wcwidth);
|
str = (gdb_byte *) alloca (j + wcwidth);
|
if (j != 0)
|
if (j != 0)
|
read_memory (tem, str, j);
|
read_memory (tem, str, j);
|
memset (&str[j], 0, wcwidth);
|
memset (&str[j], 0, wcwidth);
|
|
|
obstack_init (&output);
|
obstack_init (&output);
|
inner_cleanup = make_cleanup_obstack_free (&output);
|
inner_cleanup = make_cleanup_obstack_free (&output);
|
|
|
convert_between_encodings (target_wide_charset (byte_order),
|
convert_between_encodings (target_wide_charset (byte_order),
|
host_charset (),
|
host_charset (),
|
str, j, wcwidth,
|
str, j, wcwidth,
|
&output, translit_char);
|
&output, translit_char);
|
obstack_grow_str0 (&output, "");
|
obstack_grow_str0 (&output, "");
|
|
|
printf_filtered (current_substring, obstack_base (&output));
|
printf_filtered (current_substring, obstack_base (&output));
|
do_cleanups (inner_cleanup);
|
do_cleanups (inner_cleanup);
|
}
|
}
|
break;
|
break;
|
case wide_char_arg:
|
case wide_char_arg:
|
{
|
{
|
struct gdbarch *gdbarch
|
struct gdbarch *gdbarch
|
= get_type_arch (value_type (val_args[i]));
|
= get_type_arch (value_type (val_args[i]));
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
struct type *wctype = lookup_typename (current_language, gdbarch,
|
struct type *wctype = lookup_typename (current_language, gdbarch,
|
"wchar_t", NULL, 0);
|
"wchar_t", NULL, 0);
|
struct type *valtype;
|
struct type *valtype;
|
struct obstack output;
|
struct obstack output;
|
struct cleanup *inner_cleanup;
|
struct cleanup *inner_cleanup;
|
const gdb_byte *bytes;
|
const gdb_byte *bytes;
|
|
|
valtype = value_type (val_args[i]);
|
valtype = value_type (val_args[i]);
|
if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
|
if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
|
|| TYPE_CODE (valtype) != TYPE_CODE_INT)
|
|| TYPE_CODE (valtype) != TYPE_CODE_INT)
|
error (_("expected wchar_t argument for %%lc"));
|
error (_("expected wchar_t argument for %%lc"));
|
|
|
bytes = value_contents (val_args[i]);
|
bytes = value_contents (val_args[i]);
|
|
|
obstack_init (&output);
|
obstack_init (&output);
|
inner_cleanup = make_cleanup_obstack_free (&output);
|
inner_cleanup = make_cleanup_obstack_free (&output);
|
|
|
convert_between_encodings (target_wide_charset (byte_order),
|
convert_between_encodings (target_wide_charset (byte_order),
|
host_charset (),
|
host_charset (),
|
bytes, TYPE_LENGTH (valtype),
|
bytes, TYPE_LENGTH (valtype),
|
TYPE_LENGTH (valtype),
|
TYPE_LENGTH (valtype),
|
&output, translit_char);
|
&output, translit_char);
|
obstack_grow_str0 (&output, "");
|
obstack_grow_str0 (&output, "");
|
|
|
printf_filtered (current_substring, obstack_base (&output));
|
printf_filtered (current_substring, obstack_base (&output));
|
do_cleanups (inner_cleanup);
|
do_cleanups (inner_cleanup);
|
}
|
}
|
break;
|
break;
|
case double_arg:
|
case double_arg:
|
{
|
{
|
struct type *type = value_type (val_args[i]);
|
struct type *type = value_type (val_args[i]);
|
DOUBLEST val;
|
DOUBLEST val;
|
int inv;
|
int inv;
|
|
|
/* If format string wants a float, unchecked-convert the value
|
/* If format string wants a float, unchecked-convert the value
|
to floating point of the same size. */
|
to floating point of the same size. */
|
type = float_type_from_length (type);
|
type = float_type_from_length (type);
|
val = unpack_double (type, value_contents (val_args[i]), &inv);
|
val = unpack_double (type, value_contents (val_args[i]), &inv);
|
if (inv)
|
if (inv)
|
error (_("Invalid floating value found in program."));
|
error (_("Invalid floating value found in program."));
|
|
|
printf_filtered (current_substring, (double) val);
|
printf_filtered (current_substring, (double) val);
|
break;
|
break;
|
}
|
}
|
case long_double_arg:
|
case long_double_arg:
|
#ifdef HAVE_LONG_DOUBLE
|
#ifdef HAVE_LONG_DOUBLE
|
{
|
{
|
struct type *type = value_type (val_args[i]);
|
struct type *type = value_type (val_args[i]);
|
DOUBLEST val;
|
DOUBLEST val;
|
int inv;
|
int inv;
|
|
|
/* If format string wants a float, unchecked-convert the value
|
/* If format string wants a float, unchecked-convert the value
|
to floating point of the same size. */
|
to floating point of the same size. */
|
type = float_type_from_length (type);
|
type = float_type_from_length (type);
|
val = unpack_double (type, value_contents (val_args[i]), &inv);
|
val = unpack_double (type, value_contents (val_args[i]), &inv);
|
if (inv)
|
if (inv)
|
error (_("Invalid floating value found in program."));
|
error (_("Invalid floating value found in program."));
|
|
|
printf_filtered (current_substring, (long double) val);
|
printf_filtered (current_substring, (long double) val);
|
break;
|
break;
|
}
|
}
|
#else
|
#else
|
error (_("long double not supported in printf"));
|
error (_("long double not supported in printf"));
|
#endif
|
#endif
|
case long_long_arg:
|
case long_long_arg:
|
#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
|
#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
|
{
|
{
|
long long val = value_as_long (val_args[i]);
|
long long val = value_as_long (val_args[i]);
|
printf_filtered (current_substring, val);
|
printf_filtered (current_substring, val);
|
break;
|
break;
|
}
|
}
|
#else
|
#else
|
error (_("long long not supported in printf"));
|
error (_("long long not supported in printf"));
|
#endif
|
#endif
|
case int_arg:
|
case int_arg:
|
{
|
{
|
int val = value_as_long (val_args[i]);
|
int val = value_as_long (val_args[i]);
|
printf_filtered (current_substring, val);
|
printf_filtered (current_substring, val);
|
break;
|
break;
|
}
|
}
|
case long_arg:
|
case long_arg:
|
{
|
{
|
long val = value_as_long (val_args[i]);
|
long val = value_as_long (val_args[i]);
|
printf_filtered (current_substring, val);
|
printf_filtered (current_substring, val);
|
break;
|
break;
|
}
|
}
|
|
|
/* Handles decimal floating values. */
|
/* Handles decimal floating values. */
|
case decfloat_arg:
|
case decfloat_arg:
|
{
|
{
|
const gdb_byte *param_ptr = value_contents (val_args[i]);
|
const gdb_byte *param_ptr = value_contents (val_args[i]);
|
#if defined (PRINTF_HAS_DECFLOAT)
|
#if defined (PRINTF_HAS_DECFLOAT)
|
/* If we have native support for Decimal floating
|
/* If we have native support for Decimal floating
|
printing, handle it here. */
|
printing, handle it here. */
|
printf_filtered (current_substring, param_ptr);
|
printf_filtered (current_substring, param_ptr);
|
#else
|
#else
|
|
|
/* As a workaround until vasprintf has native support for DFP
|
/* As a workaround until vasprintf has native support for DFP
|
we convert the DFP values to string and print them using
|
we convert the DFP values to string and print them using
|
the %s format specifier. */
|
the %s format specifier. */
|
|
|
char *eos, *sos;
|
char *eos, *sos;
|
int nnull_chars = 0;
|
int nnull_chars = 0;
|
|
|
/* Parameter data. */
|
/* Parameter data. */
|
struct type *param_type = value_type (val_args[i]);
|
struct type *param_type = value_type (val_args[i]);
|
unsigned int param_len = TYPE_LENGTH (param_type);
|
unsigned int param_len = TYPE_LENGTH (param_type);
|
struct gdbarch *gdbarch = get_type_arch (param_type);
|
struct gdbarch *gdbarch = get_type_arch (param_type);
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
/* DFP output data. */
|
/* DFP output data. */
|
struct value *dfp_value = NULL;
|
struct value *dfp_value = NULL;
|
gdb_byte *dfp_ptr;
|
gdb_byte *dfp_ptr;
|
int dfp_len = 16;
|
int dfp_len = 16;
|
gdb_byte dec[16];
|
gdb_byte dec[16];
|
struct type *dfp_type = NULL;
|
struct type *dfp_type = NULL;
|
char decstr[MAX_DECIMAL_STRING];
|
char decstr[MAX_DECIMAL_STRING];
|
|
|
/* Points to the end of the string so that we can go back
|
/* Points to the end of the string so that we can go back
|
and check for DFP length modifiers. */
|
and check for DFP length modifiers. */
|
eos = current_substring + strlen (current_substring);
|
eos = current_substring + strlen (current_substring);
|
|
|
/* Look for the float/double format specifier. */
|
/* Look for the float/double format specifier. */
|
while (*eos != 'f' && *eos != 'e' && *eos != 'E'
|
while (*eos != 'f' && *eos != 'e' && *eos != 'E'
|
&& *eos != 'g' && *eos != 'G')
|
&& *eos != 'g' && *eos != 'G')
|
eos--;
|
eos--;
|
|
|
sos = eos;
|
sos = eos;
|
|
|
/* Search for the '%' char and extract the size and type of
|
/* Search for the '%' char and extract the size and type of
|
the output decimal value based on its modifiers
|
the output decimal value based on its modifiers
|
(%Hf, %Df, %DDf). */
|
(%Hf, %Df, %DDf). */
|
while (*--sos != '%')
|
while (*--sos != '%')
|
{
|
{
|
if (*sos == 'H')
|
if (*sos == 'H')
|
{
|
{
|
dfp_len = 4;
|
dfp_len = 4;
|
dfp_type = builtin_type (gdbarch)->builtin_decfloat;
|
dfp_type = builtin_type (gdbarch)->builtin_decfloat;
|
}
|
}
|
else if (*sos == 'D' && *(sos - 1) == 'D')
|
else if (*sos == 'D' && *(sos - 1) == 'D')
|
{
|
{
|
dfp_len = 16;
|
dfp_len = 16;
|
dfp_type = builtin_type (gdbarch)->builtin_declong;
|
dfp_type = builtin_type (gdbarch)->builtin_declong;
|
sos--;
|
sos--;
|
}
|
}
|
else
|
else
|
{
|
{
|
dfp_len = 8;
|
dfp_len = 8;
|
dfp_type = builtin_type (gdbarch)->builtin_decdouble;
|
dfp_type = builtin_type (gdbarch)->builtin_decdouble;
|
}
|
}
|
}
|
}
|
|
|
/* Replace %Hf, %Df and %DDf with %s's. */
|
/* Replace %Hf, %Df and %DDf with %s's. */
|
*++sos = 's';
|
*++sos = 's';
|
|
|
/* Go through the whole format string and pull the correct
|
/* Go through the whole format string and pull the correct
|
number of chars back to compensate for the change in the
|
number of chars back to compensate for the change in the
|
format specifier. */
|
format specifier. */
|
while (nnull_chars < nargs - i)
|
while (nnull_chars < nargs - i)
|
{
|
{
|
if (*eos == '\0')
|
if (*eos == '\0')
|
nnull_chars++;
|
nnull_chars++;
|
|
|
*++sos = *++eos;
|
*++sos = *++eos;
|
}
|
}
|
|
|
/* Conversion between different DFP types. */
|
/* Conversion between different DFP types. */
|
if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
|
if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
|
decimal_convert (param_ptr, param_len, byte_order,
|
decimal_convert (param_ptr, param_len, byte_order,
|
dec, dfp_len, byte_order);
|
dec, dfp_len, byte_order);
|
else
|
else
|
/* If this is a non-trivial conversion, just output 0.
|
/* If this is a non-trivial conversion, just output 0.
|
A correct converted value can be displayed by explicitly
|
A correct converted value can be displayed by explicitly
|
casting to a DFP type. */
|
casting to a DFP type. */
|
decimal_from_string (dec, dfp_len, byte_order, "0");
|
decimal_from_string (dec, dfp_len, byte_order, "0");
|
|
|
dfp_value = value_from_decfloat (dfp_type, dec);
|
dfp_value = value_from_decfloat (dfp_type, dec);
|
|
|
dfp_ptr = (gdb_byte *) value_contents (dfp_value);
|
dfp_ptr = (gdb_byte *) value_contents (dfp_value);
|
|
|
decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr);
|
decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr);
|
|
|
/* Print the DFP value. */
|
/* Print the DFP value. */
|
printf_filtered (current_substring, decstr);
|
printf_filtered (current_substring, decstr);
|
|
|
break;
|
break;
|
#endif
|
#endif
|
}
|
}
|
|
|
case ptr_arg:
|
case ptr_arg:
|
{
|
{
|
/* We avoid the host's %p because pointers are too
|
/* We avoid the host's %p because pointers are too
|
likely to be the wrong size. The only interesting
|
likely to be the wrong size. The only interesting
|
modifier for %p is a width; extract that, and then
|
modifier for %p is a width; extract that, and then
|
handle %p as glibc would: %#x or a literal "(nil)". */
|
handle %p as glibc would: %#x or a literal "(nil)". */
|
|
|
char *p, *fmt, *fmt_p;
|
char *p, *fmt, *fmt_p;
|
#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
|
#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
|
long long val = value_as_long (val_args[i]);
|
long long val = value_as_long (val_args[i]);
|
#else
|
#else
|
long val = value_as_long (val_args[i]);
|
long val = value_as_long (val_args[i]);
|
#endif
|
#endif
|
|
|
fmt = alloca (strlen (current_substring) + 5);
|
fmt = alloca (strlen (current_substring) + 5);
|
|
|
/* Copy up to the leading %. */
|
/* Copy up to the leading %. */
|
p = current_substring;
|
p = current_substring;
|
fmt_p = fmt;
|
fmt_p = fmt;
|
while (*p)
|
while (*p)
|
{
|
{
|
int is_percent = (*p == '%');
|
int is_percent = (*p == '%');
|
*fmt_p++ = *p++;
|
*fmt_p++ = *p++;
|
if (is_percent)
|
if (is_percent)
|
{
|
{
|
if (*p == '%')
|
if (*p == '%')
|
*fmt_p++ = *p++;
|
*fmt_p++ = *p++;
|
else
|
else
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (val != 0)
|
if (val != 0)
|
*fmt_p++ = '#';
|
*fmt_p++ = '#';
|
|
|
/* Copy any width. */
|
/* Copy any width. */
|
while (*p >= '0' && *p < '9')
|
while (*p >= '0' && *p < '9')
|
*fmt_p++ = *p++;
|
*fmt_p++ = *p++;
|
|
|
gdb_assert (*p == 'p' && *(p + 1) == '\0');
|
gdb_assert (*p == 'p' && *(p + 1) == '\0');
|
if (val != 0)
|
if (val != 0)
|
{
|
{
|
#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
|
#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
|
*fmt_p++ = 'l';
|
*fmt_p++ = 'l';
|
#endif
|
#endif
|
*fmt_p++ = 'l';
|
*fmt_p++ = 'l';
|
*fmt_p++ = 'x';
|
*fmt_p++ = 'x';
|
*fmt_p++ = '\0';
|
*fmt_p++ = '\0';
|
printf_filtered (fmt, val);
|
printf_filtered (fmt, val);
|
}
|
}
|
else
|
else
|
{
|
{
|
*fmt_p++ = 's';
|
*fmt_p++ = 's';
|
*fmt_p++ = '\0';
|
*fmt_p++ = '\0';
|
printf_filtered (fmt, "(nil)");
|
printf_filtered (fmt, "(nil)");
|
}
|
}
|
|
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
internal_error (__FILE__, __LINE__,
|
internal_error (__FILE__, __LINE__,
|
_("failed internal consistency check"));
|
_("failed internal consistency check"));
|
}
|
}
|
/* Skip to the next substring. */
|
/* Skip to the next substring. */
|
current_substring += strlen (current_substring) + 1;
|
current_substring += strlen (current_substring) + 1;
|
}
|
}
|
/* Print the portion of the format string after the last argument.
|
/* Print the portion of the format string after the last argument.
|
Note that this will not include any ordinary %-specs, but it
|
Note that this will not include any ordinary %-specs, but it
|
might include "%%". That is why we use printf_filtered and not
|
might include "%%". That is why we use printf_filtered and not
|
puts_filtered here. Also, we pass a dummy argument because
|
puts_filtered here. Also, we pass a dummy argument because
|
some platforms have modified GCC to include -Wformat-security
|
some platforms have modified GCC to include -Wformat-security
|
by default, which will warn here if there is no argument. */
|
by default, which will warn here if there is no argument. */
|
printf_filtered (last_arg, 0);
|
printf_filtered (last_arg, 0);
|
}
|
}
|
do_cleanups (old_cleanups);
|
do_cleanups (old_cleanups);
|
}
|
}
|
|
|
void
|
void
|
_initialize_printcmd (void)
|
_initialize_printcmd (void)
|
{
|
{
|
struct cmd_list_element *c;
|
struct cmd_list_element *c;
|
|
|
current_display_number = -1;
|
current_display_number = -1;
|
|
|
observer_attach_solib_unloaded (clear_dangling_display_expressions);
|
observer_attach_solib_unloaded (clear_dangling_display_expressions);
|
|
|
add_info ("address", address_info,
|
add_info ("address", address_info,
|
_("Describe where symbol SYM is stored."));
|
_("Describe where symbol SYM is stored."));
|
|
|
add_info ("symbol", sym_info, _("\
|
add_info ("symbol", sym_info, _("\
|
Describe what symbol is at location ADDR.\n\
|
Describe what symbol is at location ADDR.\n\
|
Only for symbols with fixed locations (global or static scope)."));
|
Only for symbols with fixed locations (global or static scope)."));
|
|
|
add_com ("x", class_vars, x_command, _("\
|
add_com ("x", class_vars, x_command, _("\
|
Examine memory: x/FMT ADDRESS.\n\
|
Examine memory: x/FMT ADDRESS.\n\
|
ADDRESS is an expression for the memory address to examine.\n\
|
ADDRESS is an expression for the memory address to examine.\n\
|
FMT is a repeat count followed by a format letter and a size letter.\n\
|
FMT is a repeat count followed by a format letter and a size letter.\n\
|
Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
|
Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
|
t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
|
t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
|
Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
|
Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
|
The specified number of objects of the specified size are printed\n\
|
The specified number of objects of the specified size are printed\n\
|
according to the format.\n\n\
|
according to the format.\n\n\
|
Defaults for format and size letters are those previously used.\n\
|
Defaults for format and size letters are those previously used.\n\
|
Default count is 1. Default address is following last thing printed\n\
|
Default count is 1. Default address is following last thing printed\n\
|
with this command or \"print\"."));
|
with this command or \"print\"."));
|
|
|
#if 0
|
#if 0
|
add_com ("whereis", class_vars, whereis_command,
|
add_com ("whereis", class_vars, whereis_command,
|
_("Print line number and file of definition of variable."));
|
_("Print line number and file of definition of variable."));
|
#endif
|
#endif
|
|
|
add_info ("display", display_info, _("\
|
add_info ("display", display_info, _("\
|
Expressions to display when program stops, with code numbers."));
|
Expressions to display when program stops, with code numbers."));
|
|
|
add_cmd ("undisplay", class_vars, undisplay_command, _("\
|
add_cmd ("undisplay", class_vars, undisplay_command, _("\
|
Cancel some expressions to be displayed when program stops.\n\
|
Cancel some expressions to be displayed when program stops.\n\
|
Arguments are the code numbers of the expressions to stop displaying.\n\
|
Arguments are the code numbers of the expressions to stop displaying.\n\
|
No argument means cancel all automatic-display expressions.\n\
|
No argument means cancel all automatic-display expressions.\n\
|
\"delete display\" has the same effect as this command.\n\
|
\"delete display\" has the same effect as this command.\n\
|
Do \"info display\" to see current list of code numbers."),
|
Do \"info display\" to see current list of code numbers."),
|
&cmdlist);
|
&cmdlist);
|
|
|
add_com ("display", class_vars, display_command, _("\
|
add_com ("display", class_vars, display_command, _("\
|
Print value of expression EXP each time the program stops.\n\
|
Print value of expression EXP each time the program stops.\n\
|
/FMT may be used before EXP as in the \"print\" command.\n\
|
/FMT may be used before EXP as in the \"print\" command.\n\
|
/FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
|
/FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
|
as in the \"x\" command, and then EXP is used to get the address to examine\n\
|
as in the \"x\" command, and then EXP is used to get the address to examine\n\
|
and examining is done as in the \"x\" command.\n\n\
|
and examining is done as in the \"x\" command.\n\n\
|
With no argument, display all currently requested auto-display expressions.\n\
|
With no argument, display all currently requested auto-display expressions.\n\
|
Use \"undisplay\" to cancel display requests previously made."));
|
Use \"undisplay\" to cancel display requests previously made."));
|
|
|
add_cmd ("display", class_vars, enable_display, _("\
|
add_cmd ("display", class_vars, enable_display, _("\
|
Enable some expressions to be displayed when program stops.\n\
|
Enable some expressions to be displayed when program stops.\n\
|
Arguments are the code numbers of the expressions to resume displaying.\n\
|
Arguments are the code numbers of the expressions to resume displaying.\n\
|
No argument means enable all automatic-display expressions.\n\
|
No argument means enable all automatic-display expressions.\n\
|
Do \"info display\" to see current list of code numbers."), &enablelist);
|
Do \"info display\" to see current list of code numbers."), &enablelist);
|
|
|
add_cmd ("display", class_vars, disable_display_command, _("\
|
add_cmd ("display", class_vars, disable_display_command, _("\
|
Disable some expressions to be displayed when program stops.\n\
|
Disable some expressions to be displayed when program stops.\n\
|
Arguments are the code numbers of the expressions to stop displaying.\n\
|
Arguments are the code numbers of the expressions to stop displaying.\n\
|
No argument means disable all automatic-display expressions.\n\
|
No argument means disable all automatic-display expressions.\n\
|
Do \"info display\" to see current list of code numbers."), &disablelist);
|
Do \"info display\" to see current list of code numbers."), &disablelist);
|
|
|
add_cmd ("display", class_vars, undisplay_command, _("\
|
add_cmd ("display", class_vars, undisplay_command, _("\
|
Cancel some expressions to be displayed when program stops.\n\
|
Cancel some expressions to be displayed when program stops.\n\
|
Arguments are the code numbers of the expressions to stop displaying.\n\
|
Arguments are the code numbers of the expressions to stop displaying.\n\
|
No argument means cancel all automatic-display expressions.\n\
|
No argument means cancel all automatic-display expressions.\n\
|
Do \"info display\" to see current list of code numbers."), &deletelist);
|
Do \"info display\" to see current list of code numbers."), &deletelist);
|
|
|
add_com ("printf", class_vars, printf_command, _("\
|
add_com ("printf", class_vars, printf_command, _("\
|
printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
|
printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
|
This is useful for formatted output in user-defined commands."));
|
This is useful for formatted output in user-defined commands."));
|
|
|
add_com ("output", class_vars, output_command, _("\
|
add_com ("output", class_vars, output_command, _("\
|
Like \"print\" but don't put in value history and don't print newline.\n\
|
Like \"print\" but don't put in value history and don't print newline.\n\
|
This is useful in user-defined commands."));
|
This is useful in user-defined commands."));
|
|
|
add_prefix_cmd ("set", class_vars, set_command, _("\
|
add_prefix_cmd ("set", class_vars, set_command, _("\
|
Evaluate expression EXP and assign result to variable VAR, using assignment\n\
|
Evaluate expression EXP and assign result to variable VAR, using assignment\n\
|
syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
|
syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
|
example). VAR may be a debugger \"convenience\" variable (names starting\n\
|
example). VAR may be a debugger \"convenience\" variable (names starting\n\
|
with $), a register (a few standard names starting with $), or an actual\n\
|
with $), a register (a few standard names starting with $), or an actual\n\
|
variable in the program being debugged. EXP is any valid expression.\n\
|
variable in the program being debugged. EXP is any valid expression.\n\
|
Use \"set variable\" for variables with names identical to set subcommands.\n\
|
Use \"set variable\" for variables with names identical to set subcommands.\n\
|
\n\
|
\n\
|
With a subcommand, this command modifies parts of the gdb environment.\n\
|
With a subcommand, this command modifies parts of the gdb environment.\n\
|
You can see these environment settings with the \"show\" command."),
|
You can see these environment settings with the \"show\" command."),
|
&setlist, "set ", 1, &cmdlist);
|
&setlist, "set ", 1, &cmdlist);
|
if (dbx_commands)
|
if (dbx_commands)
|
add_com ("assign", class_vars, set_command, _("\
|
add_com ("assign", class_vars, set_command, _("\
|
Evaluate expression EXP and assign result to variable VAR, using assignment\n\
|
Evaluate expression EXP and assign result to variable VAR, using assignment\n\
|
syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
|
syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
|
example). VAR may be a debugger \"convenience\" variable (names starting\n\
|
example). VAR may be a debugger \"convenience\" variable (names starting\n\
|
with $), a register (a few standard names starting with $), or an actual\n\
|
with $), a register (a few standard names starting with $), or an actual\n\
|
variable in the program being debugged. EXP is any valid expression.\n\
|
variable in the program being debugged. EXP is any valid expression.\n\
|
Use \"set variable\" for variables with names identical to set subcommands.\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\
|
\nWith a subcommand, this command modifies parts of the gdb environment.\n\
|
You can see these environment settings with the \"show\" command."));
|
You can see these environment settings with the \"show\" command."));
|
|
|
/* "call" is the same as "set", but handy for dbx users to call fns. */
|
/* "call" is the same as "set", but handy for dbx users to call fns. */
|
c = add_com ("call", class_vars, call_command, _("\
|
c = add_com ("call", class_vars, call_command, _("\
|
Call a function in the program.\n\
|
Call a function in the program.\n\
|
The argument is the function name and arguments, in the notation of the\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\
|
current working language. The result is printed and saved in the value\n\
|
history, if it is not void."));
|
history, if it is not void."));
|
set_cmd_completer (c, expression_completer);
|
set_cmd_completer (c, expression_completer);
|
|
|
add_cmd ("variable", class_vars, set_command, _("\
|
add_cmd ("variable", class_vars, set_command, _("\
|
Evaluate expression EXP and assign result to variable VAR, using assignment\n\
|
Evaluate expression EXP and assign result to variable VAR, using assignment\n\
|
syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
|
syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
|
example). VAR may be a debugger \"convenience\" variable (names starting\n\
|
example). VAR may be a debugger \"convenience\" variable (names starting\n\
|
with $), a register (a few standard names starting with $), or an actual\n\
|
with $), a register (a few standard names starting with $), or an actual\n\
|
variable in the program being debugged. EXP is any valid expression.\n\
|
variable in the program being debugged. EXP is any valid expression.\n\
|
This may usually be abbreviated to simply \"set\"."),
|
This may usually be abbreviated to simply \"set\"."),
|
&setlist);
|
&setlist);
|
|
|
c = add_com ("print", class_vars, print_command, _("\
|
c = add_com ("print", class_vars, print_command, _("\
|
Print value of expression EXP.\n\
|
Print value of expression EXP.\n\
|
Variables accessible are those of the lexical environment of the selected\n\
|
Variables accessible are those of the lexical environment of the selected\n\
|
stack frame, plus all those whose scope is global or an entire file.\n\
|
stack frame, plus all those whose scope is global or an entire file.\n\
|
\n\
|
\n\
|
$NUM gets previous value number NUM. $ and $$ are the last two values.\n\
|
$NUM gets previous value number NUM. $ and $$ are the last two values.\n\
|
$$NUM refers to NUM'th value back from the last one.\n\
|
$$NUM refers to NUM'th value back from the last one.\n\
|
Names starting with $ refer to registers (with the values they would have\n\
|
Names starting with $ refer to registers (with the values they would have\n\
|
if the program were to return to the stack frame now selected, restoring\n\
|
if the program were to return to the stack frame now selected, restoring\n\
|
all registers saved by frames farther in) or else to debugger\n\
|
all registers saved by frames farther in) or else to debugger\n\
|
\"convenience\" variables (any such name not a known register).\n\
|
\"convenience\" variables (any such name not a known register).\n\
|
Use assignment expressions to give values to convenience variables.\n\
|
Use assignment expressions to give values to convenience variables.\n\
|
\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\
|
@ is a binary operator for treating consecutive data objects\n\
|
anywhere in memory as an array. FOO@NUM gives an array whose first\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\
|
element is FOO, whose second element is stored in the space following\n\
|
where FOO is stored, etc. FOO must be an expression whose value\n\
|
where FOO is stored, etc. FOO must be an expression whose value\n\
|
resides in memory.\n\
|
resides in memory.\n\
|
\n\
|
\n\
|
EXP may be preceded with /FMT, where FMT is a format letter\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)."));
|
set_cmd_completer (c, expression_completer);
|
set_cmd_completer (c, expression_completer);
|
add_com_alias ("p", "print", class_vars, 1);
|
add_com_alias ("p", "print", class_vars, 1);
|
|
|
c = add_com ("inspect", class_vars, inspect_command, _("\
|
c = add_com ("inspect", class_vars, inspect_command, _("\
|
Same as \"print\" command, except that if you are running in the epoch\n\
|
Same as \"print\" command, except that if you are running in the epoch\n\
|
environment, the value is printed in its own window."));
|
environment, the value is printed in its own window."));
|
set_cmd_completer (c, expression_completer);
|
set_cmd_completer (c, expression_completer);
|
|
|
add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
|
add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
|
&max_symbolic_offset, _("\
|
&max_symbolic_offset, _("\
|
Set the largest offset that will be printed in <symbol+1234> form."), _("\
|
Set the largest offset that will be printed in <symbol+1234> form."), _("\
|
Show the largest offset that will be printed in <symbol+1234> form."), NULL,
|
Show the largest offset that will be printed in <symbol+1234> form."), NULL,
|
NULL,
|
NULL,
|
show_max_symbolic_offset,
|
show_max_symbolic_offset,
|
&setprintlist, &showprintlist);
|
&setprintlist, &showprintlist);
|
add_setshow_boolean_cmd ("symbol-filename", no_class,
|
add_setshow_boolean_cmd ("symbol-filename", no_class,
|
&print_symbol_filename, _("\
|
&print_symbol_filename, _("\
|
Set printing of source filename and line number with <symbol>."), _("\
|
Set printing of source filename and line number with <symbol>."), _("\
|
Show printing of source filename and line number with <symbol>."), NULL,
|
Show printing of source filename and line number with <symbol>."), NULL,
|
NULL,
|
NULL,
|
show_print_symbol_filename,
|
show_print_symbol_filename,
|
&setprintlist, &showprintlist);
|
&setprintlist, &showprintlist);
|
}
|
}
|
|
|
