diff options
| -rw-r--r-- | gdb/ChangeLog | 50 | ||||
| -rw-r--r-- | gdb/ada-exp.y | 2 | ||||
| -rw-r--r-- | gdb/ada-lang.c | 106 | ||||
| -rw-r--r-- | gdb/c-lang.c | 194 | ||||
| -rw-r--r-- | gdb/d-lang.c | 119 | ||||
| -rw-r--r-- | gdb/f-lang.c | 66 | ||||
| -rw-r--r-- | gdb/go-lang.c | 95 | ||||
| -rw-r--r-- | gdb/language.c | 205 | ||||
| -rw-r--r-- | gdb/language.h | 143 | ||||
| -rw-r--r-- | gdb/m2-lang.c | 42 | ||||
| -rw-r--r-- | gdb/opencl-lang.c | 244 | ||||
| -rw-r--r-- | gdb/p-lang.c | 87 | ||||
| -rw-r--r-- | gdb/rust-lang.c | 78 | ||||
| -rw-r--r-- | gdb/testsuite/ChangeLog | 4 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.fortran/types.exp | 11 |
15 files changed, 630 insertions, 816 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index abcd02b..4ab4183 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,53 @@ +2020-11-12 Andrew Burgess <andrew.burgess@embecosm.com> + + * ada-exp.y (find_primitive_type): Make parameter const. + * ada-lang.c (enum ada_primitive_types): Delete. + (ada_language::language_arch_info): Update. + * c-lang.c (enum c_primitive_types): Delete. + (c_language_arch_info): Update. + (enum cplus_primitive_types): Delete. + (cplus_language::language_arch_info): Update. + * d-lang.c (enum d_primitive_types): Delete. + (d_language::language_arch_info): Update. + * f-lang.c (enum f_primitive_types): Delete. + (f_language::language_arch_info): Update. + * go-lang.c (enum go_primitive_types): Delete. + (go_language::language_arch_info): Update. + * language.c (auto_or_unknown_language::language_arch_info): + Update. + (language_gdbarch_post_init): Use obstack_new, use array indexing. + (language_string_char_type): Add header comment, call function in + language_arch_info. + (language_bool_type): Likewise + (language_arch_info::bool_type): Define. + (language_lookup_primitive_type_1): Delete. + (language_lookup_primitive_type): Rewrite as a templated function + to call function in language_arch_info, then instantiate twice. + (language_arch_info::type_and_symbol::alloc_type_symbol): Define. + (language_arch_info::lookup_primitive_type_and_symbol): Define. + (language_arch_info::lookup_primitive_type): Define twice with + different signatures. + (language_arch_info::lookup_primitive_type_as_symbol): Define. + (language_lookup_primitive_type_as_symbol): Rewrite to call a + member function in language_arch_info. + * language.h (language_arch_info): Complete rewrite. + (language_lookup_primitive_type): Make templated. + * m2-lang.c (enum m2_primitive_types): Delete. + (m2_language::language_arch_info): Update. + * opencl-lang.c (OCL_P_TYPE): Delete. + (enum opencl_primitive_types): Delete. + (opencl_type_data): Delete. + (builtin_opencl_type): Delete. + (lookup_opencl_vector_type): Update. + (opencl_language::language_arch_info): Update, lots of content + moved from... + (build_opencl_types): ...here. This function is now deleted. + (_initialize_opencl_language): Delete. + * p-lang.c (enum pascal_primitive_types): Delete. + (pascal_language::language_arch_info): Update. + * rust-lang.c (enum rust_primitive_types): Delete. + (rust_language::language_arch_info): Update. + 2020-11-12 Simon Marchi <simon.marchi@polymtl.ca> * dwarf2/read.c (dw2_do_instantiate_symtab): Fix call to diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y index 83d711c..636ec58 100644 --- a/gdb/ada-exp.y +++ b/gdb/ada-exp.y @@ -1026,7 +1026,7 @@ select_possible_type_sym (const std::vector<struct block_symbol> &syms) } static struct type* -find_primitive_type (struct parser_state *par_state, char *name) +find_primitive_type (struct parser_state *par_state, const char *name) { struct type *type; type = language_lookup_primitive_type (par_state->language (), diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index fe3ea70..714227d 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -13595,24 +13595,6 @@ static const struct op_print ada_op_print_tab[] = { {NULL, OP_NULL, PREC_SUFFIX, 0} }; -enum ada_primitive_types { - ada_primitive_type_int, - ada_primitive_type_long, - ada_primitive_type_short, - ada_primitive_type_char, - ada_primitive_type_float, - ada_primitive_type_double, - ada_primitive_type_void, - ada_primitive_type_long_long, - ada_primitive_type_long_double, - ada_primitive_type_natural, - ada_primitive_type_positive, - ada_primitive_type_system_address, - ada_primitive_type_storage_offset, - nr_ada_primitive_types -}; - - /* Language vector */ static const struct exp_descriptor ada_exp_descriptor = { @@ -13838,63 +13820,51 @@ public: { const struct builtin_type *builtin = builtin_type (gdbarch); - lai->primitive_type_vector - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_ada_primitive_types + 1, - struct type *); - - lai->primitive_type_vector [ada_primitive_type_int] - = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), - 0, "integer"); - lai->primitive_type_vector [ada_primitive_type_long] - = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), - 0, "long_integer"); - lai->primitive_type_vector [ada_primitive_type_short] - = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), - 0, "short_integer"); - lai->string_char_type - = lai->primitive_type_vector [ada_primitive_type_char] - = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "character"); - lai->primitive_type_vector [ada_primitive_type_float] - = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), - "float", gdbarch_float_format (gdbarch)); - lai->primitive_type_vector [ada_primitive_type_double] - = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), - "long_float", gdbarch_double_format (gdbarch)); - lai->primitive_type_vector [ada_primitive_type_long_long] - = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), - 0, "long_long_integer"); - lai->primitive_type_vector [ada_primitive_type_long_double] - = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), - "long_long_float", gdbarch_long_double_format (gdbarch)); - lai->primitive_type_vector [ada_primitive_type_natural] - = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), - 0, "natural"); - lai->primitive_type_vector [ada_primitive_type_positive] - = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), - 0, "positive"); - lai->primitive_type_vector [ada_primitive_type_void] - = builtin->builtin_void; - - lai->primitive_type_vector [ada_primitive_type_system_address] + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type *t) + { + lai->add_primitive_type (t); + }; + + add (arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 0, "integer")); + add (arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), + 0, "long_integer")); + add (arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), + 0, "short_integer")); + struct type *char_type = arch_character_type (gdbarch, TARGET_CHAR_BIT, + 0, "character"); + lai->set_string_char_type (char_type); + add (char_type); + add (arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), + "float", gdbarch_float_format (gdbarch))); + add (arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), + "long_float", gdbarch_double_format (gdbarch))); + add (arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), + 0, "long_long_integer")); + add (arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), + "long_long_float", + gdbarch_long_double_format (gdbarch))); + add (arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 0, "natural")); + add (arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 0, "positive")); + add (builtin->builtin_void); + + struct type *system_addr_ptr = lookup_pointer_type (arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void")); - lai->primitive_type_vector [ada_primitive_type_system_address] - ->set_name ("system__address"); + system_addr_ptr->set_name ("system__address"); + add (system_addr_ptr); /* Create the equivalent of the System.Storage_Elements.Storage_Offset type. This is a signed integral type whose size is the same as the size of addresses. */ - { - unsigned int addr_length = TYPE_LENGTH - (lai->primitive_type_vector [ada_primitive_type_system_address]); - - lai->primitive_type_vector [ada_primitive_type_storage_offset] - = arch_integer_type (gdbarch, addr_length * HOST_CHAR_BIT, 0, - "storage_offset"); - } + unsigned int addr_length = TYPE_LENGTH (system_addr_ptr); + add (arch_integer_type (gdbarch, addr_length * HOST_CHAR_BIT, 0, + "storage_offset")); - lai->bool_type_symbol = NULL; - lai->bool_type_default = builtin->builtin_bool; + lai->set_bool_type (builtin->builtin_bool); } /* See language.h. */ diff --git a/gdb/c-lang.c b/gdb/c-lang.c index 329986c..8dbce39 100644 --- a/gdb/c-lang.c +++ b/gdb/c-lang.c @@ -803,29 +803,6 @@ const struct op_print c_op_print_tab[] = {NULL, OP_NULL, PREC_PREFIX, 0} }; -enum c_primitive_types { - c_primitive_type_int, - c_primitive_type_long, - c_primitive_type_short, - c_primitive_type_char, - c_primitive_type_float, - c_primitive_type_double, - c_primitive_type_void, - c_primitive_type_long_long, - c_primitive_type_signed_char, - c_primitive_type_unsigned_char, - c_primitive_type_unsigned_short, - c_primitive_type_unsigned_int, - c_primitive_type_unsigned_long, - c_primitive_type_unsigned_long_long, - c_primitive_type_long_double, - c_primitive_type_complex, - c_primitive_type_double_complex, - c_primitive_type_decfloat, - c_primitive_type_decdouble, - c_primitive_type_declong, - nr_c_primitive_types -}; void c_language_arch_info (struct gdbarch *gdbarch, @@ -833,32 +810,35 @@ c_language_arch_info (struct gdbarch *gdbarch, { const struct builtin_type *builtin = builtin_type (gdbarch); - lai->string_char_type = builtin->builtin_char; - lai->primitive_type_vector - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1, - struct type *); - lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int; - lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long; - lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short; - lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char; - lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float; - lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double; - lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void; - lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long; - lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char; - lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char; - lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short; - lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int; - lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long; - lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long; - lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double; - lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex; - lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex; - lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat; - lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble; - lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong; - - lai->bool_type_default = builtin->builtin_int; + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type * t) + { + lai->add_primitive_type (t); + }; + + add (builtin->builtin_int); + add (builtin->builtin_long); + add (builtin->builtin_short); + add (builtin->builtin_char); + add (builtin->builtin_float); + add (builtin->builtin_double); + add (builtin->builtin_void); + add (builtin->builtin_long_long); + add (builtin->builtin_signed_char); + add (builtin->builtin_unsigned_char); + add (builtin->builtin_unsigned_short); + add (builtin->builtin_unsigned_int); + add (builtin->builtin_unsigned_long); + add (builtin->builtin_unsigned_long_long); + add (builtin->builtin_long_double); + add (builtin->builtin_complex); + add (builtin->builtin_double_complex); + add (builtin->builtin_decfloat); + add (builtin->builtin_decdouble); + add (builtin->builtin_declong); + + lai->set_string_char_type (builtin->builtin_char); + lai->set_bool_type (builtin->builtin_int); } const struct exp_descriptor exp_descriptor_c = @@ -955,34 +935,6 @@ public: static c_language c_language_defn; -enum cplus_primitive_types { - cplus_primitive_type_int, - cplus_primitive_type_long, - cplus_primitive_type_short, - cplus_primitive_type_char, - cplus_primitive_type_float, - cplus_primitive_type_double, - cplus_primitive_type_void, - cplus_primitive_type_long_long, - cplus_primitive_type_signed_char, - cplus_primitive_type_unsigned_char, - cplus_primitive_type_unsigned_short, - cplus_primitive_type_unsigned_int, - cplus_primitive_type_unsigned_long, - cplus_primitive_type_unsigned_long_long, - cplus_primitive_type_long_double, - cplus_primitive_type_complex, - cplus_primitive_type_double_complex, - cplus_primitive_type_bool, - cplus_primitive_type_decfloat, - cplus_primitive_type_decdouble, - cplus_primitive_type_declong, - cplus_primitive_type_char16_t, - cplus_primitive_type_char32_t, - cplus_primitive_type_wchar_t, - nr_cplus_primitive_types -}; - /* A class for the C++ language. */ class cplus_language : public language_defn @@ -1025,61 +977,39 @@ public: { const struct builtin_type *builtin = builtin_type (gdbarch); - lai->string_char_type = builtin->builtin_char; - lai->primitive_type_vector - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1, - struct type *); - lai->primitive_type_vector [cplus_primitive_type_int] - = builtin->builtin_int; - lai->primitive_type_vector [cplus_primitive_type_long] - = builtin->builtin_long; - lai->primitive_type_vector [cplus_primitive_type_short] - = builtin->builtin_short; - lai->primitive_type_vector [cplus_primitive_type_char] - = builtin->builtin_char; - lai->primitive_type_vector [cplus_primitive_type_float] - = builtin->builtin_float; - lai->primitive_type_vector [cplus_primitive_type_double] - = builtin->builtin_double; - lai->primitive_type_vector [cplus_primitive_type_void] - = builtin->builtin_void; - lai->primitive_type_vector [cplus_primitive_type_long_long] - = builtin->builtin_long_long; - lai->primitive_type_vector [cplus_primitive_type_signed_char] - = builtin->builtin_signed_char; - lai->primitive_type_vector [cplus_primitive_type_unsigned_char] - = builtin->builtin_unsigned_char; - lai->primitive_type_vector [cplus_primitive_type_unsigned_short] - = builtin->builtin_unsigned_short; - lai->primitive_type_vector [cplus_primitive_type_unsigned_int] - = builtin->builtin_unsigned_int; - lai->primitive_type_vector [cplus_primitive_type_unsigned_long] - = builtin->builtin_unsigned_long; - lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long] - = builtin->builtin_unsigned_long_long; - lai->primitive_type_vector [cplus_primitive_type_long_double] - = builtin->builtin_long_double; - lai->primitive_type_vector [cplus_primitive_type_complex] - = builtin->builtin_complex; - lai->primitive_type_vector [cplus_primitive_type_double_complex] - = builtin->builtin_double_complex; - lai->primitive_type_vector [cplus_primitive_type_bool] - = builtin->builtin_bool; - lai->primitive_type_vector [cplus_primitive_type_decfloat] - = builtin->builtin_decfloat; - lai->primitive_type_vector [cplus_primitive_type_decdouble] - = builtin->builtin_decdouble; - lai->primitive_type_vector [cplus_primitive_type_declong] - = builtin->builtin_declong; - lai->primitive_type_vector [cplus_primitive_type_char16_t] - = builtin->builtin_char16; - lai->primitive_type_vector [cplus_primitive_type_char32_t] - = builtin->builtin_char32; - lai->primitive_type_vector [cplus_primitive_type_wchar_t] - = builtin->builtin_wchar; - - lai->bool_type_symbol = "bool"; - lai->bool_type_default = builtin->builtin_bool; + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type * t) + { + lai->add_primitive_type (t); + }; + + add (builtin->builtin_int); + add (builtin->builtin_long); + add (builtin->builtin_short); + add (builtin->builtin_char); + add (builtin->builtin_float); + add (builtin->builtin_double); + add (builtin->builtin_void); + add (builtin->builtin_long_long); + add (builtin->builtin_signed_char); + add (builtin->builtin_unsigned_char); + add (builtin->builtin_unsigned_short); + add (builtin->builtin_unsigned_int); + add (builtin->builtin_unsigned_long); + add (builtin->builtin_unsigned_long_long); + add (builtin->builtin_long_double); + add (builtin->builtin_complex); + add (builtin->builtin_double_complex); + add (builtin->builtin_bool); + add (builtin->builtin_decfloat); + add (builtin->builtin_decdouble); + add (builtin->builtin_declong); + add (builtin->builtin_char16); + add (builtin->builtin_char32); + add (builtin->builtin_wchar); + + lai->set_string_char_type (builtin->builtin_char); + lai->set_bool_type (builtin->builtin_bool, "bool"); } /* See language.h. */ diff --git a/gdb/d-lang.c b/gdb/d-lang.c index 2537f04..2e7b7b6 100644 --- a/gdb/d-lang.c +++ b/gdb/d-lang.c @@ -94,36 +94,6 @@ static const struct op_print d_op_print_tab[] = {NULL, OP_NULL, PREC_PREFIX, 0} }; -/* Mapping of all D basic data types into the language vector. */ - -enum d_primitive_types { - d_primitive_type_void, - d_primitive_type_bool, - d_primitive_type_byte, - d_primitive_type_ubyte, - d_primitive_type_short, - d_primitive_type_ushort, - d_primitive_type_int, - d_primitive_type_uint, - d_primitive_type_long, - d_primitive_type_ulong, - d_primitive_type_cent, /* Signed 128 bit integer. */ - d_primitive_type_ucent, /* Unsigned 128 bit integer. */ - d_primitive_type_float, - d_primitive_type_double, - d_primitive_type_real, - d_primitive_type_ifloat, /* Imaginary float types. */ - d_primitive_type_idouble, - d_primitive_type_ireal, - d_primitive_type_cfloat, /* Complex number of two float values. */ - d_primitive_type_cdouble, - d_primitive_type_creal, - d_primitive_type_char, /* Unsigned character types. */ - d_primitive_type_wchar, - d_primitive_type_dchar, - nr_d_primitive_types -}; - /* Class representing the D language. */ class d_language : public language_defn @@ -157,62 +127,39 @@ public: { const struct builtin_d_type *builtin = builtin_d_type (gdbarch); - lai->string_char_type = builtin->builtin_char; - lai->primitive_type_vector - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_d_primitive_types + 1, - struct type *); - - lai->primitive_type_vector [d_primitive_type_void] - = builtin->builtin_void; - lai->primitive_type_vector [d_primitive_type_bool] - = builtin->builtin_bool; - lai->primitive_type_vector [d_primitive_type_byte] - = builtin->builtin_byte; - lai->primitive_type_vector [d_primitive_type_ubyte] - = builtin->builtin_ubyte; - lai->primitive_type_vector [d_primitive_type_short] - = builtin->builtin_short; - lai->primitive_type_vector [d_primitive_type_ushort] - = builtin->builtin_ushort; - lai->primitive_type_vector [d_primitive_type_int] - = builtin->builtin_int; - lai->primitive_type_vector [d_primitive_type_uint] - = builtin->builtin_uint; - lai->primitive_type_vector [d_primitive_type_long] - = builtin->builtin_long; - lai->primitive_type_vector [d_primitive_type_ulong] - = builtin->builtin_ulong; - lai->primitive_type_vector [d_primitive_type_cent] - = builtin->builtin_cent; - lai->primitive_type_vector [d_primitive_type_ucent] - = builtin->builtin_ucent; - lai->primitive_type_vector [d_primitive_type_float] - = builtin->builtin_float; - lai->primitive_type_vector [d_primitive_type_double] - = builtin->builtin_double; - lai->primitive_type_vector [d_primitive_type_real] - = builtin->builtin_real; - lai->primitive_type_vector [d_primitive_type_ifloat] - = builtin->builtin_ifloat; - lai->primitive_type_vector [d_primitive_type_idouble] - = builtin->builtin_idouble; - lai->primitive_type_vector [d_primitive_type_ireal] - = builtin->builtin_ireal; - lai->primitive_type_vector [d_primitive_type_cfloat] - = builtin->builtin_cfloat; - lai->primitive_type_vector [d_primitive_type_cdouble] - = builtin->builtin_cdouble; - lai->primitive_type_vector [d_primitive_type_creal] - = builtin->builtin_creal; - lai->primitive_type_vector [d_primitive_type_char] - = builtin->builtin_char; - lai->primitive_type_vector [d_primitive_type_wchar] - = builtin->builtin_wchar; - lai->primitive_type_vector [d_primitive_type_dchar] - = builtin->builtin_dchar; - - lai->bool_type_symbol = "bool"; - lai->bool_type_default = builtin->builtin_bool; + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type * t) + { + lai->add_primitive_type (t); + }; + + add (builtin->builtin_void); + add (builtin->builtin_bool); + add (builtin->builtin_byte); + add (builtin->builtin_ubyte); + add (builtin->builtin_short); + add (builtin->builtin_ushort); + add (builtin->builtin_int); + add (builtin->builtin_uint); + add (builtin->builtin_long); + add (builtin->builtin_ulong); + add (builtin->builtin_cent); + add (builtin->builtin_ucent); + add (builtin->builtin_float); + add (builtin->builtin_double); + add (builtin->builtin_real); + add (builtin->builtin_ifloat); + add (builtin->builtin_idouble); + add (builtin->builtin_ireal); + add (builtin->builtin_cfloat); + add (builtin->builtin_cdouble); + add (builtin->builtin_creal); + add (builtin->builtin_char); + add (builtin->builtin_wchar); + add (builtin->builtin_dchar); + + lai->set_string_char_type (builtin->builtin_char); + lai->set_bool_type (builtin->builtin_bool, "bool"); } /* See language.h. */ diff --git a/gdb/f-lang.c b/gdb/f-lang.c index b775fae..75cc05e 100644 --- a/gdb/f-lang.c +++ b/gdb/f-lang.c @@ -97,22 +97,6 @@ const struct op_print f_language::op_print_tab[] = {NULL, OP_NULL, PREC_REPEAT, 0} }; -enum f_primitive_types { - f_primitive_type_character, - f_primitive_type_logical, - f_primitive_type_logical_s1, - f_primitive_type_logical_s2, - f_primitive_type_logical_s8, - f_primitive_type_integer, - f_primitive_type_integer_s2, - f_primitive_type_real, - f_primitive_type_real_s8, - f_primitive_type_real_s16, - f_primitive_type_complex_s8, - f_primitive_type_complex_s16, - f_primitive_type_void, - nr_f_primitive_types -}; /* Called from fortran_value_subarray to take a slice of an array or a string. ARRAY is the array or string to be accessed. EXP, POS, and @@ -720,36 +704,26 @@ f_language::language_arch_info (struct gdbarch *gdbarch, { const struct builtin_f_type *builtin = builtin_f_type (gdbarch); - lai->string_char_type = builtin->builtin_character; - lai->primitive_type_vector - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_f_primitive_types + 1, - struct type *); - - lai->primitive_type_vector [f_primitive_type_character] - = builtin->builtin_character; - lai->primitive_type_vector [f_primitive_type_logical] - = builtin->builtin_logical; - lai->primitive_type_vector [f_primitive_type_logical_s1] - = builtin->builtin_logical_s1; - lai->primitive_type_vector [f_primitive_type_logical_s2] - = builtin->builtin_logical_s2; - lai->primitive_type_vector [f_primitive_type_logical_s8] - = builtin->builtin_logical_s8; - lai->primitive_type_vector [f_primitive_type_real] - = builtin->builtin_real; - lai->primitive_type_vector [f_primitive_type_real_s8] - = builtin->builtin_real_s8; - lai->primitive_type_vector [f_primitive_type_real_s16] - = builtin->builtin_real_s16; - lai->primitive_type_vector [f_primitive_type_complex_s8] - = builtin->builtin_complex_s8; - lai->primitive_type_vector [f_primitive_type_complex_s16] - = builtin->builtin_complex_s16; - lai->primitive_type_vector [f_primitive_type_void] - = builtin->builtin_void; - - lai->bool_type_symbol = "logical"; - lai->bool_type_default = builtin->builtin_logical_s2; + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type * t) + { + lai->add_primitive_type (t); + }; + + add (builtin->builtin_character); + add (builtin->builtin_logical); + add (builtin->builtin_logical_s1); + add (builtin->builtin_logical_s2); + add (builtin->builtin_logical_s8); + add (builtin->builtin_real); + add (builtin->builtin_real_s8); + add (builtin->builtin_real_s16); + add (builtin->builtin_complex_s8); + add (builtin->builtin_complex_s16); + add (builtin->builtin_void); + + lai->set_string_char_type (builtin->builtin_character); + lai->set_bool_type (builtin->builtin_logical_s2, "logical"); } /* See language.h. */ diff --git a/gdb/go-lang.c b/gdb/go-lang.c index 01cd3a47..4547b52 100644 --- a/gdb/go-lang.c +++ b/gdb/go-lang.c @@ -482,28 +482,6 @@ static const struct op_print go_op_print_tab[] = {NULL, OP_NULL, PREC_SUFFIX, 0} }; -enum go_primitive_types { - go_primitive_type_void, - go_primitive_type_char, - go_primitive_type_bool, - go_primitive_type_int, - go_primitive_type_uint, - go_primitive_type_uintptr, - go_primitive_type_int8, - go_primitive_type_int16, - go_primitive_type_int32, - go_primitive_type_int64, - go_primitive_type_uint8, - go_primitive_type_uint16, - go_primitive_type_uint32, - go_primitive_type_uint64, - go_primitive_type_float32, - go_primitive_type_float64, - go_primitive_type_complex64, - go_primitive_type_complex128, - nr_go_primitive_types -}; - /* Class representing the Go language. */ class go_language : public language_defn @@ -529,51 +507,34 @@ public: { const struct builtin_go_type *builtin = builtin_go_type (gdbarch); - lai->string_char_type = builtin->builtin_char; - - lai->primitive_type_vector - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_go_primitive_types + 1, - struct type *); - - lai->primitive_type_vector [go_primitive_type_void] - = builtin->builtin_void; - lai->primitive_type_vector [go_primitive_type_char] - = builtin->builtin_char; - lai->primitive_type_vector [go_primitive_type_bool] - = builtin->builtin_bool; - lai->primitive_type_vector [go_primitive_type_int] - = builtin->builtin_int; - lai->primitive_type_vector [go_primitive_type_uint] - = builtin->builtin_uint; - lai->primitive_type_vector [go_primitive_type_uintptr] - = builtin->builtin_uintptr; - lai->primitive_type_vector [go_primitive_type_int8] - = builtin->builtin_int8; - lai->primitive_type_vector [go_primitive_type_int16] - = builtin->builtin_int16; - lai->primitive_type_vector [go_primitive_type_int32] - = builtin->builtin_int32; - lai->primitive_type_vector [go_primitive_type_int64] - = builtin->builtin_int64; - lai->primitive_type_vector [go_primitive_type_uint8] - = builtin->builtin_uint8; - lai->primitive_type_vector [go_primitive_type_uint16] - = builtin->builtin_uint16; - lai->primitive_type_vector [go_primitive_type_uint32] - = builtin->builtin_uint32; - lai->primitive_type_vector [go_primitive_type_uint64] - = builtin->builtin_uint64; - lai->primitive_type_vector [go_primitive_type_float32] - = builtin->builtin_float32; - lai->primitive_type_vector [go_primitive_type_float64] - = builtin->builtin_float64; - lai->primitive_type_vector [go_primitive_type_complex64] - = builtin->builtin_complex64; - lai->primitive_type_vector [go_primitive_type_complex128] - = builtin->builtin_complex128; - - lai->bool_type_symbol = "bool"; - lai->bool_type_default = builtin->builtin_bool; + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type * t) -> struct type * + { + lai->add_primitive_type (t); + return t; + }; + + add (builtin->builtin_void); + add (builtin->builtin_char); + add (builtin->builtin_bool); + add (builtin->builtin_int); + add (builtin->builtin_uint); + add (builtin->builtin_uintptr); + add (builtin->builtin_int8); + add (builtin->builtin_int16); + add (builtin->builtin_int32); + add (builtin->builtin_int64); + add (builtin->builtin_uint8); + add (builtin->builtin_uint16); + add (builtin->builtin_uint32); + add (builtin->builtin_uint64); + add (builtin->builtin_float32); + add (builtin->builtin_float64); + add (builtin->builtin_complex64); + add (builtin->builtin_complex128); + + lai->set_string_char_type (builtin->builtin_char); + lai->set_bool_type (builtin->builtin_bool, "bool"); } /* See language.h. */ diff --git a/gdb/language.c b/gdb/language.c index 1a0e20e..579cf91 100644 --- a/gdb/language.c +++ b/gdb/language.c @@ -797,10 +797,8 @@ public: void language_arch_info (struct gdbarch *gdbarch, struct language_arch_info *lai) const override { - lai->string_char_type = builtin_type (gdbarch)->builtin_char; - lai->bool_type_default = builtin_type (gdbarch)->builtin_int; - lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1, - struct type *); + lai->set_string_char_type (builtin_type (gdbarch)->builtin_char); + lai->set_bool_type (builtin_type (gdbarch)->builtin_int); } /* See language.h. */ @@ -985,102 +983,71 @@ struct language_gdbarch static void * language_gdbarch_post_init (struct gdbarch *gdbarch) { - struct language_gdbarch *l; - - l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch); + struct language_gdbarch *l + = obstack_new<struct language_gdbarch> (gdbarch_obstack (gdbarch)); for (const auto &lang : language_defn::languages) { gdb_assert (lang != nullptr); - lang->language_arch_info (gdbarch, - l->arch_info + lang->la_language); + lang->language_arch_info (gdbarch, &l->arch_info[lang->la_language]); } return l; } +/* See language.h. */ + struct type * language_string_char_type (const struct language_defn *la, struct gdbarch *gdbarch) { struct language_gdbarch *ld = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data); - - return ld->arch_info[la->la_language].string_char_type; + return ld->arch_info[la->la_language].string_char_type (); } +/* See language.h. */ + struct type * language_bool_type (const struct language_defn *la, struct gdbarch *gdbarch) { struct language_gdbarch *ld = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data); + return ld->arch_info[la->la_language].bool_type (); +} + +/* See language.h. */ - if (ld->arch_info[la->la_language].bool_type_symbol) +struct type * +language_arch_info::bool_type () const +{ + if (m_bool_type_name != nullptr) { struct symbol *sym; - sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol, - NULL, VAR_DOMAIN, NULL).symbol; - if (sym) + sym = lookup_symbol (m_bool_type_name, NULL, VAR_DOMAIN, NULL).symbol; + if (sym != nullptr) { struct type *type = SYMBOL_TYPE (sym); - - if (type && type->code () == TYPE_CODE_BOOL) + if (type != nullptr && type->code () == TYPE_CODE_BOOL) return type; } } - return ld->arch_info[la->la_language].bool_type_default; -} - -/* Helper function for primitive type lookup. */ - -static struct type ** -language_lookup_primitive_type_1 (const struct language_arch_info *lai, - const char *name) -{ - struct type **p; - - for (p = lai->primitive_type_vector; (*p) != NULL; p++) - { - if (strcmp ((*p)->name (), name) == 0) - return p; - } - return NULL; + return m_bool_type_default; } /* See language.h. */ -struct type * -language_lookup_primitive_type (const struct language_defn *la, - struct gdbarch *gdbarch, - const char *name) -{ - struct language_gdbarch *ld = - (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data); - struct type **typep; - - typep = language_lookup_primitive_type_1 (&ld->arch_info[la->la_language], - name); - if (typep == NULL) - return NULL; - return *typep; -} - -/* Helper function for type lookup as a symbol. - Create the symbol corresponding to type TYPE in language LANG. */ - -static struct symbol * -language_alloc_type_symbol (enum language lang, struct type *type) +struct symbol * +language_arch_info::type_and_symbol::alloc_type_symbol + (enum language lang, struct type *type) { struct symbol *symbol; struct gdbarch *gdbarch; - gdb_assert (!TYPE_OBJFILE_OWNED (type)); - gdbarch = TYPE_OWNER (type).gdbarch; symbol = new (gdbarch_obstack (gdbarch)) struct symbol (); - symbol->m_name = type->name (); symbol->set_language (lang, nullptr); symbol->owner.arch = gdbarch; @@ -1089,41 +1056,88 @@ language_alloc_type_symbol (enum language lang, struct type *type) SYMBOL_TYPE (symbol) = type; SYMBOL_DOMAIN (symbol) = VAR_DOMAIN; SYMBOL_ACLASS_INDEX (symbol) = LOC_TYPEDEF; - return symbol; } -/* Initialize the primitive type symbols of language LD. - The primitive type vector must have already been initialized. */ +/* See language.h. */ -static void -language_init_primitive_type_symbols (struct language_arch_info *lai, - const struct language_defn *la, - struct gdbarch *gdbarch) +language_arch_info::type_and_symbol * +language_arch_info::lookup_primitive_type_and_symbol (const char *name) { - int n; + for (struct type_and_symbol &tas : primitive_types_and_symbols) + { + if (strcmp (tas.type ()->name (), name) == 0) + return &tas; + } - gdb_assert (lai->primitive_type_vector != NULL); + return nullptr; +} + +/* See language.h. */ - for (n = 0; lai->primitive_type_vector[n] != NULL; ++n) - continue; +struct type * +language_arch_info::lookup_primitive_type (const char *name) +{ + type_and_symbol *tas = lookup_primitive_type_and_symbol (name); + if (tas != nullptr) + return tas->type (); + return nullptr; +} - lai->primitive_type_symbols - = GDBARCH_OBSTACK_CALLOC (gdbarch, n + 1, struct symbol *); +/* See language.h. */ - for (n = 0; lai->primitive_type_vector[n] != NULL; ++n) +struct type * +language_arch_info::lookup_primitive_type + (std::function<bool (struct type *)> filter) +{ + for (struct type_and_symbol &tas : primitive_types_and_symbols) { - lai->primitive_type_symbols[n] - = language_alloc_type_symbol (la->la_language, - lai->primitive_type_vector[n]); + if (filter (tas.type ())) + return tas.type (); } - /* Note: The result of symbol lookup is normally a symbol *and* the block - it was found in. Builtin types don't live in blocks. We *could* give - them one, but there is no current need so to keep things simple symbol - lookup is extended to allow for BLOCK_FOUND to be NULL. */ + return nullptr; +} + +/* See language.h. */ + +struct symbol * +language_arch_info::lookup_primitive_type_as_symbol (const char *name, + enum language lang) +{ + type_and_symbol *tas = lookup_primitive_type_and_symbol (name); + if (tas != nullptr) + return tas->symbol (lang); + return nullptr; +} + +/* See language.h. */ + +template<typename T> +struct type * +language_lookup_primitive_type (const struct language_defn *la, + struct gdbarch *gdbarch, + T arg) +{ + struct language_gdbarch *ld = + (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data); + return ld->arch_info[la->la_language].lookup_primitive_type (arg); } +/* Template instantiation. */ + +template struct type * +language_lookup_primitive_type (const struct language_defn *la, + struct gdbarch *gdbarch, + const char *arg); + +/* Template instantiation. */ + +template struct type * +language_lookup_primitive_type (const struct language_defn *la, + struct gdbarch *gdbarch, + std::function<bool (struct type *)> arg); + /* See language.h. */ struct symbol * @@ -1134,33 +1148,24 @@ language_lookup_primitive_type_as_symbol (const struct language_defn *la, struct language_gdbarch *ld = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data); struct language_arch_info *lai = &ld->arch_info[la->la_language]; - struct type **typep; - struct symbol *sym; if (symbol_lookup_debug) - { - fprintf_unfiltered (gdb_stdlog, - "language_lookup_primitive_type_as_symbol" - " (%s, %s, %s)", - la->name (), host_address_to_string (gdbarch), name); - } - - typep = language_lookup_primitive_type_1 (lai, name); - if (typep == NULL) - { - if (symbol_lookup_debug) - fprintf_unfiltered (gdb_stdlog, " = NULL\n"); - return NULL; - } - - /* The set of symbols is lazily initialized. */ - if (lai->primitive_type_symbols == NULL) - language_init_primitive_type_symbols (lai, la, gdbarch); + fprintf_unfiltered (gdb_stdlog, + "language_lookup_primitive_type_as_symbol" + " (%s, %s, %s)", + la->name (), host_address_to_string (gdbarch), name); - sym = lai->primitive_type_symbols[typep - lai->primitive_type_vector]; + struct symbol *sym + = lai->lookup_primitive_type_as_symbol (name, la->la_language); if (symbol_lookup_debug) fprintf_unfiltered (gdb_stdlog, " = %s\n", host_address_to_string (sym)); + + /* Note: The result of symbol lookup is normally a symbol *and* the block + it was found in. Builtin types don't live in blocks. We *could* give + them one, but there is no current need so to keep things simple symbol + lookup is extended to allow for BLOCK_FOUND to be NULL. */ + return sym; } diff --git a/gdb/language.h b/gdb/language.h index 951343f..1b60264 100644 --- a/gdb/language.h +++ b/gdb/language.h @@ -89,23 +89,129 @@ enum macro_expansion struct language_arch_info { - /* Its primitive types. This is a vector ended by a NULL pointer. - These types can be specified by name in parsing types in - expressions, regardless of whether the program being debugged - actually defines such a type. */ - struct type **primitive_type_vector; + /* A default constructor. */ + language_arch_info () = default; - /* Symbol wrappers around primitive_type_vector, so that the symbol lookup - machinery can return them. */ - struct symbol **primitive_type_symbols; + DISABLE_COPY_AND_ASSIGN (language_arch_info); + + /* Set the default boolean type to be TYPE. If NAME is not nullptr then + before using TYPE a symbol called NAME will be looked up, and the type + of this symbol will be used instead. Should only be called once when + performing setup for a particular language in combination with a + particular gdbarch. */ + void set_bool_type (struct type *type, const char *name = nullptr) + { + gdb_assert (m_bool_type_default == nullptr); + gdb_assert (m_bool_type_name == nullptr); + gdb_assert (type != nullptr); + m_bool_type_default = type; + m_bool_type_name = name; + } + + /* Set the type to be used for characters within a string. Should only + be called once when performing setup for a particular language in + combination with a particular gdbarch. */ + void set_string_char_type (struct type *type) + { + gdb_assert (m_string_char_type == nullptr); + gdb_assert (type != nullptr); + m_string_char_type = type; + } + + /* Return the type for characters within a string. */ + struct type *string_char_type () const + { return m_string_char_type; } + + /* Return the type to be used for booleans. */ + struct type *bool_type () const; + + /* Add TYPE to the list of primitive types for this particular language, + with this OS/ABI combination. */ + void add_primitive_type (struct type *type) + { + gdb_assert (type != nullptr); + primitive_types_and_symbols.push_back (type_and_symbol (type)); + } + + /* Lookup a primitive type called NAME. Will return nullptr if no + matching type is found. */ + struct type *lookup_primitive_type (const char *name); + + /* Lookup a primitive type for which FILTER returns true. Will return + nullptr if no matching type is found. */ + struct type *lookup_primitive_type + (std::function<bool (struct type *)> filter); + + /* Lookup a primitive type called NAME and return the type as a symbol. + LANG is the language for which type is being looked up. */ + struct symbol *lookup_primitive_type_as_symbol (const char *name, + enum language lang); +private: + + /* A structure storing a type and a corresponding symbol. The type is + defined at construction time, while the symbol is lazily created only + when asked for, but is then cached for future use. */ + struct type_and_symbol + { + /* Constructor. */ + explicit type_and_symbol (struct type *type) + : m_type (type) + { /* Nothing. */ } + + /* Default move constructor. */ + type_and_symbol (type_and_symbol&&) = default; + + DISABLE_COPY_AND_ASSIGN (type_and_symbol); + + /* Return the type from this object. */ + struct type *type () const + { return m_type; } + + /* Create and return a symbol wrapping M_TYPE from this object. */ + struct symbol *symbol (enum language lang) + { + if (m_symbol == nullptr) + m_symbol = alloc_type_symbol (lang, m_type); + return m_symbol; + } + + private: + /* The type primitive type. */ + struct type *m_type = nullptr; + + /* A symbol wrapping M_TYPE, only created when first asked for. */ + struct symbol *m_symbol = nullptr; + + /* Helper function for type lookup as a symbol. Create the symbol + corresponding to type TYPE in language LANG. */ + static struct symbol *alloc_type_symbol (enum language lang, + struct type *type); + }; + + /* Lookup a type_and_symbol entry from the primitive_types_and_symbols + vector for a type matching NAME. Return a pointer to the + type_and_symbol object from the vector. This will return nullptr if + there is no type matching NAME found. */ + type_and_symbol *lookup_primitive_type_and_symbol (const char *name); + + /* Vector of the primitive types added through add_primitive_type. These + types can be specified by name in parsing types in expressions, + regardless of whether the program being debugged actually defines such + a type. + + Within the vector each type is paired with a lazily created symbol, + which can be fetched by the symbol lookup machinery, should they be + needed. */ + std::vector<type_and_symbol> primitive_types_and_symbols; /* Type of elements of strings. */ - struct type *string_char_type; + struct type *m_string_char_type = nullptr; /* Symbol name of type to use as boolean type, if defined. */ - const char *bool_type_symbol; + const char *m_bool_type_name = nullptr; + /* Otherwise, this is the default boolean builtin type. */ - struct type *bool_type_default; + struct type *m_bool_type_default = nullptr; }; /* In a language (particularly C++) a function argument of an aggregate @@ -601,18 +707,27 @@ extern enum language_mode } language_mode; +/* Return the type that should be used for booleans for language L in + GDBARCH. */ + struct type *language_bool_type (const struct language_defn *l, struct gdbarch *gdbarch); +/* Return the type that should be used for characters within a string for + language L in GDBARCH. */ + struct type *language_string_char_type (const struct language_defn *l, struct gdbarch *gdbarch); -/* Look up type NAME in language L, and return its definition for architecture - GDBARCH. Returns NULL if not found. */ +/* Look up a type from the set of OS/ABI specific types defined in GDBARCH + for language L. ARG is used for selecting the matching type, and is + passed through to the corresponding lookup_primitive_type member + function inside the language_arch_info class. */ +template<typename T> struct type *language_lookup_primitive_type (const struct language_defn *l, struct gdbarch *gdbarch, - const char *name); + T arg); /* Wrapper around language_lookup_primitive_type to return the corresponding symbol. */ diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c index 1ede3ae..1155469 100644 --- a/gdb/m2-lang.c +++ b/gdb/m2-lang.c @@ -161,16 +161,6 @@ const struct op_print m2_language::op_print_tab[] = {NULL, OP_NULL, PREC_BUILTIN_FUNCTION, 0} }; -/* The built-in types of Modula-2. */ - -enum m2_primitive_types { - m2_primitive_type_char, - m2_primitive_type_int, - m2_primitive_type_card, - m2_primitive_type_real, - m2_primitive_type_bool, - nr_m2_primitive_types -}; const struct exp_descriptor m2_language::exp_descriptor_modula2 = { @@ -194,24 +184,20 @@ m2_language::language_arch_info (struct gdbarch *gdbarch, { const struct builtin_m2_type *builtin = builtin_m2_type (gdbarch); - lai->string_char_type = builtin->builtin_char; - lai->primitive_type_vector - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_m2_primitive_types + 1, - struct type *); - - lai->primitive_type_vector [m2_primitive_type_char] - = builtin->builtin_char; - lai->primitive_type_vector [m2_primitive_type_int] - = builtin->builtin_int; - lai->primitive_type_vector [m2_primitive_type_card] - = builtin->builtin_card; - lai->primitive_type_vector [m2_primitive_type_real] - = builtin->builtin_real; - lai->primitive_type_vector [m2_primitive_type_bool] - = builtin->builtin_bool; - - lai->bool_type_symbol = "BOOLEAN"; - lai->bool_type_default = builtin->builtin_bool; + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type * t) + { + lai->add_primitive_type (t); + }; + + add (builtin->builtin_char); + add (builtin->builtin_int); + add (builtin->builtin_card); + add (builtin->builtin_real); + add (builtin->builtin_bool); + + lai->set_string_char_type (builtin->builtin_char); + lai->set_bool_type (builtin->builtin_bool, "BOOLEAN"); } /* See languge.h. */ diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c index 38b98de..11032b1 100644 --- a/gdb/opencl-lang.c +++ b/gdb/opencl-lang.c @@ -28,49 +28,6 @@ #include "c-lang.h" #include "gdbarch.h" -/* This macro generates enum values from a given type. */ - -#define OCL_P_TYPE(TYPE)\ - opencl_primitive_type_##TYPE,\ - opencl_primitive_type_##TYPE##2,\ - opencl_primitive_type_##TYPE##3,\ - opencl_primitive_type_##TYPE##4,\ - opencl_primitive_type_##TYPE##8,\ - opencl_primitive_type_##TYPE##16 - -enum opencl_primitive_types { - OCL_P_TYPE (char), - OCL_P_TYPE (uchar), - OCL_P_TYPE (short), - OCL_P_TYPE (ushort), - OCL_P_TYPE (int), - OCL_P_TYPE (uint), - OCL_P_TYPE (long), - OCL_P_TYPE (ulong), - OCL_P_TYPE (half), - OCL_P_TYPE (float), - OCL_P_TYPE (double), - opencl_primitive_type_bool, - opencl_primitive_type_unsigned_char, - opencl_primitive_type_unsigned_short, - opencl_primitive_type_unsigned_int, - opencl_primitive_type_unsigned_long, - opencl_primitive_type_size_t, - opencl_primitive_type_ptrdiff_t, - opencl_primitive_type_intptr_t, - opencl_primitive_type_uintptr_t, - opencl_primitive_type_void, - nr_opencl_primitive_types -}; - -static struct gdbarch_data *opencl_type_data; - -static struct type ** -builtin_opencl_type (struct gdbarch *gdbarch) -{ - return (struct type **) gdbarch_data (gdbarch, opencl_type_data); -} - /* Returns the corresponding OpenCL vector type from the given type code, the length of the element type, the unsigned flag and the amount of elements (N). */ @@ -80,10 +37,7 @@ lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code, unsigned int el_length, unsigned int flag_unsigned, int n) { - int i; unsigned int length; - struct type *type = NULL; - struct type **types = builtin_opencl_type (gdbarch); /* Check if n describes a valid OpenCL vector size (2, 3, 4, 8, 16). */ if (n != 2 && n != 3 && n != 4 && n != 8 && n != 16) @@ -92,24 +46,20 @@ lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code, /* Triple vectors have the size of a quad vector. */ length = (n == 3) ? el_length * 4 : el_length * n; - for (i = 0; i < nr_opencl_primitive_types; i++) - { - LONGEST lowb, highb; - - if (types[i]->code () == TYPE_CODE_ARRAY && types[i]->is_vector () - && get_array_bounds (types[i], &lowb, &highb) - && TYPE_TARGET_TYPE (types[i])->code () == code - && TYPE_TARGET_TYPE (types[i])->is_unsigned () == flag_unsigned - && TYPE_LENGTH (TYPE_TARGET_TYPE (types[i])) == el_length - && TYPE_LENGTH (types[i]) == length - && highb - lowb + 1 == n) - { - type = types[i]; - break; - } - } - - return type; + std::function<bool (struct type *)> filter = [&] (struct type *type) + { + LONGEST lowb, highb; + + return (type->code () == TYPE_CODE_ARRAY && type->is_vector () + && get_array_bounds (type, &lowb, &highb) + && TYPE_TARGET_TYPE (type)->code () == code + && TYPE_TARGET_TYPE (type)->is_unsigned () == flag_unsigned + && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == el_length + && TYPE_LENGTH (type) == length + && highb - lowb + 1 == n); + }; + const struct language_defn *lang = language_def (language_opencl); + return language_lookup_primitive_type (lang, gdbarch, filter); } /* Returns nonzero if the array ARR contains duplicates within @@ -1026,17 +976,77 @@ public: void language_arch_info (struct gdbarch *gdbarch, struct language_arch_info *lai) const override { - struct type **types = builtin_opencl_type (gdbarch); + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type * t) -> struct type * + { + lai->add_primitive_type (t); + return t; + }; - /* Copy primitive types vector from gdbarch. */ - lai->primitive_type_vector = types; +/* Helper macro to create strings. */ +#define OCL_STRING(S) #S + +/* This macro allocates and assigns the type struct pointers + for the vector types. */ +#define BUILD_OCL_VTYPES(TYPE, ELEMENT_TYPE) \ + do \ + { \ + struct type *tmp; \ + tmp = add (init_vector_type (ELEMENT_TYPE, 2)); \ + tmp->set_name (OCL_STRING(TYPE ## 2)); \ + tmp = add (init_vector_type (ELEMENT_TYPE, 3)); \ + tmp->set_name (OCL_STRING(TYPE ## 3)); \ + TYPE_LENGTH (tmp) = 4 * TYPE_LENGTH (ELEMENT_TYPE); \ + tmp = add (init_vector_type (ELEMENT_TYPE, 4)); \ + tmp->set_name (OCL_STRING(TYPE ## 4)); \ + tmp = add (init_vector_type (ELEMENT_TYPE, 8)); \ + tmp->set_name (OCL_STRING(TYPE ## 8)); \ + tmp = init_vector_type (ELEMENT_TYPE, 16); \ + tmp->set_name (OCL_STRING(TYPE ## 16)); \ + } \ + while (false) + + struct type *el_type, *char_type, *int_type; + + char_type = el_type = add (arch_integer_type (gdbarch, 8, 0, "char")); + BUILD_OCL_VTYPES (char, el_type); + el_type = add (arch_integer_type (gdbarch, 8, 1, "uchar")); + BUILD_OCL_VTYPES (uchar, el_type); + el_type = add (arch_integer_type (gdbarch, 16, 0, "short")); + BUILD_OCL_VTYPES (short, el_type); + el_type = add (arch_integer_type (gdbarch, 16, 1, "ushort")); + BUILD_OCL_VTYPES (ushort, el_type); + int_type = el_type = add (arch_integer_type (gdbarch, 32, 0, "int")); + BUILD_OCL_VTYPES (int, el_type); + el_type = add (arch_integer_type (gdbarch, 32, 1, "uint")); + BUILD_OCL_VTYPES (uint, el_type); + el_type = add (arch_integer_type (gdbarch, 64, 0, "long")); + BUILD_OCL_VTYPES (long, el_type); + el_type = add (arch_integer_type (gdbarch, 64, 1, "ulong")); + BUILD_OCL_VTYPES (ulong, el_type); + el_type = add (arch_float_type (gdbarch, 16, "half", floatformats_ieee_half)); + BUILD_OCL_VTYPES (half, el_type); + el_type = add (arch_float_type (gdbarch, 32, "float", floatformats_ieee_single)); + BUILD_OCL_VTYPES (float, el_type); + el_type = add (arch_float_type (gdbarch, 64, "double", floatformats_ieee_double)); + BUILD_OCL_VTYPES (double, el_type); + + add (arch_boolean_type (gdbarch, 8, 1, "bool")); + add (arch_integer_type (gdbarch, 8, 1, "unsigned char")); + add (arch_integer_type (gdbarch, 16, 1, "unsigned short")); + add (arch_integer_type (gdbarch, 32, 1, "unsigned int")); + add (arch_integer_type (gdbarch, 64, 1, "unsigned long")); + add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t")); + add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t")); + add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t")); + add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t")); + add (arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void")); /* Type of elements of strings. */ - lai->string_char_type = types [opencl_primitive_type_char]; + lai->set_string_char_type (char_type); /* Specifies the return type of logical and relational operations. */ - lai->bool_type_symbol = "int"; - lai->bool_type_default = types [opencl_primitive_type_int]; + lai->set_bool_type (int_type, "int"); } /* See language.h. */ @@ -1078,97 +1088,3 @@ public: /* Single instance of the OpenCL language class. */ static opencl_language opencl_language_defn; - -static void * -build_opencl_types (struct gdbarch *gdbarch) -{ - struct type **types - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_opencl_primitive_types + 1, - struct type *); - -/* Helper macro to create strings. */ -#define OCL_STRING(S) #S -/* This macro allocates and assigns the type struct pointers - for the vector types. */ -#define BUILD_OCL_VTYPES(TYPE)\ - types[opencl_primitive_type_##TYPE##2] \ - = init_vector_type (types[opencl_primitive_type_##TYPE], 2); \ - types[opencl_primitive_type_##TYPE##2]->set_name (OCL_STRING(TYPE ## 2)); \ - types[opencl_primitive_type_##TYPE##3] \ - = init_vector_type (types[opencl_primitive_type_##TYPE], 3); \ - types[opencl_primitive_type_##TYPE##3]->set_name (OCL_STRING(TYPE ## 3)); \ - TYPE_LENGTH (types[opencl_primitive_type_##TYPE##3]) \ - = 4 * TYPE_LENGTH (types[opencl_primitive_type_##TYPE]); \ - types[opencl_primitive_type_##TYPE##4] \ - = init_vector_type (types[opencl_primitive_type_##TYPE], 4); \ - types[opencl_primitive_type_##TYPE##4]->set_name (OCL_STRING(TYPE ## 4)); \ - types[opencl_primitive_type_##TYPE##8] \ - = init_vector_type (types[opencl_primitive_type_##TYPE], 8); \ - types[opencl_primitive_type_##TYPE##8]->set_name (OCL_STRING(TYPE ## 8)); \ - types[opencl_primitive_type_##TYPE##16] \ - = init_vector_type (types[opencl_primitive_type_##TYPE], 16); \ - types[opencl_primitive_type_##TYPE##16]->set_name (OCL_STRING(TYPE ## 16)) - - types[opencl_primitive_type_char] - = arch_integer_type (gdbarch, 8, 0, "char"); - BUILD_OCL_VTYPES (char); - types[opencl_primitive_type_uchar] - = arch_integer_type (gdbarch, 8, 1, "uchar"); - BUILD_OCL_VTYPES (uchar); - types[opencl_primitive_type_short] - = arch_integer_type (gdbarch, 16, 0, "short"); - BUILD_OCL_VTYPES (short); - types[opencl_primitive_type_ushort] - = arch_integer_type (gdbarch, 16, 1, "ushort"); - BUILD_OCL_VTYPES (ushort); - types[opencl_primitive_type_int] - = arch_integer_type (gdbarch, 32, 0, "int"); - BUILD_OCL_VTYPES (int); - types[opencl_primitive_type_uint] - = arch_integer_type (gdbarch, 32, 1, "uint"); - BUILD_OCL_VTYPES (uint); - types[opencl_primitive_type_long] - = arch_integer_type (gdbarch, 64, 0, "long"); - BUILD_OCL_VTYPES (long); - types[opencl_primitive_type_ulong] - = arch_integer_type (gdbarch, 64, 1, "ulong"); - BUILD_OCL_VTYPES (ulong); - types[opencl_primitive_type_half] - = arch_float_type (gdbarch, 16, "half", floatformats_ieee_half); - BUILD_OCL_VTYPES (half); - types[opencl_primitive_type_float] - = arch_float_type (gdbarch, 32, "float", floatformats_ieee_single); - BUILD_OCL_VTYPES (float); - types[opencl_primitive_type_double] - = arch_float_type (gdbarch, 64, "double", floatformats_ieee_double); - BUILD_OCL_VTYPES (double); - types[opencl_primitive_type_bool] - = arch_boolean_type (gdbarch, 8, 1, "bool"); - types[opencl_primitive_type_unsigned_char] - = arch_integer_type (gdbarch, 8, 1, "unsigned char"); - types[opencl_primitive_type_unsigned_short] - = arch_integer_type (gdbarch, 16, 1, "unsigned short"); - types[opencl_primitive_type_unsigned_int] - = arch_integer_type (gdbarch, 32, 1, "unsigned int"); - types[opencl_primitive_type_unsigned_long] - = arch_integer_type (gdbarch, 64, 1, "unsigned long"); - types[opencl_primitive_type_size_t] - = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t"); - types[opencl_primitive_type_ptrdiff_t] - = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t"); - types[opencl_primitive_type_intptr_t] - = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t"); - types[opencl_primitive_type_uintptr_t] - = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t"); - types[opencl_primitive_type_void] - = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void"); - - return types; -} - -void _initialize_opencl_language (); -void -_initialize_opencl_language () -{ - opencl_type_data = gdbarch_data_register_post_init (build_opencl_types); -} diff --git a/gdb/p-lang.c b/gdb/p-lang.c index 9498dc0..1610c0a 100644 --- a/gdb/p-lang.c +++ b/gdb/p-lang.c @@ -227,26 +227,6 @@ const struct op_print pascal_op_print_tab[] = {NULL, OP_NULL, PREC_PREFIX, 0} }; -enum pascal_primitive_types { - pascal_primitive_type_int, - pascal_primitive_type_long, - pascal_primitive_type_short, - pascal_primitive_type_char, - pascal_primitive_type_float, - pascal_primitive_type_double, - pascal_primitive_type_void, - pascal_primitive_type_long_long, - pascal_primitive_type_signed_char, - pascal_primitive_type_unsigned_char, - pascal_primitive_type_unsigned_short, - pascal_primitive_type_unsigned_int, - pascal_primitive_type_unsigned_long, - pascal_primitive_type_unsigned_long_long, - pascal_primitive_type_long_double, - pascal_primitive_type_complex, - pascal_primitive_type_double_complex, - nr_pascal_primitive_types -}; /* Class representing the Pascal language. */ @@ -282,47 +262,32 @@ public: { const struct builtin_type *builtin = builtin_type (gdbarch); - lai->string_char_type = builtin->builtin_char; - lai->primitive_type_vector - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_pascal_primitive_types + 1, - struct type *); - lai->primitive_type_vector [pascal_primitive_type_int] - = builtin->builtin_int; - lai->primitive_type_vector [pascal_primitive_type_long] - = builtin->builtin_long; - lai->primitive_type_vector [pascal_primitive_type_short] - = builtin->builtin_short; - lai->primitive_type_vector [pascal_primitive_type_char] - = builtin->builtin_char; - lai->primitive_type_vector [pascal_primitive_type_float] - = builtin->builtin_float; - lai->primitive_type_vector [pascal_primitive_type_double] - = builtin->builtin_double; - lai->primitive_type_vector [pascal_primitive_type_void] - = builtin->builtin_void; - lai->primitive_type_vector [pascal_primitive_type_long_long] - = builtin->builtin_long_long; - lai->primitive_type_vector [pascal_primitive_type_signed_char] - = builtin->builtin_signed_char; - lai->primitive_type_vector [pascal_primitive_type_unsigned_char] - = builtin->builtin_unsigned_char; - lai->primitive_type_vector [pascal_primitive_type_unsigned_short] - = builtin->builtin_unsigned_short; - lai->primitive_type_vector [pascal_primitive_type_unsigned_int] - = builtin->builtin_unsigned_int; - lai->primitive_type_vector [pascal_primitive_type_unsigned_long] - = builtin->builtin_unsigned_long; - lai->primitive_type_vector [pascal_primitive_type_unsigned_long_long] - = builtin->builtin_unsigned_long_long; - lai->primitive_type_vector [pascal_primitive_type_long_double] - = builtin->builtin_long_double; - lai->primitive_type_vector [pascal_primitive_type_complex] - = builtin->builtin_complex; - lai->primitive_type_vector [pascal_primitive_type_double_complex] - = builtin->builtin_double_complex; - - lai->bool_type_symbol = "boolean"; - lai->bool_type_default = builtin->builtin_bool; + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type * t) + { + lai->add_primitive_type (t); + }; + + add (builtin->builtin_int); + add (builtin->builtin_long); + add (builtin->builtin_short); + add (builtin->builtin_char); + add (builtin->builtin_float); + add (builtin->builtin_double); + add (builtin->builtin_void); + add (builtin->builtin_long_long); + add (builtin->builtin_signed_char); + add (builtin->builtin_unsigned_char); + add (builtin->builtin_unsigned_short); + add (builtin->builtin_unsigned_int); + add (builtin->builtin_unsigned_long); + add (builtin->builtin_unsigned_long_long); + add (builtin->builtin_long_double); + add (builtin->builtin_complex); + add (builtin->builtin_double_complex); + + lai->set_string_char_type (builtin->builtin_char); + lai->set_bool_type (builtin->builtin_bool, "boolean"); } /* See language.h. */ diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c index a50f3b7..407be56 100644 --- a/gdb/rust-lang.c +++ b/gdb/rust-lang.c @@ -961,27 +961,6 @@ rust_slice_type (const char *name, struct type *elt_type, return type; } -enum rust_primitive_types -{ - rust_primitive_bool, - rust_primitive_char, - rust_primitive_i8, - rust_primitive_u8, - rust_primitive_i16, - rust_primitive_u16, - rust_primitive_i32, - rust_primitive_u32, - rust_primitive_i64, - rust_primitive_u64, - rust_primitive_isize, - rust_primitive_usize, - rust_primitive_f32, - rust_primitive_f64, - rust_primitive_unit, - rust_primitive_str, - nr_rust_primitive_types -}; - /* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */ @@ -1927,39 +1906,40 @@ public: { const struct builtin_type *builtin = builtin_type (gdbarch); - struct type **types - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_rust_primitive_types + 1, - struct type *); - - types[rust_primitive_bool] = arch_boolean_type (gdbarch, 8, 1, "bool"); - types[rust_primitive_char] = arch_character_type (gdbarch, 32, 1, "char"); - types[rust_primitive_i8] = arch_integer_type (gdbarch, 8, 0, "i8"); - types[rust_primitive_u8] = arch_integer_type (gdbarch, 8, 1, "u8"); - types[rust_primitive_i16] = arch_integer_type (gdbarch, 16, 0, "i16"); - types[rust_primitive_u16] = arch_integer_type (gdbarch, 16, 1, "u16"); - types[rust_primitive_i32] = arch_integer_type (gdbarch, 32, 0, "i32"); - types[rust_primitive_u32] = arch_integer_type (gdbarch, 32, 1, "u32"); - types[rust_primitive_i64] = arch_integer_type (gdbarch, 64, 0, "i64"); - types[rust_primitive_u64] = arch_integer_type (gdbarch, 64, 1, "u64"); + /* Helper function to allow shorter lines below. */ + auto add = [&] (struct type * t) -> struct type * + { + lai->add_primitive_type (t); + return t; + }; + + struct type *bool_type + = add (arch_boolean_type (gdbarch, 8, 1, "bool")); + add (arch_character_type (gdbarch, 32, 1, "char")); + add (arch_integer_type (gdbarch, 8, 0, "i8")); + struct type *u8_type + = add (arch_integer_type (gdbarch, 8, 1, "u8")); + add (arch_integer_type (gdbarch, 16, 0, "i16")); + add (arch_integer_type (gdbarch, 16, 1, "u16")); + add (arch_integer_type (gdbarch, 32, 0, "i32")); + add (arch_integer_type (gdbarch, 32, 1, "u32")); + add (arch_integer_type (gdbarch, 64, 0, "i64")); + add (arch_integer_type (gdbarch, 64, 1, "u64")); unsigned int length = 8 * TYPE_LENGTH (builtin->builtin_data_ptr); - types[rust_primitive_isize] = arch_integer_type (gdbarch, length, 0, "isize"); - types[rust_primitive_usize] = arch_integer_type (gdbarch, length, 1, "usize"); - - types[rust_primitive_f32] = arch_float_type (gdbarch, 32, "f32", - floatformats_ieee_single); - types[rust_primitive_f64] = arch_float_type (gdbarch, 64, "f64", - floatformats_ieee_double); + add (arch_integer_type (gdbarch, length, 0, "isize")); + struct type *usize_type + = add (arch_integer_type (gdbarch, length, 1, "usize")); - types[rust_primitive_unit] = arch_integer_type (gdbarch, 0, 1, "()"); + add (arch_float_type (gdbarch, 32, "f32", floatformats_ieee_single)); + add (arch_float_type (gdbarch, 64, "f64", floatformats_ieee_double)); + add (arch_integer_type (gdbarch, 0, 1, "()")); - struct type *tem = make_cv_type (1, 0, types[rust_primitive_u8], NULL); - types[rust_primitive_str] = rust_slice_type ("&str", tem, - types[rust_primitive_usize]); + struct type *tem = make_cv_type (1, 0, u8_type, NULL); + add (rust_slice_type ("&str", tem, usize_type)); - lai->primitive_type_vector = types; - lai->bool_type_default = types[rust_primitive_bool]; - lai->string_char_type = types[rust_primitive_u8]; + lai->set_bool_type (bool_type); + lai->set_string_char_type (u8_type); } /* See language.h. */ diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index f23721e..8cff646 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,7 @@ +2020-11-12 Andrew Burgess <andrew.burgess@embecosm.com> + + * gdb.fortran/types.exp: Add more tests. + 2020-11-12 Tom Tromey <tom@tromey.com> PR rust/26799: diff --git a/gdb/testsuite/gdb.fortran/types.exp b/gdb/testsuite/gdb.fortran/types.exp index 8c1ca5c..39dc13b 100644 --- a/gdb/testsuite/gdb.fortran/types.exp +++ b/gdb/testsuite/gdb.fortran/types.exp @@ -71,6 +71,16 @@ proc test_float_literal_types_accepted {} { gdb_test "pt 10e20" "type = real\\*\[0-9\]+" } +# Test the the primitive Fortran types, those that GDB should always +# know, even if the program does not define them, are in fact, known. +proc test_primitive_types_known {} { + foreach type {void character logical*1 integer*2 integer*8 \ + logical*2 logical*8 integer logical*4 real \ + real*8 real*16} { + gdb_test "ptype $type" [string_to_regexp "type = $type"] + } +} + # Start with a fresh gdb. gdb_exit @@ -80,6 +90,7 @@ gdb_reinitialize_dir $srcdir/$subdir gdb_test "set print sevenbit-strings" "" if [set_lang_fortran] then { + test_primitive_types_known test_integer_literal_types_accepted test_integer_literal_types_rejected test_logical_literal_types_accepted |