gdb/compile/compile-cplus.h

   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 */