X-Git-Url: https://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgo-lang.c;h=2a4fb1a35b09095f86a0eecc7be3e37e0d4db0c7;hb=456ef1c1d43c0407801fb2d59db355472be8a554;hp=0a0101d86daff3e4e48b4651eb199a00d77b3851;hpb=8b302db80cb07f5f3264b50e1b51fdb8ecb29183;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/go-lang.c b/gdb/go-lang.c index 0a0101d86d..2a4fb1a35b 100644 --- a/gdb/go-lang.c +++ b/gdb/go-lang.c @@ -1,6 +1,6 @@ /* Go language support routines for GDB, the GNU debugger. - Copyright (C) 2012-2016 Free Software Foundation, Inc. + Copyright (C) 2012-2021 Free Software Foundation, Inc. This file is part of GDB. @@ -40,6 +40,7 @@ #include "go-lang.h" #include "c-lang.h" #include "parser-defs.h" +#include "gdbarch.h" #include @@ -72,26 +73,26 @@ gccgo_string_p (struct type *type) { /* 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 (); 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); 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; } } @@ -105,9 +106,9 @@ gccgo_string_p (struct type *type) 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; @@ -333,7 +334,7 @@ unpack_mangled_go_symbol (const char *mangled_name, 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; @@ -385,22 +386,13 @@ go_demangle (const char *mangled_name, int options) return result; } -/* la_sniff_from_mangled_name for Go. */ - -static int -go_sniff_from_mangled_name (const char *mangled, char **demangled) -{ - *demangled = go_demangle (mangled, 0); - return *demangled != NULL; -} - /* Given a Go symbol, return its package or NULL if unknown. Space for the result is malloc'd, caller must free. */ 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; @@ -409,7 +401,7 @@ go_symbol_package_name (const struct symbol *sym) 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, @@ -452,166 +444,47 @@ go_block_package_name (const struct block *block) 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, OP_NULL, PREC_SUFFIX, 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, - NULL, - &exp_descriptor_c, - go_parse, - go_yyerror, - 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. */ - go_sniff_from_mangled_name, - 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, - NULL, - NULL, - LANG_MAGIC -}; +/* Single instance of the Go language class. */ + +static go_language go_language_defn; static void * build_go_types (struct gdbarch *gdbarch) @@ -620,7 +493,7 @@ 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 @@ -648,15 +521,13 @@ build_go_types (struct gdbarch *gdbarch) 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; } @@ -669,12 +540,9 @@ builtin_go_type (struct gdbarch *gdbarch) 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); }