/* Print values for GNU debugger GDB.
- Copyright (C) 1986-2016 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "charset.h"
#include "arch-utils.h"
#include "cli/cli-utils.h"
+#include "cli/cli-script.h"
#include "format.h"
#include "source.h"
+#include "common/byte-vector.h"
#ifdef TUI
#include "tui/tui.h" /* For tui_active et al. */
char *exp_string;
/* Expression to be evaluated and displayed. */
- struct expression *exp;
+ expression_up exp;
/* Item number of this auto-display item. */
int number;
B ? (TMP = B->next, 1): 0; \
B = TMP)
-/* Prototypes for exported functions. */
-
-void _initialize_printcmd (void);
-
/* Prototypes for local functions. */
static void do_one_display (struct display *);
/* User specified format, so don't look to the type to tell us
what to do. */
val_print_scalar_formatted (type,
- value_contents_for_printing (val),
value_embedded_offset (val),
val,
options, size, stream);
int size, struct ui_file *stream)
{
struct gdbarch *gdbarch = get_type_arch (type);
- LONGEST val_long = 0;
unsigned int len = TYPE_LENGTH (type);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* String printing should go through val_print_scalar_formatted. */
gdb_assert (options->format != 's');
- if (len > sizeof(LONGEST)
- && (TYPE_CODE (type) == TYPE_CODE_INT
- || TYPE_CODE (type) == TYPE_CODE_ENUM))
- {
- switch (options->format)
- {
- case 'o':
- print_octal_chars (stream, valaddr, len, byte_order);
- return;
- case 'u':
- case 'd':
- print_decimal_chars (stream, valaddr, len, byte_order);
- return;
- case 't':
- print_binary_chars (stream, valaddr, len, byte_order);
- return;
- case 'x':
- print_hex_chars (stream, valaddr, len, byte_order);
- return;
- case 'c':
- print_char_chars (stream, type, valaddr, len, byte_order);
- return;
- default:
- break;
- };
- }
-
- if (options->format != 'f')
- val_long = unpack_long (type, valaddr);
-
/* 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
gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
/* 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
(if shorts are 16 bits) instead of 4294967295). */
- if (options->format != 'd' || TYPE_UNSIGNED (type))
+ if (options->format != 'c'
+ && (options->format != 'd' || TYPE_UNSIGNED (type)))
{
- if (len < sizeof (LONGEST))
- val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
+ if (len < TYPE_LENGTH (type) && byte_order == BFD_ENDIAN_BIG)
+ valaddr += TYPE_LENGTH (type) - len;
}
- switch (options->format)
+ if (size != 0 && (options->format == 'x' || options->format == 't'))
{
- case 'x':
- if (!size)
+ /* Truncate to fit. */
+ unsigned newlen;
+ switch (size)
{
- /* No size specified, like in print. Print varying # of digits. */
- print_longest (stream, 'x', 1, val_long);
+ case 'b':
+ newlen = 1;
+ break;
+ case 'h':
+ newlen = 2;
+ break;
+ case 'w':
+ newlen = 4;
+ break;
+ case 'g':
+ newlen = 8;
+ break;
+ default:
+ error (_("Undefined output size \"%c\"."), size);
}
- else
- switch (size)
- {
- case 'b':
- case 'h':
- case 'w':
- case 'g':
- print_longest (stream, size, 1, val_long);
- break;
- default:
- error (_("Undefined output size \"%c\"."), size);
- }
- break;
+ if (newlen < len && byte_order == BFD_ENDIAN_BIG)
+ valaddr += len - newlen;
+ len = newlen;
+ }
+
+ /* Historically gdb has printed floats by first casting them to a
+ long, and then printing the long. PR cli/16242 suggests changing
+ this to using C-style hex float format. */
+ gdb::byte_vector converted_float_bytes;
+ if (TYPE_CODE (type) == TYPE_CODE_FLT
+ && (options->format == 'o'
+ || options->format == 'x'
+ || options->format == 't'
+ || options->format == 'z'
+ || options->format == 'd'
+ || options->format == 'u'))
+ {
+ LONGEST val_long = unpack_long (type, valaddr);
+ converted_float_bytes.resize (TYPE_LENGTH (type));
+ store_signed_integer (converted_float_bytes.data (), TYPE_LENGTH (type),
+ byte_order, val_long);
+ valaddr = converted_float_bytes.data ();
+ }
+ switch (options->format)
+ {
+ case 'o':
+ print_octal_chars (stream, valaddr, len, byte_order);
+ break;
case 'd':
- print_longest (stream, 'd', 1, val_long);
+ print_decimal_chars (stream, valaddr, len, true, byte_order);
break;
-
case 'u':
- print_longest (stream, 'u', 0, val_long);
+ print_decimal_chars (stream, valaddr, len, false, byte_order);
break;
-
- case 'o':
- if (val_long)
- print_longest (stream, 'o', 1, val_long);
- else
- fprintf_filtered (stream, "0");
+ case 0:
+ if (TYPE_CODE (type) != TYPE_CODE_FLT)
+ {
+ print_decimal_chars (stream, valaddr, len, !TYPE_UNSIGNED (type),
+ byte_order);
+ break;
+ }
+ /* FALLTHROUGH */
+ case 'f':
+ type = float_type_from_length (type);
+ print_floating (valaddr, type, stream);
break;
- case 'a':
- {
- CORE_ADDR addr = unpack_pointer (type, valaddr);
-
- print_address (gdbarch, addr, stream);
- }
+ case 't':
+ print_binary_chars (stream, valaddr, len, byte_order, size > 0);
+ break;
+ case 'x':
+ print_hex_chars (stream, valaddr, len, byte_order, size > 0);
+ break;
+ case 'z':
+ print_hex_chars (stream, valaddr, len, byte_order, true);
break;
-
case 'c':
{
struct value_print_options opts = *options;
+ LONGEST val_long = unpack_long (type, valaddr);
+
opts.format = 0;
if (TYPE_UNSIGNED (type))
type = builtin_type (gdbarch)->builtin_true_unsigned_char;
}
break;
- case 'f':
- type = float_type_from_length (type);
- print_floating (valaddr, type, stream);
- break;
-
- case 0:
- internal_error (__FILE__, __LINE__,
- _("failed internal consistency check"));
-
- case 't':
- /* Binary; 't' stands for "two". */
+ case 'a':
{
- char bits[8 * (sizeof val_long) + 1];
- char buf[8 * (sizeof val_long) + 32];
- char *cp = bits;
- int width;
-
- if (!size)
- width = 8 * (sizeof val_long);
- else
- switch (size)
- {
- case 'b':
- width = 8;
- break;
- case 'h':
- width = 16;
- break;
- case 'w':
- width = 32;
- break;
- case 'g':
- width = 64;
- break;
- default:
- error (_("Undefined output size \"%c\"."), size);
- }
+ CORE_ADDR addr = unpack_pointer (type, valaddr);
- bits[width] = '\0';
- while (width-- > 0)
- {
- bits[width] = (val_long & 1) ? '1' : '0';
- val_long >>= 1;
- }
- if (!size)
- {
- while (*cp && *cp == '0')
- cp++;
- if (*cp == '\0')
- cp--;
- }
- strncpy (buf, cp, sizeof (bits));
- fputs_filtered (buf, stream);
+ print_address (gdbarch, addr, stream);
}
break;
- case 'z':
- print_hex_chars (stream, valaddr, len, byte_order);
- break;
-
default:
error (_("Undefined output format \"%c\"."), options->format);
}
int
print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
struct ui_file *stream,
- int do_demangle, char *leadin)
+ int do_demangle, const char *leadin)
{
char *name = NULL;
char *filename = NULL;
/* The vector PCS is used to store instruction addresses within
a pc range. */
CORE_ADDR loop_start, loop_end, p;
- VEC (CORE_ADDR) *pcs = NULL;
+ std::vector<CORE_ADDR> pcs;
struct symtab_and_line sal;
- struct cleanup *cleanup = make_cleanup (VEC_cleanup (CORE_ADDR), &pcs);
*inst_read = 0;
loop_start = loop_end = addr;
instructions from INST_COUNT, and go to the next iteration. */
do
{
- VEC_truncate (CORE_ADDR, pcs, 0);
+ pcs.clear ();
sal = find_pc_sect_line (loop_start, NULL, 1);
if (sal.line <= 0)
{
LOOP_START to LOOP_END. */
for (p = loop_start; p < loop_end;)
{
- VEC_safe_push (CORE_ADDR, pcs, p);
+ pcs.push_back (p);
p += gdb_insn_length (gdbarch, p);
}
- inst_count -= VEC_length (CORE_ADDR, pcs);
- *inst_read += VEC_length (CORE_ADDR, pcs);
+ inst_count -= pcs.size ();
+ *inst_read += pcs.size ();
}
while (inst_count > 0);
The case when the length of PCS is 0 means that we reached an area for
which line info is not available. In such case, we return LOOP_START,
which was the lowest instruction address that had line info. */
- p = VEC_length (CORE_ADDR, pcs) > 0
- ? VEC_index (CORE_ADDR, pcs, -inst_count)
- : loop_start;
+ p = pcs.size () > 0 ? pcs[-inst_count] : loop_start;
/* INST_READ includes all instruction addresses in a pc range. Need to
exclude the beginning part up to the address we're returning. That
if (inst_count < 0)
*inst_read += inst_count;
- do_cleanups (cleanup);
return p;
}
int *strings_counted)
{
const int chunk_size = 0x20;
- gdb_byte *buffer = NULL;
- struct cleanup *cleanup = NULL;
int read_error = 0;
int chars_read = 0;
int chars_to_read = chunk_size;
CORE_ADDR string_start_addr = addr;
gdb_assert (char_size == 1 || char_size == 2 || char_size == 4);
- buffer = (gdb_byte *) xmalloc (chars_to_read * char_size);
- cleanup = make_cleanup (xfree, buffer);
+ gdb::byte_vector buffer (chars_to_read * char_size);
while (count > 0 && read_error == 0)
{
int i;
addr -= chars_to_read * char_size;
- chars_read = read_memory_backward (gdbarch, addr, buffer,
+ chars_read = read_memory_backward (gdbarch, addr, buffer.data (),
chars_to_read * char_size);
chars_read /= char_size;
read_error = (chars_read == chars_to_read) ? 0 : 1;
{
int offset = (chars_to_read - i - 1) * char_size;
- if (integer_is_zero (buffer + offset, char_size)
+ if (integer_is_zero (&buffer[offset], char_size)
|| chars_counted == options->print_max)
{
/* Found '\0' or reached print_max. As OFFSET is the offset to
string_start_addr -= chars_counted * char_size;
}
- do_cleanups (cleanup);
return string_start_addr;
}
static void
print_command_1 (const char *exp, int voidprint)
{
- struct expression *expr;
- struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
struct value *val;
struct format_data fmt;
if (exp && *exp)
{
- expr = parse_expression (exp);
- make_cleanup (free_current_contents, &expr);
- val = evaluate_expression (expr);
+ expression_up expr = parse_expression (exp);
+ val = evaluate_expression (expr.get ());
}
else
val = access_value_history (0);
if (voidprint || (val && value_type (val) &&
TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
print_value (val, &fmt);
-
- do_cleanups (old_chain);
}
static void
void
output_command_const (const char *exp, int from_tty)
{
- struct expression *expr;
- struct cleanup *old_chain;
char format = 0;
struct value *val;
struct format_data fmt;
format = fmt.format;
}
- expr = parse_expression (exp);
- old_chain = make_cleanup (free_current_contents, &expr);
+ expression_up expr = parse_expression (exp);
- val = evaluate_expression (expr);
+ val = evaluate_expression (expr.get ());
annotate_value_begin (value_type (val));
wrap_here ("");
gdb_flush (gdb_stdout);
-
- do_cleanups (old_chain);
}
static void
-set_command (char *exp, int from_tty)
+set_command (const char *exp, int from_tty)
{
- struct expression *expr = parse_expression (exp);
- struct cleanup *old_chain =
- make_cleanup (free_current_contents, &expr);
+ expression_up expr = parse_expression (exp);
if (expr->nelts >= 1)
switch (expr->elts[0].opcode)
(_("Expression is not an assignment (and might have no effect)"));
}
- evaluate_expression (expr);
- do_cleanups (old_chain);
+ evaluate_expression (expr.get ());
+}
+
+/* Temporary non-const version of set_command. */
+
+static void
+non_const_set_command (char *exp, int from_tty)
+{
+ set_command (exp, from_tty);
}
static void
-sym_info (char *arg, int from_tty)
+info_symbol_command (char *arg, int from_tty)
{
struct minimal_symbol *msymbol;
struct objfile *objfile;
= lookup_minimal_symbol_by_pc_section (sect_addr, osect).minsym))
{
const char *obj_name, *mapped, *sec_name, *msym_name;
- char *loc_string;
+ const char *loc_string;
struct cleanup *old_chain;
matches = 1;
/* Don't print the offset if it is zero.
We assume there's no need to handle i18n of "sym + offset". */
+ std::string string_holder;
if (offset)
- loc_string = xstrprintf ("%s + %u", msym_name, offset);
+ {
+ string_holder = string_printf ("%s + %u", msym_name, offset);
+ loc_string = string_holder.c_str ();
+ }
else
- loc_string = xstrprintf ("%s", msym_name);
-
- /* Use a cleanup to free loc_string in case the user quits
- a pagination request inside printf_filtered. */
- old_chain = make_cleanup (xfree, loc_string);
+ loc_string = msym_name;
gdb_assert (osect->objfile && objfile_name (osect->objfile));
obj_name = objfile_name (osect->objfile);
else
printf_filtered (_("%s in section %s\n"),
loc_string, sec_name);
-
- do_cleanups (old_chain);
}
}
if (matches == 0)
}
static void
-address_info (char *exp, int from_tty)
+info_address_command (char *exp, int from_tty)
{
struct gdbarch *gdbarch;
int regno;
static void
x_command (char *exp, int from_tty)
{
- struct expression *expr;
struct format_data fmt;
- struct cleanup *old_chain;
struct value *val;
fmt.format = last_format ? last_format : 'x';
if (exp != 0 && *exp != 0)
{
- expr = parse_expression (exp);
+ expression_up expr = parse_expression (exp);
/* Cause expression not to be there any more if this command is
repeated with Newline. But don't clobber a user-defined
command's definition. */
if (from_tty)
*exp = 0;
- old_chain = make_cleanup (free_current_contents, &expr);
- val = evaluate_expression (expr);
- if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
+ val = evaluate_expression (expr.get ());
+ if (TYPE_IS_REFERENCE (value_type (val)))
val = coerce_ref (val);
/* In rvalue contexts, such as this, functions are coerced into
pointers to functions. This makes "x/i main" work. */
next_address = value_as_address (val);
next_gdbarch = expr->gdbarch;
- do_cleanups (old_chain);
}
if (!next_gdbarch)
display_command (char *arg, int from_tty)
{
struct format_data fmt;
- struct expression *expr;
struct display *newobj;
const char *exp = arg;
}
innermost_block = NULL;
- expr = parse_expression (exp);
+ expression_up expr = parse_expression (exp);
- newobj = XNEW (struct display);
+ newobj = new display ();
newobj->exp_string = xstrdup (exp);
- newobj->exp = expr;
+ newobj->exp = std::move (expr);
newobj->block = innermost_block;
newobj->pspace = current_program_space;
newobj->number = ++display_number;
free_display (struct display *d)
{
xfree (d->exp_string);
- xfree (d->exp);
- xfree (d);
+ delete d;
}
/* Clear out the display_chain. Done when new symtabs are loaded,
ARGS. DATA is passed unmodified to FUNCTION. */
static void
-map_display_numbers (char *args,
+map_display_numbers (const char *args,
void (*function) (struct display *,
void *),
void *data)
/* "undisplay" command. */
static void
-undisplay_command (char *args, int from_tty)
+undisplay_command (const char *args, int from_tty)
{
if (args == NULL)
{
static void
do_one_display (struct display *d)
{
- struct cleanup *old_chain;
int within_current_scope;
if (d->enabled_p == 0)
expression if the current architecture has changed. */
if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
{
- xfree (d->exp);
- d->exp = NULL;
+ d->exp.reset ();
d->block = NULL;
}
if (!within_current_scope)
return;
- old_chain = make_cleanup_restore_integer (¤t_display_number);
- current_display_number = d->number;
+ scoped_restore save_display_number
+ = make_scoped_restore (¤t_display_number, d->number);
annotate_display_begin ();
printf_filtered ("%d", d->number);
struct value *val;
CORE_ADDR addr;
- val = evaluate_expression (d->exp);
+ val = evaluate_expression (d->exp.get ());
addr = value_as_address (val);
if (d->format.format == 'i')
addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
{
struct value *val;
- val = evaluate_expression (d->exp);
+ val = evaluate_expression (d->exp.get ());
print_formatted (val, d->format.size, &opts, gdb_stdout);
}
CATCH (ex, RETURN_MASK_ERROR)
annotate_display_end ();
gdb_flush (gdb_stdout);
- do_cleanups (old_chain);
}
/* Display all of the values on the auto-display chain which can be
}
static void
-display_info (char *ignore, int from_tty)
+info_display_command (char *ignore, int from_tty)
{
struct display *d;
commands. ENABLE decides what to do. */
static void
-enable_disable_display_command (char *args, int from_tty, int enable)
+enable_disable_display_command (const char *args, int from_tty, int enable)
{
if (args == NULL)
{
/* The "enable display" command. */
static void
-enable_display_command (char *args, int from_tty)
+enable_display_command (const char *args, int from_tty)
{
enable_disable_display_command (args, from_tty, 1);
}
/* The "disable display" command. */
static void
-disable_display_command (char *args, int from_tty)
+disable_display_command (const char *args, int from_tty)
{
enable_disable_display_command (args, from_tty, 0);
}
continue;
if (lookup_objfile_from_block (d->block) == objfile
- || (d->exp && exp_uses_objfile (d->exp, objfile)))
+ || (d->exp != NULL && exp_uses_objfile (d->exp.get (), objfile)))
{
- xfree (d->exp);
- d->exp = NULL;
+ d->exp.reset ();
d->block = NULL;
}
}
"wchar_t", NULL, 0);
int wcwidth = TYPE_LENGTH (wctype);
gdb_byte *buf = (gdb_byte *) alloca (wcwidth);
- struct obstack output;
- struct cleanup *inner_cleanup;
tem = value_as_address (value);
read_memory (tem, str, j);
memset (&str[j], 0, wcwidth);
- obstack_init (&output);
- inner_cleanup = make_cleanup_obstack_free (&output);
+ auto_obstack output;
convert_between_encodings (target_wide_charset (gdbarch),
host_charset (),
obstack_grow_str0 (&output, "");
fprintf_filtered (stream, format, obstack_base (&output));
- do_cleanups (inner_cleanup);
}
/* Subroutine of ui_printf to simplify it.
int dfp_len = 16;
gdb_byte dec[16];
struct type *dfp_type = NULL;
- char decstr[MAX_DECIMAL_STRING];
/* Points to the end of the string so that we can go back
and check for DFP length modifiers. */
dfp_ptr = (gdb_byte *) value_contents (dfp_value);
- decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr);
-
- /* Print the DFP value. */
- fprintf_filtered (stream, "%s", decstr);
+ /* Convert the value to a string and print it. */
+ std::string str = decimal_to_string (dfp_ptr, dfp_len, byte_order);
+ fputs_filtered (str.c_str (), stream);
#endif
}
if (s == 0)
error_no_arg (_("format-control string and values to print"));
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
/* A format string should follow, enveloped in double quotes. */
if (*s++ != '"')
if (*s++ != '"')
error (_("Bad format string, non-terminated '\"'."));
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
if (*s != ',' && *s != 0)
error (_("Invalid argument syntax"));
if (*s == ',')
s++;
- s = skip_spaces_const (s);
+ s = skip_spaces (s);
{
int nargs = 0;
struct type *wctype = lookup_typename (current_language, gdbarch,
"wchar_t", NULL, 0);
struct type *valtype;
- struct obstack output;
- struct cleanup *inner_cleanup;
const gdb_byte *bytes;
valtype = value_type (val_args[i]);
bytes = value_contents (val_args[i]);
- obstack_init (&output);
- inner_cleanup = make_cleanup_obstack_free (&output);
+ auto_obstack output;
convert_between_encodings (target_wide_charset (gdbarch),
host_charset (),
fprintf_filtered (stream, current_substring,
obstack_base (&output));
- do_cleanups (inner_cleanup);
}
break;
case double_arg:
static void
eval_command (char *arg, int from_tty)
{
- struct ui_file *ui_out = mem_fileopen ();
- struct cleanup *cleanups = make_cleanup_ui_file_delete (ui_out);
- char *expanded;
-
- ui_printf (arg, ui_out);
+ string_file stb;
- expanded = ui_file_xstrdup (ui_out, NULL);
- make_cleanup (xfree, expanded);
+ ui_printf (arg, &stb);
- execute_command (expanded, from_tty);
+ std::string expanded = insert_user_defined_cmd_args (stb.c_str ());
- do_cleanups (cleanups);
+ execute_command (&expanded[0], from_tty);
}
void
observer_attach_free_objfile (clear_dangling_display_expressions);
- add_info ("address", address_info,
+ add_info ("address", info_address_command,
_("Describe where symbol SYM is stored."));
- add_info ("symbol", sym_info, _("\
+ add_info ("symbol", info_symbol_command, _("\
Describe what symbol is at location ADDR.\n\
Only for symbols with fixed locations (global or static scope)."));
_("Print line number and file of definition of variable."));
#endif
- add_info ("display", display_info, _("\
+ add_info ("display", info_display_command, _("\
Expressions to display when program stops, with code numbers."));
add_cmd ("undisplay", class_vars, undisplay_command, _("\
You can see these environment settings with the \"show\" command."),
&setlist, "set ", 1, &cmdlist);
if (dbx_commands)
- add_com ("assign", class_vars, set_command, _("\
+ add_com ("assign", class_vars, non_const_set_command, _("\
Evaluate expression EXP and assign result to variable VAR, using assignment\n\
syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
example). VAR may be a debugger \"convenience\" variable (names starting\n\
projects / deliverable / binutils-gdb.git / blobdiff