gdb/d-lang.c

   1 /* D language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 2005-2019 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 "defs.h"
  21
  22 /* Local non-gdb includes.  */
  23 #include "c-lang.h"
  24 #include "cp-support.h"
  25 #include "d-lang.h"
  26 #include "demangle.h"
  27 #include "language.h"
  28 #include "symtab.h"
  29 #include "varobj.h"
  30
  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 {
  42   struct bound_minimal_symbol msym;
  43
  44   msym = lookup_minimal_symbol (D_MAIN, NULL, NULL);
  45   if (msym.minsym != NULL)
  46     return D_MAIN;
  47
  48   /* No known entry procedure found, the main program is probably not D.  */
  49   return NULL;
  50 }
  51
  52 /* Implements the la_demangle language_defn routine for language D.  */
  53
  54 char *
  55 d_demangle (const char *symbol, int options)
  56 {
  57   return gdb_demangle (symbol, options | DMGL_DLANG);
  58 }
  59
  60 /* la_sniff_from_mangled_name implementation for D.  */
  61
  62 static int
  63 d_sniff_from_mangled_name (const char *mangled, char **demangled)
  64 {
  65   *demangled = d_demangle (mangled, 0);
  66   return *demangled != NULL;
  67 }
  68
  69 /* Table mapping opcodes into strings for printing operators
  70    and precedences of the operators.  */
  71 static const struct op_print d_op_print_tab[] =
  72 {
  73   {",", BINOP_COMMA, PREC_COMMA, 0},
  74   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
  75   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
  76   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
  77   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
  78   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
  79   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
  80   {"==", BINOP_EQUAL, PREC_ORDER, 0},
  81   {"!=", BINOP_NOTEQUAL, PREC_ORDER, 0},
  82   {"<=", BINOP_LEQ, PREC_ORDER, 0},
  83   {">=", BINOP_GEQ, PREC_ORDER, 0},
  84   {">", BINOP_GTR, PREC_ORDER, 0},
  85   {"<", BINOP_LESS, PREC_ORDER, 0},
  86   {">>", BINOP_RSH, PREC_SHIFT, 0},
  87   {"<<", BINOP_LSH, PREC_SHIFT, 0},
  88   {"+", BINOP_ADD, PREC_ADD, 0},
  89   {"-", BINOP_SUB, PREC_ADD, 0},
  90   {"~", BINOP_CONCAT, PREC_ADD, 0},
  91   {"*", BINOP_MUL, PREC_MUL, 0},
  92   {"/", BINOP_DIV, PREC_MUL, 0},
  93   {"%", BINOP_REM, PREC_MUL, 0},
  94   {"^^", BINOP_EXP, PREC_REPEAT, 0},
  95   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
  96   {"-", UNOP_NEG, PREC_PREFIX, 0},
  97   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
  98   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
  99   {"*", UNOP_IND, PREC_PREFIX, 0},
 100   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 101   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 102   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 103   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 104   {NULL, OP_NULL, PREC_PREFIX, 0}
 105 };
 106
 107 /* Mapping of all D basic data types into the language vector.  */
 108
 109 enum d_primitive_types {
 110   d_primitive_type_void,
 111   d_primitive_type_bool,
 112   d_primitive_type_byte,
 113   d_primitive_type_ubyte,
 114   d_primitive_type_short,
 115   d_primitive_type_ushort,
 116   d_primitive_type_int,
 117   d_primitive_type_uint,
 118   d_primitive_type_long,
 119   d_primitive_type_ulong,
 120   d_primitive_type_cent,    /* Signed 128 bit integer.  */
 121   d_primitive_type_ucent,   /* Unsigned 128 bit integer.  */
 122   d_primitive_type_float,
 123   d_primitive_type_double,
 124   d_primitive_type_real,
 125   d_primitive_type_ifloat,  /* Imaginary float types.  */
 126   d_primitive_type_idouble,
 127   d_primitive_type_ireal,
 128   d_primitive_type_cfloat,  /* Complex number of two float values.  */
 129   d_primitive_type_cdouble,
 130   d_primitive_type_creal,
 131   d_primitive_type_char,    /* Unsigned character types.  */
 132   d_primitive_type_wchar,
 133   d_primitive_type_dchar,
 134   nr_d_primitive_types
 135 };
 136
 137 /* Implements the la_language_arch_info language_defn routine
 138    for language D.  */
 139
 140 static void
 141 d_language_arch_info (struct gdbarch *gdbarch,
 142                       struct language_arch_info *lai)
 143 {
 144   const struct builtin_d_type *builtin = builtin_d_type (gdbarch);
 145
 146   lai->string_char_type = builtin->builtin_char;
 147   lai->primitive_type_vector
 148     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_d_primitive_types + 1,
 149                               struct type *);
 150
 151   lai->primitive_type_vector [d_primitive_type_void]
 152     = builtin->builtin_void;
 153   lai->primitive_type_vector [d_primitive_type_bool]
 154     = builtin->builtin_bool;
 155   lai->primitive_type_vector [d_primitive_type_byte]
 156     = builtin->builtin_byte;
 157   lai->primitive_type_vector [d_primitive_type_ubyte]
 158     = builtin->builtin_ubyte;
 159   lai->primitive_type_vector [d_primitive_type_short]
 160     = builtin->builtin_short;
 161   lai->primitive_type_vector [d_primitive_type_ushort]
 162     = builtin->builtin_ushort;
 163   lai->primitive_type_vector [d_primitive_type_int]
 164     = builtin->builtin_int;
 165   lai->primitive_type_vector [d_primitive_type_uint]
 166     = builtin->builtin_uint;
 167   lai->primitive_type_vector [d_primitive_type_long]
 168     = builtin->builtin_long;
 169   lai->primitive_type_vector [d_primitive_type_ulong]
 170     = builtin->builtin_ulong;
 171   lai->primitive_type_vector [d_primitive_type_cent]
 172     = builtin->builtin_cent;
 173   lai->primitive_type_vector [d_primitive_type_ucent]
 174     = builtin->builtin_ucent;
 175   lai->primitive_type_vector [d_primitive_type_float]
 176     = builtin->builtin_float;
 177   lai->primitive_type_vector [d_primitive_type_double]
 178     = builtin->builtin_double;
 179   lai->primitive_type_vector [d_primitive_type_real]
 180     = builtin->builtin_real;
 181   lai->primitive_type_vector [d_primitive_type_ifloat]
 182     = builtin->builtin_ifloat;
 183   lai->primitive_type_vector [d_primitive_type_idouble]
 184     = builtin->builtin_idouble;
 185   lai->primitive_type_vector [d_primitive_type_ireal]
 186     = builtin->builtin_ireal;
 187   lai->primitive_type_vector [d_primitive_type_cfloat]
 188     = builtin->builtin_cfloat;
 189   lai->primitive_type_vector [d_primitive_type_cdouble]
 190     = builtin->builtin_cdouble;
 191   lai->primitive_type_vector [d_primitive_type_creal]
 192     = builtin->builtin_creal;
 193   lai->primitive_type_vector [d_primitive_type_char]
 194     = builtin->builtin_char;
 195   lai->primitive_type_vector [d_primitive_type_wchar]
 196     = builtin->builtin_wchar;
 197   lai->primitive_type_vector [d_primitive_type_dchar]
 198     = builtin->builtin_dchar;
 199
 200   lai->bool_type_symbol = "bool";
 201   lai->bool_type_default = builtin->builtin_bool;
 202 }
 203
 204 static const char *d_extensions[] =
 205 {
 206   ".d", NULL
 207 };
 208
 209 extern const struct language_defn d_language_defn =
 210 {
 211   "d",
 212   "D",
 213   language_d,
 214   range_check_off,
 215   case_sensitive_on,
 216   array_row_major,
 217   macro_expansion_no,
 218   d_extensions,
 219   &exp_descriptor_c,
 220   d_parse,
 221   null_post_parser,
 222   c_printchar,                  /* Print a character constant.  */
 223   c_printstr,                   /* Function to print string constant.  */
 224   c_emit_char,                  /* Print a single char.  */
 225   c_print_type,                 /* Print a type using appropriate syntax.  */
 226   c_print_typedef,              /* Print a typedef using appropriate
 227                                    syntax.  */
 228   d_val_print,                  /* Print a value using appropriate syntax.  */
 229   c_value_print,                /* Print a top-level value.  */
 230   default_read_var_value,       /* la_read_var_value */
 231   NULL,                         /* Language specific skip_trampoline.  */
 232   "this",
 233   false,                        /* la_store_sym_names_in_linkage_form_p */
 234   d_lookup_symbol_nonlocal,
 235   basic_lookup_transparent_type,
 236   d_demangle,                   /* Language specific symbol demangler.  */
 237   d_sniff_from_mangled_name,
 238   NULL,                         /* Language specific
 239                                    class_name_from_physname.  */
 240   d_op_print_tab,               /* Expression operators for printing.  */
 241   1,                            /* C-style arrays.  */
 242   0,                            /* String lower bound.  */
 243   default_word_break_characters,
 244   default_collect_symbol_completion_matches,
 245   d_language_arch_info,
 246   default_print_array_index,
 247   default_pass_by_reference,
 248   c_get_string,
 249   c_watch_location_expression,
 250   NULL,                         /* la_get_symbol_name_matcher */
 251   iterate_over_symbols,
 252   default_search_name_hash,
 253   &default_varobj_ops,
 254   NULL,
 255   NULL,
 256   LANG_MAGIC
 257 };
 258
 259 /* Build all D language types for the specified architecture.  */
 260
 261 static void *
 262 build_d_types (struct gdbarch *gdbarch)
 263 {
 264   struct builtin_d_type *builtin_d_type
 265     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);
 266
 267   /* Basic types.  */
 268   builtin_d_type->builtin_void
 269     = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
 270   builtin_d_type->builtin_bool
 271     = arch_boolean_type (gdbarch, 8, 1, "bool");
 272   builtin_d_type->builtin_byte
 273     = arch_integer_type (gdbarch, 8, 0, "byte");
 274   builtin_d_type->builtin_ubyte
 275     = arch_integer_type (gdbarch, 8, 1, "ubyte");
 276   builtin_d_type->builtin_short
 277     = arch_integer_type (gdbarch, 16, 0, "short");
 278   builtin_d_type->builtin_ushort
 279     = arch_integer_type (gdbarch, 16, 1, "ushort");
 280   builtin_d_type->builtin_int
 281     = arch_integer_type (gdbarch, 32, 0, "int");
 282   builtin_d_type->builtin_uint
 283     = arch_integer_type (gdbarch, 32, 1, "uint");
 284   builtin_d_type->builtin_long
 285     = arch_integer_type (gdbarch, 64, 0, "long");
 286   builtin_d_type->builtin_ulong
 287     = arch_integer_type (gdbarch, 64, 1, "ulong");
 288   builtin_d_type->builtin_cent
 289     = arch_integer_type (gdbarch, 128, 0, "cent");
 290   builtin_d_type->builtin_ucent
 291     = arch_integer_type (gdbarch, 128, 1, "ucent");
 292   builtin_d_type->builtin_float
 293     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
 294                        "float", gdbarch_float_format (gdbarch));
 295   builtin_d_type->builtin_double
 296     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
 297                        "double", gdbarch_double_format (gdbarch));
 298   builtin_d_type->builtin_real
 299     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
 300                        "real", gdbarch_long_double_format (gdbarch));
 301
 302   TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte)
 303     |= TYPE_INSTANCE_FLAG_NOTTEXT;
 304   TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte)
 305     |= TYPE_INSTANCE_FLAG_NOTTEXT;
 306
 307   /* Imaginary and complex types.  */
 308   builtin_d_type->builtin_ifloat
 309     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
 310                        "ifloat", gdbarch_float_format (gdbarch));
 311   builtin_d_type->builtin_idouble
 312     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
 313                        "idouble", gdbarch_double_format (gdbarch));
 314   builtin_d_type->builtin_ireal
 315     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
 316                        "ireal", gdbarch_long_double_format (gdbarch));
 317   builtin_d_type->builtin_cfloat
 318     = arch_complex_type (gdbarch, "cfloat",
 319                          builtin_d_type->builtin_float);
 320   builtin_d_type->builtin_cdouble
 321     = arch_complex_type (gdbarch, "cdouble",
 322                          builtin_d_type->builtin_double);
 323   builtin_d_type->builtin_creal
 324     = arch_complex_type (gdbarch, "creal",
 325                          builtin_d_type->builtin_real);
 326
 327   /* Character types.  */
 328   builtin_d_type->builtin_char
 329     = arch_character_type (gdbarch, 8, 1, "char");
 330   builtin_d_type->builtin_wchar
 331     = arch_character_type (gdbarch, 16, 1, "wchar");
 332   builtin_d_type->builtin_dchar
 333     = arch_character_type (gdbarch, 32, 1, "dchar");
 334
 335   return builtin_d_type;
 336 }
 337
 338 static struct gdbarch_data *d_type_data;
 339
 340 /* Return the D type table for the specified architecture.  */
 341
 342 const struct builtin_d_type *
 343 builtin_d_type (struct gdbarch *gdbarch)
 344 {
 345   return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
 346 }
 347
 348 void
 349 _initialize_d_language (void)
 350 {
 351   d_type_data = gdbarch_data_register_post_init (build_d_types);
 352 }