X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fc-typeprint.c;h=a8c9705c031677969cbb215dace7ad7016099922;hb=7ef412cf72a197d68e532604cc1fa21351adc858;hp=97f7aaa7770200f149fbb51ea2611b916f9a5fdc;hpb=c1ec8cea7ff53eb76cb7c354b813c67fde755409;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c index 97f7aaa777..a8c9705c03 100644 --- a/gdb/c-typeprint.c +++ b/gdb/c-typeprint.c @@ -1,5 +1,5 @@ /* Support for printing C and C++ types for GDB, the GNU debugger. - Copyright (C) 1986-2018 Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -28,18 +28,11 @@ #include "language.h" #include "demangle.h" #include "c-lang.h" +#include "cli/cli-style.h" #include "typeprint.h" #include "cp-abi.h" #include "cp-support.h" -/* When printing the offsets of a struct and its fields (i.e., 'ptype - /o'; type_print_options::print_offsets), we use this many - characters when printing the offset information at the beginning of - the line. This is needed in order to generate the correct amount - of whitespaces when no offset info should be printed for a certain - field. */ -#define OFFSET_SPC_LEN 23 - /* A list of access specifiers used for printing. */ enum access_specifier @@ -123,6 +116,7 @@ c_print_type_1 (struct type *type, type = check_typedef (type); local_name = typedef_hash_table::find_typedef (flags, type); + code = TYPE_CODE (type); if (local_name != NULL) { fputs_filtered (local_name, stream); @@ -132,7 +126,6 @@ c_print_type_1 (struct type *type, else { c_type_print_base_1 (type, stream, show, level, language, flags, podata); - code = TYPE_CODE (type); if ((varstring != NULL && *varstring != '\0') /* Need a space if going to print stars or brackets; but not if we will print just a type name. */ @@ -152,7 +145,10 @@ c_print_type_1 (struct type *type, if (varstring != NULL) { - fputs_filtered (varstring, stream); + if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD) + fputs_styled (varstring, function_name_style.style (), stream); + else + fputs_filtered (varstring, stream); /* For demangled function names, we have the arglist as part of the name, so don't print an additional pair of ()'s. */ @@ -209,13 +205,13 @@ c_print_typedef (struct type *type, { type = check_typedef (type); fprintf_filtered (stream, "typedef "); - type_print (type, "", stream, 0); + type_print (type, "", stream, -1); if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))), - SYMBOL_LINKAGE_NAME (new_symbol)) != 0 + new_symbol->linkage_name ()) != 0 || TYPE_CODE (SYMBOL_TYPE (new_symbol)) == TYPE_CODE_TYPEDEF) - fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol)); - fprintf_filtered (stream, ";\n"); + fprintf_filtered (stream, " %s", new_symbol->print_name ()); + fprintf_filtered (stream, ";"); } /* If TYPE is a derived type, then print out derivation information. @@ -260,7 +256,7 @@ cp_type_print_derivation_info (struct ui_file *stream, ? "public" : (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"), BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : ""); - name = type_name_no_tag (TYPE_BASECLASS (type, i)); + name = TYPE_NAME (TYPE_BASECLASS (type, i)); if (name) print_name_maybe_canonical (name, flags, stream); else @@ -392,9 +388,8 @@ c_type_print_varspec_prefix (struct type *type, case TYPE_CODE_MEMBERPTR: c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), - stream, show, 0, 0, language, flags, - podata); - name = type_name_no_tag (TYPE_SELF_TYPE (type)); + stream, show, 0, 0, language, flags, podata); + name = TYPE_NAME (TYPE_SELF_TYPE (type)); if (name) print_name_maybe_canonical (name, flags, stream); else @@ -409,7 +404,7 @@ c_type_print_varspec_prefix (struct type *type, stream, show, 0, 0, language, flags, podata); fprintf_filtered (stream, "("); - name = type_name_no_tag (TYPE_SELF_TYPE (type)); + name = TYPE_NAME (TYPE_SELF_TYPE (type)); if (name) print_name_maybe_canonical (name, flags, stream); else @@ -885,15 +880,14 @@ c_type_print_template_args (const struct type_print_options *flags, if (first) { wrap_here (" "); - fprintf_filtered (stream, _("[with %s = "), - SYMBOL_LINKAGE_NAME (sym)); + fprintf_filtered (stream, _("[with %s = "), sym->linkage_name ()); first = 0; } else { fputs_filtered (", ", stream); wrap_here (" "); - fprintf_filtered (stream, "%s = ", SYMBOL_LINKAGE_NAME (sym)); + fprintf_filtered (stream, "%s = ", sym->linkage_name ()); } c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags); @@ -914,7 +908,7 @@ print_spaces_filtered_with_print_options if (!flags->print_offsets) print_spaces_filtered (level, stream); else - print_spaces_filtered (level + OFFSET_SPC_LEN, stream); + print_spaces_filtered (level + print_offset_data::indentation, stream); } /* Output an access specifier to STREAM, if needed. LAST_ACCESS is the @@ -957,127 +951,6 @@ output_access_specifier (struct ui_file *stream, return last_access; } -/* Print information about field at index FIELD_IDX of the union type - TYPE. Since union fields don't have the concept of offsets, we - just print their sizes. - - The output is strongly based on pahole(1). */ - -static void -c_print_type_union_field_offset (struct type *type, unsigned int field_idx, - struct ui_file *stream) -{ - struct type *ftype = check_typedef (TYPE_FIELD_TYPE (type, field_idx)); - - fprintf_filtered (stream, "/* %4u */", TYPE_LENGTH (ftype)); -} - -/* Helper function for ptype/o implementation that prints information - about a hole, if necessary. STREAM is where to print. BITPOS is - the bitpos of the current field. PODATA is the offset-printing - state. FOR_WHAT is a string describing the purpose of the - hole. */ - -static void -maybe_print_hole (struct ui_file *stream, unsigned int bitpos, - struct print_offset_data *podata, const char *for_what) -{ - /* We check for PODATA->END_BITPOS > 0 because there is a specific - scenario when PODATA->END_BITPOS can be zero and BITPOS can be > - 0: when we are dealing with a struct/class with a virtual method. - Because of the vtable, the first field of the struct/class will - have an offset of sizeof (void *) (the size of the vtable). If - we do not check for PODATA->END_BITPOS > 0 here, GDB will report - a hole before the first field, which is not accurate. */ - if (podata->end_bitpos > 0 && podata->end_bitpos < bitpos) - { - /* If PODATA->END_BITPOS is smaller than the current type's - bitpos, it means there's a hole in the struct, so we report - it here. */ - unsigned int hole = bitpos - podata->end_bitpos; - unsigned int hole_byte = hole / TARGET_CHAR_BIT; - unsigned int hole_bit = hole % TARGET_CHAR_BIT; - - if (hole_bit > 0) - fprintf_filtered (stream, "/* XXX %2u-bit %s */\n", hole_bit, - for_what); - - if (hole_byte > 0) - fprintf_filtered (stream, "/* XXX %2u-byte %s */\n", hole_byte, - for_what); - } -} - -/* Print information about field at index FIELD_IDX of the struct type - TYPE. - - PODATA->END_BITPOS is the one-past-the-end bit position of the - previous field (where we expect this field to be if there is no - hole). At the end, ENDPOS is updated to the one-past-the-end bit - position of the current field. - - PODATA->OFFSET_BITPOS is the offset value we carry over when we are - printing a struct that is inside another struct; this is useful so - that the offset is constantly incremented (if we didn't carry it - over, the offset would be reset to zero when printing the inner - struct). - - The output is strongly based on pahole(1). */ - -static void -c_print_type_struct_field_offset (struct type *type, unsigned int field_idx, - struct ui_file *stream, - struct print_offset_data *podata) -{ - struct type *ftype = check_typedef (TYPE_FIELD_TYPE (type, field_idx)); - unsigned int bitpos = TYPE_FIELD_BITPOS (type, field_idx); - unsigned int fieldsize_byte = TYPE_LENGTH (ftype); - unsigned int fieldsize_bit = fieldsize_byte * TARGET_CHAR_BIT; - - maybe_print_hole (stream, bitpos, podata, "hole"); - - if (TYPE_FIELD_PACKED (type, field_idx)) - { - /* We're dealing with a bitfield. Print how many bits are left - to be used. */ - unsigned int bitsize = TYPE_FIELD_BITSIZE (type, field_idx); - /* The bitpos relative to the beginning of our container - field. */ - unsigned int relative_bitpos; - - /* The following was copied from - value.c:value_primitive_field. */ - if ((bitpos % fieldsize_bit) + bitsize <= fieldsize_bit) - relative_bitpos = bitpos % fieldsize_bit; - else - relative_bitpos = bitpos % TARGET_CHAR_BIT; - - /* This is the exact offset (in bits) of this bitfield. */ - unsigned int bit_offset - = (bitpos - relative_bitpos) + podata->offset_bitpos; - - /* The position of the field, relative to the beginning of the - struct, and how many bits are left to be used in this - container. */ - fprintf_filtered (stream, "/* %4u:%2u", bit_offset / TARGET_CHAR_BIT, - fieldsize_bit - (relative_bitpos + bitsize)); - fieldsize_bit = bitsize; - } - else - { - /* The position of the field, relative to the beginning of the - struct. */ - fprintf_filtered (stream, "/* %4u", - (bitpos + podata->offset_bitpos) / TARGET_CHAR_BIT); - - fprintf_filtered (stream, " "); - } - - fprintf_filtered (stream, " | %4u */", fieldsize_byte); - - podata->end_bitpos = bitpos + fieldsize_bit; -} - /* Return true if an access label (i.e., "public:", "private:", "protected:") needs to be printed for TYPE. */ @@ -1189,13 +1062,13 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream, spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}" tag for unnamed struct/union/enum's, which we don't want to print. */ - if (TYPE_TAG_NAME (type) != NULL - && !startswith (TYPE_TAG_NAME (type), "{unnamed")) + if (TYPE_NAME (type) != NULL + && !startswith (TYPE_NAME (type), "{unnamed")) { /* When printing the tag name, we are still effectively printing in the outer context, hence the use of FLAGS here. */ - print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream); + print_name_maybe_canonical (TYPE_NAME (type), flags, stream); if (show > 0) fputs_filtered (" ", stream); } @@ -1204,10 +1077,10 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream, { /* If we just printed a tag name, no need to print anything else. */ - if (TYPE_TAG_NAME (type) == NULL) + if (TYPE_NAME (type) == NULL) fprintf_filtered (stream, "{...}"); } - else if (show > 0 || TYPE_TAG_NAME (type) == NULL) + else if (show > 0 || TYPE_NAME (type) == NULL) { struct type *basetype; int vptr_fieldno; @@ -1242,10 +1115,12 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream, { if (TYPE_STUB (type)) fprintfi_filtered (level + 4, stream, - _("\n")); + _("%p[%p]\n"), + metadata_style.style ().ptr (), nullptr); else fprintfi_filtered (level + 4, stream, - _("\n")); + _("%p[%p]\n"), + metadata_style.style ().ptr (), nullptr); } /* Start off with no specific section type, so we can print @@ -1290,20 +1165,7 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream, bool is_static = field_is_static (&TYPE_FIELD (type, i)); if (flags->print_offsets) - { - if (!is_static) - { - if (TYPE_CODE (type) == TYPE_CODE_STRUCT) - { - c_print_type_struct_field_offset - (type, i, stream, podata); - } - else if (TYPE_CODE (type) == TYPE_CODE_UNION) - c_print_type_union_field_offset (type, i, stream); - } - else - print_spaces_filtered (OFFSET_SPC_LEN, stream); - } + podata->update (type, i, stream); print_spaces_filtered (level + 4, stream); if (is_static) @@ -1311,7 +1173,7 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream, int newshow = show - 1; - if (flags->print_offsets + if (!is_static && flags->print_offsets && (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_STRUCT || TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_UNION)) { @@ -1380,7 +1242,7 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream, struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i); int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i); const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i); - const char *name = type_name_no_tag (type); + const char *name = TYPE_NAME (type); int is_constructor = name && strcmp (method_name, name) == 0; @@ -1416,7 +1278,8 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream, { /* Keep GDB from crashing here. */ fprintf_filtered (stream, - _(" %s;\n"), + _("%p[%p] %s;\n"), + metadata_style.style ().ptr (), nullptr, TYPE_FN_FIELD_PHYSNAME (f, j)); break; } @@ -1464,9 +1327,9 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream, &local_flags); } else - fprintf_filtered (stream, - _(""), - mangled_name); + fprintf_styled (stream, metadata_style.style (), + _(""), + mangled_name); } else { @@ -1561,19 +1424,9 @@ c_type_print_base_struct_union (struct type *type, struct ui_file *stream, if (flags->print_offsets) { if (show > 0) - { - unsigned int bitpos = TYPE_LENGTH (type) * TARGET_CHAR_BIT; - maybe_print_hole (stream, bitpos, podata, "padding"); + podata->finish (type, level, stream); - fputs_filtered ("\n", stream); - print_spaces_filtered_with_print_options (level + 4, - stream, - flags); - fprintf_filtered (stream, "/* total size (bytes): %4u */\n", - TYPE_LENGTH (type)); - } - - print_spaces_filtered (OFFSET_SPC_LEN, stream); + print_spaces_filtered (print_offset_data::indentation, stream); if (level == 0) print_spaces_filtered (2, stream); } @@ -1614,21 +1467,39 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream, if (type == NULL) { - fputs_filtered (_(""), stream); + fputs_styled (_(""), metadata_style.style (), stream); return; } /* When SHOW is zero or less, and there is a valid type name, then always just print the type name directly from the type. */ - /* If we have "typedef struct foo {. . .} bar;" do we want to print - it as "struct foo" or as "bar"? Pick the latter, because C++ - folk tend to expect things like "class5 *foo" rather than "struct - class5 *foo". */ if (show <= 0 && TYPE_NAME (type) != NULL) { c_type_print_modifier (type, stream, 0, 1); + + /* If we have "typedef struct foo {. . .} bar;" do we want to + print it as "struct foo" or as "bar"? Pick the latter for + C++, because C++ folk tend to expect things like "class5 + *foo" rather than "struct class5 *foo". We rather + arbitrarily choose to make language_minimal work in a C-like + way. */ + if (language == language_c || language == language_minimal) + { + if (TYPE_CODE (type) == TYPE_CODE_UNION) + fprintf_filtered (stream, "union "); + else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) + { + if (TYPE_DECLARED_CLASS (type)) + fprintf_filtered (stream, "class "); + else + fprintf_filtered (stream, "struct "); + } + else if (TYPE_CODE (type) == TYPE_CODE_ENUM) + fprintf_filtered (stream, "enum "); + } + print_name_maybe_canonical (TYPE_NAME (type), flags, stream); return; } @@ -1642,7 +1513,8 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream, couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */ gdb_assert (TYPE_NAME (type) == NULL); gdb_assert (TYPE_TARGET_TYPE (type) == NULL); - fprintf_filtered (stream, _("")); + fprintf_styled (stream, metadata_style.style (), + _("")); break; case TYPE_CODE_FUNC: @@ -1679,10 +1551,10 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream, "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}" tag for unnamed struct/union/enum's, which we don't want to print. */ - if (TYPE_TAG_NAME (type) != NULL - && !startswith (TYPE_TAG_NAME (type), "{unnamed")) + if (TYPE_NAME (type) != NULL + && !startswith (TYPE_NAME (type), "{unnamed")) { - print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream); + print_name_maybe_canonical (TYPE_NAME (type), flags, stream); if (show > 0) fputs_filtered (" ", stream); } @@ -1692,10 +1564,10 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream, { /* If we just printed a tag name, no need to print anything else. */ - if (TYPE_TAG_NAME (type) == NULL) + if (TYPE_NAME (type) == NULL) fprintf_filtered (stream, "{...}"); } - else if (show > 0 || TYPE_TAG_NAME (type) == NULL) + else if (show > 0 || TYPE_NAME (type) == NULL) { LONGEST lastval = 0; @@ -1753,10 +1625,12 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream, { if (TYPE_STUB (type)) fprintfi_filtered (level + 4, stream, - _("\n")); + _("%p[%p]\n"), + metadata_style.style ().ptr (), nullptr); else fprintfi_filtered (level + 4, stream, - _("\n")); + _("%p[%p]\n"), + metadata_style.style ().ptr (), nullptr); } len = TYPE_NFIELDS (type); for (i = 0; i < len; i++) @@ -1799,12 +1673,12 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream, case TYPE_CODE_RANGE: /* This should not occur. */ - fprintf_filtered (stream, _("")); + fprintf_styled (stream, metadata_style.style (), _("")); break; case TYPE_CODE_NAMESPACE: fputs_filtered ("namespace ", stream); - fputs_filtered (TYPE_TAG_NAME (type), stream); + fputs_filtered (TYPE_NAME (type), stream); break; default: @@ -1821,8 +1695,8 @@ c_type_print_base_1 (struct type *type, struct ui_file *stream, { /* At least for dump_symtab, it is important that this not be an error (). */ - fprintf_filtered (stream, _(""), - TYPE_CODE (type)); + fprintf_styled (stream, metadata_style.style (), + _(""), TYPE_CODE (type)); } break; }