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