X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fm2-lang.c;h=f174ad55823f30a487441d9d5f0ee9b080707037;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=be7eaed12856292cbefea64d838d94d390c22028;hpb=844781a1bed001865515739fc576c268af2127d6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c index be7eaed128..f174ad5582 100644 --- a/gdb/m2-lang.c +++ b/gdb/m2-lang.c @@ -1,7 +1,6 @@ /* Modula 2 language support routines for GDB, the GNU debugger. - Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2002, 2003, 2004, - 2005, 2007 Free Software Foundation, Inc. + Copyright (C) 1992-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -24,14 +23,14 @@ #include "expression.h" #include "parser-defs.h" #include "language.h" +#include "varobj.h" #include "m2-lang.h" #include "c-lang.h" #include "valprint.h" +#include "gdbarch.h" -extern void _initialize_m2_language (void); -static struct type *m2_create_fundamental_type (struct objfile *, int); -static void m2_printchar (int, struct ui_file *); -static void m2_emit_char (int, struct ui_file *, int); +static void m2_printchar (int, struct type *, struct ui_file *); +static void m2_emit_char (int, struct type *, struct ui_file *, int); /* Print the character C on STREAM as part of the contents of a literal string whose delimiter is QUOTER. Note that that format for printing @@ -40,10 +39,10 @@ static void m2_emit_char (int, struct ui_file *, int); be replaced with a true Modula version. */ static void -m2_emit_char (int c, struct ui_file *stream, int quoter) +m2_emit_char (int c, struct type *type, struct ui_file *stream, int quoter) { - c &= 0xFF; /* Avoid sign bit follies */ + c &= 0xFF; /* Avoid sign bit follies. */ if (PRINT_LITERAL_FORM (c)) { @@ -89,10 +88,10 @@ m2_emit_char (int c, struct ui_file *stream, int quoter) be replaced with a true Modula version. */ static void -m2_printchar (int c, struct ui_file *stream) +m2_printchar (int c, struct type *type, struct ui_file *stream) { fputs_filtered ("'", stream); - LA_EMIT_CHAR (c, stream, '\''); + LA_EMIT_CHAR (c, type, stream, '\''); fputs_filtered ("'", stream); } @@ -104,8 +103,9 @@ m2_printchar (int c, struct ui_file *stream) be replaced with a true Modula version. */ static void -m2_printstr (struct ui_file *stream, const gdb_byte *string, - unsigned int length, int width, int force_ellipses) +m2_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string, + unsigned int length, const char *encoding, int force_ellipses, + const struct value_print_options *options) { unsigned int i; unsigned int things_printed = 0; @@ -118,7 +118,7 @@ m2_printstr (struct ui_file *stream, const gdb_byte *string, return; } - for (i = 0; i < length && things_printed < print_max; ++i) + for (i = 0; i < length && things_printed < options->print_max; ++i) { /* Position of the character we are examining to see whether it is repeated. */ @@ -142,50 +142,60 @@ m2_printstr (struct ui_file *stream, const gdb_byte *string, ++reps; } - if (reps > repeat_count_threshold) + if (reps > options->repeat_count_threshold) { if (in_quotes) { - if (inspect_it) - fputs_filtered ("\\\", ", stream); - else - fputs_filtered ("\", ", stream); + fputs_filtered ("\", ", stream); in_quotes = 0; } - m2_printchar (string[i], stream); + m2_printchar (string[i], type, stream); fprintf_filtered (stream, " ", reps); i = rep1 - 1; - things_printed += repeat_count_threshold; + things_printed += options->repeat_count_threshold; need_comma = 1; } else { if (!in_quotes) { - if (inspect_it) - fputs_filtered ("\\\"", stream); - else - fputs_filtered ("\"", stream); + fputs_filtered ("\"", stream); in_quotes = 1; } - LA_EMIT_CHAR (string[i], stream, '"'); + LA_EMIT_CHAR (string[i], type, stream, '"'); ++things_printed; } } /* Terminate the quotes if necessary. */ if (in_quotes) - { - if (inspect_it) - fputs_filtered ("\\\"", stream); - else - fputs_filtered ("\"", stream); - } + fputs_filtered ("\"", stream); if (force_ellipses || i < length) fputs_filtered ("...", stream); } +/* Return true if TYPE is a string. */ + +static bool +m2_is_string_type_p (struct type *type) +{ + type = check_typedef (type); + if (type->code () == TYPE_CODE_ARRAY + && TYPE_LENGTH (type) > 0 + && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0) + { + struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type)); + + if (TYPE_LENGTH (elttype) == 1 + && (elttype->code () == TYPE_CODE_INT + || elttype->code () == TYPE_CODE_CHAR)) + return true; + } + + return false; +} + static struct value * evaluate_subexp_modula2 (struct type *expect_type, struct expression *exp, int *pos, enum noside noside) @@ -194,6 +204,7 @@ evaluate_subexp_modula2 (struct type *expect_type, struct expression *exp, struct value *arg1; struct value *arg2; struct type *type; + switch (op) { case UNOP_HIGH: @@ -210,6 +221,7 @@ evaluate_subexp_modula2 (struct type *expect_type, struct expression *exp, if (m2_is_unbounded_array (type)) { struct value *temp = arg1; + type = TYPE_FIELD_TYPE (type, 1); /* i18n: Do not translate the "_m2_high" part! */ arg1 = value_struct_elt (&temp, NULL, "_m2_high", NULL, @@ -239,10 +251,12 @@ evaluate_subexp_modula2 (struct type *expect_type, struct expression *exp, { struct value *temp = arg1; type = TYPE_FIELD_TYPE (type, 0); - if (type == NULL || (TYPE_CODE (type) != TYPE_CODE_PTR)) { - warning (_("internal error: unbounded array structure is unknown")); - return evaluate_subexp_standard (expect_type, exp, pos, noside); - } + if (type == NULL || (type->code () != TYPE_CODE_PTR)) + { + warning (_("internal error: unbounded " + "array structure is unknown")); + return evaluate_subexp_standard (expect_type, exp, pos, noside); + } /* i18n: Do not translate the "_m2_contents" part! */ arg1 = value_struct_elt (&temp, NULL, "_m2_contents", NULL, _("unbounded structure " @@ -251,15 +265,15 @@ evaluate_subexp_modula2 (struct type *expect_type, struct expression *exp, if (value_type (arg1) != type) arg1 = value_cast (type, arg1); - type = check_typedef (value_type (arg1)); - return value_ind (value_add (arg1, arg2)); + check_typedef (value_type (arg1)); + return value_ind (value_ptradd (arg1, value_as_long (arg2))); } else - if (TYPE_CODE (type) != TYPE_CODE_ARRAY) + if (type->code () != TYPE_CODE_ARRAY) { - if (TYPE_NAME (type)) + if (type->name ()) error (_("cannot subscript something of type `%s'"), - TYPE_NAME (type)); + type->name ()); else error (_("cannot subscript requested type")); } @@ -267,182 +281,14 @@ evaluate_subexp_modula2 (struct type *expect_type, struct expression *exp, if (noside == EVAL_AVOID_SIDE_EFFECTS) return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1)); else - return value_subscript (arg1, arg2); + return value_subscript (arg1, value_as_long (arg2)); default: return evaluate_subexp_standard (expect_type, exp, pos, noside); } nosideret: - return value_from_longest (builtin_type_long, (LONGEST) 1); -} - -/* FIXME: This is a copy of c_create_fundamental_type(), before - all the non-C types were stripped from it. Needs to be fixed - by an experienced Modula programmer. */ - -static struct type * -m2_create_fundamental_type (struct objfile *objfile, int typeid) -{ - struct type *type = NULL; - - switch (typeid) - { - default: - /* FIXME: For now, if we are asked to produce a type not in this - language, create the equivalent of a C integer type with the - name "". When all the dust settles from the type - reconstruction work, this should probably become an error. */ - type = init_type (TYPE_CODE_INT, - gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "", objfile); - warning (_("internal error: no Modula fundamental type %d"), typeid); - break; - case FT_VOID: - type = init_type (TYPE_CODE_VOID, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "void", objfile); - break; - case FT_BOOLEAN: - type = init_type (TYPE_CODE_BOOL, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "boolean", objfile); - break; - case FT_STRING: - type = init_type (TYPE_CODE_STRING, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "string", objfile); - break; - case FT_CHAR: - type = init_type (TYPE_CODE_INT, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "char", objfile); - break; - case FT_SIGNED_CHAR: - type = init_type (TYPE_CODE_INT, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "signed char", objfile); - break; - case FT_UNSIGNED_CHAR: - type = init_type (TYPE_CODE_INT, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned char", objfile); - break; - case FT_SHORT: - type = init_type (TYPE_CODE_INT, - gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "short", objfile); - break; - case FT_SIGNED_SHORT: - type = init_type (TYPE_CODE_INT, - gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "short", objfile); /* FIXME-fnf */ - break; - case FT_UNSIGNED_SHORT: - type = init_type (TYPE_CODE_INT, - gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned short", objfile); - break; - case FT_INTEGER: - type = init_type (TYPE_CODE_INT, - gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "int", objfile); - break; - case FT_SIGNED_INTEGER: - type = init_type (TYPE_CODE_INT, - gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "int", objfile); /* FIXME -fnf */ - break; - case FT_UNSIGNED_INTEGER: - type = init_type (TYPE_CODE_INT, - gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned int", objfile); - break; - case FT_FIXED_DECIMAL: - type = init_type (TYPE_CODE_INT, - gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "fixed decimal", objfile); - break; - case FT_LONG: - type = init_type (TYPE_CODE_INT, - gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "long", objfile); - break; - case FT_SIGNED_LONG: - type = init_type (TYPE_CODE_INT, - gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "long", objfile); /* FIXME -fnf */ - break; - case FT_UNSIGNED_LONG: - type = init_type (TYPE_CODE_INT, - gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned long", objfile); - break; - case FT_LONG_LONG: - type = init_type (TYPE_CODE_INT, - gdbarch_long_long_bit (current_gdbarch) - / TARGET_CHAR_BIT, - 0, "long long", objfile); - break; - case FT_SIGNED_LONG_LONG: - type = init_type (TYPE_CODE_INT, - gdbarch_long_long_bit (current_gdbarch) - / TARGET_CHAR_BIT, - 0, "signed long long", objfile); - break; - case FT_UNSIGNED_LONG_LONG: - type = init_type (TYPE_CODE_INT, - gdbarch_long_long_bit (current_gdbarch) - / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned long long", objfile); - break; - case FT_FLOAT: - type = init_type (TYPE_CODE_FLT, - gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "float", objfile); - break; - case FT_DBL_PREC_FLOAT: - type = init_type (TYPE_CODE_FLT, - gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "double", objfile); - break; - case FT_FLOAT_DECIMAL: - type = init_type (TYPE_CODE_FLT, - gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "floating decimal", objfile); - break; - case FT_EXT_PREC_FLOAT: - type = init_type (TYPE_CODE_FLT, - gdbarch_long_double_bit (current_gdbarch) - / TARGET_CHAR_BIT, - 0, "long double", objfile); - break; - case FT_COMPLEX: - type = init_type (TYPE_CODE_COMPLEX, - 2 * gdbarch_float_bit (current_gdbarch) - / TARGET_CHAR_BIT, - 0, "complex", objfile); - TYPE_TARGET_TYPE (type) - = m2_create_fundamental_type (objfile, FT_FLOAT); - break; - case FT_DBL_PREC_COMPLEX: - type = init_type (TYPE_CODE_COMPLEX, - 2 * gdbarch_double_bit (current_gdbarch) - / TARGET_CHAR_BIT, - 0, "double complex", objfile); - TYPE_TARGET_TYPE (type) - = m2_create_fundamental_type (objfile, FT_DBL_PREC_FLOAT); - break; - case FT_EXT_PREC_COMPLEX: - type = init_type (TYPE_CODE_COMPLEX, - 2 * gdbarch_long_double_bit (current_gdbarch) - / TARGET_CHAR_BIT, - 0, "long double complex", objfile); - TYPE_TARGET_TYPE (type) - = m2_create_fundamental_type (objfile, FT_EXT_PREC_FLOAT); - break; - } - return (type); + return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1); } @@ -479,7 +325,7 @@ static const struct op_print m2_op_print_tab[] = {"MIN", UNOP_MIN, PREC_BUILTIN_FUNCTION, 0}, {"ODD", UNOP_ODD, PREC_BUILTIN_FUNCTION, 0}, {"TRUNC", UNOP_TRUNC, PREC_BUILTIN_FUNCTION, 0}, - {NULL, 0, 0, 0} + {NULL, OP_NULL, PREC_BUILTIN_FUNCTION, 0} }; /* The built-in types of Modula-2. */ @@ -493,75 +339,104 @@ enum m2_primitive_types { nr_m2_primitive_types }; -static void -m2_language_arch_info (struct gdbarch *gdbarch, - struct language_arch_info *lai) -{ - const struct builtin_m2_type *builtin = builtin_m2_type (gdbarch); - - lai->string_char_type = builtin->builtin_char; - lai->primitive_type_vector - = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_m2_primitive_types + 1, - struct type *); - - lai->primitive_type_vector [m2_primitive_type_char] - = builtin->builtin_char; - lai->primitive_type_vector [m2_primitive_type_int] - = builtin->builtin_int; - lai->primitive_type_vector [m2_primitive_type_card] - = builtin->builtin_card; - lai->primitive_type_vector [m2_primitive_type_real] - = builtin->builtin_real; - lai->primitive_type_vector [m2_primitive_type_bool] - = builtin->builtin_bool; -} - const struct exp_descriptor exp_descriptor_modula2 = { print_subexp_standard, operator_length_standard, + operator_check_standard, op_name_standard, dump_subexp_body_standard, evaluate_subexp_modula2 }; -const struct language_defn m2_language_defn = +/* Constant data describing the M2 language. */ + +extern const struct language_data m2_language_data = { "modula-2", + "Modula-2", language_m2, - NULL, range_check_on, - type_check_on, case_sensitive_on, array_row_major, + macro_expansion_no, + NULL, &exp_descriptor_modula2, m2_parse, /* parser */ - m2_error, /* parser error function */ null_post_parser, m2_printchar, /* Print character constant */ m2_printstr, /* function to print string constant */ m2_emit_char, /* Function to print a single character */ - m2_create_fundamental_type, /* Create fundamental type in this language */ - m2_print_type, /* Print a type using appropriate syntax */ - m2_val_print, /* Print a value using appropriate syntax */ + m2_print_typedef, /* Print a typedef using appropriate syntax */ + m2_value_print_inner, /* la_value_print_inner */ c_value_print, /* Print a top-level value */ - NULL, /* Language specific skip_trampoline */ - value_of_this, /* value_of_this */ + NULL, /* name_of_this */ + false, /* la_store_sym_names_in_linkage_form_p */ basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ - basic_lookup_transparent_type,/* lookup_transparent_type */ - NULL, /* Language specific symbol demangler */ - NULL, /* Language specific class_name_from_physname */ + NULL, /* Language specific + class_name_from_physname */ m2_op_print_tab, /* expression operators for printing */ 0, /* arrays are first-class (not c-style) */ 0, /* String lower bound */ - NULL, default_word_break_characters, - m2_language_arch_info, - default_print_array_index, - default_pass_by_reference, - LANG_MAGIC + default_collect_symbol_completion_matches, + c_watch_location_expression, + NULL, /* la_get_symbol_name_matcher */ + &default_varobj_ops, + NULL, + m2_is_string_type_p, + "{...}" /* la_struct_too_deep_ellipsis */ +}; + +/* Class representing the M2 language. */ + +class m2_language : public language_defn +{ +public: + m2_language () + : language_defn (language_m2, m2_language_data) + { /* Nothing. */ } + + /* See language.h. */ + void language_arch_info (struct gdbarch *gdbarch, + struct language_arch_info *lai) const override + { + const struct builtin_m2_type *builtin = builtin_m2_type (gdbarch); + + lai->string_char_type = builtin->builtin_char; + lai->primitive_type_vector + = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_m2_primitive_types + 1, + struct type *); + + lai->primitive_type_vector [m2_primitive_type_char] + = builtin->builtin_char; + lai->primitive_type_vector [m2_primitive_type_int] + = builtin->builtin_int; + lai->primitive_type_vector [m2_primitive_type_card] + = builtin->builtin_card; + lai->primitive_type_vector [m2_primitive_type_real] + = builtin->builtin_real; + lai->primitive_type_vector [m2_primitive_type_bool] + = builtin->builtin_bool; + + lai->bool_type_symbol = "BOOLEAN"; + lai->bool_type_default = builtin->builtin_bool; + } + + /* See language.h. */ + + void print_type (struct type *type, const char *varstring, + struct ui_file *stream, int show, int level, + const struct type_print_options *flags) const override + { + m2_print_type (type, varstring, stream, show, level, flags); + } }; +/* Single instance of the M2 language. */ + +static m2_language m2_language_defn; + static void * build_m2_types (struct gdbarch *gdbarch) { @@ -569,29 +444,17 @@ build_m2_types (struct gdbarch *gdbarch) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_m2_type); /* Modula-2 "pervasive" types. NOTE: these can be redefined!!! */ - builtin_m2_type->builtin_int = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, "INTEGER", (struct objfile *) NULL); - builtin_m2_type->builtin_card = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "CARDINAL", (struct objfile *) NULL); - builtin_m2_type->builtin_real = - init_type (TYPE_CODE_FLT, - gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT, - 0, - "REAL", (struct objfile *) NULL); - builtin_m2_type->builtin_char = - init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "CHAR", (struct objfile *) NULL); - builtin_m2_type->builtin_bool = - init_type (TYPE_CODE_BOOL, - gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "BOOLEAN", (struct objfile *) NULL); + builtin_m2_type->builtin_int + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "INTEGER"); + builtin_m2_type->builtin_card + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "CARDINAL"); + builtin_m2_type->builtin_real + = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "REAL", + gdbarch_float_format (gdbarch)); + builtin_m2_type->builtin_char + = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "CHAR"); + builtin_m2_type->builtin_bool + = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "BOOLEAN"); return builtin_m2_type; } @@ -601,16 +464,15 @@ static struct gdbarch_data *m2_type_data; const struct builtin_m2_type * builtin_m2_type (struct gdbarch *gdbarch) { - return gdbarch_data (gdbarch, m2_type_data); + return (const struct builtin_m2_type *) gdbarch_data (gdbarch, m2_type_data); } /* Initialization for Modula-2 */ +void _initialize_m2_language (); void -_initialize_m2_language (void) +_initialize_m2_language () { m2_type_data = gdbarch_data_register_post_init (build_m2_types); - - add_language (&m2_language_defn); }