X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fprintcmd.c;h=3bb43bdedde894a7df2ff84aa39f9476a7dd2cad;hb=edf0c1b7caed4e2bfb9a84fd9c226c6720da1d97;hp=f01d40e3a0a9afd669f52a5f4e7d66b04b95b57f;hpb=5d3729b5d11ada0b369a965d4dcb40ace00e8d84;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/printcmd.c b/gdb/printcmd.c index f01d40e3a0..3bb43bdedd 100644 --- a/gdb/printcmd.c +++ b/gdb/printcmd.c @@ -1,8 +1,6 @@ /* Print values for GNU debugger GDB. - Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, - 2008, 2009 Free Software Foundation, Inc. + Copyright (C) 1986-2012 Free Software Foundation, Inc. This file is part of GDB. @@ -32,6 +30,7 @@ #include "target.h" #include "breakpoint.h" #include "demangle.h" +#include "gdb-demangle.h" #include "valprint.h" #include "annotate.h" #include "symfile.h" /* for overlay functions */ @@ -46,12 +45,13 @@ #include "exceptions.h" #include "observer.h" #include "solist.h" -#include "solib.h" #include "parser-defs.h" #include "charset.h" +#include "arch-utils.h" +#include "cli/cli-utils.h" #ifdef TUI -#include "tui/tui.h" /* For tui_active et.al. */ +#include "tui/tui.h" /* For tui_active et al. */ #endif #if defined(__MINGW32__) && !defined(PRINTF_HAS_LONG_LONG) @@ -61,8 +61,6 @@ # define USE_PRINTF_I64 0 #endif -extern int asm_demangle; /* Whether to demangle syms in asm printouts */ - struct format_data { int count; @@ -108,8 +106,9 @@ static void show_max_symbolic_offset (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (file, _("\ -The largest offset that will be printed in form is %s.\n"), + fprintf_filtered (file, + _("The largest offset that will be " + "printed in form is %s.\n"), value); } @@ -120,13 +119,13 @@ static void show_print_symbol_filename (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (file, _("\ -Printing of source filename and line number with is %s.\n"), + fprintf_filtered (file, _("Printing of source filename and " + "line number with is %s.\n"), value); } /* 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 a signal within it. -1 when not doing one. */ int current_display_number; @@ -135,17 +134,26 @@ struct display { /* Chain link to next auto-display item. */ struct display *next; + /* The expression as the user typed it. */ char *exp_string; + /* Expression to be evaluated and displayed. */ struct expression *exp; + /* Item number of this auto-display item. */ int number; + /* Display format specified. */ struct format_data format; - /* Innermost block required by this expression when evaluated */ + + /* Program space associated with `block'. */ + struct program_space *pspace; + + /* Innermost block required by this expression when evaluated. */ struct block *block; - /* Status of this display (enabled or disabled) */ + + /* Status of this display (enabled or disabled). */ int enabled_p; }; @@ -156,13 +164,25 @@ static struct display *display_chain; static int display_number; -/* Prototypes for exported functions. */ +/* Walk the following statement or block through all displays. + ALL_DISPLAYS_SAFE does so even if the statement deletes the current + display. */ + +#define ALL_DISPLAYS(B) \ + for (B = display_chain; B; B = B->next) + +#define ALL_DISPLAYS_SAFE(B,TMP) \ + for (B = display_chain; \ + B ? (TMP = B->next, 1): 0; \ + B = TMP) + +/* Prototypes for exported functions. */ void output_command (char *, int); void _initialize_printcmd (void); -/* Prototypes for local functions. */ +/* Prototypes for local functions. */ static void do_one_display (struct display *); @@ -250,6 +270,12 @@ decode_format (char **string_ptr, int oformat, int osize) /* Characters default to one byte. */ val.size = osize ? 'b' : osize; break; + case 's': + /* Display strings with byte size chars unless explicitly + specified. */ + val.size = '\0'; + break; + default: /* The default is the size most recently specified. */ val.size = osize; @@ -282,10 +308,11 @@ print_formatted (struct value *val, int size, case 's': { struct type *elttype = value_type (val); + next_address = (value_address (val) - + val_print_string (elttype, + + val_print_string (elttype, NULL, value_address (val), -1, - stream, options)); + stream, options) * len); } return; @@ -293,7 +320,8 @@ print_formatted (struct value *val, int size, /* We often wrap here if there are long symbolic names. */ wrap_here (" "); next_address = (value_address (val) - + gdb_print_insn (value_address (val), stream, + + gdb_print_insn (get_type_arch (type), + value_address (val), stream, &branch_delay_insns)); return; } @@ -308,17 +336,21 @@ print_formatted (struct value *val, int size, || TYPE_CODE (type) == TYPE_CODE_NAMESPACE) value_print (val, stream, options); else - /* User specified format, so don't look to the the type to - tell us what to do. */ - print_scalar_formatted (value_contents (val), type, - options, size, stream); + /* 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); } /* Return builtin floating point type of same length as TYPE. If no such type is found, return TYPE itself. */ static struct type * -float_type_from_length (struct gdbarch *gdbarch, struct type *type) +float_type_from_length (struct type *type) { + struct gdbarch *gdbarch = get_type_arch (type); const struct builtin_type *builtin = builtin_type (gdbarch); unsigned int len = TYPE_LENGTH (type); @@ -333,33 +365,21 @@ float_type_from_length (struct gdbarch *gdbarch, struct type *type) } /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR, - according to OPTIONS and SIZE on STREAM. - Formats s and i are not supported at this level. - - This is how the elements of an array or structure are printed - with a format. */ + according to OPTIONS and SIZE on STREAM. Formats s and i are not + supported at this level. */ void print_scalar_formatted (const void *valaddr, struct type *type, const struct value_print_options *options, 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 (current_gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - /* 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 - again. */ - if (options->format == 's') - { - struct value_print_options opts = *options; - opts.format = 0; - opts.deref_ref = 0; - val_print (type, valaddr, 0, 0, stream, 0, &opts, - current_language); - return; - } + /* String printing should go through val_print_scalar_formatted. */ + gdb_assert (options->format != 's'); if (len > sizeof(LONGEST) && (TYPE_CODE (type) == TYPE_CODE_INT @@ -395,7 +415,7 @@ print_scalar_formatted (const void *valaddr, struct type *type, same, then at this point, the value's length (in target bytes) is gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */ if (TYPE_CODE (type) == TYPE_CODE_PTR) - len = gdbarch_addr_bit (current_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 a negative signed value (e.g. "print/u (short)-1" should print 65535 @@ -446,26 +466,27 @@ print_scalar_formatted (const void *valaddr, struct type *type, case 'a': { CORE_ADDR addr = unpack_pointer (type, valaddr); - print_address (addr, stream); + + print_address (gdbarch, addr, stream); } break; case 'c': { struct value_print_options opts = *options; + opts.format = 0; if (TYPE_UNSIGNED (type)) - value_print (value_from_longest (builtin_type_true_unsigned_char, - val_long), - stream, &opts); - else - value_print (value_from_longest (builtin_type_true_char, val_long), - stream, &opts); + type = builtin_type (gdbarch)->builtin_true_unsigned_char; + else + type = builtin_type (gdbarch)->builtin_true_char; + + value_print (value_from_longest (type, val_long), stream, &opts); } break; case 'f': - type = float_type_from_length (current_gdbarch, type); + type = float_type_from_length (type); print_floating (valaddr, type, stream); break; @@ -515,7 +536,7 @@ print_scalar_formatted (const void *valaddr, struct type *type, if (*cp == '\0') cp--; } - strcpy (buf, cp); + strncpy (buf, cp, sizeof (bits)); fputs_filtered (buf, stream); } break; @@ -550,7 +571,8 @@ set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr) settings of the demangle and asm_demangle variables. */ void -print_address_symbolic (CORE_ADDR addr, struct ui_file *stream, +print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr, + struct ui_file *stream, int do_demangle, char *leadin) { char *name = NULL; @@ -563,7 +585,7 @@ print_address_symbolic (CORE_ADDR addr, struct ui_file *stream, struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name); make_cleanup (free_current_contents, &filename); - if (build_address_symbolic (addr, do_demangle, &name, &offset, + if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset, &filename, &line, &unmapped)) { do_cleanups (cleanup_chain); @@ -597,13 +619,14 @@ print_address_symbolic (CORE_ADDR addr, struct ui_file *stream, } /* 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, - manipulated via ''set print asm-demangle''). Return 0 in case of - success, when all the info in the OUT paramters is valid. Return 1 - otherwise. */ + manipulated via ''set print asm-demangle''). Return 0 in case of + success, when all the info in the OUT paramters is valid. Return 1 + otherwise. */ int -build_address_symbolic (CORE_ADDR addr, /* IN */ +build_address_symbolic (struct gdbarch *gdbarch, + CORE_ADDR addr, /* IN */ int do_demangle, /* IN */ char **name, /* OUT */ int *offset, /* OUT */ @@ -615,7 +638,7 @@ build_address_symbolic (CORE_ADDR addr, /* IN */ struct symbol *symbol; CORE_ADDR name_location = 0; struct obj_section *section = NULL; - char *name_temp = ""; + const char *name_temp = ""; /* Let's say it is mapped (not unmapped). */ *unmapped = 0; @@ -646,6 +669,13 @@ build_address_symbolic (CORE_ADDR addr, /* IN */ if (symbol) { + /* If this is a function (i.e. a code address), strip out any + non-address bits. For instance, display a pointer to the + first instruction of a Thumb function as ; the + second instruction will be , even though the + pointer is . This matches the ISA behavior. */ + addr = gdbarch_addr_bits_remove (gdbarch, addr); + name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)); if (do_demangle || asm_demangle) name_temp = SYMBOL_PRINT_NAME (symbol); @@ -706,10 +736,29 @@ build_address_symbolic (CORE_ADDR addr, /* IN */ after the number. */ void -print_address (CORE_ADDR addr, struct ui_file *stream) +print_address (struct gdbarch *gdbarch, + CORE_ADDR addr, struct ui_file *stream) +{ + fputs_filtered (paddress (gdbarch, addr), stream); + print_address_symbolic (gdbarch, addr, stream, asm_demangle, " "); +} + +/* Return a prefix for instruction address: + "=> " for current instruction, else " ". */ + +const char * +pc_prefix (CORE_ADDR addr) { - fputs_filtered (paddress (addr), stream); - print_address_symbolic (addr, stream, asm_demangle, " "); + if (has_stack_frames ()) + { + struct frame_info *frame; + CORE_ADDR pc; + + frame = get_selected_frame (NULL); + if (get_frame_pc_if_available (frame, &pc) && pc == addr) + return "=> "; + } + return " "; } /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE @@ -718,23 +767,22 @@ print_address (CORE_ADDR addr, struct ui_file *stream) or not. */ void -print_address_demangle (CORE_ADDR addr, struct ui_file *stream, - int do_demangle) +print_address_demangle (const struct value_print_options *opts, + struct gdbarch *gdbarch, CORE_ADDR addr, + struct ui_file *stream, int do_demangle) { - struct value_print_options opts; - get_user_print_options (&opts); if (addr == 0) { fprintf_filtered (stream, "0"); } - else if (opts.addressprint) + else if (opts->addressprint) { - fputs_filtered (paddress (addr), stream); - print_address_symbolic (addr, stream, do_demangle, " "); + fputs_filtered (paddress (gdbarch, addr), stream); + print_address_symbolic (gdbarch, addr, stream, do_demangle, " "); } else { - print_address_symbolic (addr, stream, do_demangle, ""); + print_address_symbolic (gdbarch, addr, stream, do_demangle, ""); } } @@ -759,9 +807,11 @@ do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr) next_gdbarch = gdbarch; next_address = addr; - /* String or instruction format implies fetch single bytes - regardless of the specified size. */ - if (format == 's' || format == 'i') + /* Instruction format implies fetch single bytes + regardless of the specified size. + The case of strings is handled in decode_format, only explicit + size operator are not changed to 'b'. */ + if (format == 'i') size = 'b'; if (size == 'a') @@ -780,13 +830,35 @@ do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr) } if (size == 'b') - val_type = builtin_type_int8; + val_type = builtin_type (next_gdbarch)->builtin_int8; else if (size == 'h') - val_type = builtin_type_int16; + val_type = builtin_type (next_gdbarch)->builtin_int16; else if (size == 'w') - val_type = builtin_type_int32; + val_type = builtin_type (next_gdbarch)->builtin_int32; else if (size == 'g') - val_type = builtin_type_int64; + val_type = builtin_type (next_gdbarch)->builtin_int64; + + if (format == 's') + { + struct type *char_type = NULL; + + /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char + if type is not found. */ + if (size == 'h') + char_type = builtin_type (next_gdbarch)->builtin_char16; + else if (size == 'w') + char_type = builtin_type (next_gdbarch)->builtin_char32; + if (char_type) + val_type = char_type; + else + { + if (size != '\0' && size != 'b') + warning (_("Unable to display strings with " + "size '%c', using 'b' instead."), size); + size = 'b'; + val_type = builtin_type (next_gdbarch)->builtin_int8; + } + } maxelts = 8; if (size == 'w') @@ -804,7 +876,9 @@ do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr) while (count > 0) { QUIT; - print_address (next_address, gdb_stdout); + if (format == 'i') + fputs_filtered (pc_prefix (next_address), gdb_stdout); + print_address (next_gdbarch, next_address, gdb_stdout); printf_filtered (":"); for (i = maxelts; i > 0 && count > 0; @@ -826,7 +900,7 @@ do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr) the address stored in LAST_EXAMINE_VALUE. FIXME: Should the disassembler be modified so that LAST_EXAMINE_VALUE 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); if (last_examine_value) @@ -887,7 +961,6 @@ print_command_1 (char *exp, int inspect, int voidprint) if (exp && *exp) { - struct type *type; expr = parse_expression (exp); old_chain = make_cleanup (free_current_contents, &expr); cleanup = 1; @@ -1004,6 +1077,23 @@ set_command (char *exp, int from_tty) struct expression *expr = parse_expression (exp); struct cleanup *old_chain = make_cleanup (free_current_contents, &expr); + + if (expr->nelts >= 1) + switch (expr->elts[0].opcode) + { + case UNOP_PREINCREMENT: + case UNOP_POSTINCREMENT: + case UNOP_PREDECREMENT: + case UNOP_POSTDECREMENT: + case BINOP_ASSIGN: + case BINOP_ASSIGN_MODIFY: + case BINOP_COMMA: + break; + default: + warning + (_("Expression is not an assignment (and might have no effect)")); + } + evaluate_expression (expr); do_cleanups (old_chain); } @@ -1109,14 +1199,14 @@ address_info (char *exp, int from_tty) struct minimal_symbol *msymbol; long val; struct obj_section *section; - CORE_ADDR load_addr; + CORE_ADDR load_addr, context_pc = 0; 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) error (_("Argument required.")); - sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN, + sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN, &is_a_field_of_this); if (sym == NULL) { @@ -1137,20 +1227,21 @@ address_info (char *exp, int from_tty) if (msymbol != NULL) { + gdbarch = get_objfile_arch (msymbol_objfile (msymbol)); load_addr = SYMBOL_VALUE_ADDRESS (msymbol); printf_filtered ("Symbol \""); fprintf_symbol_filtered (gdb_stdout, exp, current_language->la_language, DMGL_ANSI); printf_filtered ("\" is at "); - fputs_filtered (paddress (load_addr), gdb_stdout); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); printf_filtered (" in a file compiled without debugging"); section = SYMBOL_OBJ_SECTION (msymbol); if (section_is_overlay (section)) { load_addr = overlay_unmapped_address (load_addr, section); printf_filtered (",\n -- loaded at "); - fputs_filtered (paddress (load_addr), gdb_stdout); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); printf_filtered (" in overlay section %s", section->the_bfd_section->name); } @@ -1178,13 +1269,13 @@ address_info (char *exp, int from_tty) case LOC_LABEL: printf_filtered ("a label at address "); - fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)), - gdb_stdout); + load_addr = SYMBOL_VALUE_ADDRESS (sym); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); if (section_is_overlay (section)) { load_addr = overlay_unmapped_address (load_addr, section); printf_filtered (",\n -- loaded at "); - fputs_filtered (paddress (load_addr), gdb_stdout); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); printf_filtered (" in overlay section %s", section->the_bfd_section->name); } @@ -1196,7 +1287,8 @@ address_info (char *exp, int from_tty) Unfortunately DWARF 2 stores the frame-base (instead of the function) location in a function's symbol. Oops! For the moment enable this when/where applicable. */ - SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout); + SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc, + gdb_stdout); break; case LOC_REGISTER: @@ -1218,13 +1310,13 @@ address_info (char *exp, int from_tty) case LOC_STATIC: printf_filtered (_("static storage at address ")); - fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)), - gdb_stdout); + load_addr = SYMBOL_VALUE_ADDRESS (sym); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); if (section_is_overlay (section)) { load_addr = overlay_unmapped_address (load_addr, section); printf_filtered (_(",\n -- loaded at ")); - fputs_filtered (paddress (load_addr), gdb_stdout); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); printf_filtered (_(" in overlay section %s"), section->the_bfd_section->name); } @@ -1256,12 +1348,12 @@ address_info (char *exp, int from_tty) case LOC_BLOCK: printf_filtered (_("a function at address ")); load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); - fputs_filtered (paddress (load_addr), gdb_stdout); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); if (section_is_overlay (section)) { load_addr = overlay_unmapped_address (load_addr, section); printf_filtered (_(",\n -- loaded at ")); - fputs_filtered (paddress (load_addr), gdb_stdout); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); printf_filtered (_(" in overlay section %s"), section->the_bfd_section->name); } @@ -1283,16 +1375,17 @@ address_info (char *exp, int from_tty) && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) printf_filtered (_("a thread-local variable at offset %s " "in the thread-local storage for `%s'"), - paddr_nz (load_addr), section->objfile->name); + paddress (gdbarch, load_addr), + section->objfile->name); else { printf_filtered (_("static storage at address ")); - fputs_filtered (paddress (load_addr), gdb_stdout); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); if (section_is_overlay (section)) { load_addr = overlay_unmapped_address (load_addr, section); printf_filtered (_(",\n -- loaded at ")); - fputs_filtered (paddress (load_addr), gdb_stdout); + fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout); printf_filtered (_(" in overlay section %s"), section->the_bfd_section->name); } @@ -1345,7 +1438,7 @@ x_command (char *exp, int from_tty) old_chain = make_cleanup (free_current_contents, &expr); val = evaluate_expression (expr); if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF) - val = value_ind (val); + val = coerce_ref (val); /* In rvalue contexts, such as this, functions are coerced into pointers to functions. This makes "x/i main" work. */ if (/* last_format == 'i' && */ @@ -1365,11 +1458,14 @@ x_command (char *exp, int from_tty) do_examine (fmt, next_gdbarch, next_address); /* If the examine succeeds, we remember its size and format for next - time. */ - last_size = fmt.size; + time. Set last_size to 'b' for strings. */ + if (fmt.format == 's') + last_size = 'b'; + else + last_size = fmt.size; last_format = fmt.format; - /* Set a couple of internal variables if appropriate. */ + /* Set a couple of internal variables if appropriate. */ if (last_examine_value) { /* Make last address examined available to the user as $_. Use @@ -1443,6 +1539,7 @@ display_command (char *exp, int from_tty) new->exp_string = xstrdup (exp); new->exp = expr; new->block = innermost_block; + new->pspace = current_program_space; new->next = display_chain; new->number = ++display_number; new->format = fmt; @@ -1479,48 +1576,85 @@ clear_displays (void) } } -/* Delete the auto-display number NUM. */ +/* Delete the auto-display DISPLAY. */ static void -delete_display (int num) +delete_display (struct display *display) { - struct display *d1, *d; + struct display *d; - if (!display_chain) - error (_("No display number %d."), num); + gdb_assert (display != NULL); - if (display_chain->number == num) - { - d1 = display_chain; - display_chain = d1->next; - free_display (d1); - } - else - for (d = display_chain;; d = d->next) + if (display_chain == display) + display_chain = display->next; + + ALL_DISPLAYS (d) + if (d->next == display) { - if (d->next == 0) - error (_("No display number %d."), num); - if (d->next->number == num) - { - d1 = d->next; - d->next = d1->next; - free_display (d1); - break; - } + d->next = display->next; + break; } + + free_display (display); +} + +/* Call FUNCTION on each of the displays whose numbers are given in + ARGS. DATA is passed unmodified to FUNCTION. */ + +static void +map_display_numbers (char *args, + void (*function) (struct display *, + void *), + void *data) +{ + struct get_number_or_range_state state; + struct display *b, *tmp; + int num; + + if (args == NULL) + error_no_arg (_("one or more display numbers")); + + init_number_or_range (&state, args); + + while (!state.finished) + { + char *p = state.string; + + num = get_number_or_range (&state); + if (num == 0) + warning (_("bad display number at or near '%s'"), p); + else + { + struct display *d, *tmp; + + ALL_DISPLAYS_SAFE (d, tmp) + if (d->number == num) + break; + if (d == NULL) + printf_unfiltered (_("No display number %d.\n"), num); + else + function (d, data); + } + } } -/* Delete some values from the auto-display chain. - Specify the element numbers. */ +/* Callback for map_display_numbers, that deletes a display. */ + +static void +do_delete_display (struct display *d, void *data) +{ + delete_display (d); +} + +/* "undisplay" command. */ static void undisplay_command (char *args, int from_tty) { - char *p = args; - char *p1; int num; + struct get_number_or_range_state state; - if (args == 0) + if (args == NULL) { if (query (_("Delete all auto-display expressions? "))) clear_displays (); @@ -1528,40 +1662,41 @@ undisplay_command (char *args, int from_tty) return; } - while (*p) - { - p1 = p; - while (*p1 >= '0' && *p1 <= '9') - p1++; - if (*p1 && *p1 != ' ' && *p1 != '\t') - error (_("Arguments must be display numbers.")); - - num = atoi (p); - - delete_display (num); - - p = p1; - while (*p == ' ' || *p == '\t') - p++; - } + map_display_numbers (args, do_delete_display, NULL); dont_repeat (); } /* Display a single auto-display. 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 do_one_display (struct display *d) { + struct cleanup *old_chain; int within_current_scope; if (d->enabled_p == 0) return; + /* The expression carries the architecture that was used at parse time. + This is a problem if the expression depends on architecture features + (e.g. register numbers), and the current architecture is now different. + For example, a display statement like "display/i $pc" is expected to + display the PC register of the current architecture, not the arch at + the time the display command was given. Therefore, we re-parse the + expression if the current architecture has changed. */ + if (d->exp != NULL && d->exp->gdbarch != get_current_arch ()) + { + xfree (d->exp); + d->exp = NULL; + d->block = NULL; + } + if (d->exp == NULL) { volatile struct gdb_exception ex; + TRY_CATCH (ex, RETURN_MASK_ALL) { innermost_block = NULL; @@ -1579,12 +1714,18 @@ do_one_display (struct display *d) } if (d->block) - within_current_scope = contained_in (get_selected_block (0), d->block); + { + if (d->pspace == current_program_space) + within_current_scope = contained_in (get_selected_block (0), d->block); + else + within_current_scope = 0; + } else within_current_scope = 1; if (!within_current_scope) return; + old_chain = make_cleanup_restore_integer (¤t_display_number); current_display_number = d->number; annotate_display_begin (); @@ -1593,8 +1734,7 @@ do_one_display (struct display *d) printf_filtered (": "); if (d->format.size) { - CORE_ADDR addr; - struct value *val; + volatile struct gdb_exception ex; annotate_display_format (); @@ -1616,18 +1756,26 @@ do_one_display (struct display *d) else printf_filtered (" "); - val = evaluate_expression (d->exp); - addr = value_as_address (val); - if (d->format.format == 'i') - addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr); - annotate_display_value (); - do_examine (d->format, d->exp->gdbarch, addr); + TRY_CATCH (ex, RETURN_MASK_ERROR) + { + struct value *val; + CORE_ADDR addr; + + val = evaluate_expression (d->exp); + addr = value_as_address (val); + if (d->format.format == 'i') + addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr); + do_examine (d->format, d->exp->gdbarch, addr); + } + if (ex.reason < 0) + fprintf_filtered (gdb_stdout, _("\n"), ex.message); } else { struct value_print_options opts; + volatile struct gdb_exception ex; annotate_display_format (); @@ -1645,15 +1793,23 @@ do_one_display (struct display *d) get_formatted_print_options (&opts, d->format.format); opts.raw = d->format.raw; - print_formatted (evaluate_expression (d->exp), - d->format.size, &opts, gdb_stdout); + + TRY_CATCH (ex, RETURN_MASK_ERROR) + { + struct value *val; + + val = evaluate_expression (d->exp); + print_formatted (val, d->format.size, &opts, gdb_stdout); + } + if (ex.reason < 0) + fprintf_filtered (gdb_stdout, _(""), ex.message); printf_filtered ("\n"); } annotate_display_end (); gdb_flush (gdb_stdout); - current_display_number = -1; + do_cleanups (old_chain); } /* Display all of the values on the auto-display chain which can be @@ -1691,8 +1847,9 @@ disable_current_display (void) if (current_display_number >= 0) { disable_display (current_display_number); - fprintf_unfiltered (gdb_stderr, _("\ -Disabling display %d to avoid infinite recursion.\n"), + fprintf_unfiltered (gdb_stderr, + _("Disabling display %d to " + "avoid infinite recursion.\n"), current_display_number); } current_display_number = -1; @@ -1725,115 +1882,47 @@ Num Enb Expression\n")); } } +/* Callback fo map_display_numbers, that enables or disables the + passed in display D. */ + static void -enable_display (char *args, int from_tty) +do_enable_disable_display (struct display *d, void *data) { - char *p = args; - char *p1; - int num; - struct display *d; - - if (p == 0) - { - for (d = display_chain; d; d = d->next) - d->enabled_p = 1; - } - else - while (*p) - { - p1 = p; - while (*p1 >= '0' && *p1 <= '9') - p1++; - if (*p1 && *p1 != ' ' && *p1 != '\t') - error (_("Arguments must be display numbers.")); - - num = atoi (p); - - for (d = display_chain; d; d = d->next) - if (d->number == num) - { - d->enabled_p = 1; - goto win; - } - printf_unfiltered (_("No display number %d.\n"), num); - win: - p = p1; - while (*p == ' ' || *p == '\t') - p++; - } + d->enabled_p = *(int *) data; } +/* Implamentation of both the "disable display" and "enable display" + commands. ENABLE decides what to do. */ + static void -disable_display_command (char *args, int from_tty) +enable_disable_display_command (char *args, int from_tty, int enable) { - char *p = args; - char *p1; - struct display *d; - - if (p == 0) + if (args == NULL) { - for (d = display_chain; d; d = d->next) - d->enabled_p = 0; - } - else - while (*p) - { - p1 = p; - while (*p1 >= '0' && *p1 <= '9') - p1++; - if (*p1 && *p1 != ' ' && *p1 != '\t') - error (_("Arguments must be display numbers.")); + struct display *d; - disable_display (atoi (p)); + ALL_DISPLAYS (d) + d->enabled_p = enable; + return; + } - p = p1; - while (*p == ' ' || *p == '\t') - p++; - } + map_display_numbers (args, do_enable_disable_display, &enable); } -/* Return 1 if D uses SOLIB (and will become dangling when SOLIB - is unloaded), otherwise return 0. */ +/* The "enable display" command. */ -static int -display_uses_solib_p (const struct display *d, - const struct so_list *solib) +static void +enable_display_command (char *args, int from_tty) { - int endpos; - struct expression *const exp = d->exp; - const union exp_element *const elts = exp->elts; - - if (d->block != NULL - && solib_contains_address_p (solib, d->block->startaddr)) - return 1; - - for (endpos = exp->nelts; endpos > 0; ) - { - int i, args, oplen = 0; - - exp->language_defn->la_exp_desc->operator_length (exp, endpos, - &oplen, &args); - gdb_assert (oplen > 0); - - i = endpos - oplen; - if (elts[i].opcode == OP_VAR_VALUE) - { - const struct block *const block = elts[i + 1].block; - const struct symbol *const symbol = elts[i + 2].symbol; - const struct obj_section *const section = - SYMBOL_OBJ_SECTION (symbol); - - if (block != NULL - && solib_contains_address_p (solib, block->startaddr)) - return 1; + enable_disable_display_command (args, from_tty, 1); +} - if (section && section->objfile == solib->objfile) - return 1; - } - endpos -= oplen; - } +/* The "disable display" command. */ - return 0; +static void +disable_display_command (char *args, int from_tty) +{ + enable_disable_display_command (args, from_tty, 0); } /* display_chain items point to blocks and expressions. Some expressions in @@ -1847,17 +1936,28 @@ display_uses_solib_p (const struct display *d, static void clear_dangling_display_expressions (struct so_list *solib) { + struct objfile *objfile = solib->objfile; struct display *d; - struct objfile *objfile = NULL; - for (d = display_chain; d; d = d->next) + /* With no symbol file we cannot have a block or expression from it. */ + if (objfile == NULL) + return; + if (objfile->separate_debug_objfile_backlink) + objfile = objfile->separate_debug_objfile_backlink; + gdb_assert (objfile->pspace == solib->pspace); + + for (d = display_chain; d != NULL; d = d->next) { - if (d->exp && display_uses_solib_p (d, solib)) - { - xfree (d->exp); - d->exp = NULL; - d->block = NULL; - } + if (d->pspace != solib->pspace) + continue; + + if (lookup_objfile_from_block (d->block) == objfile + || (d->exp && exp_uses_objfile (d->exp, objfile))) + { + xfree (d->exp); + d->exp = NULL; + d->block = NULL; + } } } @@ -1873,22 +1973,32 @@ print_variable_and_value (const char *name, struct symbol *var, struct frame_info *frame, struct ui_file *stream, int indent) { - struct value *val; - struct value_print_options opts; + volatile struct gdb_exception except; if (!name) name = SYMBOL_PRINT_NAME (var); fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name); + TRY_CATCH (except, RETURN_MASK_ERROR) + { + struct value *val; + struct value_print_options opts; - val = read_var_value (var, frame); - get_user_print_options (&opts); - common_val_print (val, stream, indent, &opts, current_language); + val = read_var_value (var, frame); + get_user_print_options (&opts); + opts.deref_ref = 1; + common_val_print (val, stream, indent, &opts, current_language); + } + if (except.reason < 0) + fprintf_filtered(stream, "", name, + except.message); fprintf_filtered (stream, "\n"); } +/* printf "printf format string" ARG to STREAM. */ + static void -printf_command (char *arg, int from_tty) +ui_printf (char *arg, struct ui_file *stream) { char *f = NULL; char *s = arg; @@ -1906,9 +2016,7 @@ printf_command (char *arg, int from_tty) if (s == 0) error_no_arg (_("format-control string and values to print")); - /* Skip white space before format string */ - while (*s == ' ' || *s == '\t') - s++; + s = skip_spaces (s); /* A format string should follow, enveloped in double quotes. */ if (*s++ != '"') @@ -1958,7 +2066,7 @@ printf_command (char *arg, int from_tty) *f++ = '"'; break; default: - /* ??? TODO: handle other escape sequences */ + /* ??? TODO: handle other escape sequences. */ error (_("Unrecognized escape character \\%c in format string."), c); } @@ -1972,16 +2080,14 @@ printf_command (char *arg, int from_tty) /* Skip over " and following space and comma. */ s++; *f++ = '\0'; - while (*s == ' ' || *s == '\t') - s++; + s = skip_spaces (s); if (*s != ',' && *s != 0) error (_("Invalid argument syntax")); if (*s == ',') s++; - while (*s == ' ' || *s == '\t') - s++; + s = skip_spaces (s); /* Need extra space for the '\0's. Doubling the size is sufficient. */ substrings = alloca (strlen (string) * 2); @@ -2180,7 +2286,8 @@ printf_command (char *arg, int from_tty) } if (bad) - error (_("Inappropriate modifiers to format specifier '%c' in printf"), + error (_("Inappropriate modifiers to " + "format specifier '%c' in printf"), *f); f++; @@ -2190,6 +2297,7 @@ printf_command (char *arg, int from_tty) /* Windows' printf does support long long, but not the usual way. Convert %lld to %I64d. */ int length_before_ll = f - last_arg - 1 - lcount; + strncpy (current_substring, last_arg, length_before_ll); strcpy (current_substring + length_before_ll, "I64"); current_substring[length_before_ll + 3] = @@ -2201,6 +2309,7 @@ printf_command (char *arg, int from_tty) { /* Convert %ls or %lc to %s. */ int length_before_ls = f - last_arg - 2; + strncpy (current_substring, last_arg, length_before_ls); strcpy (current_substring + length_before_ls, "s"); current_substring += length_before_ls + 2; @@ -2221,6 +2330,7 @@ printf_command (char *arg, int from_tty) while (*s != '\0') { char *s1; + if (nargs == allocated_args) val_args = (struct value **) xrealloc ((char *) val_args, (allocated_args *= 2) @@ -2248,12 +2358,14 @@ printf_command (char *arg, int from_tty) gdb_byte *str; CORE_ADDR tem; int j; + tem = value_as_address (val_args[i]); /* This is a %s argument. Find the length of the string. */ for (j = 0;; j++) { gdb_byte c; + QUIT; read_memory (tem + j, &c, 1); if (c == 0) @@ -2266,7 +2378,7 @@ printf_command (char *arg, int from_tty) read_memory (tem, str, j); str[j] = 0; - printf_filtered (current_substring, (char *) str); + fprintf_filtered (stream, current_substring, (char *) str); } break; case wide_string_arg: @@ -2274,8 +2386,10 @@ printf_command (char *arg, int from_tty) gdb_byte *str; CORE_ADDR tem; int j; - struct type *wctype = lookup_typename (current_language, - current_gdbarch, + struct gdbarch *gdbarch + = get_type_arch (value_type (val_args[i])); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + struct type *wctype = lookup_typename (current_language, gdbarch, "wchar_t", NULL, 0); int wcwidth = TYPE_LENGTH (wctype); gdb_byte *buf = alloca (wcwidth); @@ -2289,7 +2403,7 @@ printf_command (char *arg, int from_tty) { QUIT; read_memory (tem + j, buf, wcwidth); - if (extract_unsigned_integer (buf, wcwidth) == 0) + if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0) break; } @@ -2302,20 +2416,22 @@ printf_command (char *arg, int from_tty) obstack_init (&output); inner_cleanup = make_cleanup_obstack_free (&output); - convert_between_encodings (target_wide_charset (), + convert_between_encodings (target_wide_charset (gdbarch), host_charset (), str, j, wcwidth, &output, translit_char); obstack_grow_str0 (&output, ""); - printf_filtered (current_substring, obstack_base (&output)); + fprintf_filtered (stream, current_substring, + obstack_base (&output)); do_cleanups (inner_cleanup); } break; case wide_char_arg: { - struct type *wctype = lookup_typename (current_language, - current_gdbarch, + struct gdbarch *gdbarch + = get_type_arch (value_type (val_args[i])); + struct type *wctype = lookup_typename (current_language, gdbarch, "wchar_t", NULL, 0); struct type *valtype; struct obstack output; @@ -2332,14 +2448,15 @@ printf_command (char *arg, int from_tty) obstack_init (&output); inner_cleanup = make_cleanup_obstack_free (&output); - convert_between_encodings (target_wide_charset (), + convert_between_encodings (target_wide_charset (gdbarch), host_charset (), bytes, TYPE_LENGTH (valtype), TYPE_LENGTH (valtype), &output, translit_char); obstack_grow_str0 (&output, ""); - printf_filtered (current_substring, obstack_base (&output)); + fprintf_filtered (stream, current_substring, + obstack_base (&output)); do_cleanups (inner_cleanup); } break; @@ -2351,12 +2468,12 @@ printf_command (char *arg, int from_tty) /* If format string wants a float, unchecked-convert the value to floating point of the same size. */ - type = float_type_from_length (current_gdbarch, type); + type = float_type_from_length (type); val = unpack_double (type, value_contents (val_args[i]), &inv); if (inv) error (_("Invalid floating value found in program.")); - printf_filtered (current_substring, (double) val); + fprintf_filtered (stream, current_substring, (double) val); break; } case long_double_arg: @@ -2368,12 +2485,13 @@ printf_command (char *arg, int from_tty) /* If format string wants a float, unchecked-convert the value to floating point of the same size. */ - type = float_type_from_length (current_gdbarch, type); + type = float_type_from_length (type); val = unpack_double (type, value_contents (val_args[i]), &inv); if (inv) error (_("Invalid floating value found in program.")); - printf_filtered (current_substring, (long double) val); + fprintf_filtered (stream, current_substring, + (long double) val); break; } #else @@ -2383,7 +2501,8 @@ printf_command (char *arg, int from_tty) #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG) { long long val = value_as_long (val_args[i]); - printf_filtered (current_substring, val); + + fprintf_filtered (stream, current_substring, val); break; } #else @@ -2392,13 +2511,15 @@ printf_command (char *arg, int from_tty) case int_arg: { int val = value_as_long (val_args[i]); - printf_filtered (current_substring, val); + + fprintf_filtered (stream, current_substring, val); break; } case long_arg: { long val = value_as_long (val_args[i]); - printf_filtered (current_substring, val); + + fprintf_filtered (stream, current_substring, val); break; } @@ -2406,10 +2527,11 @@ printf_command (char *arg, int from_tty) case decfloat_arg: { const gdb_byte *param_ptr = value_contents (val_args[i]); + #if defined (PRINTF_HAS_DECFLOAT) /* If we have native support for Decimal floating printing, handle it here. */ - printf_filtered (current_substring, param_ptr); + fprintf_filtered (stream, current_substring, param_ptr); #else /* As a workaround until vasprintf has native support for DFP @@ -2422,6 +2544,8 @@ printf_command (char *arg, int from_tty) /* Parameter data. */ struct type *param_type = value_type (val_args[i]); unsigned int param_len = TYPE_LENGTH (param_type); + struct gdbarch *gdbarch = get_type_arch (param_type); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); /* DFP output data. */ struct value *dfp_value = NULL; @@ -2450,18 +2574,18 @@ printf_command (char *arg, int from_tty) if (*sos == 'H') { dfp_len = 4; - dfp_type = builtin_type (current_gdbarch)->builtin_decfloat; + dfp_type = builtin_type (gdbarch)->builtin_decfloat; } else if (*sos == 'D' && *(sos - 1) == 'D') { dfp_len = 16; - dfp_type = builtin_type (current_gdbarch)->builtin_declong; + dfp_type = builtin_type (gdbarch)->builtin_declong; sos--; } else { dfp_len = 8; - dfp_type = builtin_type (current_gdbarch)->builtin_decdouble; + dfp_type = builtin_type (gdbarch)->builtin_decdouble; } } @@ -2481,21 +2605,22 @@ printf_command (char *arg, int from_tty) /* Conversion between different DFP types. */ if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT) - decimal_convert (param_ptr, param_len, dec, dfp_len); + decimal_convert (param_ptr, param_len, byte_order, + dec, dfp_len, byte_order); else /* If this is a non-trivial conversion, just output 0. A correct converted value can be displayed by explicitly casting to a DFP type. */ - decimal_from_string (dec, dfp_len, "0"); + decimal_from_string (dec, dfp_len, byte_order, "0"); dfp_value = value_from_decfloat (dfp_type, dec); dfp_ptr = (gdb_byte *) value_contents (dfp_value); - decimal_to_string (dfp_ptr, dfp_len, decstr); + decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr); /* Print the DFP value. */ - printf_filtered (current_substring, decstr); + fprintf_filtered (stream, current_substring, decstr); break; #endif @@ -2523,6 +2648,7 @@ printf_command (char *arg, int from_tty) while (*p) { int is_percent = (*p == '%'); + *fmt_p++ = *p++; if (is_percent) { @@ -2549,13 +2675,13 @@ printf_command (char *arg, int from_tty) *fmt_p++ = 'l'; *fmt_p++ = 'x'; *fmt_p++ = '\0'; - printf_filtered (fmt, val); + fprintf_filtered (stream, fmt, val); } else { *fmt_p++ = 's'; *fmt_p++ = '\0'; - printf_filtered (fmt, "(nil)"); + fprintf_filtered (stream, fmt, "(nil)"); } break; @@ -2567,12 +2693,44 @@ printf_command (char *arg, int from_tty) /* Skip to the next substring. */ current_substring += strlen (current_substring) + 1; } - /* Print the portion of the format string after the last argument. */ - puts_filtered (last_arg); + /* Print the portion of the format string after the last argument. + Note that this will not include any ordinary %-specs, but it + might include "%%". That is why we use printf_filtered and not + puts_filtered here. Also, we pass a dummy argument because + some platforms have modified GCC to include -Wformat-security + by default, which will warn here if there is no argument. */ + fprintf_filtered (stream, last_arg, 0); } do_cleanups (old_cleanups); } +/* Implement the "printf" command. */ + +static void +printf_command (char *arg, int from_tty) +{ + ui_printf (arg, gdb_stdout); +} + +/* Implement the "eval" command. */ + +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); + + expanded = ui_file_xstrdup (ui_out, NULL); + make_cleanup (xfree, expanded); + + execute_command (expanded, from_tty); + + do_cleanups (cleanups); +} + void _initialize_printcmd (void) { @@ -2627,7 +2785,7 @@ and examining is done as in the \"x\" command.\n\n\ With no argument, display all currently requested auto-display expressions.\n\ Use \"undisplay\" to cancel display requests previously made.")); - add_cmd ("display", class_vars, enable_display, _("\ + add_cmd ("display", class_vars, enable_display_command, _("\ Enable some expressions to be displayed when program stops.\n\ Arguments are the code numbers of the expressions to resume displaying.\n\ No argument means enable all automatic-display expressions.\n\ @@ -2675,7 +2833,7 @@ Use \"set variable\" for variables with names identical to set subcommands.\n\ \nWith a subcommand, this command modifies parts of the gdb environment.\n\ You can see these environment settings with the \"show\" command.")); - /* "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, _("\ Call a function in the program.\n\ The argument is the function name and arguments, in the notation of the\n\ @@ -2736,4 +2894,8 @@ Show printing of source filename and line number with ."), NULL, NULL, show_print_symbol_filename, &setprintlist, &showprintlist); + + add_com ("eval", no_class, eval_command, _("\ +Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\ +a command line, and call it.")); }