| 1 | /* Header file for GDB compile C++ language support. |
| 2 | Copyright (C) 2016-2019 Free Software Foundation, Inc. |
| 3 | |
| 4 | This program is free software; you can redistribute it and/or modify |
| 5 | it under the terms of the GNU General Public License as published by |
| 6 | the Free Software Foundation; either version 3 of the License, or |
| 7 | (at your option) any later version. |
| 8 | |
| 9 | This program is distributed in the hope that it will be useful, |
| 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 | GNU General Public License for more details. |
| 13 | |
| 14 | You should have received a copy of the GNU General Public License |
| 15 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
| 16 | |
| 17 | #ifndef GDB_COMPILE_CPLUS_H |
| 18 | #define GDB_COMPILE_CPLUS_H |
| 19 | |
| 20 | #include "common/enum-flags.h" |
| 21 | #include "gcc-cp-plugin.h" |
| 22 | |
| 23 | struct type; |
| 24 | struct block; |
| 25 | |
| 26 | /* enum-flags wrapper */ |
| 27 | DEF_ENUM_FLAGS_TYPE (enum gcc_cp_qualifiers, gcc_cp_qualifiers_flags); |
| 28 | DEF_ENUM_FLAGS_TYPE (enum gcc_cp_ref_qualifiers, gcc_cp_ref_qualifiers_flags); |
| 29 | DEF_ENUM_FLAGS_TYPE (enum gcc_cp_symbol_kind, gcc_cp_symbol_kind_flags); |
| 30 | |
| 31 | class compile_cplus_instance; |
| 32 | |
| 33 | /* A single component of a type's scope. Type names are broken into |
| 34 | "components," a series of unqualified names comprising the type name, |
| 35 | e.g., "namespace1", "namespace2", "myclass". */ |
| 36 | |
| 37 | struct scope_component |
| 38 | { |
| 39 | /* The unqualified name of this scope. */ |
| 40 | std::string name; |
| 41 | |
| 42 | /* The block symbol for this type/scope. */ |
| 43 | struct block_symbol bsymbol; |
| 44 | }; |
| 45 | |
| 46 | /* Comparison operators for scope_components. */ |
| 47 | |
| 48 | bool operator== (const scope_component &lhs, const scope_component &rhs); |
| 49 | bool operator!= (const scope_component &lhs, const scope_component &rhs); |
| 50 | |
| 51 | |
| 52 | /* A single compiler scope used to define a type. |
| 53 | |
| 54 | A compile_scope is a list of scope_components, where all leading |
| 55 | scope_components are namespaces, followed by a single non-namespace |
| 56 | type component (the actual type we are converting). */ |
| 57 | |
| 58 | class compile_scope : private std::vector<scope_component> |
| 59 | { |
| 60 | public: |
| 61 | |
| 62 | using std::vector<scope_component>::push_back; |
| 63 | using std::vector<scope_component>::pop_back; |
| 64 | using std::vector<scope_component>::back; |
| 65 | using std::vector<scope_component>::empty; |
| 66 | using std::vector<scope_component>::size; |
| 67 | using std::vector<scope_component>::begin; |
| 68 | using std::vector<scope_component>::end; |
| 69 | using std::vector<scope_component>::operator[]; |
| 70 | |
| 71 | compile_scope () |
| 72 | : m_nested_type (GCC_TYPE_NONE), m_pushed (false) |
| 73 | { |
| 74 | } |
| 75 | |
| 76 | /* Return the gcc_type of the type if it is a nested definition. |
| 77 | Returns GCC_TYPE_NONE if this type was not nested. */ |
| 78 | gcc_type nested_type () |
| 79 | { |
| 80 | return m_nested_type; |
| 81 | } |
| 82 | |
| 83 | private: |
| 84 | |
| 85 | /* compile_cplus_instance is a friend class so that it can set the |
| 86 | following private members when compile_scopes are created. */ |
| 87 | friend compile_cplus_instance; |
| 88 | |
| 89 | /* If the type was actually a nested type, this will hold that nested |
| 90 | type after the scope is pushed. */ |
| 91 | gcc_type m_nested_type; |
| 92 | |
| 93 | /* If true, this scope was pushed to the compiler and all namespaces |
| 94 | must be popped when leaving the scope. */ |
| 95 | bool m_pushed; |
| 96 | }; |
| 97 | |
| 98 | /* Comparison operators for compile_scopes. */ |
| 99 | |
| 100 | bool operator== (const compile_scope &lhs, const compile_scope &rhs); |
| 101 | bool operator!= (const compile_scope &lhs, const compile_scope &rhs); |
| 102 | |
| 103 | /* Convert TYPENAME into a vector of namespace and top-most/super |
| 104 | composite scopes. |
| 105 | |
| 106 | For example, for the input "Namespace::classB::classInner", the |
| 107 | resultant vector will contain the tokens "Namespace" and |
| 108 | "classB". */ |
| 109 | |
| 110 | compile_scope type_name_to_scope (const char *type_name, |
| 111 | const struct block *block); |
| 112 | |
| 113 | /* A callback suitable for use as the GCC C++ symbol oracle. */ |
| 114 | |
| 115 | extern gcc_cp_oracle_function gcc_cplus_convert_symbol; |
| 116 | |
| 117 | /* A callback suitable for use as the GCC C++ address oracle. */ |
| 118 | |
| 119 | extern gcc_cp_symbol_address_function gcc_cplus_symbol_address; |
| 120 | |
| 121 | /* A subclass of compile_instance that is specific to the C++ front |
| 122 | end. */ |
| 123 | |
| 124 | class compile_cplus_instance : public compile_instance |
| 125 | { |
| 126 | public: |
| 127 | |
| 128 | explicit compile_cplus_instance (struct gcc_cp_context *gcc_cp) |
| 129 | : compile_instance (&gcc_cp->base, m_default_cflags), |
| 130 | m_plugin (gcc_cp) |
| 131 | { |
| 132 | m_plugin.set_callbacks (gcc_cplus_convert_symbol, |
| 133 | gcc_cplus_symbol_address, |
| 134 | gcc_cplus_enter_scope, gcc_cplus_leave_scope, |
| 135 | this); |
| 136 | } |
| 137 | |
| 138 | /* Convert a gdb type, TYPE, to a GCC type. |
| 139 | |
| 140 | If this type was defined in another type, NESTED_ACCESS should indicate |
| 141 | the accessibility of this type (or GCC_CP_ACCESS_NONE if not a nested |
| 142 | type). GCC_CP_ACCESS_NONE is the default nested access. |
| 143 | |
| 144 | The new GCC type is returned. */ |
| 145 | gcc_type convert_type |
| 146 | (struct type *type, |
| 147 | enum gcc_cp_symbol_kind nested_access = GCC_CP_ACCESS_NONE); |
| 148 | |
| 149 | /* Return a handle for the GCC plug-in. */ |
| 150 | gcc_cp_plugin &plugin () { return m_plugin; } |
| 151 | |
| 152 | /* Factory method to create a new scope based on TYPE with name TYPE_NAME. |
| 153 | [TYPE_NAME could be TYPE_NAME or SYMBOL_NATURAL_NAME.] |
| 154 | |
| 155 | If TYPE is a nested or local definition, nested_type () will return |
| 156 | the gcc_type of the conversion. |
| 157 | |
| 158 | Otherwise, nested_type () is GCC_TYPE_NONE. */ |
| 159 | compile_scope new_scope (const char *type_name, struct type *type); |
| 160 | |
| 161 | /* Enter the given NEW_SCOPE. */ |
| 162 | void enter_scope (compile_scope &&scope); |
| 163 | |
| 164 | /* Leave the current scope. */ |
| 165 | void leave_scope (); |
| 166 | |
| 167 | /* Add the qualifiers given by QUALS to BASE. */ |
| 168 | gcc_type convert_qualified_base (gcc_type base, |
| 169 | gcc_cp_qualifiers_flags quals); |
| 170 | |
| 171 | /* Convert TARGET into a pointer type. */ |
| 172 | gcc_type convert_pointer_base (gcc_type target); |
| 173 | |
| 174 | /* Convert BASE into a reference type. RQUALS describes the reference. */ |
| 175 | gcc_type convert_reference_base (gcc_type base, |
| 176 | enum gcc_cp_ref_qualifiers rquals); |
| 177 | |
| 178 | /* Return the declaration name of the symbol named NATURAL. |
| 179 | This returns a name with no function arguments or template parameters, |
| 180 | suitable for passing to the compiler plug-in. */ |
| 181 | static gdb::unique_xmalloc_ptr<char> decl_name (const char *natural); |
| 182 | |
| 183 | private: |
| 184 | |
| 185 | /* Callbacks suitable for use as the GCC C++ enter/leave scope requests. */ |
| 186 | static gcc_cp_enter_leave_user_expr_scope_function gcc_cplus_enter_scope; |
| 187 | static gcc_cp_enter_leave_user_expr_scope_function gcc_cplus_leave_scope; |
| 188 | |
| 189 | /* Default compiler flags for C++. */ |
| 190 | static const char *m_default_cflags; |
| 191 | |
| 192 | /* The GCC plug-in. */ |
| 193 | gcc_cp_plugin m_plugin; |
| 194 | |
| 195 | /* A list of scopes we are processing. */ |
| 196 | std::vector<compile_scope> m_scopes; |
| 197 | }; |
| 198 | |
| 199 | /* Get the access flag for the NUM'th method of TYPE's FNI'th |
| 200 | fieldlist. */ |
| 201 | |
| 202 | enum gcc_cp_symbol_kind get_method_access_flag (const struct type *type, |
| 203 | int fni, int num); |
| 204 | |
| 205 | #endif /* GDB_COMPILE_CPLUS_H */ |