From 024f65b1800f3882845e0e92e75ffd5dbf08ec9d Mon Sep 17 00:00:00 2001 From: Kung Hsu Date: Sat, 6 Nov 1993 01:32:11 +0000 Subject: [PATCH] Modified Files: gdbtypes.h stabsread.c cp-valprint.c ChangeLog * gdbtypes.h : add a field 'ignore_field_bits in cplus_specific, and macros to handle the bits. * stabsread.c (read_one_struct_field): add VISIBILITY_IGNORE, and for field of length 0, set this bit on. * cp-valprint.c (cp_print_value_fields): for VISIBILITY_IGNORE field, print . --- gdb/ChangeLog | 9 +++++++++ gdb/cp-valprint.c | 20 +++++++++++++++++--- gdb/gdbtypes.h | 12 ++++++++++++ gdb/stabsread.c | 17 +++++++++++++---- 4 files changed, 51 insertions(+), 7 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 9e483d83df4..d346183859d 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,12 @@ +Fri Nov 5 17:19:30 1993 Kung Hsu (kung@cirdan.cygnus.com) + + * gdbtypes.h : add a field 'ignore_field_bits in cplus_specific, + and macros to handle the bits. + * stabsread.c (read_one_struct_field): add VISIBILITY_IGNORE, and + for field of length 0, set this bit on. + * cp-valprint.c (cp_print_value_fields): for VISIBILITY_IGNORE + field, print . + Fri Nov 5 14:43:46 1993 Jim Kingdon (kingdon@lioth.cygnus.com) * Version 4.11.2. diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c index cce1f191407..806687ebd8b 100644 --- a/gdb/cp-valprint.c +++ b/gdb/cp-valprint.c @@ -296,17 +296,31 @@ cp_print_value_fields (type, valaddr, stream, format, recurse, pretty, /* Bitfields require special handling, especially due to byte order problems. */ - v = value_from_longest (TYPE_FIELD_TYPE (type, i), + if (TYPE_FIELD_IGNORE (type, i)) + { + fputs_filtered ("", stream); + } + else + { + v = value_from_longest (TYPE_FIELD_TYPE (type, i), unpack_field_as_long (type, valaddr, i)); - c_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, + c_val_print (TYPE_FIELD_TYPE(type, i), VALUE_CONTENTS (v), 0, stream, format, 0, recurse + 1, pretty); + } } else { - c_val_print (TYPE_FIELD_TYPE (type, i), + if (TYPE_FIELD_IGNORE (type, i)) + { + fputs_filtered ("", stream); + } + else + { + c_val_print (TYPE_FIELD_TYPE (type, i), valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0, stream, format, 0, recurse + 1, pretty); + } } } if (pretty) diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 2ab04060681..84abd86eeb9 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -347,6 +347,11 @@ struct cplus_struct_type B_TYPE *protected_field_bits; + /* for classes with fields to be ignored, either this is optimized out + or this field has length 0 */ + + B_TYPE *ignore_field_bits; + /* For classes, structures, and unions, a description of each field, which consists of an overloaded name, followed by the types of arguments that the method expects, and then the name after it @@ -484,12 +489,16 @@ allocate_cplus_struct_type PARAMS ((struct type *)); TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits #define TYPE_FIELD_PROTECTED_BITS(thistype) \ TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits +#define TYPE_FIELD_IGNORE_BITS(thistype) \ + TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits #define TYPE_FIELD_VIRTUAL_BITS(thistype) \ TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits #define SET_TYPE_FIELD_PRIVATE(thistype, n) \ B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)) #define SET_TYPE_FIELD_PROTECTED(thistype, n) \ B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)) +#define SET_TYPE_FIELD_IGNORE(thistype, n) \ + B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)) #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \ B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)) #define TYPE_FIELD_PRIVATE(thistype, n) \ @@ -498,6 +507,9 @@ allocate_cplus_struct_type PARAMS ((struct type *)); #define TYPE_FIELD_PROTECTED(thistype, n) \ (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \ : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))) +#define TYPE_FIELD_IGNORE(thistype, n) \ + (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \ + : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))) #define TYPE_FIELD_VIRTUAL(thistype, n) \ B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)) diff --git a/gdb/stabsread.c b/gdb/stabsread.c index ddb18c963a0..c35ea6c8087 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -1730,6 +1730,7 @@ rs6000_builtin_type (typenum) #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */ #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */ #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */ +#define VISIBILITY_IGNORE '9' /* artificial character for ignore the field */ /* Read member function stabs info for C++ classes. The form of each member function data is: @@ -2217,7 +2218,9 @@ read_one_struct_field (fip, pp, p, type, objfile) return; } } -#if 0 + /* kung: I add a new visibility type VISIBILITY_IGNORE, so that + when printing value, this field will print . ptype + will still print the type info of the field. */ /* FIXME-tiemann: Can't the compiler put out something which lets us distinguish these? (or maybe just not put out anything for the field). What is the story here? What does the compiler @@ -2240,12 +2243,11 @@ read_one_struct_field (fip, pp, p, type, objfile) stuff. */ if (fip -> list -> field.bitpos == 0 && fip -> list -> field.bitsize == 0) { - complain (&dbx_class_complaint); + /* complain (&dbx_class_complaint); */ /* Ignore this field. */ - fip -> list = fip -> list -> next; + fip -> list-> visibility = VISIBILITY_IGNORE; } else -#endif /* 0 */ { /* Detect an unpacked field and mark it as such. dbx gives a bit size for all fields. @@ -2664,6 +2666,10 @@ attach_fields_to_type (fip, type, objfile) TYPE_FIELD_PROTECTED_BITS (type) = (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields); + + TYPE_FIELD_IGNORE_BITS (type) = + (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); + B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields); } /* Copy the saved-up fields into the field vector. Start from the head @@ -2683,6 +2689,9 @@ attach_fields_to_type (fip, type, objfile) SET_TYPE_FIELD_PROTECTED (type, nfields); break; + case VISIBILITY_IGNORE: + SET_TYPE_FIELD_IGNORE (type, nfields); + case VISIBILITY_PUBLIC: break; -- 2.30.2