gdb/d-lang.c

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