/* Go language support routines for GDB, the GNU debugger.
- Copyright (C) 2012-2013 Free Software Foundation, Inc.
+ Copyright (C) 2012-2021 Free Software Foundation, Inc.
This file is part of GDB.
*/
#include "defs.h"
-#include "gdb_assert.h"
#include "gdb_obstack.h"
-#include <string.h>
#include "block.h"
#include "symtab.h"
#include "language.h"
#include "go-lang.h"
#include "c-lang.h"
#include "parser-defs.h"
+#include "gdbarch.h"
#include <ctype.h>
const char *
go_main_name (void)
{
- struct minimal_symbol *msym;
+ struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol (GO_MAIN_MAIN, NULL, NULL);
- if (msym != NULL)
+ if (msym.minsym != NULL)
return GO_MAIN_MAIN;
/* No known entry procedure found, the main program is probably not Go. */
{
/* gccgo strings don't necessarily have a name we can use. */
- if (TYPE_NFIELDS (type) == 2)
+ if (type->num_fields () == 2)
{
- struct type *type0 = TYPE_FIELD_TYPE (type, 0);
- struct type *type1 = TYPE_FIELD_TYPE (type, 1);
+ struct type *type0 = type->field (0).type ();
+ struct type *type1 = type->field (1).type ();
- CHECK_TYPEDEF (type0);
- CHECK_TYPEDEF (type1);
+ type0 = check_typedef (type0);
+ type1 = check_typedef (type1);
- if (TYPE_CODE (type0) == TYPE_CODE_PTR
+ if (type0->code () == TYPE_CODE_PTR
&& strcmp (TYPE_FIELD_NAME (type, 0), "__data") == 0
- && TYPE_CODE (type1) == TYPE_CODE_INT
+ && type1->code () == TYPE_CODE_INT
&& strcmp (TYPE_FIELD_NAME (type, 1), "__length") == 0)
{
struct type *target_type = TYPE_TARGET_TYPE (type0);
- CHECK_TYPEDEF (target_type);
+ target_type = check_typedef (target_type);
- if (TYPE_CODE (target_type) == TYPE_CODE_INT
+ if (target_type->code () == TYPE_CODE_INT
&& TYPE_LENGTH (target_type) == 1
- && strcmp (TYPE_NAME (target_type), "uint8") == 0)
+ && strcmp (target_type->name (), "uint8") == 0)
return 1;
}
}
static int
sixg_string_p (struct type *type)
{
- if (TYPE_NFIELDS (type) == 2
- && TYPE_TAG_NAME (type) != NULL
- && strcmp (TYPE_TAG_NAME (type), "string") == 0)
+ if (type->num_fields () == 2
+ && type->name () != NULL
+ && strcmp (type->name (), "string") == 0)
return 1;
return 0;
enum go_type
go_classify_struct_type (struct type *type)
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
/* Recognize strings as they're useful to be able to print without
pretty-printers. */
/* Pointer to "N" if valid "N<digit(s)>_" found. */
char *method_type;
/* Pointer to the first '.'. */
- char *first_dot;
+ const char *first_dot;
/* Pointer to the last '.'. */
- char *last_dot;
+ const char *last_dot;
/* Non-zero if we saw a pointer indicator. */
int saw_pointer;
libgo_.*: used by gccgo's runtime
Thus we don't support -fgo-prefix (except as used by the runtime). */
- if (strncmp (mangled_name, "go.", 3) != 0
- && strncmp (mangled_name, "libgo_", 6) != 0)
+ if (!startswith (mangled_name, "go.")
+ && !startswith (mangled_name, "libgo_"))
return NULL;
/* Quick check for whether a search may be fruitful. */
thus not too much effort is currently put into it. */
char *
-go_demangle (const char *mangled_name, int options)
+go_language::demangle_symbol (const char *mangled_name, int options) const
{
struct obstack tempbuf;
char *result;
}
obstack_grow_str0 (&tempbuf, "");
- result = xstrdup (obstack_finish (&tempbuf));
+ result = xstrdup ((const char *) obstack_finish (&tempbuf));
obstack_free (&tempbuf, NULL);
xfree (name_buf);
return result;
char *
go_symbol_package_name (const struct symbol *sym)
{
- const char *mangled_name = SYMBOL_LINKAGE_NAME (sym);
+ const char *mangled_name = sym->linkage_name ();
const char *package_name;
const char *object_name;
const char *method_type_package_name;
char *name_buf;
char *result;
- gdb_assert (SYMBOL_LANGUAGE (sym) == language_go);
+ gdb_assert (sym->language () == language_go);
name_buf = unpack_mangled_go_symbol (mangled_name,
&package_name, &object_name,
&method_type_package_name,
return NULL;
}
-/* Table mapping opcodes into strings for printing operators
- and precedences of the operators.
- TODO(dje): &^ ? */
-
-static const struct op_print go_op_print_tab[] =
-{
- {",", BINOP_COMMA, PREC_COMMA, 0},
- {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
- {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
- {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
- {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
- {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
- {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
- {"==", BINOP_EQUAL, PREC_EQUAL, 0},
- {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
- {"<=", BINOP_LEQ, PREC_ORDER, 0},
- {">=", BINOP_GEQ, PREC_ORDER, 0},
- {">", BINOP_GTR, PREC_ORDER, 0},
- {"<", BINOP_LESS, PREC_ORDER, 0},
- {">>", BINOP_RSH, PREC_SHIFT, 0},
- {"<<", BINOP_LSH, PREC_SHIFT, 0},
- {"+", BINOP_ADD, PREC_ADD, 0},
- {"-", BINOP_SUB, PREC_ADD, 0},
- {"*", BINOP_MUL, PREC_MUL, 0},
- {"/", BINOP_DIV, PREC_MUL, 0},
- {"%", BINOP_REM, PREC_MUL, 0},
- {"@", BINOP_REPEAT, PREC_REPEAT, 0},
- {"-", UNOP_NEG, PREC_PREFIX, 0},
- {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
- {"^", UNOP_COMPLEMENT, PREC_PREFIX, 0},
- {"*", UNOP_IND, PREC_PREFIX, 0},
- {"&", UNOP_ADDR, PREC_PREFIX, 0},
- {"unsafe.Sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
- {"++", UNOP_POSTINCREMENT, PREC_SUFFIX, 0},
- {"--", UNOP_POSTDECREMENT, PREC_SUFFIX, 0},
- {NULL, 0, 0, 0}
-};
-
-enum go_primitive_types {
- go_primitive_type_void,
- go_primitive_type_char,
- go_primitive_type_bool,
- go_primitive_type_int,
- go_primitive_type_uint,
- go_primitive_type_uintptr,
- go_primitive_type_int8,
- go_primitive_type_int16,
- go_primitive_type_int32,
- go_primitive_type_int64,
- go_primitive_type_uint8,
- go_primitive_type_uint16,
- go_primitive_type_uint32,
- go_primitive_type_uint64,
- go_primitive_type_float32,
- go_primitive_type_float64,
- go_primitive_type_complex64,
- go_primitive_type_complex128,
- nr_go_primitive_types
-};
+/* See language.h. */
-static void
-go_language_arch_info (struct gdbarch *gdbarch,
- struct language_arch_info *lai)
+void
+go_language::language_arch_info (struct gdbarch *gdbarch,
+ struct language_arch_info *lai) const
{
const struct builtin_go_type *builtin = builtin_go_type (gdbarch);
- lai->string_char_type = builtin->builtin_char;
-
- lai->primitive_type_vector
- = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_go_primitive_types + 1,
- struct type *);
-
- lai->primitive_type_vector [go_primitive_type_void]
- = builtin->builtin_void;
- lai->primitive_type_vector [go_primitive_type_char]
- = builtin->builtin_char;
- lai->primitive_type_vector [go_primitive_type_bool]
- = builtin->builtin_bool;
- lai->primitive_type_vector [go_primitive_type_int]
- = builtin->builtin_int;
- lai->primitive_type_vector [go_primitive_type_uint]
- = builtin->builtin_uint;
- lai->primitive_type_vector [go_primitive_type_uintptr]
- = builtin->builtin_uintptr;
- lai->primitive_type_vector [go_primitive_type_int8]
- = builtin->builtin_int8;
- lai->primitive_type_vector [go_primitive_type_int16]
- = builtin->builtin_int16;
- lai->primitive_type_vector [go_primitive_type_int32]
- = builtin->builtin_int32;
- lai->primitive_type_vector [go_primitive_type_int64]
- = builtin->builtin_int64;
- lai->primitive_type_vector [go_primitive_type_uint8]
- = builtin->builtin_uint8;
- lai->primitive_type_vector [go_primitive_type_uint16]
- = builtin->builtin_uint16;
- lai->primitive_type_vector [go_primitive_type_uint32]
- = builtin->builtin_uint32;
- lai->primitive_type_vector [go_primitive_type_uint64]
- = builtin->builtin_uint64;
- lai->primitive_type_vector [go_primitive_type_float32]
- = builtin->builtin_float32;
- lai->primitive_type_vector [go_primitive_type_float64]
- = builtin->builtin_float64;
- lai->primitive_type_vector [go_primitive_type_complex64]
- = builtin->builtin_complex64;
- lai->primitive_type_vector [go_primitive_type_complex128]
- = builtin->builtin_complex128;
-
- lai->bool_type_symbol = "bool";
- lai->bool_type_default = builtin->builtin_bool;
+ /* Helper function to allow shorter lines below. */
+ auto add = [&] (struct type * t) -> struct type *
+ {
+ lai->add_primitive_type (t);
+ return t;
+ };
+
+ add (builtin->builtin_void);
+ add (builtin->builtin_char);
+ add (builtin->builtin_bool);
+ add (builtin->builtin_int);
+ add (builtin->builtin_uint);
+ add (builtin->builtin_uintptr);
+ add (builtin->builtin_int8);
+ add (builtin->builtin_int16);
+ add (builtin->builtin_int32);
+ add (builtin->builtin_int64);
+ add (builtin->builtin_uint8);
+ add (builtin->builtin_uint16);
+ add (builtin->builtin_uint32);
+ add (builtin->builtin_uint64);
+ add (builtin->builtin_float32);
+ add (builtin->builtin_float64);
+ add (builtin->builtin_complex64);
+ add (builtin->builtin_complex128);
+
+ lai->set_string_char_type (builtin->builtin_char);
+ lai->set_bool_type (builtin->builtin_bool, "bool");
}
-static const struct language_defn go_language_defn =
-{
- "go",
- "Go",
- language_go,
- range_check_off,
- case_sensitive_on,
- array_row_major,
- macro_expansion_no,
- &exp_descriptor_c,
- go_parse,
- go_error,
- null_post_parser,
- c_printchar, /* Print a character constant. */
- c_printstr, /* Function to print string constant. */
- c_emit_char, /* Print a single char. */
- go_print_type, /* Print a type using appropriate syntax. */
- c_print_typedef, /* Print a typedef using appropriate
- syntax. */
- go_val_print, /* Print a value using appropriate syntax. */
- c_value_print, /* Print a top-level value. */
- default_read_var_value, /* la_read_var_value */
- NULL, /* Language specific skip_trampoline. */
- NULL, /* name_of_this */
- basic_lookup_symbol_nonlocal,
- basic_lookup_transparent_type,
- go_demangle, /* Language specific symbol demangler. */
- NULL, /* Language specific
- class_name_from_physname. */
- go_op_print_tab, /* Expression operators for printing. */
- 1, /* C-style arrays. */
- 0, /* String lower bound. */
- default_word_break_characters,
- default_make_symbol_completion_list,
- go_language_arch_info,
- default_print_array_index,
- default_pass_by_reference,
- c_get_string,
- NULL,
- iterate_over_symbols,
- &default_varobj_ops,
- LANG_MAGIC
-};
+/* Single instance of the Go language class. */
+
+static go_language go_language_defn;
static void *
build_go_types (struct gdbarch *gdbarch)
= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_go_type);
builtin_go_type->builtin_void
- = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
+ = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
builtin_go_type->builtin_char
= arch_character_type (gdbarch, 8, 1, "char");
builtin_go_type->builtin_bool
builtin_go_type->builtin_uint64
= arch_integer_type (gdbarch, 64, 1, "uint64");
builtin_go_type->builtin_float32
- = arch_float_type (gdbarch, 32, "float32", NULL);
+ = arch_float_type (gdbarch, 32, "float32", floatformats_ieee_single);
builtin_go_type->builtin_float64
- = arch_float_type (gdbarch, 64, "float64", NULL);
+ = arch_float_type (gdbarch, 64, "float64", floatformats_ieee_double);
builtin_go_type->builtin_complex64
- = arch_complex_type (gdbarch, "complex64",
- builtin_go_type->builtin_float32);
+ = init_complex_type ("complex64", builtin_go_type->builtin_float32);
builtin_go_type->builtin_complex128
- = arch_complex_type (gdbarch, "complex128",
- builtin_go_type->builtin_float64);
+ = init_complex_type ("complex128", builtin_go_type->builtin_float64);
return builtin_go_type;
}
const struct builtin_go_type *
builtin_go_type (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, go_type_data);
+ return (const struct builtin_go_type *) gdbarch_data (gdbarch, go_type_data);
}
-extern initialize_file_ftype _initialize_go_language;
-
+void _initialize_go_language ();
void
-_initialize_go_language (void)
+_initialize_go_language ()
{
go_type_data = gdbarch_data_register_post_init (build_go_types);
-
- add_language (&go_language_defn);
}
projects / deliverable / binutils-gdb.git / blobdiff