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

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

   Copyright (C) 2005-2025 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 "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)
{
  bound_minimal_symbol msym
    = lookup_minimal_symbol (current_program_space, D_MAIN);
  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.  */

gdb::unique_xmalloc_ptr<char>
d_demangle (const char *symbol, int options)
{
  return gdb_demangle (symbol, options | DMGL_DLANG);
}

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

  /* See language.h.  */

  gdb::unique_xmalloc_ptr<char> demangle_symbol (const char *mangled,
						 int options) const override
  {
    return d_demangle (mangled, options);
  }

  /* See language.h.  */

  bool can_print_type_offsets () const override
  {
    return true;
  }

  /* 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, la_language, 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_search_flags 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"; }
};

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

static d_language d_language_defn;

/* Build all D language types for the specified architecture.  */

static struct builtin_d_type *
build_d_types (struct gdbarch *gdbarch)
{
  struct builtin_d_type *builtin_d_type = new struct builtin_d_type;

  /* Basic types.  */
  type_allocator alloc (gdbarch);
  builtin_d_type->builtin_void = builtin_type (gdbarch)->builtin_void;
  builtin_d_type->builtin_bool
    = init_boolean_type (alloc, 8, 1, "bool");
  builtin_d_type->builtin_byte
    = init_integer_type (alloc, 8, 0, "byte");
  builtin_d_type->builtin_ubyte
    = init_integer_type (alloc, 8, 1, "ubyte");
  builtin_d_type->builtin_short
    = init_integer_type (alloc, 16, 0, "short");
  builtin_d_type->builtin_ushort
    = init_integer_type (alloc, 16, 1, "ushort");
  builtin_d_type->builtin_int
    = init_integer_type (alloc, 32, 0, "int");
  builtin_d_type->builtin_uint
    = init_integer_type (alloc, 32, 1, "uint");
  builtin_d_type->builtin_long
    = init_integer_type (alloc, 64, 0, "long");
  builtin_d_type->builtin_ulong
    = init_integer_type (alloc, 64, 1, "ulong");
  builtin_d_type->builtin_cent
    = init_integer_type (alloc, 128, 0, "cent");
  builtin_d_type->builtin_ucent
    = init_integer_type (alloc, 128, 1, "ucent");
  builtin_d_type->builtin_float
    = init_float_type (alloc, gdbarch_float_bit (gdbarch),
		       "float", gdbarch_float_format (gdbarch));
  builtin_d_type->builtin_double
    = init_float_type (alloc, gdbarch_double_bit (gdbarch),
		       "double", gdbarch_double_format (gdbarch));
  builtin_d_type->builtin_real
    = init_float_type (alloc, 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
    = init_float_type (alloc, gdbarch_float_bit (gdbarch),
		       "ifloat", gdbarch_float_format (gdbarch));
  builtin_d_type->builtin_idouble
    = init_float_type (alloc, gdbarch_double_bit (gdbarch),
		       "idouble", gdbarch_double_format (gdbarch));
  builtin_d_type->builtin_ireal
    = init_float_type (alloc, 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
    = init_character_type (alloc, 8, 1, "char");
  builtin_d_type->builtin_wchar
    = init_character_type (alloc, 16, 1, "wchar");
  builtin_d_type->builtin_dchar
    = init_character_type (alloc, 32, 1, "dchar");

  return builtin_d_type;
}

static const registry<gdbarch>::key<struct builtin_d_type> d_type_data;

/* Return the D type table for the specified architecture.  */

const struct builtin_d_type *
builtin_d_type (struct gdbarch *gdbarch)
{
  struct builtin_d_type *result = d_type_data.get (gdbarch);
  if (result == nullptr)
    {
      result = build_d_types (gdbarch);
      d_type_data.set (gdbarch, result);
    }

  return result;
}
Commit	Line	Data
	1	/* D language support routines for GDB, the GNU debugger.
	2
	3	Copyright (C) 2005-2025 Free Software Foundation, Inc.
	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 "symtab.h"
	21	#include "language.h"
	22	#include "varobj.h"
	23	#include "d-lang.h"
	24	#include "c-lang.h"
	25	#include "demangle.h"
	26	#include "cp-support.h"
	27	#include "gdbarch.h"
	28	#include "parser-defs.h"
	29
	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	{
	41	bound_minimal_symbol msym
	42	= lookup_minimal_symbol (current_program_space, D_MAIN);
	43	if (msym.minsym != NULL)
	44	return D_MAIN;
	45
	46	/* No known entry procedure found, the main program is probably not D. */
	47	return NULL;
	48	}
	49
	50	/* Implements the la_demangle language_defn routine for language D. */
	51
	52	gdb::unique_xmalloc_ptr<char>
	53	d_demangle (const char *symbol, int options)
	54	{
	55	return gdb_demangle (symbol, options \| DMGL_DLANG);
	56	}
	57
	58	/* Class representing the D language. */
	59
	60	class d_language : public language_defn
	61	{
	62	public:
	63	d_language ()
	64	: language_defn (language_d)
	65	{ /* Nothing. */ }
	66
	67	/* See language.h. */
	68
	69	const char *name () const override
	70	{ return "d"; }
	71
	72	/* See language.h. */
	73
	74	const char *natural_name () const override
	75	{ return "D"; }
	76
	77	/* See language.h. */
	78
	79	const std::vector<const char *> &filename_extensions () const override
	80	{
	81	static const std::vector<const char *> extensions = { ".d" };
	82	return extensions;
	83	}
	84
	85	/* See language.h. */
	86	void language_arch_info (struct gdbarch *gdbarch,
	87	struct language_arch_info *lai) const override
	88	{
	89	const struct builtin_d_type *builtin = builtin_d_type (gdbarch);
	90
	91	/* Helper function to allow shorter lines below. */
	92	auto add = [&] (struct type * t)
	93	{
	94	lai->add_primitive_type (t);
	95	};
	96
	97	add (builtin->builtin_void);
	98	add (builtin->builtin_bool);
	99	add (builtin->builtin_byte);
	100	add (builtin->builtin_ubyte);
	101	add (builtin->builtin_short);
	102	add (builtin->builtin_ushort);
	103	add (builtin->builtin_int);
	104	add (builtin->builtin_uint);
	105	add (builtin->builtin_long);
	106	add (builtin->builtin_ulong);
	107	add (builtin->builtin_cent);
	108	add (builtin->builtin_ucent);
	109	add (builtin->builtin_float);
	110	add (builtin->builtin_double);
	111	add (builtin->builtin_real);
	112	add (builtin->builtin_ifloat);
	113	add (builtin->builtin_idouble);
	114	add (builtin->builtin_ireal);
	115	add (builtin->builtin_cfloat);
	116	add (builtin->builtin_cdouble);
	117	add (builtin->builtin_creal);
	118	add (builtin->builtin_char);
	119	add (builtin->builtin_wchar);
	120	add (builtin->builtin_dchar);
	121
	122	lai->set_string_char_type (builtin->builtin_char);
	123	lai->set_bool_type (builtin->builtin_bool, "bool");
	124	}
	125
	126	/* See language.h. */
	127	bool sniff_from_mangled_name
	128	(const char *mangled,
	129	gdb::unique_xmalloc_ptr<char> *demangled) const override
	130	{
	131	*demangled = d_demangle (mangled, 0);
	132	return *demangled != NULL;
	133	}
	134
	135	/* See language.h. */
	136
	137	gdb::unique_xmalloc_ptr<char> demangle_symbol (const char *mangled,
	138	int options) const override
	139	{
	140	return d_demangle (mangled, options);
	141	}
	142
	143	/* See language.h. */
	144
	145	bool can_print_type_offsets () const override
	146	{
	147	return true;
	148	}
	149
	150	/* See language.h. */
	151
	152	void print_type (struct type type, const char varstring,
	153	struct ui_file *stream, int show, int level,
	154	const struct type_print_options *flags) const override
	155	{
	156	c_print_type (type, varstring, stream, show, level, la_language, flags);
	157	}
	158
	159	/* See language.h. */
	160
	161	void value_print_inner
	162	(struct value val, struct ui_file stream, int recurse,
	163	const struct value_print_options *options) const override
	164	{
	165	return d_value_print_inner (val, stream, recurse, options);
	166	}
	167
	168	/* See language.h. */
	169
	170	struct block_symbol lookup_symbol_nonlocal
	171	(const char name, const struct block block,
	172	const domain_search_flags domain) const override
	173	{
	174	return d_lookup_symbol_nonlocal (this, name, block, domain);
	175	}
	176
	177	/* See language.h. */
	178
	179	int parser (struct parser_state *ps) const override
	180	{
	181	return d_parse (ps);
	182	}
	183
	184	/* See language.h. */
	185
	186	const char *name_of_this () const override
	187	{ return "this"; }
	188	};
	189
	190	/* Single instance of the D language class. */
	191
	192	static d_language d_language_defn;
	193
	194	/* Build all D language types for the specified architecture. */
	195
	196	static struct builtin_d_type *
	197	build_d_types (struct gdbarch *gdbarch)
	198	{
	199	struct builtin_d_type *builtin_d_type = new struct builtin_d_type;
	200
	201	/* Basic types. */
	202	type_allocator alloc (gdbarch);
	203	builtin_d_type->builtin_void = builtin_type (gdbarch)->builtin_void;
	204	builtin_d_type->builtin_bool
	205	= init_boolean_type (alloc, 8, 1, "bool");
	206	builtin_d_type->builtin_byte
	207	= init_integer_type (alloc, 8, 0, "byte");
	208	builtin_d_type->builtin_ubyte
	209	= init_integer_type (alloc, 8, 1, "ubyte");
	210	builtin_d_type->builtin_short
	211	= init_integer_type (alloc, 16, 0, "short");
	212	builtin_d_type->builtin_ushort
	213	= init_integer_type (alloc, 16, 1, "ushort");
	214	builtin_d_type->builtin_int
	215	= init_integer_type (alloc, 32, 0, "int");
	216	builtin_d_type->builtin_uint
	217	= init_integer_type (alloc, 32, 1, "uint");
	218	builtin_d_type->builtin_long
	219	= init_integer_type (alloc, 64, 0, "long");
	220	builtin_d_type->builtin_ulong
	221	= init_integer_type (alloc, 64, 1, "ulong");
	222	builtin_d_type->builtin_cent
	223	= init_integer_type (alloc, 128, 0, "cent");
	224	builtin_d_type->builtin_ucent
	225	= init_integer_type (alloc, 128, 1, "ucent");
	226	builtin_d_type->builtin_float
	227	= init_float_type (alloc, gdbarch_float_bit (gdbarch),
	228	"float", gdbarch_float_format (gdbarch));
	229	builtin_d_type->builtin_double
	230	= init_float_type (alloc, gdbarch_double_bit (gdbarch),
	231	"double", gdbarch_double_format (gdbarch));
	232	builtin_d_type->builtin_real
	233	= init_float_type (alloc, gdbarch_long_double_bit (gdbarch),
	234	"real", gdbarch_long_double_format (gdbarch));
	235
	236	builtin_d_type->builtin_byte->set_instance_flags
	237	(builtin_d_type->builtin_byte->instance_flags ()
	238	\| TYPE_INSTANCE_FLAG_NOTTEXT);
	239
	240	builtin_d_type->builtin_ubyte->set_instance_flags
	241	(builtin_d_type->builtin_ubyte->instance_flags ()
	242	\| TYPE_INSTANCE_FLAG_NOTTEXT);
	243
	244	/* Imaginary and complex types. */
	245	builtin_d_type->builtin_ifloat
	246	= init_float_type (alloc, gdbarch_float_bit (gdbarch),
	247	"ifloat", gdbarch_float_format (gdbarch));
	248	builtin_d_type->builtin_idouble
	249	= init_float_type (alloc, gdbarch_double_bit (gdbarch),
	250	"idouble", gdbarch_double_format (gdbarch));
	251	builtin_d_type->builtin_ireal
	252	= init_float_type (alloc, gdbarch_long_double_bit (gdbarch),
	253	"ireal", gdbarch_long_double_format (gdbarch));
	254	builtin_d_type->builtin_cfloat
	255	= init_complex_type ("cfloat", builtin_d_type->builtin_float);
	256	builtin_d_type->builtin_cdouble
	257	= init_complex_type ("cdouble", builtin_d_type->builtin_double);
	258	builtin_d_type->builtin_creal
	259	= init_complex_type ("creal", builtin_d_type->builtin_real);
	260
	261	/* Character types. */
	262	builtin_d_type->builtin_char
	263	= init_character_type (alloc, 8, 1, "char");
	264	builtin_d_type->builtin_wchar
	265	= init_character_type (alloc, 16, 1, "wchar");
	266	builtin_d_type->builtin_dchar
	267	= init_character_type (alloc, 32, 1, "dchar");
	268
	269	return builtin_d_type;
	270	}
	271
	272	static const registry<gdbarch>::key<struct builtin_d_type> d_type_data;
	273
	274	/* Return the D type table for the specified architecture. */
	275
	276	const struct builtin_d_type *
	277	builtin_d_type (struct gdbarch *gdbarch)
	278	{
	279	struct builtin_d_type *result = d_type_data.get (gdbarch);
	280	if (result == nullptr)
	281	{
	282	result = build_d_types (gdbarch);
	283	d_type_data.set (gdbarch, result);
	284	}
	285
	286	return result;
	287	}