1 /* Generic code for supporting multiple C++ ABI's 2 3 Copyright (C) 2001-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "value.h" 22 #include "cp-abi.h" 23 #include "command.h" 24 #include "exceptions.h" 25 #include "gdbcmd.h" 26 #include "ui-out.h" 27 #include "gdb_assert.h" 28 #include "gdb_string.h" 29 30 static struct cp_abi_ops *find_cp_abi (const char *short_name); 31 32 static struct cp_abi_ops current_cp_abi = { "", NULL }; 33 static struct cp_abi_ops auto_cp_abi = { "auto", NULL }; 34 35 #define CP_ABI_MAX 8 36 static struct cp_abi_ops *cp_abis[CP_ABI_MAX]; 37 static int num_cp_abis = 0; 38 39 enum ctor_kinds 40 is_constructor_name (const char *name) 41 { 42 if ((current_cp_abi.is_constructor_name) == NULL) 43 error (_("ABI doesn't define required function is_constructor_name")); 44 return (*current_cp_abi.is_constructor_name) (name); 45 } 46 47 enum dtor_kinds 48 is_destructor_name (const char *name) 49 { 50 if ((current_cp_abi.is_destructor_name) == NULL) 51 error (_("ABI doesn't define required function is_destructor_name")); 52 return (*current_cp_abi.is_destructor_name) (name); 53 } 54 55 int 56 is_vtable_name (const char *name) 57 { 58 if ((current_cp_abi.is_vtable_name) == NULL) 59 error (_("ABI doesn't define required function is_vtable_name")); 60 return (*current_cp_abi.is_vtable_name) (name); 61 } 62 63 int 64 is_operator_name (const char *name) 65 { 66 if ((current_cp_abi.is_operator_name) == NULL) 67 error (_("ABI doesn't define required function is_operator_name")); 68 return (*current_cp_abi.is_operator_name) (name); 69 } 70 71 int 72 baseclass_offset (struct type *type, int index, const gdb_byte *valaddr, 73 int embedded_offset, CORE_ADDR address, 74 const struct value *val) 75 { 76 volatile struct gdb_exception ex; 77 int res = 0; 78 79 gdb_assert (current_cp_abi.baseclass_offset != NULL); 80 81 TRY_CATCH (ex, RETURN_MASK_ERROR) 82 { 83 res = (*current_cp_abi.baseclass_offset) (type, index, valaddr, 84 embedded_offset, 85 address, val); 86 } 87 88 if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR) 89 throw_error (NOT_AVAILABLE_ERROR, 90 _("Cannot determine virtual baseclass offset " 91 "of incomplete object")); 92 else if (ex.reason < 0) 93 throw_exception (ex); 94 else 95 return res; 96 } 97 98 struct value * 99 value_virtual_fn_field (struct value **arg1p, 100 struct fn_field *f, int j, 101 struct type *type, int offset) 102 { 103 if ((current_cp_abi.virtual_fn_field) == NULL) 104 return NULL; 105 return (*current_cp_abi.virtual_fn_field) (arg1p, f, j, 106 type, offset); 107 } 108 109 struct type * 110 value_rtti_type (struct value *v, int *full, 111 int *top, int *using_enc) 112 { 113 struct type *ret = NULL; 114 volatile struct gdb_exception e; 115 116 if ((current_cp_abi.rtti_type) == NULL) 117 return NULL; 118 TRY_CATCH (e, RETURN_MASK_ERROR) 119 { 120 ret = (*current_cp_abi.rtti_type) (v, full, top, using_enc); 121 } 122 if (e.reason < 0) 123 return NULL; 124 return ret; 125 } 126 127 void 128 cplus_print_method_ptr (const gdb_byte *contents, 129 struct type *type, 130 struct ui_file *stream) 131 { 132 if (current_cp_abi.print_method_ptr == NULL) 133 error (_("GDB does not support pointers to methods on this target")); 134 (*current_cp_abi.print_method_ptr) (contents, type, stream); 135 } 136 137 int 138 cplus_method_ptr_size (struct type *to_type) 139 { 140 if (current_cp_abi.method_ptr_size == NULL) 141 error (_("GDB does not support pointers to methods on this target")); 142 return (*current_cp_abi.method_ptr_size) (to_type); 143 } 144 145 void 146 cplus_make_method_ptr (struct type *type, gdb_byte *contents, 147 CORE_ADDR value, int is_virtual) 148 { 149 if (current_cp_abi.make_method_ptr == NULL) 150 error (_("GDB does not support pointers to methods on this target")); 151 (*current_cp_abi.make_method_ptr) (type, contents, value, is_virtual); 152 } 153 154 CORE_ADDR 155 cplus_skip_trampoline (struct frame_info *frame, 156 CORE_ADDR stop_pc) 157 { 158 if (current_cp_abi.skip_trampoline == NULL) 159 return 0; 160 return (*current_cp_abi.skip_trampoline) (frame, stop_pc); 161 } 162 163 struct value * 164 cplus_method_ptr_to_value (struct value **this_p, 165 struct value *method_ptr) 166 { 167 if (current_cp_abi.method_ptr_to_value == NULL) 168 error (_("GDB does not support pointers to methods on this target")); 169 return (*current_cp_abi.method_ptr_to_value) (this_p, method_ptr); 170 } 171 172 /* See cp-abi.h. */ 173 174 void 175 cplus_print_vtable (struct value *value) 176 { 177 if (current_cp_abi.print_vtable == NULL) 178 error (_("GDB cannot print the vtable on this target")); 179 (*current_cp_abi.print_vtable) (value); 180 } 181 182 int 183 cp_pass_by_reference (struct type *type) 184 { 185 if ((current_cp_abi.pass_by_reference) == NULL) 186 return 0; 187 return (*current_cp_abi.pass_by_reference) (type); 188 } 189 190 /* Set the current C++ ABI to SHORT_NAME. */ 191 192 static int 193 switch_to_cp_abi (const char *short_name) 194 { 195 struct cp_abi_ops *abi; 196 197 abi = find_cp_abi (short_name); 198 if (abi == NULL) 199 return 0; 200 201 current_cp_abi = *abi; 202 return 1; 203 } 204 205 /* Add ABI to the list of supported C++ ABI's. */ 206 207 int 208 register_cp_abi (struct cp_abi_ops *abi) 209 { 210 if (num_cp_abis == CP_ABI_MAX) 211 internal_error (__FILE__, __LINE__, 212 _("Too many C++ ABIs, please increase " 213 "CP_ABI_MAX in cp-abi.c")); 214 215 cp_abis[num_cp_abis++] = abi; 216 217 return 1; 218 } 219 220 /* Set the ABI to use in "auto" mode to SHORT_NAME. */ 221 222 void 223 set_cp_abi_as_auto_default (const char *short_name) 224 { 225 char *new_longname, *new_doc; 226 struct cp_abi_ops *abi = find_cp_abi (short_name); 227 228 if (abi == NULL) 229 internal_error (__FILE__, __LINE__, 230 _("Cannot find C++ ABI \"%s\" to set it as auto default."), 231 short_name); 232 233 if (auto_cp_abi.longname != NULL) 234 xfree ((char *) auto_cp_abi.longname); 235 if (auto_cp_abi.doc != NULL) 236 xfree ((char *) auto_cp_abi.doc); 237 238 auto_cp_abi = *abi; 239 240 auto_cp_abi.shortname = "auto"; 241 new_longname = xstrprintf ("currently \"%s\"", abi->shortname); 242 auto_cp_abi.longname = new_longname; 243 244 new_doc = xstrprintf ("Automatically selected; currently \"%s\"", 245 abi->shortname); 246 auto_cp_abi.doc = new_doc; 247 248 /* Since we copy the current ABI into current_cp_abi instead of 249 using a pointer, if auto is currently the default, we need to 250 reset it. */ 251 if (strcmp (current_cp_abi.shortname, "auto") == 0) 252 switch_to_cp_abi ("auto"); 253 } 254 255 /* Return the ABI operations associated with SHORT_NAME. */ 256 257 static struct cp_abi_ops * 258 find_cp_abi (const char *short_name) 259 { 260 int i; 261 262 for (i = 0; i < num_cp_abis; i++) 263 if (strcmp (cp_abis[i]->shortname, short_name) == 0) 264 return cp_abis[i]; 265 266 return NULL; 267 } 268 269 /* Display the list of registered C++ ABIs. */ 270 271 static void 272 list_cp_abis (int from_tty) 273 { 274 struct ui_out *uiout = current_uiout; 275 struct cleanup *cleanup_chain; 276 int i; 277 278 ui_out_text (uiout, "The available C++ ABIs are:\n"); 279 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, 280 "cp-abi-list"); 281 for (i = 0; i < num_cp_abis; i++) 282 { 283 char pad[14]; 284 int padcount; 285 286 ui_out_text (uiout, " "); 287 ui_out_field_string (uiout, "cp-abi", cp_abis[i]->shortname); 288 289 padcount = 16 - 2 - strlen (cp_abis[i]->shortname); 290 pad[padcount] = 0; 291 while (padcount > 0) 292 pad[--padcount] = ' '; 293 ui_out_text (uiout, pad); 294 295 ui_out_field_string (uiout, "doc", cp_abis[i]->doc); 296 ui_out_text (uiout, "\n"); 297 } 298 do_cleanups (cleanup_chain); 299 } 300 301 /* Set the current C++ ABI, or display the list of options if no 302 argument is given. */ 303 304 static void 305 set_cp_abi_cmd (char *args, int from_tty) 306 { 307 if (args == NULL) 308 { 309 list_cp_abis (from_tty); 310 return; 311 } 312 313 if (!switch_to_cp_abi (args)) 314 error (_("Could not find \"%s\" in ABI list"), args); 315 } 316 317 /* A completion function for "set cp-abi". */ 318 319 static VEC (char_ptr) * 320 cp_abi_completer (struct cmd_list_element *ignore, 321 char *text, char *word) 322 { 323 static const char **cp_abi_names; 324 325 if (cp_abi_names == NULL) 326 { 327 int i; 328 329 cp_abi_names = XNEWVEC (const char *, num_cp_abis + 1); 330 for (i = 0; i < num_cp_abis; ++i) 331 cp_abi_names[i] = cp_abis[i]->shortname; 332 cp_abi_names[i] = NULL; 333 } 334 335 return complete_on_enum (cp_abi_names, text, word); 336 } 337 338 /* Show the currently selected C++ ABI. */ 339 340 static void 341 show_cp_abi_cmd (char *args, int from_tty) 342 { 343 struct ui_out *uiout = current_uiout; 344 345 ui_out_text (uiout, "The currently selected C++ ABI is \""); 346 347 ui_out_field_string (uiout, "cp-abi", current_cp_abi.shortname); 348 ui_out_text (uiout, "\" ("); 349 ui_out_field_string (uiout, "longname", current_cp_abi.longname); 350 ui_out_text (uiout, ").\n"); 351 } 352 353 extern initialize_file_ftype _initialize_cp_abi; /* -Wmissing-prototypes */ 354 355 void 356 _initialize_cp_abi (void) 357 { 358 struct cmd_list_element *c; 359 360 register_cp_abi (&auto_cp_abi); 361 switch_to_cp_abi ("auto"); 362 363 c = add_cmd ("cp-abi", class_obscure, set_cp_abi_cmd, _("\ 364 Set the ABI used for inspecting C++ objects.\n\ 365 \"set cp-abi\" with no arguments will list the available ABIs."), 366 &setlist); 367 set_cmd_completer (c, cp_abi_completer); 368 369 add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd, 370 _("Show the ABI used for inspecting C++ objects."), 371 &showlist); 372 } 373