gdb/d-lang.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* D language support routines for GDB, the GNU debugger.

  3.    Copyright (C) 2005-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  29. /* The name of the symbol to use to get the name of the main subprogram.  */
  30. ‌static const char D_MAIN[] = "D main";

  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.  */

  37. const char *
  38. ‌d_main_name (void)
  39. {
  40.   struct bound_minimal_symbol msym;

  42.   msym = lookup_minimal_symbol (D_MAIN, NULL, NULL);
  43.   if (msym.minsym != NULL)
  44.     return D_MAIN;

  46.   /* No known entry procedure found, the main program is probably not D.  */
  47.   return NULL;
  48. }

  50. /* Implements the la_demangle language_defn routine for language D.  */

  52. char *
  53. ‌d_demangle (const char *symbol, int options)
  54. {
  55.   return gdb_demangle (symbol, options | DMGL_DLANG);
  56. }

  58. /* Table mapping opcodes into strings for printing operators
  59.    and precedences of the operators.  */
  60. ‌static const struct op_print d_op_print_tab[] =
  61. {
  62.   {",", BINOP_COMMA, PREC_COMMA, 0},
  63.   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
  64.   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
  65.   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
  66.   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
  67.   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
  68.   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
  69.   {"==", BINOP_EQUAL, PREC_ORDER, 0},
  70.   {"!=", BINOP_NOTEQUAL, PREC_ORDER, 0},
  71.   {"<=", BINOP_LEQ, PREC_ORDER, 0},
  72.   {">=", BINOP_GEQ, PREC_ORDER, 0},
  73.   {">", BINOP_GTR, PREC_ORDER, 0},
  74.   {"<", BINOP_LESS, PREC_ORDER, 0},
  75.   {">>", BINOP_RSH, PREC_SHIFT, 0},
  76.   {"<<", BINOP_LSH, PREC_SHIFT, 0},
  77.   {"+", BINOP_ADD, PREC_ADD, 0},
  78.   {"-", BINOP_SUB, PREC_ADD, 0},
  79.   {"~", BINOP_CONCAT, PREC_ADD, 0},
  80.   {"*", BINOP_MUL, PREC_MUL, 0},
  81.   {"/", BINOP_DIV, PREC_MUL, 0},
  82.   {"%", BINOP_REM, PREC_MUL, 0},
  83.   {"^^", BINOP_EXP, PREC_REPEAT, 0},
  84.   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
  85.   {"-", UNOP_NEG, PREC_PREFIX, 0},
  86.   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
  87.   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
  88.   {"*", UNOP_IND, PREC_PREFIX, 0},
  89.   {"&", UNOP_ADDR, PREC_PREFIX, 0},
  90.   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
  91.   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
  92.   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
  93.   {NULL, 0, 0, 0}
  94. };

  96. /* Mapping of all D basic data types into the language vector.  */

  98. ‌enum d_primitive_types {
  99.   d_primitive_type_void,
  100.   d_primitive_type_bool,
  101.   d_primitive_type_byte,
  102.   d_primitive_type_ubyte,
  103.   d_primitive_type_short,
  104.   d_primitive_type_ushort,
  105.   d_primitive_type_int,
  106.   d_primitive_type_uint,
  107.   d_primitive_type_long,
  108.   d_primitive_type_ulong,
  109.   d_primitive_type_cent,    /* Signed 128 bit integer.  */
  110.   d_primitive_type_ucent,   /* Unsigned 128 bit integer.  */
  111.   d_primitive_type_float,
  112.   d_primitive_type_double,
  113.   d_primitive_type_real,
  114.   d_primitive_type_ifloat,  /* Imaginary float types.  */
  115.   d_primitive_type_idouble,
  116.   d_primitive_type_ireal,
  117.   d_primitive_type_cfloat,  /* Complex number of two float values.  */
  118.   d_primitive_type_cdouble,
  119.   d_primitive_type_creal,
  120.   d_primitive_type_char,    /* Unsigned character types.  */
  121.   d_primitive_type_wchar,
  122.   d_primitive_type_dchar,
  123.   nr_d_primitive_types
  124. };

  126. /* Implements the la_language_arch_info language_defn routine
  127.    for language D.  */

  129. static void
  130. ‌d_language_arch_info (struct gdbarch *gdbarch,
  131.                       struct language_arch_info *lai)
  132. {
  133.   const struct builtin_d_type *builtin = builtin_d_type (gdbarch);

  135.   lai->string_char_type = builtin->builtin_char;
  136.   lai->primitive_type_vector
  137.     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_d_primitive_types + 1,
  138.                               struct type *);

  140.   lai->primitive_type_vector [d_primitive_type_void]
  141.     = builtin->builtin_void;
  142.   lai->primitive_type_vector [d_primitive_type_bool]
  143.     = builtin->builtin_bool;
  144.   lai->primitive_type_vector [d_primitive_type_byte]
  145.     = builtin->builtin_byte;
  146.   lai->primitive_type_vector [d_primitive_type_ubyte]
  147.     = builtin->builtin_ubyte;
  148.   lai->primitive_type_vector [d_primitive_type_short]
  149.     = builtin->builtin_short;
  150.   lai->primitive_type_vector [d_primitive_type_ushort]
  151.     = builtin->builtin_ushort;
  152.   lai->primitive_type_vector [d_primitive_type_int]
  153.     = builtin->builtin_int;
  154.   lai->primitive_type_vector [d_primitive_type_uint]
  155.     = builtin->builtin_uint;
  156.   lai->primitive_type_vector [d_primitive_type_long]
  157.     = builtin->builtin_long;
  158.   lai->primitive_type_vector [d_primitive_type_ulong]
  159.     = builtin->builtin_ulong;
  160.   lai->primitive_type_vector [d_primitive_type_cent]
  161.     = builtin->builtin_cent;
  162.   lai->primitive_type_vector [d_primitive_type_ucent]
  163.     = builtin->builtin_ucent;
  164.   lai->primitive_type_vector [d_primitive_type_float]
  165.     = builtin->builtin_float;
  166.   lai->primitive_type_vector [d_primitive_type_double]
  167.     = builtin->builtin_double;
  168.   lai->primitive_type_vector [d_primitive_type_real]
  169.     = builtin->builtin_real;
  170.   lai->primitive_type_vector [d_primitive_type_ifloat]
  171.     = builtin->builtin_ifloat;
  172.   lai->primitive_type_vector [d_primitive_type_idouble]
  173.     = builtin->builtin_idouble;
  174.   lai->primitive_type_vector [d_primitive_type_ireal]
  175.     = builtin->builtin_ireal;
  176.   lai->primitive_type_vector [d_primitive_type_cfloat]
  177.     = builtin->builtin_cfloat;
  178.   lai->primitive_type_vector [d_primitive_type_cdouble]
  179.     = builtin->builtin_cdouble;
  180.   lai->primitive_type_vector [d_primitive_type_creal]
  181.     = builtin->builtin_creal;
  182.   lai->primitive_type_vector [d_primitive_type_char]
  183.     = builtin->builtin_char;
  184.   lai->primitive_type_vector [d_primitive_type_wchar]
  185.     = builtin->builtin_wchar;
  186.   lai->primitive_type_vector [d_primitive_type_dchar]
  187.     = builtin->builtin_dchar;

  189.   lai->bool_type_symbol = "bool";
  190.   lai->bool_type_default = builtin->builtin_bool;
  191. }

  193. ‌static const struct language_defn d_language_defn =
  194. {
  195.   "d",
  196.   "D",
  197.   language_d,
  198.   range_check_off,
  199.   case_sensitive_on,
  200.   array_row_major,
  201.   macro_expansion_no,
  202.   &exp_descriptor_c,
  203.   d_parse,
  204.   d_error,
  205.   null_post_parser,
  206.   c_printchar,                        /* Print a character constant.  */
  207.   c_printstr,                        /* Function to print string constant.  */
  208.   c_emit_char,                        /* Print a single char.  */
  209.   c_print_type,                        /* Print a type using appropriate syntax.  */
  210.   c_print_typedef,                /* Print a typedef using appropriate
  211.                                    syntax.  */
  212.   d_val_print,                        /* Print a value using appropriate syntax.  */
  213.   c_value_print,                /* Print a top-level value.  */
  214.   default_read_var_value,        /* la_read_var_value */
  215.   NULL,                                /* Language specific skip_trampoline.  */
  216.   "this",
  217.   basic_lookup_symbol_nonlocal,
  218.   basic_lookup_transparent_type,
  219.   d_demangle,                        /* Language specific symbol demangler.  */
  220.   NULL,                                /* Language specific
  221.                                    class_name_from_physname.  */
  222.   d_op_print_tab,                /* Expression operators for printing.  */
  223.   1,                                /* C-style arrays.  */
  224.   0,                                /* String lower bound.  */
  225.   default_word_break_characters,
  226.   default_make_symbol_completion_list,
  227.   d_language_arch_info,
  228.   default_print_array_index,
  229.   default_pass_by_reference,
  230.   c_get_string,
  231.   NULL,                                /* la_get_symbol_name_cmp */
  232.   iterate_over_symbols,
  233.   &default_varobj_ops,
  234.   NULL,
  235.   NULL,
  236.   LANG_MAGIC
  237. };

  239. /* Build all D language types for the specified architecture.  */

  241. static void *
  242. ‌build_d_types (struct gdbarch *gdbarch)
  243. {
  244.   struct builtin_d_type *builtin_d_type
  245.     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);

  247.   /* Basic types.  */
  248.   builtin_d_type->builtin_void
  249.     = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
  250.   builtin_d_type->builtin_bool
  251.     = arch_boolean_type (gdbarch, 8, 1, "bool");
  252.   builtin_d_type->builtin_byte
  253.     = arch_integer_type (gdbarch, 8, 0, "byte");
  254.   builtin_d_type->builtin_ubyte
  255.     = arch_integer_type (gdbarch, 8, 1, "ubyte");
  256.   builtin_d_type->builtin_short
  257.     = arch_integer_type (gdbarch, 16, 0, "short");
  258.   builtin_d_type->builtin_ushort
  259.     = arch_integer_type (gdbarch, 16, 1, "ushort");
  260.   builtin_d_type->builtin_int
  261.     = arch_integer_type (gdbarch, 32, 0, "int");
  262.   builtin_d_type->builtin_uint
  263.     = arch_integer_type (gdbarch, 32, 1, "uint");
  264.   builtin_d_type->builtin_long
  265.     = arch_integer_type (gdbarch, 64, 0, "long");
  266.   builtin_d_type->builtin_ulong
  267.     = arch_integer_type (gdbarch, 64, 1, "ulong");
  268.   builtin_d_type->builtin_cent
  269.     = arch_integer_type (gdbarch, 128, 0, "cent");
  270.   builtin_d_type->builtin_ucent
  271.     = arch_integer_type (gdbarch, 128, 1, "ucent");
  272.   builtin_d_type->builtin_float
  273.     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
  274.                        "float", NULL);
  275.   builtin_d_type->builtin_double
  276.     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
  277.                        "double", NULL);
  278.   builtin_d_type->builtin_real
  279.     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
  280.                        "real", NULL);

  282.   TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte)
  283.     |= TYPE_INSTANCE_FLAG_NOTTEXT;
  284.   TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte)
  285.     |= TYPE_INSTANCE_FLAG_NOTTEXT;

  287.   /* Imaginary and complex types.  */
  288.   builtin_d_type->builtin_ifloat
  289.     = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
  290.                        "ifloat", NULL);
  291.   builtin_d_type->builtin_idouble
  292.     = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
  293.                        "idouble", NULL);
  294.   builtin_d_type->builtin_ireal
  295.     = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
  296.                        "ireal", NULL);
  297.   builtin_d_type->builtin_cfloat
  298.     = arch_complex_type (gdbarch, "cfloat",
  299.                          builtin_d_type->builtin_float);
  300.   builtin_d_type->builtin_cdouble
  301.     = arch_complex_type (gdbarch, "cdouble",
  302.                          builtin_d_type->builtin_double);
  303.   builtin_d_type->builtin_creal
  304.     = arch_complex_type (gdbarch, "creal",
  305.                          builtin_d_type->builtin_real);

  307.   /* Character types.  */
  308.   builtin_d_type->builtin_char
  309.     = arch_character_type (gdbarch, 8, 1, "char");
  310.   builtin_d_type->builtin_wchar
  311.     = arch_character_type (gdbarch, 16, 1, "wchar");
  312.   builtin_d_type->builtin_dchar
  313.     = arch_character_type (gdbarch, 32, 1, "dchar");

  315.   return builtin_d_type;
  316. }

  318. ‌static struct gdbarch_data *d_type_data;

  320. /* Return the D type table for the specified architecture.  */

  322. const struct builtin_d_type *
  323. ‌builtin_d_type (struct gdbarch *gdbarch)
  324. {
  325.   return gdbarch_data (gdbarch, d_type_data);
  326. }

  328. /* Provide a prototype to silence -Wmissing-prototypes.  */
  329. extern initialize_file_ftype _initialize_d_language;

  331. void
  332. ‌_initialize_d_language (void)
  333. {
  334.   d_type_data = gdbarch_data_register_post_init (build_d_types);

  336.   add_language (&d_language_defn);
  337. }