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 COMPILE_COMPILE_CPLUS_H 18 #define COMPILE_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 /* COMPILE_COMPILE_CPLUS_H */ 206