diff options
Diffstat (limited to 'gdb/compile/compile-cplus.h')
| -rw-r--r-- | gdb/compile/compile-cplus.h | 399 |
1 files changed, 399 insertions, 0 deletions
diff --git a/gdb/compile/compile-cplus.h b/gdb/compile/compile-cplus.h new file mode 100644 index 0000000..2ab31fe --- /dev/null +++ b/gdb/compile/compile-cplus.h @@ -0,0 +1,399 @@ +/* Header file for GDB compile C++ language support. + Copyright (C) 2016, 2017 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#ifndef GDB_COMPILE_CPLUS_H +#define GDB_COMPILE_CPLUS_H + +#include "gcc-cp-interface.h" +#include "common/enum-flags.h" +#include "compile-cplus-templates.h" + +#include <string> +#include <memory> + +struct type; +struct block; + +/* enum-flags wrapper */ +DEF_ENUM_FLAGS_TYPE (enum gcc_cp_qualifiers, gcc_cp_qualifiers_flags); +DEF_ENUM_FLAGS_TYPE (enum gcc_cp_ref_qualifiers, gcc_cp_ref_qualifiers_flags); +DEF_ENUM_FLAGS_TYPE (enum gcc_cp_symbol_kind, gcc_cp_symbol_kind_flags); + +namespace compile +{ + class compile_cplus_instance; + + /* A single component of a type's scope. Type names are broken into + "components," a series of unqualified names comprising the type name, + e.g., "namespace1", "namespace2", "myclass". */ + + struct scope_component + { + /* The unqualified name of this scope. */ + std::string name; + + /* The block symbol for this type/scope. */ + struct block_symbol bsymbol; + }; + + /* Comparison operators for scope_components. */ + + bool operator== (const scope_component &lhs, const scope_component &rhs); + bool operator!= (const scope_component &lhs, const scope_component &rhs); + + + /* A single compiler scope used to define a type. + + A compile_scope is a list of scope_components, where all leading + scope_components are namespaces, followed by a single non-namespace + type component (the actual type we are converting). */ + + class compile_scope : private std::vector<scope_component> + { + public: + + using std::vector<scope_component>::push_back; + using std::vector<scope_component>::pop_back; + using std::vector<scope_component>::back; + using std::vector<scope_component>::empty; + using std::vector<scope_component>::size; + using std::vector<scope_component>::begin; + using std::vector<scope_component>::end; + using std::vector<scope_component>::operator[]; + + compile_scope () + : m_nested_type (GCC_TYPE_NONE), m_pushed (false) + { + } + + /* Return the gcc_type of the type if it is a nested definition. + Returns GCC_TYPE_NONE if this type was not nested. */ + + gcc_type nested_type () + { + return m_nested_type; + } + + private: + /* compile_cplus_instance is a friend class so that it can set the + following private members when compile_scopes are created. */ + + friend compile_cplus_instance; + + /* If the type was actually a nested type, this will hold that nested + type after the scope is pushed. */ + gcc_type m_nested_type; + + /* If true, this scope was pushed to the compiler and all namespaces + must be popped when leaving the scope. */ + bool m_pushed; + }; + + /* Comparison operators for compile_scopes. */ + + bool operator== (const compile_scope &lhs, const compile_scope &rhs); + bool operator!= (const compile_scope &lhs, const compile_scope &rhs); + + /* Convert TYPENAME into a vector of namespace and top-most/super + composite scopes. + + For example, for the input "Namespace::classB::classInner", the + resultant vector will contain the tokens "Namespace" and + "classB". */ + + compile_scope type_name_to_scope (const char *type_name, + const struct block *block); + + /* A subclass of compile_instance that is specific to the C++ front + end. */ + + class compile_cplus_instance + : public compile_instance + { + public: + + explicit compile_cplus_instance (struct gcc_cp_context *gcc_fe); + + /* If SYM is a template symbol whose generic we have not yet declared, + add it to INSTANCE's list of template definitions and scan for default + values. */ + + void maybe_define_new_function_template (const struct symbol *sym, + struct type *parent_type, + int f_idx, int m_idx); + + /* If TYPE (with declaration name DECL_NAME) represents a concrete instance + of a new class template, note the new template definition. */ + + void maybe_define_new_class_template (struct type *type, + const char *decl_name); + + /* Find the generic template definition for TSYM or NULL if none was + found. */ + + function_template_defn *find_function_template_defn + (struct template_symbol *tsym); + + /* Search for an existing class template definition based on TYPE. + Returns NULL if no template based on TYPE is known. */ + + class_template_defn *find_class_template_defn (struct type *type); + + /* Emit any new function template definitions to the compiler + plug-in. */ + + void emit_function_template_decls (); + + /* Emit any new class template definitions to the compiler + plug-in. */ + + void emit_class_template_decls (); + + /* Convert a gdb type, TYPE, to a GCC type. + + If this type was defined in another type, NESTED_ACCESS should indicate + the accessibility of this type (or GCC_CP_ACCESS_NONE if not a nested + type). GCC_CP_ACCESS_NONE is the default nested access. + + The new GCC type is returned. */ + + gcc_type convert_type + (struct type *type, + enum gcc_cp_symbol_kind nested_access = GCC_CP_ACCESS_NONE); + + /* Factory method to create a new scope based on TYPE with name TYPE_NAME. + [TYPE_NAME could be TYPE_NAME or SYMBOL_NATURAL_NAME.] + + If TYPE is a nested or local definition, nested_type () will return + the gcc_type of the conversion. + + Otherwise, nested_type () is GCC_TYPE_NONE. */ + + compile_scope new_scope (const char *type_name, struct type *type); + + /* Enter the given NEW_SCOPE. */ + + void enter_scope (compile_scope &scope); + + /* Leave the current scope. */ + + void leave_scope (); + + /* Plug-in forwards */ + + gcc_type get_bool_type (); + + gcc_decl build_enum_constant (gcc_type enum_type, const char *name, + unsigned long value); + + gcc_type build_array_type (gcc_type element_type, int num_elements); + + bool build_constant (gcc_type type, const char *name, unsigned long value, + const char *filename, unsigned int line_number); + + gcc_type build_complex_type (gcc_type element_type); + + gcc_type build_function_type (gcc_type return_type, + const struct gcc_type_array *argument_types, + bool is_varargs); + + gcc_type build_method_type (gcc_type class_type, gcc_type func_type, + enum gcc_cp_qualifiers quals, + enum gcc_cp_ref_qualifiers rquals); + + gcc_type build_qualified_type (gcc_type unqualified_type, + enum gcc_cp_qualifiers qualifiers); + + gcc_type build_pointer_to_member_type (gcc_type class_type, + gcc_type member_type); + + gcc_type build_pointer_type (gcc_type base_type); + + gcc_type build_reference_type (gcc_type base_type, + enum gcc_cp_ref_qualifiers rquals); + + gcc_type build_vla_array_type (gcc_type element_type, + const char *upper_bound_name); + + gcc_type build_vector_type (gcc_type element_type, int num_elements); + + gcc_type get_char_type (); + + gcc_type error (const char *message); + + bool finish_enum_type (gcc_type enum_type); + + /* NAME is for debugging only. */ + + bool finish_class_type (const char *name, unsigned long size_in_bytes); + + gcc_type get_float_type (unsigned long size_in_bytes, + const char *builtin_name); + + gcc_type get_int_type (bool is_unsigned, unsigned long size_in_bytes, + const char *builtin_name); + + gcc_expr build_literal_expr (gcc_type type, unsigned long value); + + /* DECL_DESC is for debugging only. */ + + gcc_decl build_decl (const char *decl_desc, const char *name, + enum gcc_cp_symbol_kind sym_kind, + gcc_type sym_type, const char *substitution_name, + gcc_address address, + const char *filename, unsigned int line_number); + + gcc_decl build_field (const char *field_name, gcc_type field_type, + enum gcc_cp_symbol_kind field_flags, + unsigned long bitsize, unsigned long bitpos); + + gcc_type build_type_template_parameter (const char *id, bool pack_p, + gcc_type default_type, + const char *filename, + unsigned int line_number); + + gcc_decl build_value_template_parameter (gcc_type type, const char *id, + gcc_expr default_value, + const char *filename, + unsigned int line_number); + + /* NAME is for debugging only. */ + + bool pop_binding_level (const char *name); + + bool push_namespace (const char *name); + + gcc_decl build_class_template_specialization (struct type *concrete, + const char *filename, + unsigned int line_number); + + gcc_decl build_function_template_specialization + (struct template_symbol *concrete, gcc_address address, + const char *filename, unsigned int line_number); + + /* NAME is for debugging only. */ + + gcc_type start_class_type (const char *name, gcc_decl typedecl, + const struct gcc_vbase_array *base_classes, + const char *filename, + unsigned int line_number); + + gcc_type start_enum_type (const char *name, + gcc_type underlying_int_type, + enum gcc_cp_symbol_kind flags, + const char *filename, + unsigned int line_number); + + /* GENERIC is for debugging only. */ + + bool start_template_decl (const char *generic); + + gcc_type get_void_type (); + + + private: + + /* Default compiler flags for C++. */ + static const char *m_default_cflags; + + /* Enumerate the template arguments of template DEFN into DEST. */ + + void enumerate_template_arguments + (struct gcc_cp_template_args *dest, const template_defn *defn, + const struct template_argument_info *arg_info); + + /* The C++ compile plug-in context. */ + struct gcc_cp_context *m_context; + + /* A cache of function template definitions. */ + std::unique_ptr<function_template_defn_map_t> m_function_template_defns; + + /* A cache of class template definitions. */ + std::unique_ptr<class_template_defn_map_t> m_class_template_defns; + + /* A list of scopes we are processing. */ + std::vector<compile_scope> m_scopes; + }; + + /* Return the declaration name of the natural name NATURAL. + This returns a name with no function arguments or template parameters. + The result must be freed by the caller. */ + + char *decl_name (const char *natural); + + /* Add the qualifiers given by QUALS to BASE. */ + + gcc_type convert_qualified_base (compile_cplus_instance *instance, + gcc_type base, + gcc_cp_qualifiers_flags quals); + + /* Convert TARGET into a pointer type in the given compiler + INSTANCE. */ + + gcc_type convert_pointer_base (compile_cplus_instance *instance, + gcc_type target); + + /* Convert BASE into a reference type in the given compile + INSTANCE. */ + + gcc_type convert_reference_base (compile_cplus_instance *instance, + gcc_type base); + + /* Returns non-zero if the given TYPE represents a varargs function, + zero otherwise. */ + + int is_varargs_p (const struct type *type); + + /* Get the access flag for the NUM'th method of TYPE's FNI'th + fieldlist. */ + + enum gcc_cp_symbol_kind get_method_access_flag (const struct type *type, + int fni, int num); + +/* Maybe canonicalize FIELD_NAME with function field METHOD_FIELD (may + be NULL for non-constructors) and METHOD_TYPE (may not be NULL). + + If the field is not represented by one of the plug-in's "special functions," + (operators, ctors, dtors), return FIELD_NAME. + + Otherwise return the unique plug-in identifier for the function. + + If memory was allocated for the name (required by some function types), + it *OUTNAME will be set and should be used over the return value. It + must subsequently be freed by the caller. + + If the given method should be ignored (not defined to the plug-in), + IGNORE will be true. */ + + const char *maybe_canonicalize_special_function + (const char *field_name, const struct fn_field *method_field, + const struct type *method_type, char **outname, bool *ignore); +}; + +/* A callback suitable for use as the GCC C++ symbol oracle. */ + +extern gcc_cp_oracle_function gcc_cplus_convert_symbol; + +/* A callback suitable for use as the GCC C++ address oracle. */ + +extern gcc_cp_symbol_address_function gcc_cplus_symbol_address; + +/* Callbacks suitable for use as the GCC C++ enter/leave scope requests. */ + +extern gcc_cp_enter_leave_user_expr_scope_function gcc_cplus_enter_scope; +extern gcc_cp_enter_leave_user_expr_scope_function gcc_cplus_leave_scope; + +#endif /* GDB_COMPILE_CPLUS_H */ |