From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2126) id BE5C8385BF92; Wed, 1 Apr 2020 20:12:41 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org BE5C8385BF92 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Tom Tromey To: gdb-cvs@sourceware.org Subject: [binutils-gdb] Change how complex types are created X-Act-Checkin: binutils-gdb X-Git-Author: Tom Tromey X-Git-Refname: refs/heads/master X-Git-Oldrev: 3d1cfd43bec7c22928d12ab235151b8eeeaf4e96 X-Git-Newrev: 5b930b4538f70a9f09280e36164840e48fb1c042 Message-Id: <20200401201241.BE5C8385BF92@sourceware.org> Date: Wed, 1 Apr 2020 20:12:41 +0000 (GMT) X-BeenThere: gdb-cvs@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 01 Apr 2020 20:12:41 -0000 https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=5b930b4538f70a9f09280e36164840e48fb1c042 commit 5b930b4538f70a9f09280e36164840e48fb1c042 Author: Tom Tromey Date: Wed Apr 1 14:09:52 2020 -0600 Change how complex types are created This patch changes how complex types are created. init_complex_type and arch_complex_type are unified, and complex types are reused, by attaching them to the underlying scalar type. gdb/ChangeLog 2020-04-01 Tom Tromey * stabsread.c (rs6000_builtin_type, read_sun_floating_type) (read_range_type): Update. * mdebugread.c (basic_type): Update. * go-lang.c (build_go_types): Use init_complex_type. * gdbtypes.h (struct main_type) : New member. (init_complex_type): Update. (arch_complex_type): Don't declare. * gdbtypes.c (init_complex_type): Remove "objfile" parameter. Make name if none given. Use alloc_type_copy. Look for cached complex type. (arch_complex_type): Remove. (gdbtypes_post_init): Use init_complex_type. * f-lang.c (build_fortran_types): Use init_complex_type. * dwarf2/read.c (read_base_type): Update. * d-lang.c (build_d_types): Use init_complex_type. * ctfread.c (read_base_type): Update. Diff: --- gdb/ChangeLog | 19 ++++++++++++++++++ gdb/ctfread.c | 2 +- gdb/d-lang.c | 9 +++------ gdb/dwarf2/read.c | 2 +- gdb/f-lang.c | 9 +++------ gdb/gdbtypes.c | 58 +++++++++++++++++++++++++++++-------------------------- gdb/gdbtypes.h | 9 +++++---- gdb/go-lang.c | 6 ++---- gdb/mdebugread.c | 6 ++---- gdb/stabsread.c | 8 ++++---- 10 files changed, 71 insertions(+), 57 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index ef62216e0ad..7a883e81c2f 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,22 @@ +2020-04-01 Tom Tromey + + * stabsread.c (rs6000_builtin_type, read_sun_floating_type) + (read_range_type): Update. + * mdebugread.c (basic_type): Update. + * go-lang.c (build_go_types): Use init_complex_type. + * gdbtypes.h (struct main_type) : New member. + (init_complex_type): Update. + (arch_complex_type): Don't declare. + * gdbtypes.c (init_complex_type): Remove "objfile" parameter. + Make name if none given. Use alloc_type_copy. Look for cached + complex type. + (arch_complex_type): Remove. + (gdbtypes_post_init): Use init_complex_type. + * f-lang.c (build_fortran_types): Use init_complex_type. + * dwarf2/read.c (read_base_type): Update. + * d-lang.c (build_d_types): Use init_complex_type. + * ctfread.c (read_base_type): Update. + 2020-04-01 Tankut Baris Aktemur * infrun.c (stop_all_threads): Update assertion, plus when diff --git a/gdb/ctfread.c b/gdb/ctfread.c index 241d0b6da94..7784e9d35d6 100644 --- a/gdb/ctfread.c +++ b/gdb/ctfread.c @@ -553,7 +553,7 @@ read_base_type (struct ctf_context *ccp, ctf_id_t tid) { struct type *t = ctf_init_float_type (of, cet.cte_bits / 2, NULL, name); - type = init_complex_type (of, name, t); + type = init_complex_type (name, t); } } else diff --git a/gdb/d-lang.c b/gdb/d-lang.c index f50c31a018e..951e664ceda 100644 --- a/gdb/d-lang.c +++ b/gdb/d-lang.c @@ -314,14 +314,11 @@ build_d_types (struct gdbarch *gdbarch) = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), "ireal", gdbarch_long_double_format (gdbarch)); builtin_d_type->builtin_cfloat - = arch_complex_type (gdbarch, "cfloat", - builtin_d_type->builtin_float); + = init_complex_type ("cfloat", builtin_d_type->builtin_float); builtin_d_type->builtin_cdouble - = arch_complex_type (gdbarch, "cdouble", - builtin_d_type->builtin_double); + = init_complex_type ("cdouble", builtin_d_type->builtin_double); builtin_d_type->builtin_creal - = arch_complex_type (gdbarch, "creal", - builtin_d_type->builtin_real); + = init_complex_type ("creal", builtin_d_type->builtin_real); /* Character types. */ builtin_d_type->builtin_char diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index 6ee33fcd6ed..2db527ecb82 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -16880,7 +16880,7 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) case DW_ATE_complex_float: type = dwarf2_init_complex_target_type (cu, objfile, bits / 2, name, byte_order); - type = init_complex_type (objfile, name, type); + type = init_complex_type (name, type); break; case DW_ATE_decimal_float: type = init_decfloat_type (objfile, bits, name); diff --git a/gdb/f-lang.c b/gdb/f-lang.c index 75a131d76d8..2ce4ad43610 100644 --- a/gdb/f-lang.c +++ b/gdb/f-lang.c @@ -741,14 +741,11 @@ build_fortran_types (struct gdbarch *gdbarch) = arch_type (gdbarch, TYPE_CODE_ERROR, 128, "real*16"); builtin_f_type->builtin_complex_s8 - = arch_complex_type (gdbarch, "complex*8", - builtin_f_type->builtin_real); + = init_complex_type ("complex*8", builtin_f_type->builtin_real); builtin_f_type->builtin_complex_s16 - = arch_complex_type (gdbarch, "complex*16", - builtin_f_type->builtin_real_s8); + = init_complex_type ("complex*16", builtin_f_type->builtin_real_s8); builtin_f_type->builtin_complex_s32 - = arch_complex_type (gdbarch, "complex*32", - builtin_f_type->builtin_real_s16); + = init_complex_type ("complex*32", builtin_f_type->builtin_real_s16); return builtin_f_type; } diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index d89df9f7409..f23def1ff71 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -3025,19 +3025,40 @@ init_decfloat_type (struct objfile *objfile, int bit, const char *name) return t; } -/* Allocate a TYPE_CODE_COMPLEX type structure associated with OBJFILE. - NAME is the type name. TARGET_TYPE is the component float type. */ +/* Allocate a TYPE_CODE_COMPLEX type structure. NAME is the type + name. TARGET_TYPE is the component type. */ struct type * -init_complex_type (struct objfile *objfile, - const char *name, struct type *target_type) +init_complex_type (const char *name, struct type *target_type) { struct type *t; - t = init_type (objfile, TYPE_CODE_COMPLEX, - 2 * TYPE_LENGTH (target_type) * TARGET_CHAR_BIT, name); - TYPE_TARGET_TYPE (t) = target_type; - return t; + gdb_assert (TYPE_CODE (target_type) == TYPE_CODE_INT + || TYPE_CODE (target_type) == TYPE_CODE_FLT); + + if (TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type == nullptr) + { + if (name == nullptr) + { + char *new_name + = (char *) TYPE_ALLOC (target_type, + strlen (TYPE_NAME (target_type)) + + strlen ("_Complex ") + 1); + strcpy (new_name, "_Complex "); + strcat (new_name, TYPE_NAME (target_type)); + name = new_name; + } + + t = alloc_type_copy (target_type); + set_type_code (t, TYPE_CODE_COMPLEX); + TYPE_LENGTH (t) = 2 * TYPE_LENGTH (target_type); + TYPE_NAME (t) = name; + + TYPE_TARGET_TYPE (t) = target_type; + TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type = t; + } + + return TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type; } /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE. @@ -5259,21 +5280,6 @@ arch_decfloat_type (struct gdbarch *gdbarch, int bit, const char *name) return t; } -/* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH. - NAME is the type name. TARGET_TYPE is the component float type. */ - -struct type * -arch_complex_type (struct gdbarch *gdbarch, - const char *name, struct type *target_type) -{ - struct type *t; - - t = arch_type (gdbarch, TYPE_CODE_COMPLEX, - 2 * TYPE_LENGTH (target_type) * TARGET_CHAR_BIT, name); - TYPE_TARGET_TYPE (t) = target_type; - return t; -} - /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH. BIT is the pointer type size in bits. NAME is the type name. TARGET_TYPE is the pointer target type. Always sets the pointer type's @@ -5497,11 +5503,9 @@ gdbtypes_post_init (struct gdbarch *gdbarch) = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), "long double", gdbarch_long_double_format (gdbarch)); builtin_type->builtin_complex - = arch_complex_type (gdbarch, "complex", - builtin_type->builtin_float); + = init_complex_type ("complex", builtin_type->builtin_float); builtin_type->builtin_double_complex - = arch_complex_type (gdbarch, "double complex", - builtin_type->builtin_double); + = init_complex_type ("double complex", builtin_type->builtin_double); builtin_type->builtin_string = arch_type (gdbarch, TYPE_CODE_STRING, TARGET_CHAR_BIT, "string"); builtin_type->builtin_bool diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index cb674dbc1e8..77cc92e419d 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -803,6 +803,10 @@ struct main_type struct range_bounds *bounds; + /* If this is a scalar type, then this is its corresponding + complex type. */ + struct type *complex_type; + } flds_bnds; /* * Slot to point to additional language-specific fields of this @@ -1841,8 +1845,7 @@ extern struct type *init_float_type (struct objfile *, int, const char *, const struct floatformat **, enum bfd_endian = BFD_ENDIAN_UNKNOWN); extern struct type *init_decfloat_type (struct objfile *, int, const char *); -extern struct type *init_complex_type (struct objfile *, const char *, - struct type *); +extern struct type *init_complex_type (const char *, struct type *); extern struct type *init_pointer_type (struct objfile *, int, const char *, struct type *); @@ -1858,8 +1861,6 @@ extern struct type *arch_boolean_type (struct gdbarch *, int, int, extern struct type *arch_float_type (struct gdbarch *, int, const char *, const struct floatformat **); extern struct type *arch_decfloat_type (struct gdbarch *, int, const char *); -extern struct type *arch_complex_type (struct gdbarch *, const char *, - struct type *); extern struct type *arch_pointer_type (struct gdbarch *, int, const char *, struct type *); diff --git a/gdb/go-lang.c b/gdb/go-lang.c index 53e342963d9..03dc986ab6a 100644 --- a/gdb/go-lang.c +++ b/gdb/go-lang.c @@ -665,11 +665,9 @@ build_go_types (struct gdbarch *gdbarch) builtin_go_type->builtin_float64 = arch_float_type (gdbarch, 64, "float64", floatformats_ieee_double); builtin_go_type->builtin_complex64 - = arch_complex_type (gdbarch, "complex64", - builtin_go_type->builtin_float32); + = init_complex_type ("complex64", builtin_go_type->builtin_float32); builtin_go_type->builtin_complex128 - = arch_complex_type (gdbarch, "complex128", - builtin_go_type->builtin_float64); + = init_complex_type ("complex128", builtin_go_type->builtin_float64); return builtin_go_type; } diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index d9ad8eef425..bac6fd6c465 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -1429,13 +1429,11 @@ basic_type (int bt, struct objfile *objfile) break; case btComplex: - tp = init_complex_type (objfile, "complex", - basic_type (btFloat, objfile)); + tp = init_complex_type ("complex", basic_type (btFloat, objfile)); break; case btDComplex: - tp = init_complex_type (objfile, "double complex", - basic_type (btFloat, objfile)); + tp = init_complex_type ("double complex", basic_type (btFloat, objfile)); break; case btFixedDec: diff --git a/gdb/stabsread.c b/gdb/stabsread.c index a23ebf6b606..068ece2ff53 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -2186,12 +2186,12 @@ rs6000_builtin_type (int typenum, struct objfile *objfile) break; case 25: /* Complex type consisting of two IEEE single precision values. */ - rettype = init_complex_type (objfile, "complex", + rettype = init_complex_type ("complex", rs6000_builtin_type (12, objfile)); break; case 26: /* Complex type consisting of two IEEE double precision values. */ - rettype = init_complex_type (objfile, "double complex", + rettype = init_complex_type ("double complex", rs6000_builtin_type (13, objfile)); break; case 27: @@ -3805,7 +3805,7 @@ read_sun_floating_type (const char **pp, int typenums[2], || details == NF_COMPLEX32) { rettype = dbx_init_float_type (objfile, nbits / 2); - return init_complex_type (objfile, NULL, rettype); + return init_complex_type (NULL, rettype); } return dbx_init_float_type (objfile, nbits); @@ -4099,7 +4099,7 @@ read_range_type (const char **pp, int typenums[2], int type_size, = dbx_init_float_type (objfile, n2 * TARGET_CHAR_BIT); if (self_subrange) - return init_complex_type (objfile, NULL, float_type); + return init_complex_type (NULL, float_type); else return float_type; }