From: Tankut Baris Aktemur Date: Thu, 23 Jul 2026 10:04:42 +0000 (-0500) Subject: gdb: split make_type_with_address_space X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=d833949b1e7cfa000f00a5b73117713a52bb2254;p=thirdparty%2Fbinutils-gdb.git gdb: split make_type_with_address_space The function make_type_with_address_space is used for creating a type variant with a particular Harvard address space or an address class id. The argument is type instance flags. Split the function into two, each doing one task: (1) making a type variant with a given Harvard address space id, and (2) making a type variant with a given address class id. This is a step towards making function signatures clearer and more descriptive. Hardcoded shift operations ("<< 2", "<< 4", ">> 4") will go away in a future patch. Approved-By: Tom Tromey --- diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index 3671e39daa2..ce4d6ca8675 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -12056,11 +12056,7 @@ read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu) unsigned int aclass = gdbarch_address_class_dwarf_to_id (gdbarch, byte_size, addr_class); - type_instance_flags type_flags - = (enum type_instance_flag_value) (aclass << 4); - gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) - == 0); - type = make_type_with_address_space (type, type_flags); + type = make_type_with_address_class (type, aclass); } else if (type->length () != byte_size) { diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 97f1b3e1417..aa80dfb51c0 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -590,7 +590,7 @@ make_qualified_type (struct type *type, type_instance_flags new_flags, return ntype; } -/* Make an address-space-delimited variant of a type -- a type that +/* Make a Harvard-address-space-delimited variant of a type -- a type that is identical to the one supplied except that it has an address space attribute attached to it (such as "code" or "data"). @@ -600,16 +600,40 @@ make_qualified_type (struct type *type, type_instance_flags new_flags, representations. */ struct type * -make_type_with_address_space (struct type *type, - type_instance_flags space_flag) +make_type_with_harvard_address_space (struct type *type, + enum harvard_address_space aspace) { - type_instance_flags new_flags = ((type->instance_flags () - & ~(TYPE_INSTANCE_FLAG_CODE_SPACE - | TYPE_INSTANCE_FLAG_DATA_SPACE - | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)) - | space_flag); + type_instance_flags new_flags + = (enum type_instance_flag_value) (aspace << 2); - return make_qualified_type (type, new_flags, NULL); + gdb_assert ((new_flags & ~(TYPE_INSTANCE_FLAG_CODE_SPACE + | TYPE_INSTANCE_FLAG_DATA_SPACE)) == 0); + new_flags |= (type->instance_flags () + & ~(TYPE_INSTANCE_FLAG_CODE_SPACE + | TYPE_INSTANCE_FLAG_DATA_SPACE)); + + return make_qualified_type (type, new_flags, nullptr); +} + +/* Make an address-class-delimited variant of a type -- a type that is + identical to the one supplied except that it has an address class + attribute attached to it. The address class attribute is + architecture specific. It may denote an alternately sized pointer + or a pointer with alternate representation. */ + +struct type * +make_type_with_address_class (struct type *type, + unsigned int address_class) +{ + type_instance_flags new_flags + = (enum type_instance_flag_value) (address_class << 4); + + gdb_assert ((new_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) == 0); + + new_flags |= (type->instance_flags () + & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL); + + return make_qualified_type (type, new_flags, nullptr); } /* See gdbtypes.h. */ diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 1d5c96ab2c1..1749c3ba741 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -71,6 +71,34 @@ enum type_code }; +/* Enum encoded in instance flags of a type to denote which Harvard + address space the type refers to. + + Harvard architectures have separate instruction and data address + spaces (and perhaps others). GDB usually defines a flat address + space that is a superset of the architecture's two (or more) + address spaces, but this is an extension of the architecture's + model. + + If using HARVARD_ASPACE_CODE, an object of the corresponding type + resides in instruction memory, even if its address (in the extended + flat address space) does not reflect this. + + Similarly, if using HARVARD_ASPACE_DATA, then an object of the + corresponding type resides in the data memory space, even if this + is not indicated by its (flat address space) address. + + If using HARVARD_ASPACE_NONE, the default space for functions / + methods is instruction space, and for data objects is data + memory. */ + +enum harvard_address_space +{ + HARVARD_ASPACE_NONE = 0, + HARVARD_ASPACE_CODE = 1, + HARVARD_ASPACE_DATA = 2, +}; + /* Some bits for the type's instance_flags word. See the macros below for documentation on each bit. */ @@ -135,24 +163,7 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); (((t)->dyn_prop (DYN_PROP_BYTE_SIZE) != nullptr) \ || ((t)->dyn_prop (DYN_PROP_BIT_SIZE) != nullptr)) -/* Instruction-space delimited type. This is for Harvard architectures - which have separate instruction and data address spaces (and perhaps - others). - - GDB usually defines a flat address space that is a superset of the - architecture's two (or more) address spaces, but this is an extension - of the architecture's model. - - If TYPE_INSTANCE_FLAG_CODE_SPACE is set, an object of the corresponding type - resides in instruction memory, even if its address (in the extended - flat address space) does not reflect this. - - Similarly, if TYPE_INSTANCE_FLAG_DATA_SPACE is set, then an object of the - corresponding type resides in the data memory space, even if - this is not indicated by its (flat address space) address. - - If neither flag is set, the default space for functions / methods - is instruction space, and for data objects is data memory. */ +/* See enum harvard_address_space above. */ #define TYPE_CODE_SPACE(t) \ ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_CODE_SPACE) != 0) @@ -2420,8 +2431,11 @@ extern struct type *make_atomic_type (struct type *); extern void replace_type (struct type *, struct type *); -extern struct type *make_type_with_address_space - (struct type *type, type_instance_flags space_identifier); +extern struct type *make_type_with_harvard_address_space + (struct type *type, enum harvard_address_space aspace); + +extern struct type *make_type_with_address_class + (struct type *type, unsigned int address_class); /* Implement direct support for MEMBER_TYPE in GNU C++. TO_TYPE is the type of the member. DOMAIN is the type of the aggregate that diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c index 35910be0f06..52e31776242 100644 --- a/gdb/gnu-v3-abi.c +++ b/gdb/gnu-v3-abi.c @@ -184,7 +184,7 @@ get_gdb_vtable_type (struct gdbarch *arch) t->set_name ("gdb_gnu_v3_abi_vtable"); INIT_CPLUS_SPECIFIC (t); - result = make_type_with_address_space (t, TYPE_INSTANCE_FLAG_CODE_SPACE); + result = make_type_with_harvard_address_space (t, HARVARD_ASPACE_CODE); vtable_type_gdbarch_data.set (arch, result); return result; } diff --git a/gdb/printcmd.c b/gdb/printcmd.c index 15c086a9284..b79dbe24c17 100644 --- a/gdb/printcmd.c +++ b/gdb/printcmd.c @@ -1055,7 +1055,18 @@ format_to_type (format_data fmt, gdbarch *gdbarch, type_instance_flags flags) } gdb_assert (val_type != nullptr); - val_type = make_type_with_address_space (val_type, flags); + + if ((flags & TYPE_INSTANCE_FLAG_CODE_SPACE) != 0) + val_type = make_type_with_harvard_address_space (val_type, + HARVARD_ASPACE_CODE); + else if ((flags & TYPE_INSTANCE_FLAG_DATA_SPACE) != 0) + val_type = make_type_with_harvard_address_space (val_type, + HARVARD_ASPACE_DATA); + + unsigned int aclass + = (unsigned int) (flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) >> 4; + if (aclass != 0) + val_type = make_type_with_address_class (val_type, aclass); return val_type; } diff --git a/gdb/type-stack.c b/gdb/type-stack.c index dce1a138e36..c5ff1d718c4 100644 --- a/gdb/type-stack.c +++ b/gdb/type-stack.c @@ -57,12 +57,12 @@ type_stack::insert (struct gdbarch *gdbarch, const char *string) if (streq (string, "code")) { insert_into (slot, tp_harvard_aspace_identifier); - insert_into (slot, TYPE_INSTANCE_FLAG_CODE_SPACE); + insert_into (slot, HARVARD_ASPACE_CODE); } else if (streq (string, "data")) { insert_into (slot, tp_harvard_aspace_identifier); - insert_into (slot, TYPE_INSTANCE_FLAG_DATA_SPACE); + insert_into (slot, HARVARD_ASPACE_DATA); } else if (unsigned int aclass = 0; gdbarch_address_class_name_to_id_p (gdbarch) @@ -71,7 +71,7 @@ type_stack::insert (struct gdbarch *gdbarch, const char *string) aclass)) { insert_into (slot, tp_aclass_identifier); - insert_into (slot, (enum type_instance_flag_value) (aclass << 4)); + insert_into (slot, aclass); } else error (_("Unknown address space/class specifier: \"%s\""), string); @@ -114,7 +114,8 @@ type_stack::follow_types (struct type *follow_type) int done = 0; int make_const = 0; int make_volatile = 0; - type_instance_flags make_addr_space = 0; + harvard_address_space make_harvard_aspace = HARVARD_ASPACE_NONE; + int make_address_class = 0; bool make_restrict = false; bool make_atomic = false; int array_size; @@ -133,10 +134,10 @@ type_stack::follow_types (struct type *follow_type) make_volatile = 1; break; case tp_harvard_aspace_identifier: - make_addr_space = (enum type_instance_flag_value) pop_int (); + make_harvard_aspace = (harvard_address_space) pop_int (); break; case tp_aclass_identifier: - make_addr_space = (enum type_instance_flag_value) pop_int (); + make_address_class = pop_int (); break; case tp_atomic: make_atomic = true; @@ -161,15 +162,21 @@ type_stack::follow_types (struct type *follow_type) follow_type = make_cv_type (TYPE_CONST (follow_type), make_volatile, follow_type); - if (make_addr_space) - follow_type = make_type_with_address_space (follow_type, - make_addr_space); + if (make_harvard_aspace != HARVARD_ASPACE_NONE) + follow_type + = make_type_with_harvard_address_space (follow_type, + make_harvard_aspace); + if (make_address_class != 0) + follow_type + = make_type_with_address_class (follow_type, + make_address_class); if (make_restrict) follow_type = make_restrict_type (follow_type); if (make_atomic) follow_type = make_atomic_type (follow_type); make_const = make_volatile = 0; - make_addr_space = 0; + make_harvard_aspace = HARVARD_ASPACE_NONE; + make_address_class = 0; make_restrict = make_atomic = false; break; case tp_array: