Re: [PATCH 4/5] Implement D primitive types in GDB

[Iain Buclaw <ibuclaw at gdcproject dot org>]

On 10 January 2014 21:18, Tom Tromey <tromey@redhat.com> wrote:
>
> Blank line here and elsewhere.
>
> This is ok with those nits fixed.
>

Third time a charm.  Re-done with your nits fixed.

Regards
Iain
---

 gdb/ChangeLog                               |  12 ++
 gdb/d-lang.c                                | 190 +++++++++++++++++++++++++++-
 gdb/d-lang.h                                |  36 ++++++
 gdb/testsuite/ChangeLog                     |   4 +
 gdb/testsuite/gdb.dlang/primitive-types.exp |  61 +++++++++
 5 files changed, 302 insertions(+), 1 deletion(-)

diff --git a/gdb/d-lang.c b/gdb/d-lang.c
index b693829..71a2524 100644
--- a/gdb/d-lang.c
+++ b/gdb/d-lang.c
@@ -257,6 +257,103 @@ static const struct op_print d_op_print_tab[] =
   {NULL, 0, 0, 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
+};
+
+/* Implements the la_language_arch_info language_defn routine
+   for language D.  */
+
+static void
+d_language_arch_info (struct gdbarch *gdbarch,
+		      struct language_arch_info *lai)
+{
+  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;
+}
+
 static const struct language_defn d_language_defn =
 {
   "d",
@@ -291,7 +388,7 @@ static const struct language_defn d_language_defn =
   0,				/* String lower bound.  */
   default_word_break_characters,
   default_make_symbol_completion_list,
-  c_language_arch_info,
+  d_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
   c_get_string,
@@ -301,11 +398,102 @@ static const struct language_defn d_language_defn =
   LANG_MAGIC
 };
 
+/* Build all D language types for the specified architecture.  */
+
+static void *
+build_d_types (struct gdbarch *gdbarch)
+{
+  struct builtin_d_type *builtin_d_type
+    = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);
+
+  /* Basic types.  */
+  builtin_d_type->builtin_void
+    = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
+  builtin_d_type->builtin_bool
+    = arch_boolean_type (gdbarch, 8, 1, "bool");
+  builtin_d_type->builtin_byte
+    = arch_integer_type (gdbarch, 8, 0, "byte");
+  builtin_d_type->builtin_ubyte
+    = arch_integer_type (gdbarch, 8, 1, "ubyte");
+  builtin_d_type->builtin_short
+    = arch_integer_type (gdbarch, 16, 0, "short");
+  builtin_d_type->builtin_ushort
+    = arch_integer_type (gdbarch, 16, 1, "ushort");
+  builtin_d_type->builtin_int
+    = arch_integer_type (gdbarch, 32, 0, "int");
+  builtin_d_type->builtin_uint
+    = arch_integer_type (gdbarch, 32, 1, "uint");
+  builtin_d_type->builtin_long
+    = arch_integer_type (gdbarch, 64, 0, "long");
+  builtin_d_type->builtin_ulong
+    = arch_integer_type (gdbarch, 64, 1, "ulong");
+  builtin_d_type->builtin_cent
+    = arch_integer_type (gdbarch, 128, 0, "cent");
+  builtin_d_type->builtin_ucent
+    = arch_integer_type (gdbarch, 128, 1, "ucent");
+  builtin_d_type->builtin_float
+    = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
+		       "float", NULL);
+  builtin_d_type->builtin_double
+    = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
+		       "double", NULL);
+  builtin_d_type->builtin_real
+    = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
+		       "real", NULL);
+
+  TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte)
+    |= TYPE_INSTANCE_FLAG_NOTTEXT;
+  TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte)
+    |= TYPE_INSTANCE_FLAG_NOTTEXT;
+
+  /* Imaginary and complex types.  */
+  builtin_d_type->builtin_ifloat
+    = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
+		       "ifloat", NULL);
+  builtin_d_type->builtin_idouble
+    = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
+		       "idouble", NULL);
+  builtin_d_type->builtin_ireal
+    = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
+		       "ireal", NULL);
+  builtin_d_type->builtin_cfloat
+    = arch_complex_type (gdbarch, "cfloat",
+			 builtin_d_type->builtin_float);
+  builtin_d_type->builtin_cdouble
+    = arch_complex_type (gdbarch, "cdouble",
+			 builtin_d_type->builtin_double);
+  builtin_d_type->builtin_creal
+    = arch_complex_type (gdbarch, "creal",
+			 builtin_d_type->builtin_real);
+
+  /* Character types.  */
+  builtin_d_type->builtin_char
+    = arch_character_type (gdbarch, 8, 1, "char");
+  builtin_d_type->builtin_wchar
+    = arch_character_type (gdbarch, 16, 1, "wchar");
+  builtin_d_type->builtin_dchar
+    = arch_character_type (gdbarch, 32, 1, "dchar");
+
+  return builtin_d_type;
+}
+
+static struct gdbarch_data *d_type_data;
+
+/* Return the D type table for the specified architecture.  */
+
+const struct builtin_d_type *
+builtin_d_type (struct gdbarch *gdbarch)
+{
+  return gdbarch_data (gdbarch, d_type_data);
+}
+
 /* Provide a prototype to silence -Wmissing-prototypes.  */
 extern initialize_file_ftype _initialize_d_language;
 
 void
 _initialize_d_language (void)
 {
+  d_type_data = gdbarch_data_register_post_init (build_d_types);
+
   add_language (&d_language_defn);
 }
diff --git a/gdb/d-lang.h b/gdb/d-lang.h
index 9ede338..455c808 100644
--- a/gdb/d-lang.h
+++ b/gdb/d-lang.h
@@ -22,12 +22,48 @@
 
 #include "symtab.h"
 
+/* Language specific builtin types for D.  Any additional types added
+   should be kept in sync with enum d_primitive_types, where these
+   types are documented.  */
+
+struct builtin_d_type
+{
+  struct type *builtin_void;
+  struct type *builtin_bool;
+  struct type *builtin_byte;
+  struct type *builtin_ubyte;
+  struct type *builtin_short;
+  struct type *builtin_ushort;
+  struct type *builtin_int;
+  struct type *builtin_uint;
+  struct type *builtin_long;
+  struct type *builtin_ulong;
+  struct type *builtin_cent;
+  struct type *builtin_ucent;
+  struct type *builtin_float;
+  struct type *builtin_double;
+  struct type *builtin_real;
+  struct type *builtin_ifloat;
+  struct type *builtin_idouble;
+  struct type *builtin_ireal;
+  struct type *builtin_cfloat;
+  struct type *builtin_cdouble;
+  struct type *builtin_creal;
+  struct type *builtin_char;
+  struct type *builtin_wchar;
+  struct type *builtin_dchar;
+};
+
 /* Defined in d-lang.c  */
 
 extern const char *d_main_name (void);
 
 extern char *d_demangle (const char *mangled, int options);
 
+extern const struct builtin_d_type *builtin_d_type (struct gdbarch *);
+
+/* Defined in d-valprint.c  */
+
 extern void d_val_print (struct type *type, const gdb_byte *valaddr,
 			 int embedded_offset, CORE_ADDR address,
 			 struct ui_file *stream, int recurse,
diff --git a/gdb/testsuite/gdb.dlang/primitive-types.exp b/gdb/testsuite/gdb.dlang/primitive-types.exp
new file mode 100644
index 0000000..7bbdd25
--- /dev/null
+++ b/gdb/testsuite/gdb.dlang/primitive-types.exp
@@ -0,0 +1,61 @@
+# Copyright (C) 2014 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Test basic builtin types.
+# NOTE: The tests here intentionally do not require a D compiler.
+
+load_lib "d-support.exp"
+
+if { [skip_d_tests] } { continue }
+
+proc test_builtin_d_types_accepted {} {
+    # Test types are recognised.
+
+    gdb_test "ptype void" "type = void"
+    gdb_test "ptype bool" "type = bool"
+    gdb_test "ptype byte" "type = byte"
+    gdb_test "ptype ubyte" "type = ubyte"
+    gdb_test "ptype short" "type = short"
+    gdb_test "ptype ushort" "type = ushort"
+    gdb_test "ptype int" "type = int"
+    gdb_test "ptype uint" "type = uint"
+    gdb_test "ptype long" "type = long"
+    gdb_test "ptype ulong" "type = ulong"
+    gdb_test "ptype cent" "type = cent"
+    gdb_test "ptype ucent" "type = ucent"
+    gdb_test "ptype float" "type = float"
+    gdb_test "ptype double" "type = double"
+    gdb_test "ptype real" "type = real"
+    gdb_test "ptype ifloat" "type = ifloat"
+    gdb_test "ptype idouble" "type = idouble"
+    gdb_test "ptype ireal" "type = ireal"
+    gdb_test "ptype cfloat" "type = cfloat"
+    gdb_test "ptype cdouble" "type = cdouble"
+    gdb_test "ptype creal" "type = creal"
+    gdb_test "ptype char" "type = char"
+    gdb_test "ptype wchar" "type = wchar"
+    gdb_test "ptype dchar" "type = dchar"
+}
+
+# Start with a fresh gdb.
+
+gdb_exit
+gdb_start
+
+if [set_lang_d] {
+    test_builtin_d_types_accepted
+} else {
+    warning "D type tests suppressed."
+}