X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Flanguage.h;h=f2885000259b2df35dbd0f555a15323f88c22630;hb=cb1a6dda0d7b14034f647fbc48a7d6a2d212db7f;hp=980e3647af994469b753dc4bfa30fdc29d85d6ac;hpb=6f7664a9c33b110248d0fb68bcc41fdb48396c51;p=binutils-gdb.git diff --git a/gdb/language.h b/gdb/language.h index 980e3647af9..f2885000259 100644 --- a/gdb/language.h +++ b/gdb/language.h @@ -1,6 +1,6 @@ /* Source-language-related definitions for GDB. - Copyright (C) 1991-2020 Free Software Foundation, Inc. + Copyright (C) 1991-2022 Free Software Foundation, Inc. Contributed by the Department of Computer Science at the State University of New York at Buffalo. @@ -42,16 +42,6 @@ class innermost_block_tracker; #define MAX_FORTRAN_DIMS 7 /* Maximum number of F77 array dims. */ -/* range_mode == - range_mode_auto: range_check set automatically to default of language. - range_mode_manual: range_check set manually by user. */ - -extern enum range_mode - { - range_mode_auto, range_mode_manual - } -range_mode; - /* range_check == range_check_on: Ranges are checked in GDB expressions, producing errors. range_check_warn: Ranges are checked, producing warnings. @@ -63,16 +53,6 @@ extern enum range_check } range_check; -/* case_mode == - case_mode_auto: case_sensitivity set upon selection of scope. - case_mode_manual: case_sensitivity set only by user. */ - -extern enum case_mode - { - case_mode_auto, case_mode_manual - } -case_mode; - /* array_ordering == array_row_major: Arrays are in row major order. array_column_major: Arrays are in column major order. */ @@ -109,23 +89,129 @@ enum macro_expansion struct language_arch_info { - /* Its primitive types. This is a vector ended by a NULL pointer. - These types can be specified by name in parsing types in - expressions, regardless of whether the program being debugged - actually defines such a type. */ - struct type **primitive_type_vector; + /* A default constructor. */ + language_arch_info () = default; + + DISABLE_COPY_AND_ASSIGN (language_arch_info); + + /* Set the default boolean type to be TYPE. If NAME is not nullptr then + before using TYPE a symbol called NAME will be looked up, and the type + of this symbol will be used instead. Should only be called once when + performing setup for a particular language in combination with a + particular gdbarch. */ + void set_bool_type (struct type *type, const char *name = nullptr) + { + gdb_assert (m_bool_type_default == nullptr); + gdb_assert (m_bool_type_name == nullptr); + gdb_assert (type != nullptr); + m_bool_type_default = type; + m_bool_type_name = name; + } + + /* Set the type to be used for characters within a string. Should only + be called once when performing setup for a particular language in + combination with a particular gdbarch. */ + void set_string_char_type (struct type *type) + { + gdb_assert (m_string_char_type == nullptr); + gdb_assert (type != nullptr); + m_string_char_type = type; + } + + /* Return the type for characters within a string. */ + struct type *string_char_type () const + { return m_string_char_type; } + + /* Return the type to be used for booleans. */ + struct type *bool_type () const; + + /* Add TYPE to the list of primitive types for this particular language, + with this OS/ABI combination. */ + void add_primitive_type (struct type *type) + { + gdb_assert (type != nullptr); + primitive_types_and_symbols.push_back (type_and_symbol (type)); + } + + /* Lookup a primitive type called NAME. Will return nullptr if no + matching type is found. */ + struct type *lookup_primitive_type (const char *name); + + /* Lookup a primitive type for which FILTER returns true. Will return + nullptr if no matching type is found. */ + struct type *lookup_primitive_type + (gdb::function_view filter); + + /* Lookup a primitive type called NAME and return the type as a symbol. + LANG is the language for which type is being looked up. */ + struct symbol *lookup_primitive_type_as_symbol (const char *name, + enum language lang); +private: + + /* A structure storing a type and a corresponding symbol. The type is + defined at construction time, while the symbol is lazily created only + when asked for, but is then cached for future use. */ + struct type_and_symbol + { + /* Constructor. */ + explicit type_and_symbol (struct type *type) + : m_type (type) + { /* Nothing. */ } + + /* Default move constructor. */ + type_and_symbol (type_and_symbol&&) = default; + + DISABLE_COPY_AND_ASSIGN (type_and_symbol); + + /* Return the type from this object. */ + struct type *type () const + { return m_type; } + + /* Create and return a symbol wrapping M_TYPE from this object. */ + struct symbol *symbol (enum language lang) + { + if (m_symbol == nullptr) + m_symbol = alloc_type_symbol (lang, m_type); + return m_symbol; + } + + private: + /* The type primitive type. */ + struct type *m_type = nullptr; + + /* A symbol wrapping M_TYPE, only created when first asked for. */ + struct symbol *m_symbol = nullptr; + + /* Helper function for type lookup as a symbol. Create the symbol + corresponding to type TYPE in language LANG. */ + static struct symbol *alloc_type_symbol (enum language lang, + struct type *type); + }; + + /* Lookup a type_and_symbol entry from the primitive_types_and_symbols + vector for a type matching NAME. Return a pointer to the + type_and_symbol object from the vector. This will return nullptr if + there is no type matching NAME found. */ + type_and_symbol *lookup_primitive_type_and_symbol (const char *name); - /* Symbol wrappers around primitive_type_vector, so that the symbol lookup - machinery can return them. */ - struct symbol **primitive_type_symbols; + /* Vector of the primitive types added through add_primitive_type. These + types can be specified by name in parsing types in expressions, + regardless of whether the program being debugged actually defines such + a type. + + Within the vector each type is paired with a lazily created symbol, + which can be fetched by the symbol lookup machinery, should they be + needed. */ + std::vector primitive_types_and_symbols; /* Type of elements of strings. */ - struct type *string_char_type; + struct type *m_string_char_type = nullptr; /* Symbol name of type to use as boolean type, if defined. */ - const char *bool_type_symbol; + const char *m_bool_type_name = nullptr; + /* Otherwise, this is the default boolean builtin type. */ - struct type *bool_type_default; + struct type *m_bool_type_default = nullptr; }; /* In a language (particularly C++) a function argument of an aggregate @@ -172,101 +258,22 @@ struct language_pass_by_ref_info /* Splitting strings into words. */ extern const char *default_word_break_characters (void); -/* Structure tying together assorted information about a language. - - As we move over from the old structure based languages to a class - hierarchy of languages this structure will continue to contain a - mixture of both data and function pointers. - - Once the class hierarchy of languages in place the first task is to - remove the function pointers from this structure and convert them into - member functions on the different language classes. - - The current plan it to keep the constant data that describes a language - in this structure, and have each language pass in an instance of this - structure at construction time. */ - -struct language_data - { - /* its symtab language-enum (defs.h). */ - - enum language la_language; - - /* Default range checking. */ - - enum range_check la_range_check; - - /* Default case sensitivity. */ - enum case_sensitivity la_case_sensitivity; - - /* Multi-dimensional array ordering. */ - enum array_ordering la_array_ordering; - - /* Style of macro expansion, if any, supported by this language. */ - enum macro_expansion la_macro_expansion; - - /* A NULL-terminated array of file extensions for this language. - The extension must include the ".", like ".c". If this - language doesn't need to provide any filename extensions, this - may be NULL. */ - - const char *const *la_filename_extensions; - - /* Definitions related to expression printing, prefixifying, and - dumping. */ - - const struct exp_descriptor *la_exp_desc; - - /* Now come some hooks for lookup_symbol. */ - - /* True if the symbols names should be stored in GDB's data structures - for minimal/partial/full symbols using their linkage (aka mangled) - form; false if the symbol names should be demangled first. - - Most languages implement symbol lookup by comparing the demangled - names, in which case it is advantageous to store that information - already demangled, and so would set this field to false. - - On the other hand, some languages have opted for doing symbol - lookups by comparing mangled names instead, for reasons usually - specific to the language. Those languages should set this field - to true. - - And finally, other languages such as C or Asm do not have - the concept of mangled vs demangled name, so those languages - should set this field to true as well, to prevent any accidental - demangling through an unrelated language's demangler. */ - - const bool la_store_sym_names_in_linkage_form_p; - - /* Table for printing expressions. */ - - const struct op_print *la_op_print_tab; - - /* Zero if the language has first-class arrays. True if there are no - array values, and array objects decay to pointers, as in C. */ - - char c_style_arrays; - - /* Index to use for extracting the first element of a string. */ - char string_lower_bound; - - /* Various operations on varobj. */ - const struct lang_varobj_ops *la_varobj_ops; - }; - /* Base class from which all other language classes derive. */ -struct language_defn : language_data +struct language_defn { - language_defn (enum language lang, const language_data &init_data) - : language_data (init_data) + language_defn (enum language lang) + : la_language (lang) { /* We should only ever create one instance of each language. */ gdb_assert (languages[lang] == nullptr); languages[lang] = this; } + /* Which language this is. */ + + const enum language la_language; + /* Name of the language. */ virtual const char *name () const = 0; @@ -275,6 +282,17 @@ struct language_defn : language_data virtual const char *natural_name () const = 0; + /* Return a vector of file extensions for this language. The extension + must include the ".", like ".c". If this language doesn't need to + provide any filename extensions, this may be an empty vector (which is + the default). */ + + virtual const std::vector &filename_extensions () const + { + static const std::vector no_extensions; + return no_extensions; + } + /* Print the index of an element of an array. This default implementation prints using C99 syntax. */ @@ -309,6 +327,14 @@ struct language_defn : language_data return {}; } + /* Return true if SYMBOL represents an entity that is not + supposed to be seen by the user. To be used to filter symbols + during printing. */ + virtual bool symbol_printing_suppressed (struct symbol *symbol) const + { + return false; + } + /* The per-architecture (OS/ABI) language information. */ virtual void language_arch_info (struct gdbarch *, @@ -356,18 +382,14 @@ struct language_defn : language_data symbol_name_matcher_ftype *get_symbol_name_matcher (const lookup_name_info &lookup_name) const; - /* If this language allows compilation from the gdb command line, then - this method will return an instance of struct gcc_context appropriate - to the language. If compilation for this language is generally - supported, but something goes wrong then an exception is thrown. The - returned compiler instance is owned by its caller and must be - deallocated by the caller. If compilation is not supported for this - language then this method returns NULL. */ + /* If this language allows compilation from the gdb command line, + then this method will return an instance of struct gcc_context + appropriate to the language. If compilation for this language is + generally supported, but something goes wrong then an exception + is thrown. If compilation is not supported for this language + then this method returns NULL. */ - virtual compile_instance *get_compile_instance () const - { - return nullptr; - } + virtual std::unique_ptr get_compile_instance () const; /* This method must be overridden if 'get_compile_instance' is overridden. @@ -408,23 +430,28 @@ struct language_defn : language_data The resulting string should be of the form that will be installed into a symbol. */ - virtual bool sniff_from_mangled_name (const char *mangled, - char **demangled) const + virtual bool sniff_from_mangled_name + (const char *mangled, gdb::unique_xmalloc_ptr *demangled) const { *demangled = nullptr; return false; } /* Return demangled language symbol version of MANGLED, or NULL. */ - virtual char *demangle (const char *mangled, int options) const + virtual gdb::unique_xmalloc_ptr demangle_symbol (const char *mangled, + int options) const { return nullptr; } - /* Print a type using syntax appropriate for this language. */ + /* Print TYPE to STREAM using syntax appropriate for this language. + LEVEL is the depth to indent lines by. VARSTRING, if not NULL or the + empty string, is the name of a variable and TYPE should be printed in + the form of a declaration of a variable named VARSTRING. */ - virtual void print_type (struct type *, const char *, struct ui_file *, int, - int, const struct type_print_options *) const = 0; + virtual void print_type (struct type *type, const char *varstring, + struct ui_file *stream, int show, int level, + const struct type_print_options *flags) const = 0; /* PC is possibly an unknown languages trampoline. If that PC falls in a trampoline belonging to this language, return @@ -497,21 +524,6 @@ struct language_defn : language_data virtual int parser (struct parser_state *ps) const; - /* Given an expression *EXPP created by prefixifying the result of - la_parser, perform any remaining processing necessary to complete its - translation. *EXPP may change; la_post_parser is responsible for - releasing its previous contents, if necessary. If VOID_CONTEXT_P, - then no value is expected from the expression. If COMPLETING is - non-zero, then the expression has been parsed for completion, not - evaluation. */ - - virtual void post_parser (expression_up *expp, int void_context_p, - int completing, - innermost_block_tracker *tracker) const - { - /* By default the post-parser does nothing. */ - } - /* Print the character CH (of type CHTYPE) on STREAM as part of the contents of a literal string whose delimiter is QUOTER. */ @@ -560,6 +572,74 @@ struct language_defn : language_data virtual const char *name_of_this () const { return nullptr; } + /* Return false if the language has first-class arrays. Return true if + there are no array values, and array objects decay to pointers, as in + C. The default is true as currently most supported languages behave + in this manner. */ + + virtual bool c_style_arrays_p () const + { return true; } + + /* Return the index to use for extracting the first element of a string, + or as the lower bound when creating a new string. The default of + choosing 0 or 1 based on C_STYLE_ARRAYS_P works for all currently + supported languages except Modula-2. */ + + virtual char string_lower_bound () const + { return c_style_arrays_p () ? 0 : 1; } + + /* Returns true if the symbols names should be stored in GDB's data + structures for minimal/partial/full symbols using their linkage (aka + mangled) form; false if the symbol names should be demangled first. + + Most languages implement symbol lookup by comparing the demangled + names, in which case it is advantageous to store that information + already demangled, and so would return false, which is the default. + + On the other hand, some languages have opted for doing symbol lookups + by comparing mangled names instead, for reasons usually specific to + the language. Those languages should override this function and + return true. + + And finally, other languages such as C or Asm do not have the concept + of mangled vs demangled name, so those languages should also override + this function and return true, to prevent any accidental demangling + through an unrelated language's demangler. */ + + virtual bool store_sym_names_in_linkage_form_p () const + { return false; } + + /* Default range checking preference. The return value from this + function provides the automatic setting for 'set check range'. As a + consequence a user is free to override this setting if they want. */ + + virtual bool range_checking_on_by_default () const + { return false; } + + /* Is this language case sensitive? The return value from this function + provides the automativ setting for 'set case-sensitive', as a + consequence, a user is free to override this setting if they want. */ + + virtual enum case_sensitivity case_sensitivity () const + { return case_sensitive_on; } + + + /* Multi-dimensional array ordering. */ + + virtual enum array_ordering array_ordering () const + { return array_row_major; } + + /* Style of macro expansion, if any, supported by this language. The + default is no macro expansion. */ + + virtual enum macro_expansion macro_expansion () const + { return macro_expansion_no; } + + /* Return a structure containing various operations on varobj specific + for this language. */ + + virtual const struct lang_varobj_ops *varobj_ops () const; + protected: /* This is the overridable part of the GET_SYMBOL_NAME_MATCHER method. @@ -608,19 +688,39 @@ extern enum language_mode } language_mode; +/* Return the type that should be used for booleans for language L in + GDBARCH. */ + struct type *language_bool_type (const struct language_defn *l, struct gdbarch *gdbarch); +/* Return the type that should be used for characters within a string for + language L in GDBARCH. */ + struct type *language_string_char_type (const struct language_defn *l, struct gdbarch *gdbarch); -/* Look up type NAME in language L, and return its definition for architecture - GDBARCH. Returns NULL if not found. */ +/* Look up a type from the set of OS/ABI specific types defined in + GDBARCH for language L. NAME is used for selecting the matching + type, and is passed through to the corresponding + lookup_primitive_type member function inside the language_arch_info + class. */ struct type *language_lookup_primitive_type (const struct language_defn *l, struct gdbarch *gdbarch, const char *name); +/* Look up a type from the set of OS/ABI specific types defined in + GDBARCH for language L. FILTER is used for selecting the matching + type, and is passed through to the corresponding + lookup_primitive_type member function inside the language_arch_info + class. */ + +struct type *language_lookup_primitive_type + (const struct language_defn *la, + struct gdbarch *gdbarch, + gdb::function_view filter); + /* Wrapper around language_lookup_primitive_type to return the corresponding symbol. */ @@ -642,40 +742,14 @@ struct symbol * (LANG)->la_language == language_cplus || \ (LANG)->la_language == language_objc) -extern void language_info (int); +/* Print out the current language settings: language, range and + type checking. */ + +extern void language_info (); extern enum language set_language (enum language); -/* This page contains functions that return things that are - specific to languages. Each of these functions is based on - the current setting of working_lang, which the user sets - with the "set language" command. */ - -#define LA_PRINT_TYPE(type,varstring,stream,show,level,flags) \ - (current_language->print_type(type,varstring,stream,show,level,flags)) - -#define LA_PRINT_TYPEDEF(type,new_symbol,stream) \ - (current_language->print_typedef (type,new_symbol,stream)) - -#define LA_VALUE_PRINT(val,stream,options) \ - (current_language->value_print (val,stream,options)) - -#define LA_PRINT_CHAR(ch, type, stream) \ - (current_language->printchar (ch, type, stream)) -#define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses, options) \ - (current_language->printstr (stream, elttype, string, length, \ - encoding, force_ellipses,options)) -#define LA_EMIT_CHAR(ch, type, stream, quoter) \ - (current_language->emitchar (ch, type, stream, quoter)) - -#define LA_PRINT_ARRAY_INDEX(index_type, index_value, stream, options) \ - (current_language->print_array_index(index_type, index_value, stream, \ - options)) - -#define LA_ITERATE_OVER_SYMBOLS(BLOCK, NAME, DOMAIN, CALLBACK) \ - (current_language->iterate_over_symbols (BLOCK, NAME, DOMAIN, CALLBACK)) - /* Test a character to decide whether it can be printed in literal form or needs to be printed in another representation. For example, in C the literal form of the character with octal value 141 is 'a' @@ -687,18 +761,10 @@ extern enum language set_language (enum language); && ((c) < 0x7F || (c) >= 0xA0) \ && (!sevenbit_strings || (c) < 0x80)) -/* Type predicates */ - -extern int pointer_type (struct type *); - /* Error messages */ extern void range_error (const char *, ...) ATTRIBUTE_PRINTF (1, 2); -/* Data: Does this value represent "truth" to the current language? */ - -extern int value_true (struct value *); - /* Misc: The string representing a particular enum language. */ extern enum language language_enum (const char *str); @@ -712,8 +778,9 @@ extern const char *language_str (enum language); extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc); /* Return demangled language symbol, or NULL. */ -extern char *language_demangle (const struct language_defn *current_language, - const char *mangled, int options); +extern gdb::unique_xmalloc_ptr language_demangle + (const struct language_defn *current_language, + const char *mangled, int options); /* Return information about whether TYPE should be passed (and returned) by reference at the language level. */