gdb/d-lang.c

   1 /* D language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 2005-2021 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 #include "symtab.h"
  22 #include "language.h"
  23 #include "varobj.h"
  24 #include "d-lang.h"
  25 #include "c-lang.h"
  26 #include "demangle.h"
  27 #include "cp-support.h"
  28 #include "gdbarch.h"
  29 #include "parser-defs.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 /* 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},
  71   {"==", BINOP_EQUAL, PREC_ORDER, 0},
  72   {"!=", BINOP_NOTEQUAL, PREC_ORDER, 0},
  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},
  81   {"~", BINOP_CONCAT, PREC_ADD, 0},
  82   {"*", BINOP_MUL, PREC_MUL, 0},
  83   {"/", BINOP_DIV, PREC_MUL, 0},
  84   {"%", BINOP_REM, PREC_MUL, 0},
  85   {"^^", BINOP_EXP, PREC_REPEAT, 0},
  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},
  95   {NULL, OP_NULL, PREC_PREFIX, 0}
  96 };
  97
  98 /* Class representing the D language.  */
  99
 100 class d_language : public language_defn
 101 {
 102 public:
 103   d_language ()
 104     : language_defn (language_d)
 105   { /* Nothing.  */ }
 106
 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
 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
 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
 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");
 164   }
 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   }
 173
 174   /* See language.h.  */
 175
 176   char *demangle_symbol (const char *mangled, int options) const override
 177   {
 178     return d_demangle (mangled, options);
 179   }
 180
 181   /* See language.h.  */
 182
 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   }
 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   }
 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   }
 207
 208   /* See language.h.  */
 209
 210   int parser (struct parser_state *ps) const override
 211   {
 212     return d_parse (ps);
 213   }
 214
 215   /* See language.h.  */
 216
 217   const char *name_of_this () const override
 218   { return "this"; }
 219
 220   /* See language.h.  */
 221
 222   const struct op_print *opcode_print_table () const override
 223   { return d_op_print_tab; }
 224 };
 225
 226 /* Single instance of the D language class.  */
 227
 228 static d_language d_language_defn;
 229
 230 /* Build all D language types for the specified architecture.  */
 231
 232 static void *
 233 build_d_types (struct gdbarch *gdbarch)
 234 {
 235   struct builtin_d_type *builtin_d_type
 236     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);
 237
 238   /* Basic types.  */
 239   builtin_d_type->builtin_void
 240     = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
 241   builtin_d_type->builtin_bool
 242     = arch_boolean_type (gdbarch, 8, 1, "bool");
 243   builtin_d_type->builtin_byte
 244     = arch_integer_type (gdbarch, 8, 0, "byte");
 245   builtin_d_type->builtin_ubyte
 246     = arch_integer_type (gdbarch, 8, 1, "ubyte");
 247   builtin_d_type->builtin_short
 248     = arch_integer_type (gdbarch, 16, 0, "short");
 249   builtin_d_type->builtin_ushort
 250     = arch_integer_type (gdbarch, 16, 1, "ushort");
 251   builtin_d_type->builtin_int
 252     = arch_integer_type (gdbarch, 32, 0, "int");
 253   builtin_d_type->builtin_uint
 254     = arch_integer_type (gdbarch, 32, 1, "uint");
 255   builtin_d_type->builtin_long
 256     = arch_integer_type (gdbarch, 64, 0, "long");
 257   builtin_d_type->builtin_ulong
 258     = arch_integer_type (gdbarch, 64, 1, "ulong");
 259   builtin_d_type->builtin_cent
 260     = arch_integer_type (gdbarch, 128, 0, "cent");
 261   builtin_d_type->builtin_ucent
 262     = arch_integer_type (gdbarch, 128, 1, "ucent");
 263   builtin_d_type->builtin_float
 264     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
 265                        "float", gdbarch_float_format (gdbarch));
 266   builtin_d_type->builtin_double
 267     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
 268                        "double", gdbarch_double_format (gdbarch));
 269   builtin_d_type->builtin_real
 270     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
 271                        "real", gdbarch_long_double_format (gdbarch));
 272
 273   builtin_d_type->builtin_byte->set_instance_flags
 274     (builtin_d_type->builtin_byte->instance_flags ()
 275      | TYPE_INSTANCE_FLAG_NOTTEXT);
 276
 277   builtin_d_type->builtin_ubyte->set_instance_flags
 278     (builtin_d_type->builtin_ubyte->instance_flags ()
 279      | TYPE_INSTANCE_FLAG_NOTTEXT);
 280
 281   /* Imaginary and complex types.  */
 282   builtin_d_type->builtin_ifloat
 283     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
 284                        "ifloat", gdbarch_float_format (gdbarch));
 285   builtin_d_type->builtin_idouble
 286     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
 287                        "idouble", gdbarch_double_format (gdbarch));
 288   builtin_d_type->builtin_ireal
 289     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
 290                        "ireal", gdbarch_long_double_format (gdbarch));
 291   builtin_d_type->builtin_cfloat
 292     = init_complex_type ("cfloat", builtin_d_type->builtin_float);
 293   builtin_d_type->builtin_cdouble
 294     = init_complex_type ("cdouble", builtin_d_type->builtin_double);
 295   builtin_d_type->builtin_creal
 296     = init_complex_type ("creal", builtin_d_type->builtin_real);
 297
 298   /* Character types.  */
 299   builtin_d_type->builtin_char
 300     = arch_character_type (gdbarch, 8, 1, "char");
 301   builtin_d_type->builtin_wchar
 302     = arch_character_type (gdbarch, 16, 1, "wchar");
 303   builtin_d_type->builtin_dchar
 304     = arch_character_type (gdbarch, 32, 1, "dchar");
 305
 306   return builtin_d_type;
 307 }
 308
 309 static struct gdbarch_data *d_type_data;
 310
 311 /* Return the D type table for the specified architecture.  */
 312
 313 const struct builtin_d_type *
 314 builtin_d_type (struct gdbarch *gdbarch)
 315 {
 316   return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
 317 }
 318
 319 void _initialize_d_language ();
 320 void
 321 _initialize_d_language ()
 322 {
 323   d_type_data = gdbarch_data_register_post_init (build_d_types);
 324 }