[deliverable/binutils-gdb.git] / gdb / d-lang.c

/* D language support routines for GDB, the GNU debugger.

   Copyright (C) 2005-2021 Free Software Foundation, Inc.

   This file is part of GDB.

   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/>.  */

#include "defs.h"
#include "symtab.h"
#include "language.h"
#include "varobj.h"
#include "d-lang.h"
#include "c-lang.h"
#include "demangle.h"
#include "cp-support.h"
#include "gdbarch.h"
#include "parser-defs.h"

/* The name of the symbol to use to get the name of the main subprogram.  */
static const char D_MAIN[] = "D main";

/* Function returning the special symbol name used by D for the main
   procedure in the main program if it is found in minimal symbol list.
   This function tries to find minimal symbols so that it finds them even
   if the program was compiled without debugging information.  */

const char *
d_main_name (void)
{
  struct bound_minimal_symbol msym;

  msym = lookup_minimal_symbol (D_MAIN, NULL, NULL);
  if (msym.minsym != NULL)
    return D_MAIN;

  /* No known entry procedure found, the main program is probably not D.  */
  return NULL;
}

/* Implements the la_demangle language_defn routine for language D.  */

char *
d_demangle (const char *symbol, int options)
{
  return gdb_demangle (symbol, options | DMGL_DLANG);
}

/* Table mapping opcodes into strings for printing operators
   and precedences of the operators.  */
static const struct op_print d_op_print_tab[] =
{
  {",", BINOP_COMMA, PREC_COMMA, 0},
  {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
  {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
  {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
  {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
  {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
  {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
  {"==", BINOP_EQUAL, PREC_ORDER, 0},
  {"!=", BINOP_NOTEQUAL, PREC_ORDER, 0},
  {"<=", BINOP_LEQ, PREC_ORDER, 0},
  {">=", BINOP_GEQ, PREC_ORDER, 0},
  {">", BINOP_GTR, PREC_ORDER, 0},
  {"<", BINOP_LESS, PREC_ORDER, 0},
  {">>", BINOP_RSH, PREC_SHIFT, 0},
  {"<<", BINOP_LSH, PREC_SHIFT, 0},
  {"+", BINOP_ADD, PREC_ADD, 0},
  {"-", BINOP_SUB, PREC_ADD, 0},
  {"~", BINOP_CONCAT, PREC_ADD, 0},
  {"*", BINOP_MUL, PREC_MUL, 0},
  {"/", BINOP_DIV, PREC_MUL, 0},
  {"%", BINOP_REM, PREC_MUL, 0},
  {"^^", BINOP_EXP, PREC_REPEAT, 0},
  {"@", BINOP_REPEAT, PREC_REPEAT, 0},
  {"-", UNOP_NEG, PREC_PREFIX, 0},
  {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
  {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
  {"*", UNOP_IND, PREC_PREFIX, 0},
  {"&", UNOP_ADDR, PREC_PREFIX, 0},
  {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
  {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
  {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
  {NULL, OP_NULL, PREC_PREFIX, 0}
};

/* Class representing the D language.  */

class d_language : public language_defn
{
public:
  d_language ()
    : language_defn (language_d)
  { /* Nothing.  */ }

  /* See language.h.  */

  const char *name () const override
  { return "d"; }

  /* See language.h.  */

  const char *natural_name () const override
  { return "D"; }

  /* See language.h.  */

  const std::vector<const char *> &filename_extensions () const override
  {
    static const std::vector<const char *> extensions = { ".d" };
    return extensions;
  }

  /* See language.h.  */
  void language_arch_info (struct gdbarch *gdbarch,
			   struct language_arch_info *lai) const override
  {
    const struct builtin_d_type *builtin = builtin_d_type (gdbarch);

    /* 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.  */
  bool sniff_from_mangled_name (const char *mangled,
				char **demangled) const override
  {
    *demangled = d_demangle (mangled, 0);
    return *demangled != NULL;
  }

  /* See language.h.  */

  char *demangle_symbol (const char *mangled, int options) const override
  {
    return d_demangle (mangled, options);
  }

  /* See language.h.  */

  void print_type (struct type *type, const char *varstring,
		   struct ui_file *stream, int show, int level,
		   const struct type_print_options *flags) const override
  {
    c_print_type (type, varstring, stream, show, level, flags);
  }

  /* See language.h.  */

  void value_print_inner
	(struct value *val, struct ui_file *stream, int recurse,
	 const struct value_print_options *options) const override
  {
    return d_value_print_inner (val, stream, recurse, options);
  }

  /* See language.h.  */

  struct block_symbol lookup_symbol_nonlocal
	(const char *name, const struct block *block,
	 const domain_enum domain) const override
  {
    return d_lookup_symbol_nonlocal (this, name, block, domain);
  }

  /* See language.h.  */

  int parser (struct parser_state *ps) const override
  {
    return d_parse (ps);
  }

  /* See language.h.  */

  const char *name_of_this () const override
  { return "this"; }

  /* See language.h.  */

  const struct exp_descriptor *expression_ops () const override
  { return &exp_descriptor_c; }

  /* See language.h.  */

  const struct op_print *opcode_print_table () const override
  { return d_op_print_tab; }
};

/* Single instance of the D language class.  */

static d_language d_language_defn;

/* 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, TARGET_CHAR_BIT, "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", gdbarch_float_format (gdbarch));
  builtin_d_type->builtin_double
    = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
		       "double", gdbarch_double_format (gdbarch));
  builtin_d_type->builtin_real
    = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
		       "real", gdbarch_long_double_format (gdbarch));

  builtin_d_type->builtin_byte->set_instance_flags
    (builtin_d_type->builtin_byte->instance_flags ()
     | TYPE_INSTANCE_FLAG_NOTTEXT);

  builtin_d_type->builtin_ubyte->set_instance_flags
    (builtin_d_type->builtin_ubyte->instance_flags ()
     | TYPE_INSTANCE_FLAG_NOTTEXT);

  /* Imaginary and complex types.  */
  builtin_d_type->builtin_ifloat
    = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
		       "ifloat", gdbarch_float_format (gdbarch));
  builtin_d_type->builtin_idouble
    = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
		       "idouble", gdbarch_double_format (gdbarch));
  builtin_d_type->builtin_ireal
    = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
		       "ireal", gdbarch_long_double_format (gdbarch));
  builtin_d_type->builtin_cfloat
    = init_complex_type ("cfloat", builtin_d_type->builtin_float);
  builtin_d_type->builtin_cdouble
    = init_complex_type ("cdouble", builtin_d_type->builtin_double);
  builtin_d_type->builtin_creal
    = init_complex_type ("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 (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
}

void _initialize_d_language ();
void
_initialize_d_language ()
{
  d_type_data = gdbarch_data_register_post_init (build_d_types);
}
Commit	Line	Data
6aecb9c2 JB	1	/* D language support routines for GDB, the GNU debugger.
6aecb9c2 JB	2
3666a048	3	Copyright (C) 2005-2021 Free Software Foundation, Inc.
6aecb9c2 JB	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "defs.h"
d55e5aa6	21	#include "symtab.h"
4de283e4	22	#include "language.h"
d55e5aa6	23	#include "varobj.h"
4de283e4 TT	24	#include "d-lang.h"
	25	#include "c-lang.h"
	26	#include "demangle.h"
	27	#include "cp-support.h"
0d12e84c	28	#include "gdbarch.h"
af30c400	29	#include "parser-defs.h"
6aecb9c2	30
63778547 IB	31	/* The name of the symbol to use to get the name of the main subprogram. */
	32	static const char D_MAIN[] = "D main";
	33
	34	/* Function returning the special symbol name used by D for the main
	35	procedure in the main program if it is found in minimal symbol list.
	36	This function tries to find minimal symbols so that it finds them even
	37	if the program was compiled without debugging information. */
	38
	39	const char *
	40	d_main_name (void)
	41	{
3b7344d5	42	struct bound_minimal_symbol msym;
63778547 IB	43
63778547 IB	44	msym = lookup_minimal_symbol (D_MAIN, NULL, NULL);
3b7344d5	45	if (msym.minsym != NULL)
63778547 IB	46	return D_MAIN;
	47
	48	/* No known entry procedure found, the main program is probably not D. */
	49	return NULL;
	50	}
	51
6aecb9c2	52	/* Implements the la_demangle language_defn routine for language D. */
ec9f644a	53
6aecb9c2 JB	54	char *
	55	d_demangle (const char *symbol, int options)
	56	{
35a49624	57	return gdb_demangle (symbol, options \| DMGL_DLANG);
6aecb9c2 JB	58	}
	59
	60	/* Table mapping opcodes into strings for printing operators
	61	and precedences of the operators. */
	62	static const struct op_print d_op_print_tab[] =
	63	{
	64	{",", BINOP_COMMA, PREC_COMMA, 0},
	65	{"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
	66	{"\|\|", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
	67	{"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
	68	{"\|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
	69	{"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
	70	{"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
3ed9baed IB	71	{"==", BINOP_EQUAL, PREC_ORDER, 0},
3ed9baed IB	72	{"!=", BINOP_NOTEQUAL, PREC_ORDER, 0},
6aecb9c2 JB	73	{"<=", BINOP_LEQ, PREC_ORDER, 0},
	74	{">=", BINOP_GEQ, PREC_ORDER, 0},
	75	{">", BINOP_GTR, PREC_ORDER, 0},
	76	{"<", BINOP_LESS, PREC_ORDER, 0},
	77	{">>", BINOP_RSH, PREC_SHIFT, 0},
	78	{"<<", BINOP_LSH, PREC_SHIFT, 0},
	79	{"+", BINOP_ADD, PREC_ADD, 0},
	80	{"-", BINOP_SUB, PREC_ADD, 0},
3ed9baed	81	{"~", BINOP_CONCAT, PREC_ADD, 0},
6aecb9c2 JB	82	{"*", BINOP_MUL, PREC_MUL, 0},
	83	{"/", BINOP_DIV, PREC_MUL, 0},
	84	{"%", BINOP_REM, PREC_MUL, 0},
3ed9baed	85	{"^^", BINOP_EXP, PREC_REPEAT, 0},
6aecb9c2 JB	86	{"@", BINOP_REPEAT, PREC_REPEAT, 0},
	87	{"-", UNOP_NEG, PREC_PREFIX, 0},
	88	{"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
	89	{"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
	90	{"*", UNOP_IND, PREC_PREFIX, 0},
	91	{"&", UNOP_ADDR, PREC_PREFIX, 0},
	92	{"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
	93	{"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
	94	{"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
f486487f	95	{NULL, OP_NULL, PREC_PREFIX, 0}
6aecb9c2 JB	96	};
6aecb9c2 JB	97
0874fd07 AB	98	/* Class representing the D language. */
	99
	100	class d_language : public language_defn
	101	{
	102	public:
	103	d_language ()
0e25e767	104	: language_defn (language_d)
0874fd07	105	{ /* Nothing. */ }
1fb314aa	106
6f7664a9 AB	107	/* See language.h. */
	108
	109	const char *name () const override
	110	{ return "d"; }
	111
	112	/* See language.h. */
	113
	114	const char *natural_name () const override
	115	{ return "D"; }
	116
e171d6f1 AB	117	/* See language.h. */
	118
	119	const std::vector<const char *> &filename_extensions () const override
	120	{
	121	static const std::vector<const char *> extensions = { ".d" };
	122	return extensions;
	123	}
	124
1fb314aa AB	125	/* See language.h. */
	126	void language_arch_info (struct gdbarch *gdbarch,
	127	struct language_arch_info *lai) const override
	128	{
	129	const struct builtin_d_type *builtin = builtin_d_type (gdbarch);
	130
7bea47f0 AB	131	/* Helper function to allow shorter lines below. */
	132	auto add = [&] (struct type * t)
	133	{
	134	lai->add_primitive_type (t);
	135	};
	136
	137	add (builtin->builtin_void);
	138	add (builtin->builtin_bool);
	139	add (builtin->builtin_byte);
	140	add (builtin->builtin_ubyte);
	141	add (builtin->builtin_short);
	142	add (builtin->builtin_ushort);
	143	add (builtin->builtin_int);
	144	add (builtin->builtin_uint);
	145	add (builtin->builtin_long);
	146	add (builtin->builtin_ulong);
	147	add (builtin->builtin_cent);
	148	add (builtin->builtin_ucent);
	149	add (builtin->builtin_float);
	150	add (builtin->builtin_double);
	151	add (builtin->builtin_real);
	152	add (builtin->builtin_ifloat);
	153	add (builtin->builtin_idouble);
	154	add (builtin->builtin_ireal);
	155	add (builtin->builtin_cfloat);
	156	add (builtin->builtin_cdouble);
	157	add (builtin->builtin_creal);
	158	add (builtin->builtin_char);
	159	add (builtin->builtin_wchar);
	160	add (builtin->builtin_dchar);
	161
	162	lai->set_string_char_type (builtin->builtin_char);
	163	lai->set_bool_type (builtin->builtin_bool, "bool");
1fb314aa	164	}
6f827019 AB	165
	166	/* See language.h. */
	167	bool sniff_from_mangled_name (const char *mangled,
	168	char **demangled) const override
	169	{
	170	*demangled = d_demangle (mangled, 0);
	171	return *demangled != NULL;
	172	}
fbfb0a46 AB	173
	174	/* See language.h. */
	175
5399db93	176	char demangle_symbol (const char mangled, int options) const override
0a50df5d AB	177	{
	178	return d_demangle (mangled, options);
	179	}
	180
	181	/* See language.h. */
	182
fbfb0a46 AB	183	void print_type (struct type type, const char varstring,
	184	struct ui_file *stream, int show, int level,
	185	const struct type_print_options *flags) const override
	186	{
	187	c_print_type (type, varstring, stream, show, level, flags);
	188	}
ebe2334e AB	189
	190	/* See language.h. */
	191
	192	void value_print_inner
	193	(struct value val, struct ui_file stream, int recurse,
	194	const struct value_print_options *options) const override
	195	{
	196	return d_value_print_inner (val, stream, recurse, options);
	197	}
a78a19b1 AB	198
	199	/* See language.h. */
	200
	201	struct block_symbol lookup_symbol_nonlocal
	202	(const char name, const struct block block,
	203	const domain_enum domain) const override
	204	{
	205	return d_lookup_symbol_nonlocal (this, name, block, domain);
	206	}
87afa652 AB	207
	208	/* See language.h. */
	209
	210	int parser (struct parser_state *ps) const override
	211	{
	212	return d_parse (ps);
	213	}
5bae7c4e AB	214
	215	/* See language.h. */
	216
	217	const char *name_of_this () const override
	218	{ return "this"; }
5aba6ebe AB	219
	220	/* See language.h. */
	221
	222	const struct exp_descriptor *expression_ops () const override
	223	{ return &exp_descriptor_c; }
b7c6e27d AB	224
	225	/* See language.h. */
	226
	227	const struct op_print *opcode_print_table () const override
	228	{ return d_op_print_tab; }
0874fd07 AB	229	};
	230
	231	/* Single instance of the D language class. */
	232
	233	static d_language d_language_defn;
	234
94b1b47e IB	235	/* Build all D language types for the specified architecture. */
	236
	237	static void *
	238	build_d_types (struct gdbarch *gdbarch)
	239	{
	240	struct builtin_d_type *builtin_d_type
	241	= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);
	242
	243	/* Basic types. */
	244	builtin_d_type->builtin_void
77b7c781	245	= arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
94b1b47e IB	246	builtin_d_type->builtin_bool
	247	= arch_boolean_type (gdbarch, 8, 1, "bool");
	248	builtin_d_type->builtin_byte
	249	= arch_integer_type (gdbarch, 8, 0, "byte");
	250	builtin_d_type->builtin_ubyte
	251	= arch_integer_type (gdbarch, 8, 1, "ubyte");
	252	builtin_d_type->builtin_short
	253	= arch_integer_type (gdbarch, 16, 0, "short");
	254	builtin_d_type->builtin_ushort
	255	= arch_integer_type (gdbarch, 16, 1, "ushort");
	256	builtin_d_type->builtin_int
	257	= arch_integer_type (gdbarch, 32, 0, "int");
	258	builtin_d_type->builtin_uint
	259	= arch_integer_type (gdbarch, 32, 1, "uint");
	260	builtin_d_type->builtin_long
	261	= arch_integer_type (gdbarch, 64, 0, "long");
	262	builtin_d_type->builtin_ulong
	263	= arch_integer_type (gdbarch, 64, 1, "ulong");
	264	builtin_d_type->builtin_cent
	265	= arch_integer_type (gdbarch, 128, 0, "cent");
	266	builtin_d_type->builtin_ucent
	267	= arch_integer_type (gdbarch, 128, 1, "ucent");
	268	builtin_d_type->builtin_float
	269	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
49f190bc	270	"float", gdbarch_float_format (gdbarch));
94b1b47e IB	271	builtin_d_type->builtin_double
94b1b47e IB	272	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
49f190bc	273	"double", gdbarch_double_format (gdbarch));
94b1b47e IB	274	builtin_d_type->builtin_real
94b1b47e IB	275	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
49f190bc	276	"real", gdbarch_long_double_format (gdbarch));
94b1b47e	277
314ad88d PA	278	builtin_d_type->builtin_byte->set_instance_flags
	279	(builtin_d_type->builtin_byte->instance_flags ()
	280	\| TYPE_INSTANCE_FLAG_NOTTEXT);
	281
	282	builtin_d_type->builtin_ubyte->set_instance_flags
	283	(builtin_d_type->builtin_ubyte->instance_flags ()
	284	\| TYPE_INSTANCE_FLAG_NOTTEXT);
94b1b47e IB	285
	286	/* Imaginary and complex types. */
	287	builtin_d_type->builtin_ifloat
	288	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
49f190bc	289	"ifloat", gdbarch_float_format (gdbarch));
94b1b47e IB	290	builtin_d_type->builtin_idouble
94b1b47e IB	291	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
49f190bc	292	"idouble", gdbarch_double_format (gdbarch));
94b1b47e IB	293	builtin_d_type->builtin_ireal
94b1b47e IB	294	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
49f190bc	295	"ireal", gdbarch_long_double_format (gdbarch));
94b1b47e	296	builtin_d_type->builtin_cfloat
5b930b45	297	= init_complex_type ("cfloat", builtin_d_type->builtin_float);
94b1b47e	298	builtin_d_type->builtin_cdouble
5b930b45	299	= init_complex_type ("cdouble", builtin_d_type->builtin_double);
94b1b47e	300	builtin_d_type->builtin_creal
5b930b45	301	= init_complex_type ("creal", builtin_d_type->builtin_real);
94b1b47e IB	302
	303	/* Character types. */
	304	builtin_d_type->builtin_char
	305	= arch_character_type (gdbarch, 8, 1, "char");
	306	builtin_d_type->builtin_wchar
	307	= arch_character_type (gdbarch, 16, 1, "wchar");
	308	builtin_d_type->builtin_dchar
	309	= arch_character_type (gdbarch, 32, 1, "dchar");
	310
	311	return builtin_d_type;
	312	}
	313
	314	static struct gdbarch_data *d_type_data;
	315
	316	/* Return the D type table for the specified architecture. */
	317
	318	const struct builtin_d_type *
	319	builtin_d_type (struct gdbarch *gdbarch)
	320	{
9a3c8263	321	return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
94b1b47e IB	322	}
94b1b47e IB	323
6c265988	324	void _initialize_d_language ();
6aecb9c2	325	void
6c265988	326	_initialize_d_language ()
6aecb9c2	327	{
94b1b47e	328	d_type_data = gdbarch_data_register_post_init (build_d_types);
6aecb9c2	329	}