X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalprint.c;h=ad6268e2c48b90ca4d7ddfadf1b859a7a85ee26c;hb=7155d5780a29c29184d5794107f87a5f3b5e8517;hp=d13dc4cd20cc03397e8aa49e2b49fccdaa8cc882;hpb=ae6a3a4c2a48a78e57332eb9489c3065a8b9aca1;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valprint.c b/gdb/valprint.c index d13dc4cd20..ad6268e2c4 100644 --- a/gdb/valprint.c +++ b/gdb/valprint.c @@ -2,7 +2,7 @@ Copyright (C) 1986, 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. + 2009, 2010 Free Software Foundation, Inc. This file is part of GDB. @@ -34,6 +34,8 @@ #include "doublest.h" #include "exceptions.h" #include "dfp.h" +#include "python/python.h" +#include "ada-lang.h" #include @@ -80,7 +82,9 @@ struct value_print_options user_print_options = 0, /* print_array_indexes */ 0, /* deref_ref */ 1, /* static_field_print */ - 1 /* pascal_static_field_print */ + 1, /* pascal_static_field_print */ + 0, /* raw */ + 0 /* summary */ }; /* Initialize *OPTS to be a copy of the user print options. */ @@ -214,6 +218,66 @@ show_addressprint (struct ui_file *file, int from_tty, } +/* A helper function for val_print. When printing in "summary" mode, + we want to print scalar arguments, but not aggregate arguments. + This function distinguishes between the two. */ + +static int +scalar_type_p (struct type *type) +{ + CHECK_TYPEDEF (type); + while (TYPE_CODE (type) == TYPE_CODE_REF) + { + type = TYPE_TARGET_TYPE (type); + CHECK_TYPEDEF (type); + } + switch (TYPE_CODE (type)) + { + case TYPE_CODE_ARRAY: + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + case TYPE_CODE_SET: + case TYPE_CODE_STRING: + case TYPE_CODE_BITSTRING: + return 0; + default: + return 1; + } +} + +/* Helper function to check the validity of some bits of a value. + + If TYPE represents some aggregate type (e.g., a structure), return 1. + + Otherwise, any of the bytes starting at OFFSET and extending for + TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and + return 0. The checking is done using FUNCS. + + Otherwise, return 1. */ + +static int +valprint_check_validity (struct ui_file *stream, + struct type *type, + int offset, + const struct value *val) +{ + CHECK_TYPEDEF (type); + + if (TYPE_CODE (type) != TYPE_CODE_UNION + && TYPE_CODE (type) != TYPE_CODE_STRUCT + && TYPE_CODE (type) != TYPE_CODE_ARRAY) + { + if (! value_bits_valid (val, TARGET_CHAR_BIT * offset, + TARGET_CHAR_BIT * TYPE_LENGTH (type))) + { + fprintf_filtered (stream, _("")); + return 0; + } + } + + return 1; +} + /* Print using the given LANGUAGE the data of type TYPE located at VALADDR (within GDB), which came from the inferior at address ADDRESS, onto stdio stream STREAM according to OPTIONS. @@ -232,6 +296,7 @@ show_addressprint (struct ui_file *file, int from_tty, int val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, + const struct value *val, const struct value_print_options *options, const struct language_defn *language) { @@ -252,15 +317,36 @@ val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset, if (TYPE_STUB (real_type)) { - fprintf_filtered (stream, ""); + fprintf_filtered (stream, _("")); gdb_flush (stream); return (0); } + if (!valprint_check_validity (stream, real_type, embedded_offset, val)) + return 0; + + if (!options->raw) + { + ret = apply_val_pretty_printer (type, valaddr, embedded_offset, + address, stream, recurse, + val, options, language); + if (ret) + return ret; + } + + /* Handle summary mode. If the value is a scalar, print it; + otherwise, print an ellipsis. */ + if (options->summary && !scalar_type_p (type)) + { + fprintf_filtered (stream, "..."); + return 0; + } + TRY_CATCH (except, RETURN_MASK_ERROR) { ret = language->la_val_print (type, valaddr, embedded_offset, address, - stream, recurse, &local_opts); + stream, recurse, val, + &local_opts); } if (except.reason < 0) fprintf_filtered (stream, _("")); @@ -281,12 +367,19 @@ value_check_printable (struct value *val, struct ui_file *stream) return 0; } - if (value_optimized_out (val)) + if (value_entirely_optimized_out (val)) { fprintf_filtered (stream, _("")); return 0; } + if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION) + { + fprintf_filtered (stream, _(""), + value_internal_function_name (val)); + return 0; + } + return 1; } @@ -307,15 +400,24 @@ common_val_print (struct value *val, struct ui_file *stream, int recurse, if (!value_check_printable (val, stream)) return 0; - return val_print (value_type (val), value_contents_all (val), - value_embedded_offset (val), VALUE_ADDRESS (val), - stream, recurse, options, language); + if (language->la_language == language_ada) + /* The value might have a dynamic type, which would cause trouble + below when trying to extract the value contents (since the value + size is determined from the type size which is unknown). So + get a fixed representation of our value. */ + val = ada_to_fixed_value (val); + + return val_print (value_type (val), value_contents_for_printing (val), + value_embedded_offset (val), value_address (val), + stream, recurse, + val, options, language); } -/* Print the value VAL in C-ish syntax on stream STREAM according to - OPTIONS. - If the object printed is a string pointer, returns - the number of string bytes printed. */ +/* Print on stream STREAM the value VAL according to OPTIONS. The value + is printed using the current_language syntax. + + If the object printed is a string pointer, return the number of string + bytes printed. */ int value_print (struct value *val, struct ui_file *stream, @@ -324,6 +426,19 @@ value_print (struct value *val, struct ui_file *stream, if (!value_check_printable (val, stream)) return 0; + if (!options->raw) + { + int r = apply_val_pretty_printer (value_type (val), + value_contents_for_printing (val), + value_embedded_offset (val), + value_address (val), + stream, 0, + val, options, current_language); + + if (r) + return r; + } + return LA_VALUE_PRINT (val, stream, options); } @@ -335,7 +450,7 @@ 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 (current_gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); if (TYPE_LENGTH (type) > sizeof (LONGEST)) { @@ -343,7 +458,7 @@ val_print_type_code_int (struct type *type, const gdb_byte *valaddr, if (TYPE_UNSIGNED (type) && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type), - &val)) + byte_order, &val)) { print_longest (stream, 'u', 0, val); } @@ -539,10 +654,11 @@ 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, decstr); + decimal_to_string (valaddr, len, byte_order, decstr); fputs_filtered (decstr, stream); return; } @@ -919,7 +1035,8 @@ print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr, Omit any leading zero chars. */ void -print_char_chars (struct ui_file *stream, const gdb_byte *valaddr, +print_char_chars (struct ui_file *stream, struct type *type, + const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order) { const gdb_byte *p; @@ -932,7 +1049,7 @@ print_char_chars (struct ui_file *stream, const gdb_byte *valaddr, while (p < valaddr + len) { - LA_EMIT_CHAR (*p, stream, '\''); + LA_EMIT_CHAR (*p, type, stream, '\''); ++p; } } @@ -944,7 +1061,7 @@ print_char_chars (struct ui_file *stream, const gdb_byte *valaddr, while (p >= valaddr) { - LA_EMIT_CHAR (*p, stream, '\''); + LA_EMIT_CHAR (*p, type, stream, '\''); --p; } } @@ -956,44 +1073,27 @@ print_char_chars (struct ui_file *stream, const gdb_byte *valaddr, Return 1 if the operation was successful. Return zero otherwise, in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified. - - Computing the array upper and lower bounds is pretty easy, but this - function does some additional verifications before returning them. - If something incorrect is detected, it is better to return a status - rather than throwing an error, making it easier for the caller to - implement an error-recovery plan. For instance, it may decide to - warn the user that the bounds were not found and then use some - default values instead. */ + + We now simply use get_discrete_bounds call to get the values + of the low and high bounds. + get_discrete_bounds can return three values: + 1, meaning that index is a range, + 0, meaning that index is a discrete type, + or -1 for failure. */ int -get_array_bounds (struct type *type, long *low_bound, long *high_bound) +get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) { struct type *index = TYPE_INDEX_TYPE (type); - long low = 0; - long high = 0; - + LONGEST low = 0; + LONGEST high = 0; + int res; + if (index == NULL) return 0; - if (TYPE_CODE (index) == TYPE_CODE_RANGE) - { - low = TYPE_LOW_BOUND (index); - high = TYPE_HIGH_BOUND (index); - } - else if (TYPE_CODE (index) == TYPE_CODE_ENUM) - { - const int n_enums = TYPE_NFIELDS (index); - - low = TYPE_FIELD_BITPOS (index, 0); - high = TYPE_FIELD_BITPOS (index, n_enums - 1); - } - else - return 0; - - /* Abort if the lower bound is greater than the higher bound, except - when low = high + 1. This is a very common idiom used in Ada when - defining empty ranges (for instance "range 1 .. 0"). */ - if (low > high + 1) + res = get_discrete_bounds (index, &low, &high); + if (res == -1) return 0; if (low_bound) @@ -1036,6 +1136,7 @@ void val_print_array_elements (struct type *type, const gdb_byte *valaddr, CORE_ADDR address, struct ui_file *stream, int recurse, + const struct value *val, const struct value_print_options *options, unsigned int i) { @@ -1048,7 +1149,7 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr, unsigned int rep1; /* Number of repetitions we have detected so far. */ unsigned int reps; - long low_bound_index = 0; + LONGEST low_bound_index = 0; elttype = TYPE_TARGET_TYPE (type); eltlen = TYPE_LENGTH (check_typedef (elttype)); @@ -1063,7 +1164,8 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr, len = TYPE_LENGTH (type) / eltlen; else { - long low, hi; + LONGEST low, hi; + if (get_array_bounds (type, &low, &hi)) len = hi - low + 1; else @@ -1113,7 +1215,7 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr, if (reps > options->repeat_count_threshold) { val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen, - stream, recurse + 1, options, current_language); + stream, recurse + 1, val, options, current_language); annotate_elt_rep (reps); fprintf_filtered (stream, " ", reps); annotate_elt_rep_end (); @@ -1124,7 +1226,7 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr, else { val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen, - stream, recurse + 1, options, current_language); + stream, recurse + 1, val, options, current_language); annotate_elt (); things_printed++; } @@ -1201,7 +1303,7 @@ partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int *errnoptr int read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, - gdb_byte **buffer, int *bytes_read) + enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read) { int found_nul; /* Non-zero if we found the nul char. */ int errcode; /* Errno returned from bad reads. */ @@ -1226,13 +1328,14 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, some error, such as bumping into the end of the address space. */ found_nul = 0; - old_chain = make_cleanup (null_cleanup, 0); + *buffer = NULL; + + old_chain = make_cleanup (free_current_contents, buffer); if (len > 0) { *buffer = (gdb_byte *) xmalloc (len * width); bufptr = *buffer; - old_chain = make_cleanup (xfree, *buffer); nfetch = partial_memory_read (addr, bufptr, len * width, &errcode) / width; @@ -1243,8 +1346,6 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, { unsigned long bufsize = 0; - *buffer = NULL; - do { QUIT; @@ -1253,13 +1354,9 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, if (*buffer == NULL) *buffer = (gdb_byte *) xmalloc (nfetch * width); else - { - discard_cleanups (old_chain); - *buffer = (gdb_byte *) xrealloc (*buffer, - (nfetch + bufsize) * width); - } + *buffer = (gdb_byte *) xrealloc (*buffer, + (nfetch + bufsize) * width); - old_chain = make_cleanup (xfree, *buffer); bufptr = *buffer + bufsize * width; bufsize += nfetch; @@ -1278,7 +1375,7 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, { unsigned long c; - c = extract_unsigned_integer (bufptr, width); + c = extract_unsigned_integer (bufptr, width, byte_order); addr += width; bufptr += width; if (c == 0) @@ -1320,7 +1417,8 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, whichever is smaller. */ int -val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream, +val_print_string (struct type *elttype, CORE_ADDR addr, int len, + struct ui_file *stream, const struct value_print_options *options) { int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */ @@ -1330,6 +1428,9 @@ val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream, int bytes_read; gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */ struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */ + struct gdbarch *gdbarch = get_type_arch (elttype); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + int width = TYPE_LENGTH (elttype); /* First we need to figure out the limit on the number of characters we are going to attempt to fetch and print. This is actually pretty simple. If @@ -1341,7 +1442,8 @@ val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream, fetchlimit = (len == -1 ? options->print_max : min (len, options->print_max)); - errcode = read_string (addr, len, width, fetchlimit, &buffer, &bytes_read); + errcode = read_string (addr, len, width, fetchlimit, byte_order, + &buffer, &bytes_read); old_chain = make_cleanup (xfree, buffer); addr += bytes_read; @@ -1350,8 +1452,8 @@ val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream, terminated early due to an error or finding a null char when LEN is -1. */ /* Determine found_nul by looking at the last character read. */ - found_nul = extract_unsigned_integer (buffer + bytes_read - width, width) == 0; - + found_nul = extract_unsigned_integer (buffer + bytes_read - width, width, + byte_order) == 0; if (len == -1 && !found_nul) { gdb_byte *peekbuf; @@ -1363,7 +1465,7 @@ val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream, peekbuf = (gdb_byte *) alloca (width); if (target_read_memory (addr, peekbuf, width) == 0 - && extract_unsigned_integer (peekbuf, width) != 0) + && extract_unsigned_integer (peekbuf, width, byte_order) != 0) force_ellipsis = 1; } else if ((len >= 0 && errcode != 0) || (len > bytes_read / width)) @@ -1383,7 +1485,8 @@ val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream, { fputs_filtered (" ", stream); } - LA_PRINT_STRING (stream, buffer, bytes_read / width, width, force_ellipsis, options); + LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width, + NULL, force_ellipsis, options); } if (errcode != 0) @@ -1391,13 +1494,13 @@ val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream, if (errcode == EIO) { fprintf_filtered (stream, "
"); } else { fprintf_filtered (stream, " ", safe_strerror (errcode)); } } @@ -1553,8 +1656,6 @@ show_print (char *args, int from_tty) void _initialize_valprint (void) { - struct cmd_list_element *c; - add_prefix_cmd ("print", no_class, set_print, _("Generic command for setting how things print."), &setprintlist, "set print ", 0, &setlist);