0874fd075b
This commit converts all languages to sub-classes of a language_defn
base class.
The motivation for this change is to make it easier to add new methods
onto languages without having to update all of the individual language
structures. In the future it might be possible to move more things,
like expression parsing, into the language class(es) for better
encapsulation, however I have no plans to tackle this in the short
term.
This commit sets up a strategy for transitioning from the current
language system, where each language is an instance of the
language_defn structure, to the class hierarchy system.
The plan is to rename the existing language_defn into language_data,
and make this a base class for the new language_defn class, something
like this:
struct language_data
{
... old language_defn fields here ...
};
struct language_defn : public language_data
{
language_defn (const language_data d)
: language_data (d)
{ .... }
};
Then each existing language, for example ada_language_defn can be
converted into an instance of language_data, and passed into the
constructor of a new language class, something like this:
language_data ada_language_data =
{
... old ada_language_defn values here ...
};
struct ada_language : public language_defn
{
ada_language (ada_language_data)
{ .... }
};
What this means is that immediately after the conversion nothing much
changes. Every language is now its own class, but all the old
language fields still exist and can be accessed in the same way.
In later commits I will convert function pointers from the old
language_defn structure into real class methods on language_defn, with
overrides on sub-classes where needed.
At this point I imagine that those fields of the old language_defn
structure that contained only data will probably remain as data fields
within the new language_data base structure, it is only the methods
that I plan to change initially.
I tweaked how we manage the list of languages a bit, each language is
now registered as it is created, and this resulted in a small number
of changes in language.c.
Most of the changes in the *-lang.c files are identical.
There should be no user visible changes after this commit.
gdb/ChangeLog:
* gdb/ada-lang.c (ada_language_defn): Convert to...
(ada_language_data): ...this.
(class ada_language): New class.
(ada_language_defn): New static global.
* gdb/c-lang.c (c_language_defn): Convert to...
(c_language_data): ...this.
(class c_language): New class.
(c_language_defn): New static global.
(cplus_language_defn): Convert to...
(cplus_language_data): ...this.
(class cplus_language): New class.
(cplus_language_defn): New static global.
(asm_language_defn): Convert to...
(asm_language_data): ...this.
(class asm_language): New class.
(asm_language_defn): New static global.
(minimal_language_defn): Convert to...
(minimal_language_data): ...this.
(class minimal_language): New class.
(minimal_language_defn): New static global.
* gdb/d-lang.c (d_language_defn): Convert to...
(d_language_data): ...this.
(class d_language): New class.
(d_language_defn): New static global.
* gdb/f-lang.c (f_language_defn): Convert to...
(f_language_data): ...this.
(class f_language): New class.
(f_language_defn): New static global.
* gdb/go-lang.c (go_language_defn): Convert to...
(go_language_data): ...this.
(class go_language): New class.
(go_language_defn): New static global.
* gdb/language.c (unknown_language_defn): Remove declaration.
(current_language): Initialize to nullptr, real initialization is
moved to _initialize_language.
(languages): Delete global.
(language_defn::languages): Define.
(set_language_command): Use language_defn::languages.
(set_language): Likewise.
(range_error): Likewise.
(language_enum): Likewise.
(language_def): Likewise.
(add_set_language_command): Use language_def::languages for the
language list, and language_def to lookup language pointers.
(skip_language_trampoline): Use language_defn::languages.
(unknown_language_defn): Convert to...
(unknown_language_data): ...this.
(class unknown_language): New class.
(unknown_language_defn): New static global.
(auto_language_defn): Convert to...
(auto_language_data): ...this.
(class auto_language): New class.
(auto_language_defn): New static global.
(language_gdbarch_post_init): Use language_defn::languages.
(_initialize_language): Initialize current_language.
* gdb/language.h (struct language_defn): Rename to...
(struct language_data): ...this.
(struct language_defn): New.
(auto_language_defn): Delete.
(unknown_language_defn): Delete.
(minimal_language_defn): Delete.
(ada_language_defn): Delete.
(asm_language_defn): Delete.
(c_language_defn): Delete.
(cplus_language_defn): Delete.
(d_language_defn): Delete.
(f_language_defn): Delete.
(go_language_defn): Delete.
(m2_language_defn): Delete.
(objc_language_defn): Delete.
(opencl_language_defn): Delete.
(pascal_language_defn): Delete.
(rust_language_defn): Delete.
* gdb/m2-lang.c (m2_language_defn): Convert to...
(m2_language_data): ...this.
(class m2_language): New class.
(m2_language_defn): New static global.
* gdb/objc-lang.c (objc_language_defn): Convert to...
(objc_language_data): ...this.
(class objc_language): New class.
(objc_language_defn): New static global.
* gdb/opencl-lang.c (opencl_language_defn): Convert to...
(opencl_language_data): ...this.
(class opencl_language): New class.
(opencl_language_defn): New static global.
* gdb/p-lang.c (pascal_language_defn): Convert to...
(pascal_language_data): ...this.
(class pascal_language): New class.
(pascal_language_defn): New static global.
* gdb/rust-exp.y (rust_lex_tests): Use language_def to find
language pointer, update comment format.
* gdb/rust-lang.c (rust_language_defn): Convert to...
(rust_language_data): ...this.
(class rust_language): New class.
(rust_language_defn): New static global.
365 lines
12 KiB
C
365 lines
12 KiB
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);
|
|
}
|
|
|
|
/* la_sniff_from_mangled_name implementation for D. */
|
|
|
|
static int
|
|
d_sniff_from_mangled_name (const char *mangled, char **demangled)
|
|
{
|
|
*demangled = d_demangle (mangled, 0);
|
|
return *demangled != NULL;
|
|
}
|
|
|
|
/* 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
|
|
};
|
|
|
|
/* 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 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_type, /* Print a type using appropriate syntax. */
|
|
c_print_typedef, /* Print a typedef using appropriate
|
|
syntax. */
|
|
d_value_print_inner, /* la_value_print_inner */
|
|
c_value_print, /* Print a top-level value. */
|
|
default_read_var_value, /* la_read_var_value */
|
|
NULL, /* Language specific skip_trampoline. */
|
|
"this",
|
|
false, /* la_store_sym_names_in_linkage_form_p */
|
|
d_lookup_symbol_nonlocal,
|
|
basic_lookup_transparent_type,
|
|
d_demangle, /* Language specific symbol demangler. */
|
|
d_sniff_from_mangled_name,
|
|
NULL, /* Language specific
|
|
class_name_from_physname. */
|
|
d_op_print_tab, /* Expression operators for printing. */
|
|
1, /* C-style arrays. */
|
|
0, /* String lower bound. */
|
|
default_word_break_characters,
|
|
default_collect_symbol_completion_matches,
|
|
d_language_arch_info,
|
|
default_print_array_index,
|
|
default_pass_by_reference,
|
|
c_watch_location_expression,
|
|
NULL, /* la_get_symbol_name_matcher */
|
|
iterate_over_symbols,
|
|
default_search_name_hash,
|
|
&default_varobj_ops,
|
|
NULL,
|
|
NULL,
|
|
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. */ }
|
|
};
|
|
|
|
/* 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);
|
|
}
|