X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fvalprint.c;h=10020901c2df781033c31d6ee27dbaedae6514d1;hb=3d6e9d2336c9ffcedb10f89631981a23dd518e8e;hp=2420fb5c96cde28edf34e1326d0ee134241c5f14;hpb=4ac0cb1cf04f105586746a6cce5b0f93d76f2b33;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valprint.c b/gdb/valprint.c index 2420fb5c96..10020901c2 100644 --- a/gdb/valprint.c +++ b/gdb/valprint.c @@ -1,6 +1,6 @@ /* Print values for GDB, the GNU debugger. - Copyright (C) 1986-2017 Free Software Foundation, Inc. + Copyright (C) 1986-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -27,9 +27,7 @@ #include "language.h" #include "annotate.h" #include "valprint.h" -#include "floatformat.h" -#include "doublest.h" -#include "dfp.h" +#include "target-float.h" #include "extension.h" #include "ada-lang.h" #include "gdb_obstack.h" @@ -37,6 +35,7 @@ #include "typeprint.h" #include #include +#include "common/byte-vector.h" /* Maximum number of wchars returned from wchar_iterate. */ #define MAX_WCHARS 4 @@ -71,9 +70,6 @@ struct converted_character int repeat_count; }; -typedef struct converted_character converted_character_d; -DEF_VEC_O (converted_character_d); - /* Command lists for set/show print raw. */ struct cmd_list_element *setprintrawlist; struct cmd_list_element *showprintrawlist; @@ -83,28 +79,14 @@ struct cmd_list_element *showprintrawlist; static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int *errptr); -static void show_print (char *, int); - -static void set_print (char *, int); - -static void set_radix (char *, int); - -static void show_radix (char *, int); - -static void set_input_radix (char *, int, struct cmd_list_element *); - static void set_input_radix_1 (int, unsigned); -static void set_output_radix (char *, int, struct cmd_list_element *); - static void set_output_radix_1 (int, unsigned); static void val_print_type_code_flags (struct type *type, const gdb_byte *valaddr, struct ui_file *stream); -void _initialize_valprint (void); - #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */ struct value_print_options user_print_options = @@ -781,25 +763,12 @@ generic_val_print_int (struct type *type, struct value *original_value, const struct value_print_options *options) { - struct gdbarch *gdbarch = get_type_arch (type); - int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); - - if (options->format || options->output_format) - { - struct value_print_options opts = *options; - - opts.format = (options->format ? options->format - : options->output_format); - val_print_scalar_formatted (type, embedded_offset, - original_value, &opts, 0, stream); - } - else - { - const gdb_byte *valaddr = value_contents_for_printing (original_value); + struct value_print_options opts = *options; - val_print_type_code_int (type, valaddr + embedded_offset * unit_size, - stream); - } + opts.format = (options->format ? options->format + : options->output_format); + val_print_scalar_formatted (type, embedded_offset, + original_value, &opts, 0, stream); } /* generic_val_print helper for TYPE_CODE_CHAR. */ @@ -838,7 +807,7 @@ generic_val_print_char (struct type *type, struct type *unresolved_type, } } -/* generic_val_print helper for TYPE_CODE_FLT. */ +/* generic_val_print helper for TYPE_CODE_FLT and TYPE_CODE_DECFLOAT. */ static void generic_val_print_float (struct type *type, @@ -862,29 +831,6 @@ generic_val_print_float (struct type *type, } } -/* generic_val_print helper for TYPE_CODE_DECFLOAT. */ - -static void -generic_val_print_decfloat (struct type *type, - int embedded_offset, struct ui_file *stream, - struct value *original_value, - const struct value_print_options *options) -{ - struct gdbarch *gdbarch = get_type_arch (type); - int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); - - if (options->format) - val_print_scalar_formatted (type, embedded_offset, original_value, - options, 0, stream); - else - { - const gdb_byte *valaddr = value_contents_for_printing (original_value); - - print_decimal_floating (valaddr + embedded_offset * unit_size, type, - stream); - } -} - /* generic_val_print helper for TYPE_CODE_COMPLEX. */ static void @@ -1008,15 +954,11 @@ generic_val_print (struct type *type, break; case TYPE_CODE_FLT: + case TYPE_CODE_DECFLOAT: generic_val_print_float (type, embedded_offset, stream, original_value, options); break; - case TYPE_CODE_DECFLOAT: - generic_val_print_decfloat (type, embedded_offset, stream, - original_value, options); - break; - case TYPE_CODE_VOID: fputs_filtered (decorations->void_name, stream); break; @@ -1044,7 +986,6 @@ generic_val_print (struct type *type, error (_("Unhandled type code %d in symbol table."), TYPE_CODE (type)); } - gdb_flush (stream); } /* Print using the given LANGUAGE the data of type TYPE located at @@ -1090,7 +1031,6 @@ val_print (struct type *type, LONGEST embedded_offset, if (TYPE_STUB (real_type)) { fprintf_filtered (stream, _("")); - gdb_flush (stream); return; } @@ -1237,43 +1177,6 @@ value_print (struct value *val, struct ui_file *stream, LA_VALUE_PRINT (val, stream, options); } -/* Called by various _val_print routines to print - TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the - value. STREAM is where to print the value. */ - -void -val_print_type_code_int (struct type *type, const gdb_byte *valaddr, - struct ui_file *stream) -{ - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); - - if (TYPE_LENGTH (type) > sizeof (LONGEST)) - { - LONGEST val; - - if (TYPE_UNSIGNED (type) - && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type), - byte_order, &val)) - { - print_longest (stream, 'u', 0, val); - } - else - { - /* Signed, or we couldn't turn an unsigned value into a - LONGEST. For signed values, one could assume two's - complement (a reasonable assumption, I think) and do - better than this. */ - print_hex_chars (stream, (unsigned char *) valaddr, - TYPE_LENGTH (type), byte_order, false); - } - } - else - { - print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, - unpack_long (type, valaddr)); - } -} - static void val_print_type_code_flags (struct type *type, const gdb_byte *valaddr, struct ui_file *stream) @@ -1446,102 +1349,21 @@ longest_to_int (LONGEST arg) return (rtnval); } -/* Print a floating point value of type TYPE (not always a - TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */ +/* Print a floating point value of floating-point type TYPE, + pointed to in GDB by VALADDR, on STREAM. */ void print_floating (const gdb_byte *valaddr, struct type *type, struct ui_file *stream) { - DOUBLEST doub; - int inv; - const struct floatformat *fmt = NULL; - unsigned len = TYPE_LENGTH (type); - enum float_kind kind; - - /* If it is a floating-point, check for obvious problems. */ - if (TYPE_CODE (type) == TYPE_CODE_FLT) - fmt = floatformat_from_type (type); - if (fmt != NULL) - { - kind = floatformat_classify (fmt, valaddr); - if (kind == float_nan) - { - if (floatformat_is_negative (fmt, valaddr)) - fprintf_filtered (stream, "-"); - fprintf_filtered (stream, "nan("); - fputs_filtered ("0x", stream); - fputs_filtered (floatformat_mantissa (fmt, valaddr), stream); - fprintf_filtered (stream, ")"); - return; - } - else if (kind == float_infinite) - { - if (floatformat_is_negative (fmt, valaddr)) - fputs_filtered ("-", stream); - fputs_filtered ("inf", stream); - return; - } - } - - /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating() - isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double - needs to be used as that takes care of any necessary type - conversions. Such conversions are of course direct to DOUBLEST - and disregard any possible target floating point limitations. - For instance, a u64 would be converted and displayed exactly on a - host with 80 bit DOUBLEST but with loss of information on a host - with 64 bit DOUBLEST. */ - - doub = unpack_double (type, valaddr, &inv); - if (inv) - { - fprintf_filtered (stream, ""); - return; - } - - /* FIXME: kettenis/2001-01-20: The following code makes too much - assumptions about the host and target floating point format. */ - - /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may - not necessarily be a TYPE_CODE_FLT, the below ignores that and - instead uses the type's length to determine the precision of the - floating-point value being printed. */ - - if (len < sizeof (double)) - fprintf_filtered (stream, "%.9g", (double) doub); - else if (len == sizeof (double)) - fprintf_filtered (stream, "%.17g", (double) doub); - else -#ifdef PRINTF_HAS_LONG_DOUBLE - fprintf_filtered (stream, "%.35Lg", doub); -#else - /* This at least wins with values that are representable as - doubles. */ - fprintf_filtered (stream, "%.17g", (double) doub); -#endif -} - -void -print_decimal_floating (const gdb_byte *valaddr, struct type *type, - struct ui_file *stream) -{ - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); - char decstr[MAX_DECIMAL_STRING]; - unsigned len = TYPE_LENGTH (type); - - decimal_to_string (valaddr, len, byte_order, decstr); - fputs_filtered (decstr, stream); - return; + std::string str = target_float_to_string (valaddr, type); + fputs_filtered (str.c_str (), stream); } void print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order, bool zero_pad) { - -#define BITS_IN_BYTES 8 - const gdb_byte *p; unsigned int i; int b; @@ -1561,7 +1383,7 @@ print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr, /* Every byte has 8 binary characters; peel off and print from the MSB end. */ - for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++) + for (i = 0; i < (HOST_CHAR_BIT * sizeof (*p)); i++) { if (*p & (mask >> i)) b = '1'; @@ -1581,7 +1403,7 @@ print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr, p >= valaddr; p--) { - for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++) + for (i = 0; i < (HOST_CHAR_BIT * sizeof (*p)); i++) { if (*p & (mask >> i)) b = '1'; @@ -1642,20 +1464,26 @@ print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr, */ #define BITS_IN_OCTAL 3 #define HIGH_ZERO 0340 -#define LOW_ZERO 0016 +#define LOW_ZERO 0034 #define CARRY_ZERO 0003 + static_assert (HIGH_ZERO + LOW_ZERO + CARRY_ZERO == 0xff, + "cycle zero constants are wrong"); #define HIGH_ONE 0200 #define MID_ONE 0160 #define LOW_ONE 0016 #define CARRY_ONE 0001 + static_assert (HIGH_ONE + MID_ONE + LOW_ONE + CARRY_ONE == 0xff, + "cycle one constants are wrong"); #define HIGH_TWO 0300 #define MID_TWO 0070 #define LOW_TWO 0007 + static_assert (HIGH_TWO + MID_TWO + LOW_TWO == 0xff, + "cycle two constants are wrong"); /* For 32 we start in cycle 2, with two bits and one bit carry; for 64 in cycle in cycle 1, with one bit and a two bit carry. */ - cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL; + cycle = (len * HOST_CHAR_BIT) % BITS_IN_OCTAL; carry = 0; fputs_filtered ("0", stream); @@ -1771,9 +1599,10 @@ print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr, static bool maybe_negate_by_bytes (const gdb_byte *bytes, unsigned len, enum bfd_endian byte_order, - std::vector *out_vec) + gdb::byte_vector *out_vec) { gdb_byte sign_byte; + gdb_assert (len > 0); if (byte_order == BFD_ENDIAN_BIG) sign_byte = bytes[0]; else @@ -1830,7 +1659,7 @@ print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr, int dummy; int flip; - std::vector negated_bytes; + gdb::byte_vector negated_bytes; if (is_signed && maybe_negate_by_bytes (valaddr, len, byte_order, &negated_bytes)) { @@ -2055,7 +1884,7 @@ print_function_pointer_address (const struct value_print_options *options, { CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, address, - ¤t_target); + current_top_target ()); /* If the function pointer is represented by a description, print the address of the description. */ @@ -2266,10 +2095,10 @@ partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, return (nread); } -/* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes - each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly - allocated buffer containing the string, which the caller is responsible to - free, and BYTES_READ will be set to the number of bytes read. Returns 0 on +/* Read a string from the inferior, at ADDR, with LEN characters of + WIDTH bytes each. Fetch at most FETCHLIMIT characters. BUFFER + will be set to a newly allocated buffer containing the string, and + BYTES_READ will be set to the number of bytes read. Returns 0 on success, or a target_xfer_status on failure. If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters @@ -2292,20 +2121,18 @@ partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, int read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, - enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read) + enum bfd_endian byte_order, gdb::unique_xmalloc_ptr *buffer, + int *bytes_read) { int errcode; /* Errno returned from bad reads. */ unsigned int nfetch; /* Chars to fetch / chars fetched. */ gdb_byte *bufptr; /* Pointer to next available byte in buffer. */ - struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */ /* Loop until we either have all the characters, or we encounter some error, such as bumping into the end of the address space. */ - *buffer = NULL; - - old_chain = make_cleanup (free_current_contents, buffer); + buffer->reset (nullptr); if (len > 0) { @@ -2313,8 +2140,8 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, one operation. */ unsigned int fetchlen = std::min ((unsigned) len, fetchlimit); - *buffer = (gdb_byte *) xmalloc (fetchlen * width); - bufptr = *buffer; + buffer->reset ((gdb_byte *) xmalloc (fetchlen * width)); + bufptr = buffer->get (); nfetch = partial_memory_read (addr, bufptr, fetchlen * width, &errcode) / width; @@ -2343,12 +2170,12 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, nfetch = std::min ((unsigned long) chunksize, fetchlimit - bufsize); if (*buffer == NULL) - *buffer = (gdb_byte *) xmalloc (nfetch * width); + buffer->reset ((gdb_byte *) xmalloc (nfetch * width)); else - *buffer = (gdb_byte *) xrealloc (*buffer, - (nfetch + bufsize) * width); + buffer->reset ((gdb_byte *) xrealloc (buffer->release (), + (nfetch + bufsize) * width)); - bufptr = *buffer + bufsize * width; + bufptr = buffer->get () + bufsize * width; bufsize += nfetch; /* Read as much as we can. */ @@ -2380,24 +2207,23 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, } } while (errcode == 0 /* no error */ - && bufptr - *buffer < fetchlimit * width /* no overrun */ + && bufptr - buffer->get () < fetchlimit * width /* no overrun */ && !found_nul); /* haven't found NUL yet */ } else { /* Length of string is really 0! */ /* We always allocate *buffer. */ - *buffer = bufptr = (gdb_byte *) xmalloc (1); + buffer->reset ((gdb_byte *) xmalloc (1)); + bufptr = buffer->get (); errcode = 0; } /* bufptr and addr now point immediately beyond the last byte which we consider part of the string (including a '\0' which ends the string). */ - *bytes_read = bufptr - *buffer; + *bytes_read = bufptr - buffer->get (); QUIT; - discard_cleanups (old_chain); - return errcode; } @@ -2533,19 +2359,16 @@ generic_emit_char (int c, struct type *type, struct ui_file *stream, { enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); - struct obstack wchar_buf, output; - struct cleanup *cleanups; - gdb_byte *buf; + gdb_byte *c_buf; int need_escape = 0; - buf = (gdb_byte *) alloca (TYPE_LENGTH (type)); - pack_long (buf, type, c); + c_buf = (gdb_byte *) alloca (TYPE_LENGTH (type)); + pack_long (c_buf, type, c); - wchar_iterator iter (buf, TYPE_LENGTH (type), encoding, TYPE_LENGTH (type)); + wchar_iterator iter (c_buf, TYPE_LENGTH (type), encoding, TYPE_LENGTH (type)); /* This holds the printable form of the wchar_t data. */ - obstack_init (&wchar_buf); - cleanups = make_cleanup_obstack_free (&wchar_buf); + auto_obstack wchar_buf; while (1) { @@ -2592,8 +2415,7 @@ generic_emit_char (int c, struct type *type, struct ui_file *stream, } /* The output in the host encoding. */ - obstack_init (&output); - make_cleanup_obstack_free (&output); + auto_obstack output; convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (), (gdb_byte *) obstack_base (&wchar_buf), @@ -2602,8 +2424,6 @@ generic_emit_char (int c, struct type *type, struct ui_file *stream, obstack_1grow (&output, '\0'); fputs_filtered ((const char *) obstack_base (&output), stream); - - do_cleanups (cleanups); } /* Return the repeat count of the next character/byte in ITER, @@ -2611,11 +2431,11 @@ generic_emit_char (int c, struct type *type, struct ui_file *stream, static int count_next_character (wchar_iterator *iter, - VEC (converted_character_d) **vec) + std::vector *vec) { struct converted_character *current; - if (VEC_empty (converted_character_d, *vec)) + if (vec->empty ()) { struct converted_character tmp; gdb_wchar_t *chars; @@ -2627,10 +2447,10 @@ count_next_character (wchar_iterator *iter, gdb_assert (tmp.num_chars < MAX_WCHARS); memcpy (tmp.chars, chars, tmp.num_chars * sizeof (gdb_wchar_t)); } - VEC_safe_push (converted_character_d, *vec, &tmp); + vec->push_back (tmp); } - current = VEC_last (converted_character_d, *vec); + current = &vec->back (); /* Count repeated characters or bytes. */ current->repeat_count = 1; @@ -2684,25 +2504,25 @@ count_next_character (wchar_iterator *iter, /* Push this next converted character onto the result vector. */ repeat = current->repeat_count; - VEC_safe_push (converted_character_d, *vec, &d); + vec->push_back (d); return repeat; } } /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote character to use with string output. WIDTH is the size of the output - character type. BYTE_ORDER is the the target byte order. OPTIONS + character type. BYTE_ORDER is the target byte order. OPTIONS is the user's print options. */ static void print_converted_chars_to_obstack (struct obstack *obstack, - VEC (converted_character_d) *chars, + const std::vector &chars, int quote_char, int width, enum bfd_endian byte_order, const struct value_print_options *options) { unsigned int idx; - struct converted_character *elem; + const converted_character *elem; enum {START, SINGLE, REPEAT, INCOMPLETE, FINISH} state, last; gdb_wchar_t wide_quote_char = gdb_btowc (quote_char); int need_escape = 0; @@ -2751,7 +2571,6 @@ print_converted_chars_to_obstack (struct obstack *obstack, case REPEAT: { int j; - char *s; /* We are outputting a character with a repeat count greater than options->repeat_count_threshold. */ @@ -2774,13 +2593,13 @@ print_converted_chars_to_obstack (struct obstack *obstack, print_wchar (gdb_WEOF, elem->buf, elem->buflen, width, byte_order, obstack, quote_char, &need_escape); obstack_grow_wstr (obstack, LCST ("'")); - s = xstrprintf (_(" "), elem->repeat_count); + std::string s = string_printf (_(" "), + elem->repeat_count); for (j = 0; s[j]; ++j) { gdb_wchar_t w = gdb_btowc (s[j]); obstack_grow (obstack, &w, sizeof (gdb_wchar_t)); } - xfree (s); } break; @@ -2819,7 +2638,7 @@ print_converted_chars_to_obstack (struct obstack *obstack, last = state; if (state != FINISH) { - elem = VEC_index (converted_character_d, chars, idx++); + elem = &chars[idx++]; switch (elem->result) { case wchar_iterate_ok: @@ -2862,11 +2681,8 @@ generic_printstr (struct ui_file *stream, struct type *type, enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); unsigned int i; int width = TYPE_LENGTH (type); - struct obstack wchar_buf, output; - struct cleanup *cleanup; int finished = 0; struct converted_character *last; - VEC (converted_character_d) *converted_chars; if (length == -1) { @@ -2899,9 +2715,7 @@ generic_printstr (struct ui_file *stream, struct type *type, /* Arrange to iterate over the characters, in wchar_t form. */ wchar_iterator iter (string, length * width, encoding, width); - converted_chars = NULL; - cleanup = make_cleanup (VEC_cleanup (converted_character_d), - &converted_chars); + std::vector converted_chars; /* Convert characters until the string is over or the maximum number of printed characters has been reached. */ @@ -2926,7 +2740,7 @@ generic_printstr (struct ui_file *stream, struct type *type, /* Get the last element and determine if the entire string was processed. */ - last = VEC_last (converted_character_d, converted_chars); + last = &converted_chars.back (); finished = (last->result == wchar_iterate_eof); /* Ensure that CONVERTED_CHARS is terminated. */ @@ -2934,8 +2748,7 @@ generic_printstr (struct ui_file *stream, struct type *type, /* WCHAR_BUF is the obstack we use to represent the string in wchar_t form. */ - obstack_init (&wchar_buf); - make_cleanup_obstack_free (&wchar_buf); + auto_obstack wchar_buf; /* Print the output string to the obstack. */ print_converted_chars_to_obstack (&wchar_buf, converted_chars, quote_char, @@ -2945,8 +2758,7 @@ generic_printstr (struct ui_file *stream, struct type *type, obstack_grow_wstr (&wchar_buf, LCST ("...")); /* OUTPUT is where we collect `char's for printing. */ - obstack_init (&output); - make_cleanup_obstack_free (&output); + auto_obstack output; convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (), (gdb_byte *) obstack_base (&wchar_buf), @@ -2955,8 +2767,6 @@ generic_printstr (struct ui_file *stream, struct type *type, obstack_1grow (&output, '\0'); fputs_filtered ((const char *) obstack_base (&output), stream); - - do_cleanups (cleanup); } /* Print a string from the inferior, starting at ADDR and printing up to LEN @@ -2978,8 +2788,7 @@ val_print_string (struct type *elttype, const char *encoding, int found_nul; /* Non-zero if we found the nul char. */ unsigned int fetchlimit; /* Maximum number of chars to print. */ int bytes_read; - gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */ - struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */ + gdb::unique_xmalloc_ptr buffer; /* Dynamically growable fetch buffer. */ struct gdbarch *gdbarch = get_type_arch (elttype); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int width = TYPE_LENGTH (elttype); @@ -2997,7 +2806,6 @@ val_print_string (struct type *elttype, const char *encoding, err = read_string (addr, len, width, fetchlimit, byte_order, &buffer, &bytes_read); - old_chain = make_cleanup (xfree, buffer); addr += bytes_read; @@ -3008,8 +2816,8 @@ val_print_string (struct type *elttype, const char *encoding, /* Determine found_nul by looking at the last character read. */ found_nul = 0; if (bytes_read >= width) - found_nul = extract_unsigned_integer (buffer + bytes_read - width, width, - byte_order) == 0; + found_nul = extract_unsigned_integer (buffer.get () + bytes_read - width, + width, byte_order) == 0; if (len == -1 && !found_nul) { gdb_byte *peekbuf; @@ -3037,25 +2845,19 @@ val_print_string (struct type *elttype, const char *encoding, and then the error message. */ if (err == 0 || bytes_read > 0) { - LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width, + LA_PRINT_STRING (stream, elttype, buffer.get (), bytes_read / width, encoding, force_ellipsis, options); } if (err != 0) { - char *str; - - str = memory_error_message (TARGET_XFER_E_IO, gdbarch, addr); - make_cleanup (xfree, str); + std::string str = memory_error_message (TARGET_XFER_E_IO, gdbarch, addr); fprintf_filtered (stream, ""); } - gdb_flush (stream); - do_cleanups (old_chain); - return (bytes_read / width); } @@ -3071,7 +2873,7 @@ static unsigned input_radix_1 = 10; setting the input radix to "10" never changes it! */ static void -set_input_radix (char *args, int from_tty, struct cmd_list_element *c) +set_input_radix (const char *args, int from_tty, struct cmd_list_element *c) { set_input_radix_1 (from_tty, input_radix_1); } @@ -3108,7 +2910,7 @@ set_input_radix_1 (int from_tty, unsigned radix) static unsigned output_radix_1 = 10; static void -set_output_radix (char *args, int from_tty, struct cmd_list_element *c) +set_output_radix (const char *args, int from_tty, struct cmd_list_element *c) { set_output_radix_1 (from_tty, output_radix_1); } @@ -3153,7 +2955,7 @@ set_output_radix_1 (int from_tty, unsigned radix) the 'set input-radix' command. */ static void -set_radix (char *arg, int from_tty) +set_radix (const char *arg, int from_tty) { unsigned radix; @@ -3171,7 +2973,7 @@ set_radix (char *arg, int from_tty) /* Show both the input and output radices. */ static void -show_radix (char *arg, int from_tty) +show_radix (const char *arg, int from_tty) { if (from_tty) { @@ -3195,7 +2997,7 @@ show_radix (char *arg, int from_tty) static void -set_print (char *arg, int from_tty) +set_print (const char *arg, int from_tty) { printf_unfiltered ( "\"set print\" must be followed by the name of a print subcommand.\n"); @@ -3203,13 +3005,13 @@ set_print (char *arg, int from_tty) } static void -show_print (char *args, int from_tty) +show_print (const char *args, int from_tty) { cmd_show_list (showprintlist, from_tty, ""); } static void -set_print_raw (char *arg, int from_tty) +set_print_raw (const char *arg, int from_tty) { printf_unfiltered ( "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n"); @@ -3217,7 +3019,7 @@ set_print_raw (char *arg, int from_tty) } static void -show_print_raw (char *args, int from_tty) +show_print_raw (const char *args, int from_tty) { cmd_show_list (showprintrawlist, from_tty, ""); }