gdb/cp-abi.h

   1 /* Abstraction of various C++ ABI's we support, and the info we need
   2    to get from them.
   3
   4    Contributed by Daniel Berlin <dberlin@redhat.com>
   5
   6    Copyright (C) 2001, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #ifndef CP_ABI_H_
  24 #define CP_ABI_H_ 1
  25
  26 struct fn_field;
  27 struct type;
  28 struct value;
  29 struct ui_file;
  30 struct frame_info;
  31
  32 /* The functions here that attempt to determine what sort of thing a
  33    mangled name refers to may well be revised in the future.  It would
  34    certainly be cleaner to carry this information explicitly in GDB's
  35    data structures than to derive it from the mangled name.  */
  36
  37
  38 /* Kinds of constructors.  All these values are guaranteed to be
  39    non-zero.  */
  40 enum ctor_kinds {
  41
  42   /* Initialize a complete object, including virtual bases, using
  43      memory provided by caller.  */
  44   complete_object_ctor = 1,
  45
  46   /* Initialize a base object of some larger object.  */
  47   base_object_ctor,
  48
  49   /* An allocating complete-object constructor.  */
  50   complete_object_allocating_ctor
  51 };
  52
  53 /* Return non-zero iff NAME is the mangled name of a constructor.
  54    Actually, return an `enum ctor_kind' value describing what *kind*
  55    of constructor it is.  */
  56 extern enum ctor_kinds is_constructor_name (const char *name);
  57
  58
  59 /* Kinds of destructors.  All these values are guaranteed to be
  60    non-zero.  */
  61 enum dtor_kinds {
  62
  63   /* A destructor which finalizes the entire object, and then calls
  64      `delete' on its storage.  */
  65   deleting_dtor = 1,
  66
  67   /* A destructor which finalizes the entire object, but does not call
  68      `delete'.  */
  69   complete_object_dtor,
  70
  71   /* A destructor which finalizes a subobject of some larger object.  */
  72   base_object_dtor
  73 };
  74
  75 /* Return non-zero iff NAME is the mangled name of a destructor.
  76    Actually, return an `enum dtor_kind' value describing what *kind*
  77    of destructor it is.  */
  78 extern enum dtor_kinds is_destructor_name (const char *name);
  79
  80
  81 /* Return non-zero iff NAME is the mangled name of a vtable.  */
  82 extern int is_vtable_name (const char *name);
  83
  84
  85 /* Return non-zero iff NAME is the un-mangled name of an operator,
  86    perhaps scoped within some class.  */
  87 extern int is_operator_name (const char *name);
  88
  89
  90 /* Return an object's virtual function as a value.
  91
  92    VALUEP is a pointer to a pointer to a value, holding the object
  93    whose virtual function we want to invoke.  If the ABI requires a
  94    virtual function's caller to adjust the `this' pointer by an amount
  95    retrieved from the vtable before invoking the function (i.e., we're
  96    not using "vtable thunks" to do the adjustment automatically), then
  97    this function may set *VALUEP to point to a new object with an
  98    appropriately tweaked address.
  99
 100    The J'th element of the overload set F is the virtual function of
 101    *VALUEP we want to invoke.
 102
 103    TYPE is the base type of *VALUEP whose method we're invoking ---
 104    this is the type containing F.  OFFSET is the offset of that base
 105    type within *VALUEP.  */
 106 extern struct value *value_virtual_fn_field (struct value **valuep,
 107                                              struct fn_field *f, int j,
 108                                              struct type *type, int offset);
 109
 110
 111 /* Try to find the run-time type of VALUE, using C++ run-time type
 112    information.  Return the run-time type, or zero if we can't figure
 113    it out.
 114
 115    If we do find the run-time type:
 116    - Set *FULL to non-zero if VALUE already contains the complete
 117      run-time object, not just some embedded base class of the object.
 118    - Set *TOP and *USING_ENC to indicate where the enclosing object
 119      starts relative to VALUE:
 120      - If *USING_ENC is zero, then *TOP is the offset from the start
 121        of the complete object to the start of the embedded subobject
 122        VALUE represents.  In other words, the enclosing object starts
 123        at VALUE_ADDR (VALUE) + VALUE_OFFSET (VALUE) +
 124        value_embedded_offset (VALUE) + *TOP
 125      - If *USING_ENC is non-zero, then *TOP is the offset from the
 126        address of the complete object to the enclosing object stored
 127        in VALUE.  In other words, the enclosing object starts at
 128        VALUE_ADDR (VALUE) + VALUE_OFFSET (VALUE) + *TOP.
 129      If VALUE's type and enclosing type are the same, then these two
 130      cases are equivalent.
 131
 132    FULL, TOP, and USING_ENC can each be zero, in which case we don't
 133    provide the corresponding piece of information.  */
 134 extern struct type *value_rtti_type (struct value *value,
 135                                      int *full, int *top, int *using_enc);
 136
 137 /* Compute the offset of the baseclass which is
 138    the INDEXth baseclass of class TYPE,
 139    for value at VALADDR (in host) at ADDRESS (in target).
 140    The result is the offset of the baseclass value relative
 141    to (the address of)(ARG) + OFFSET.
 142
 143    -1 is returned on error. */
 144
 145 extern int baseclass_offset (struct type *type, int index,
 146                              const bfd_byte *valaddr, CORE_ADDR address);
 147
 148 /* Describe the target of a pointer to method.  CONTENTS is the byte
 149    pattern representing the pointer to method.  TYPE is the pointer to
 150    method type.  STREAM is the stream to print it to.  */
 151 void cplus_print_method_ptr (const gdb_byte *contents, struct type *type,
 152                              struct ui_file *stream);
 153
 154 /* Return the size of a pointer to member function for the current
 155    architecture.  */
 156 int cplus_method_ptr_size (void);
 157
 158 /* Return the method which should be called by applying METHOD_PTR
 159    to *THIS_P, and adjust *THIS_P if necessary.  */
 160 struct value *cplus_method_ptr_to_value (struct value **this_p,
 161                                          struct value *method_ptr);
 162
 163 /* Create the byte pattern in CONTENTS representing a pointer to
 164    member function at ADDRESS (if IS_VIRTUAL is 0) or with virtual
 165    table offset ADDRESS (if IS_VIRTUAL is 1).  This is the opposite
 166    of cplus_method_ptr_to_value.  */
 167 void cplus_make_method_ptr (gdb_byte *CONTENTS, CORE_ADDR address,
 168                             int is_virtual);
 169
 170 /* Determine if we are currently in a C++ thunk.  If so, get the address
 171    of the routine we are thunking to and continue to there instead.  */
 172
 173 CORE_ADDR cplus_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc);
 174
 175 /* Return non-zero if an argument of type TYPE should be passed by reference
 176    instead of value.  */
 177 extern int cp_pass_by_reference (struct type *type);
 178
 179 struct cp_abi_ops
 180 {
 181   const char *shortname;
 182   const char *longname;
 183   const char *doc;
 184
 185   /* ABI-specific implementations for the functions declared above.  */
 186   enum ctor_kinds (*is_constructor_name) (const char *name);
 187   enum dtor_kinds (*is_destructor_name) (const char *name);
 188   int (*is_vtable_name) (const char *name);
 189   int (*is_operator_name) (const char *name);
 190   struct value *(*virtual_fn_field) (struct value **arg1p, struct fn_field * f,
 191                                      int j, struct type * type, int offset);
 192   struct type *(*rtti_type) (struct value *v, int *full, int *top,
 193                              int *using_enc);
 194   int (*baseclass_offset) (struct type *type, int index,
 195                            const bfd_byte *valaddr, CORE_ADDR address);
 196   void (*print_method_ptr) (const gdb_byte *contents, struct type *type,
 197                             struct ui_file *stream);
 198   int (*method_ptr_size) (void);
 199   void (*make_method_ptr) (gdb_byte *, CORE_ADDR, int);
 200   struct value * (*method_ptr_to_value) (struct value **, struct value *);
 201   CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
 202   int (*pass_by_reference) (struct type *type);
 203 };
 204
 205
 206 extern int register_cp_abi (struct cp_abi_ops *abi);
 207 extern void set_cp_abi_as_auto_default (const char *short_name);
 208
 209 #endif
 210