gdb/d-lang.c

   1 /* D language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 2005-2020 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 exp_descriptor *expression_ops () const override
 223   { return &exp_descriptor_c; }
 224
 225   /* See language.h.  */
 226
 227   const struct op_print *opcode_print_table () const override
 228   { return d_op_print_tab; }
 229 };
 230
 231 /* Single instance of the D language class.  */
 232
 233 static d_language d_language_defn;
 234
 235 /* Build all D language types for the specified architecture.  */
 236
 237 static void *
 238 build_d_types (struct gdbarch *gdbarch)
 239 {
 240   struct builtin_d_type *builtin_d_type
 241     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);
 242
 243   /* Basic types.  */
 244   builtin_d_type->builtin_void
 245     = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
 246   builtin_d_type->builtin_bool
 247     = arch_boolean_type (gdbarch, 8, 1, "bool");
 248   builtin_d_type->builtin_byte
 249     = arch_integer_type (gdbarch, 8, 0, "byte");
 250   builtin_d_type->builtin_ubyte
 251     = arch_integer_type (gdbarch, 8, 1, "ubyte");
 252   builtin_d_type->builtin_short
 253     = arch_integer_type (gdbarch, 16, 0, "short");
 254   builtin_d_type->builtin_ushort
 255     = arch_integer_type (gdbarch, 16, 1, "ushort");
 256   builtin_d_type->builtin_int
 257     = arch_integer_type (gdbarch, 32, 0, "int");
 258   builtin_d_type->builtin_uint
 259     = arch_integer_type (gdbarch, 32, 1, "uint");
 260   builtin_d_type->builtin_long
 261     = arch_integer_type (gdbarch, 64, 0, "long");
 262   builtin_d_type->builtin_ulong
 263     = arch_integer_type (gdbarch, 64, 1, "ulong");
 264   builtin_d_type->builtin_cent
 265     = arch_integer_type (gdbarch, 128, 0, "cent");
 266   builtin_d_type->builtin_ucent
 267     = arch_integer_type (gdbarch, 128, 1, "ucent");
 268   builtin_d_type->builtin_float
 269     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
 270                        "float", gdbarch_float_format (gdbarch));
 271   builtin_d_type->builtin_double
 272     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
 273                        "double", gdbarch_double_format (gdbarch));
 274   builtin_d_type->builtin_real
 275     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
 276                        "real", gdbarch_long_double_format (gdbarch));
 277
 278   builtin_d_type->builtin_byte->set_instance_flags
 279     (builtin_d_type->builtin_byte->instance_flags ()
 280      | TYPE_INSTANCE_FLAG_NOTTEXT);
 281
 282   builtin_d_type->builtin_ubyte->set_instance_flags
 283     (builtin_d_type->builtin_ubyte->instance_flags ()
 284      | TYPE_INSTANCE_FLAG_NOTTEXT);
 285
 286   /* Imaginary and complex types.  */
 287   builtin_d_type->builtin_ifloat
 288     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
 289                        "ifloat", gdbarch_float_format (gdbarch));
 290   builtin_d_type->builtin_idouble
 291     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
 292                        "idouble", gdbarch_double_format (gdbarch));
 293   builtin_d_type->builtin_ireal
 294     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
 295                        "ireal", gdbarch_long_double_format (gdbarch));
 296   builtin_d_type->builtin_cfloat
 297     = init_complex_type ("cfloat", builtin_d_type->builtin_float);
 298   builtin_d_type->builtin_cdouble
 299     = init_complex_type ("cdouble", builtin_d_type->builtin_double);
 300   builtin_d_type->builtin_creal
 301     = init_complex_type ("creal", builtin_d_type->builtin_real);
 302
 303   /* Character types.  */
 304   builtin_d_type->builtin_char
 305     = arch_character_type (gdbarch, 8, 1, "char");
 306   builtin_d_type->builtin_wchar
 307     = arch_character_type (gdbarch, 16, 1, "wchar");
 308   builtin_d_type->builtin_dchar
 309     = arch_character_type (gdbarch, 32, 1, "dchar");
 310
 311   return builtin_d_type;
 312 }
 313
 314 static struct gdbarch_data *d_type_data;
 315
 316 /* Return the D type table for the specified architecture.  */
 317
 318 const struct builtin_d_type *
 319 builtin_d_type (struct gdbarch *gdbarch)
 320 {
 321   return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
 322 }
 323
 324 void _initialize_d_language ();
 325 void
 326 _initialize_d_language ()
 327 {
 328   d_type_data = gdbarch_data_register_post_init (build_d_types);
 329 }