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

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

   Copyright (C) 2005-2020 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"

/* 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}
};

/* 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
};

static const char *d_extensions[] =
{
  ".d", NULL
};

/* Constant data that describes the D language.  */

extern const struct language_data d_language_data =
{
  "d",
  "D",
  language_d,
  range_check_off,
  case_sensitive_on,
  array_row_major,
  macro_expansion_no,
  d_extensions,
  &exp_descriptor_c,
  d_parse,
  null_post_parser,
  c_printchar,			/* Print a character constant.  */
  c_printstr,			/* Function to print string constant.  */
  c_emit_char,			/* Print a single char.  */
  c_print_typedef,		/* Print a typedef using appropriate
				   syntax.  */
  "this",
  false,			/* la_store_sym_names_in_linkage_form_p */
  d_op_print_tab,		/* Expression operators for printing.  */
  1,				/* C-style arrays.  */
  0,				/* String lower bound.  */
  &default_varobj_ops,
  c_is_string_type_p,
  "{...}"			/* la_struct_too_deep_ellipsis */
};

/* Class representing the D language.  */

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

  /* 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);

    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;
  }

  /* 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 (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);
  }
};

/* 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));

  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", 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
b811d2c2	3	Copyright (C) 2005-2020 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"
6aecb9c2	29
63778547 IB	30	/* The name of the symbol to use to get the name of the main subprogram. */
	31	static const char D_MAIN[] = "D main";
	32
	33	/* Function returning the special symbol name used by D for the main
	34	procedure in the main program if it is found in minimal symbol list.
	35	This function tries to find minimal symbols so that it finds them even
	36	if the program was compiled without debugging information. */
	37
	38	const char *
	39	d_main_name (void)
	40	{
3b7344d5	41	struct bound_minimal_symbol msym;
63778547 IB	42
63778547 IB	43	msym = lookup_minimal_symbol (D_MAIN, NULL, NULL);
3b7344d5	44	if (msym.minsym != NULL)
63778547 IB	45	return D_MAIN;
	46
	47	/* No known entry procedure found, the main program is probably not D. */
	48	return NULL;
	49	}
	50
6aecb9c2	51	/* Implements the la_demangle language_defn routine for language D. */
ec9f644a	52
6aecb9c2 JB	53	char *
	54	d_demangle (const char *symbol, int options)
	55	{
35a49624	56	return gdb_demangle (symbol, options \| DMGL_DLANG);
6aecb9c2 JB	57	}
	58
	59	/* Table mapping opcodes into strings for printing operators
	60	and precedences of the operators. */
	61	static const struct op_print d_op_print_tab[] =
	62	{
	63	{",", BINOP_COMMA, PREC_COMMA, 0},
	64	{"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
	65	{"\|\|", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
	66	{"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
	67	{"\|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
	68	{"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
	69	{"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
3ed9baed IB	70	{"==", BINOP_EQUAL, PREC_ORDER, 0},
3ed9baed IB	71	{"!=", BINOP_NOTEQUAL, PREC_ORDER, 0},
6aecb9c2 JB	72	{"<=", BINOP_LEQ, PREC_ORDER, 0},
	73	{">=", BINOP_GEQ, PREC_ORDER, 0},
	74	{">", BINOP_GTR, PREC_ORDER, 0},
	75	{"<", BINOP_LESS, PREC_ORDER, 0},
	76	{">>", BINOP_RSH, PREC_SHIFT, 0},
	77	{"<<", BINOP_LSH, PREC_SHIFT, 0},
	78	{"+", BINOP_ADD, PREC_ADD, 0},
	79	{"-", BINOP_SUB, PREC_ADD, 0},
3ed9baed	80	{"~", BINOP_CONCAT, PREC_ADD, 0},
6aecb9c2 JB	81	{"*", BINOP_MUL, PREC_MUL, 0},
	82	{"/", BINOP_DIV, PREC_MUL, 0},
	83	{"%", BINOP_REM, PREC_MUL, 0},
3ed9baed	84	{"^^", BINOP_EXP, PREC_REPEAT, 0},
6aecb9c2 JB	85	{"@", BINOP_REPEAT, PREC_REPEAT, 0},
	86	{"-", UNOP_NEG, PREC_PREFIX, 0},
	87	{"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
	88	{"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
	89	{"*", UNOP_IND, PREC_PREFIX, 0},
	90	{"&", UNOP_ADDR, PREC_PREFIX, 0},
	91	{"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
	92	{"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
	93	{"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
f486487f	94	{NULL, OP_NULL, PREC_PREFIX, 0}
6aecb9c2 JB	95	};
6aecb9c2 JB	96
94b1b47e IB	97	/* Mapping of all D basic data types into the language vector. */
	98
	99	enum d_primitive_types {
	100	d_primitive_type_void,
	101	d_primitive_type_bool,
	102	d_primitive_type_byte,
	103	d_primitive_type_ubyte,
	104	d_primitive_type_short,
	105	d_primitive_type_ushort,
	106	d_primitive_type_int,
	107	d_primitive_type_uint,
	108	d_primitive_type_long,
	109	d_primitive_type_ulong,
	110	d_primitive_type_cent, /* Signed 128 bit integer. */
	111	d_primitive_type_ucent, /* Unsigned 128 bit integer. */
	112	d_primitive_type_float,
	113	d_primitive_type_double,
	114	d_primitive_type_real,
	115	d_primitive_type_ifloat, /* Imaginary float types. */
	116	d_primitive_type_idouble,
	117	d_primitive_type_ireal,
	118	d_primitive_type_cfloat, /* Complex number of two float values. */
	119	d_primitive_type_cdouble,
	120	d_primitive_type_creal,
	121	d_primitive_type_char, /* Unsigned character types. */
	122	d_primitive_type_wchar,
	123	d_primitive_type_dchar,
	124	nr_d_primitive_types
	125	};
	126
56618e20 TT	127	static const char *d_extensions[] =
	128	{
	129	".d", NULL
	130	};
	131
0874fd07 AB	132	/* Constant data that describes the D language. */
	133
	134	extern const struct language_data d_language_data =
6aecb9c2 JB	135	{
6aecb9c2 JB	136	"d",
6abde28f	137	"D",
6aecb9c2 JB	138	language_d,
6aecb9c2 JB	139	range_check_off,
6aecb9c2 JB	140	case_sensitive_on,
6aecb9c2 JB	141	array_row_major,
3271ba66	142	macro_expansion_no,
56618e20	143	d_extensions,
6aecb9c2	144	&exp_descriptor_c,
3ed9baed	145	d_parse,
6aecb9c2 JB	146	null_post_parser,
	147	c_printchar, /* Print a character constant. */
	148	c_printstr, /* Function to print string constant. */
	149	c_emit_char, /* Print a single char. */
0963b4bd MS	150	c_print_typedef, /* Print a typedef using appropriate
0963b4bd MS	151	syntax. */
6aecb9c2	152	"this",
59cc4834	153	false, /* la_store_sym_names_in_linkage_form_p */
6aecb9c2 JB	154	d_op_print_tab, /* Expression operators for printing. */
	155	1, /* C-style arrays. */
	156	0, /* String lower bound. */
a53b64ea	157	&default_varobj_ops,
4be290b2	158	c_is_string_type_p,
721b08c6	159	"{...}" /* la_struct_too_deep_ellipsis */
6aecb9c2 JB	160	};
6aecb9c2 JB	161
0874fd07 AB	162	/* Class representing the D language. */
	163
	164	class d_language : public language_defn
	165	{
	166	public:
	167	d_language ()
	168	: language_defn (language_d, d_language_data)
	169	{ /* Nothing. */ }
1fb314aa AB	170
	171	/* See language.h. */
	172	void language_arch_info (struct gdbarch *gdbarch,
	173	struct language_arch_info *lai) const override
	174	{
	175	const struct builtin_d_type *builtin = builtin_d_type (gdbarch);
	176
	177	lai->string_char_type = builtin->builtin_char;
	178	lai->primitive_type_vector
	179	= GDBARCH_OBSTACK_CALLOC (gdbarch, nr_d_primitive_types + 1,
	180	struct type *);
	181
	182	lai->primitive_type_vector [d_primitive_type_void]
	183	= builtin->builtin_void;
	184	lai->primitive_type_vector [d_primitive_type_bool]
	185	= builtin->builtin_bool;
	186	lai->primitive_type_vector [d_primitive_type_byte]
	187	= builtin->builtin_byte;
	188	lai->primitive_type_vector [d_primitive_type_ubyte]
	189	= builtin->builtin_ubyte;
	190	lai->primitive_type_vector [d_primitive_type_short]
	191	= builtin->builtin_short;
	192	lai->primitive_type_vector [d_primitive_type_ushort]
	193	= builtin->builtin_ushort;
	194	lai->primitive_type_vector [d_primitive_type_int]
	195	= builtin->builtin_int;
	196	lai->primitive_type_vector [d_primitive_type_uint]
	197	= builtin->builtin_uint;
	198	lai->primitive_type_vector [d_primitive_type_long]
	199	= builtin->builtin_long;
	200	lai->primitive_type_vector [d_primitive_type_ulong]
	201	= builtin->builtin_ulong;
	202	lai->primitive_type_vector [d_primitive_type_cent]
	203	= builtin->builtin_cent;
	204	lai->primitive_type_vector [d_primitive_type_ucent]
	205	= builtin->builtin_ucent;
	206	lai->primitive_type_vector [d_primitive_type_float]
	207	= builtin->builtin_float;
	208	lai->primitive_type_vector [d_primitive_type_double]
	209	= builtin->builtin_double;
	210	lai->primitive_type_vector [d_primitive_type_real]
	211	= builtin->builtin_real;
	212	lai->primitive_type_vector [d_primitive_type_ifloat]
	213	= builtin->builtin_ifloat;
	214	lai->primitive_type_vector [d_primitive_type_idouble]
	215	= builtin->builtin_idouble;
	216	lai->primitive_type_vector [d_primitive_type_ireal]
	217	= builtin->builtin_ireal;
	218	lai->primitive_type_vector [d_primitive_type_cfloat]
	219	= builtin->builtin_cfloat;
	220	lai->primitive_type_vector [d_primitive_type_cdouble]
	221	= builtin->builtin_cdouble;
	222	lai->primitive_type_vector [d_primitive_type_creal]
	223	= builtin->builtin_creal;
	224	lai->primitive_type_vector [d_primitive_type_char]
	225	= builtin->builtin_char;
	226	lai->primitive_type_vector [d_primitive_type_wchar]
	227	= builtin->builtin_wchar;
	228	lai->primitive_type_vector [d_primitive_type_dchar]
	229	= builtin->builtin_dchar;
	230
	231	lai->bool_type_symbol = "bool";
	232	lai->bool_type_default = builtin->builtin_bool;
	233	}
6f827019 AB	234
	235	/* See language.h. */
	236	bool sniff_from_mangled_name (const char *mangled,
	237	char **demangled) const override
	238	{
	239	*demangled = d_demangle (mangled, 0);
	240	return *demangled != NULL;
	241	}
fbfb0a46 AB	242
	243	/* See language.h. */
	244
0a50df5d AB	245	char demangle (const char mangled, int options) const override
	246	{
	247	return d_demangle (mangled, options);
	248	}
	249
	250	/* See language.h. */
	251
fbfb0a46 AB	252	void print_type (struct type type, const char varstring,
	253	struct ui_file *stream, int show, int level,
	254	const struct type_print_options *flags) const override
	255	{
	256	c_print_type (type, varstring, stream, show, level, flags);
	257	}
ebe2334e AB	258
	259	/* See language.h. */
	260
	261	void value_print_inner
	262	(struct value val, struct ui_file stream, int recurse,
	263	const struct value_print_options *options) const override
	264	{
	265	return d_value_print_inner (val, stream, recurse, options);
	266	}
a78a19b1 AB	267
	268	/* See language.h. */
	269
	270	struct block_symbol lookup_symbol_nonlocal
	271	(const char name, const struct block block,
	272	const domain_enum domain) const override
	273	{
	274	return d_lookup_symbol_nonlocal (this, name, block, domain);
	275	}
0874fd07 AB	276	};
	277
	278	/* Single instance of the D language class. */
	279
	280	static d_language d_language_defn;
	281
94b1b47e IB	282	/* Build all D language types for the specified architecture. */
	283
	284	static void *
	285	build_d_types (struct gdbarch *gdbarch)
	286	{
	287	struct builtin_d_type *builtin_d_type
	288	= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);
	289
	290	/* Basic types. */
	291	builtin_d_type->builtin_void
77b7c781	292	= arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
94b1b47e IB	293	builtin_d_type->builtin_bool
	294	= arch_boolean_type (gdbarch, 8, 1, "bool");
	295	builtin_d_type->builtin_byte
	296	= arch_integer_type (gdbarch, 8, 0, "byte");
	297	builtin_d_type->builtin_ubyte
	298	= arch_integer_type (gdbarch, 8, 1, "ubyte");
	299	builtin_d_type->builtin_short
	300	= arch_integer_type (gdbarch, 16, 0, "short");
	301	builtin_d_type->builtin_ushort
	302	= arch_integer_type (gdbarch, 16, 1, "ushort");
	303	builtin_d_type->builtin_int
	304	= arch_integer_type (gdbarch, 32, 0, "int");
	305	builtin_d_type->builtin_uint
	306	= arch_integer_type (gdbarch, 32, 1, "uint");
	307	builtin_d_type->builtin_long
	308	= arch_integer_type (gdbarch, 64, 0, "long");
	309	builtin_d_type->builtin_ulong
	310	= arch_integer_type (gdbarch, 64, 1, "ulong");
	311	builtin_d_type->builtin_cent
	312	= arch_integer_type (gdbarch, 128, 0, "cent");
	313	builtin_d_type->builtin_ucent
	314	= arch_integer_type (gdbarch, 128, 1, "ucent");
	315	builtin_d_type->builtin_float
	316	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
49f190bc	317	"float", gdbarch_float_format (gdbarch));
94b1b47e IB	318	builtin_d_type->builtin_double
94b1b47e IB	319	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
49f190bc	320	"double", gdbarch_double_format (gdbarch));
94b1b47e IB	321	builtin_d_type->builtin_real
94b1b47e IB	322	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
49f190bc	323	"real", gdbarch_long_double_format (gdbarch));
94b1b47e IB	324
	325	TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte)
	326	\|= TYPE_INSTANCE_FLAG_NOTTEXT;
	327	TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte)
	328	\|= TYPE_INSTANCE_FLAG_NOTTEXT;
	329
	330	/* Imaginary and complex types. */
	331	builtin_d_type->builtin_ifloat
	332	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
49f190bc	333	"ifloat", gdbarch_float_format (gdbarch));
94b1b47e IB	334	builtin_d_type->builtin_idouble
94b1b47e IB	335	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
49f190bc	336	"idouble", gdbarch_double_format (gdbarch));
94b1b47e IB	337	builtin_d_type->builtin_ireal
94b1b47e IB	338	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
49f190bc	339	"ireal", gdbarch_long_double_format (gdbarch));
94b1b47e	340	builtin_d_type->builtin_cfloat
5b930b45	341	= init_complex_type ("cfloat", builtin_d_type->builtin_float);
94b1b47e	342	builtin_d_type->builtin_cdouble
5b930b45	343	= init_complex_type ("cdouble", builtin_d_type->builtin_double);
94b1b47e	344	builtin_d_type->builtin_creal
5b930b45	345	= init_complex_type ("creal", builtin_d_type->builtin_real);
94b1b47e IB	346
	347	/* Character types. */
	348	builtin_d_type->builtin_char
	349	= arch_character_type (gdbarch, 8, 1, "char");
	350	builtin_d_type->builtin_wchar
	351	= arch_character_type (gdbarch, 16, 1, "wchar");
	352	builtin_d_type->builtin_dchar
	353	= arch_character_type (gdbarch, 32, 1, "dchar");
	354
	355	return builtin_d_type;
	356	}
	357
	358	static struct gdbarch_data *d_type_data;
	359
	360	/* Return the D type table for the specified architecture. */
	361
	362	const struct builtin_d_type *
	363	builtin_d_type (struct gdbarch *gdbarch)
	364	{
9a3c8263	365	return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
94b1b47e IB	366	}
94b1b47e IB	367
6c265988	368	void _initialize_d_language ();
6aecb9c2	369	void
6c265988	370	_initialize_d_language ()
6aecb9c2	371	{
94b1b47e	372	d_type_data = gdbarch_data_register_post_init (build_d_types);
6aecb9c2	373	}