PR c++/13588:
[external/binutils.git] / gdb / cp-abi.c
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 /* See cp-abi.h.  */
183
184 struct value *
185 cplus_typeid (struct value *value)
186 {
187   if (current_cp_abi.get_typeid == NULL)
188     error (_("GDB cannot find the typeid on this target"));
189   return (*current_cp_abi.get_typeid) (value);
190 }
191
192 /* See cp-abi.h.  */
193
194 struct type *
195 cplus_typeid_type (struct gdbarch *gdbarch)
196 {
197   if (current_cp_abi.get_typeid_type == NULL)
198     error (_("GDB cannot find the type for 'typeid' on this target"));
199   return (*current_cp_abi.get_typeid_type) (gdbarch);
200 }
201
202 /* See cp-abi.h.  */
203
204 struct type *
205 cplus_type_from_type_info (struct value *value)
206 {
207   if (current_cp_abi.get_type_from_type_info == NULL)
208     error (_("GDB cannot find the type from a std::type_info on this target"));
209   return (*current_cp_abi.get_type_from_type_info) (value);
210 }
211
212 /* See cp-abi.h.  */
213
214 char *
215 cplus_typename_from_type_info (struct value *value)
216 {
217   if (current_cp_abi.get_typename_from_type_info == NULL)
218     error (_("GDB cannot find the type name "
219              "from a std::type_info on this target"));
220   return (*current_cp_abi.get_typename_from_type_info) (value);
221 }
222
223 int
224 cp_pass_by_reference (struct type *type)
225 {
226   if ((current_cp_abi.pass_by_reference) == NULL)
227     return 0;
228   return (*current_cp_abi.pass_by_reference) (type);
229 }
230
231 /* Set the current C++ ABI to SHORT_NAME.  */
232
233 static int
234 switch_to_cp_abi (const char *short_name)
235 {
236   struct cp_abi_ops *abi;
237
238   abi = find_cp_abi (short_name);
239   if (abi == NULL)
240     return 0;
241
242   current_cp_abi = *abi;
243   return 1;
244 }
245
246 /* Add ABI to the list of supported C++ ABI's.  */
247
248 int
249 register_cp_abi (struct cp_abi_ops *abi)
250 {
251   if (num_cp_abis == CP_ABI_MAX)
252     internal_error (__FILE__, __LINE__,
253                     _("Too many C++ ABIs, please increase "
254                       "CP_ABI_MAX in cp-abi.c"));
255
256   cp_abis[num_cp_abis++] = abi;
257
258   return 1;
259 }
260
261 /* Set the ABI to use in "auto" mode to SHORT_NAME.  */
262
263 void
264 set_cp_abi_as_auto_default (const char *short_name)
265 {
266   char *new_longname, *new_doc;
267   struct cp_abi_ops *abi = find_cp_abi (short_name);
268
269   if (abi == NULL)
270     internal_error (__FILE__, __LINE__,
271                     _("Cannot find C++ ABI \"%s\" to set it as auto default."),
272                     short_name);
273
274   if (auto_cp_abi.longname != NULL)
275     xfree ((char *) auto_cp_abi.longname);
276   if (auto_cp_abi.doc != NULL)
277     xfree ((char *) auto_cp_abi.doc);
278
279   auto_cp_abi = *abi;
280
281   auto_cp_abi.shortname = "auto";
282   new_longname = xstrprintf ("currently \"%s\"", abi->shortname);
283   auto_cp_abi.longname = new_longname;
284
285   new_doc = xstrprintf ("Automatically selected; currently \"%s\"",
286              abi->shortname);
287   auto_cp_abi.doc = new_doc;
288
289   /* Since we copy the current ABI into current_cp_abi instead of
290      using a pointer, if auto is currently the default, we need to
291      reset it.  */
292   if (strcmp (current_cp_abi.shortname, "auto") == 0)
293     switch_to_cp_abi ("auto");
294 }
295
296 /* Return the ABI operations associated with SHORT_NAME.  */
297
298 static struct cp_abi_ops *
299 find_cp_abi (const char *short_name)
300 {
301   int i;
302
303   for (i = 0; i < num_cp_abis; i++)
304     if (strcmp (cp_abis[i]->shortname, short_name) == 0)
305       return cp_abis[i];
306
307   return NULL;
308 }
309
310 /* Display the list of registered C++ ABIs.  */
311
312 static void
313 list_cp_abis (int from_tty)
314 {
315   struct ui_out *uiout = current_uiout;
316   struct cleanup *cleanup_chain;
317   int i;
318
319   ui_out_text (uiout, "The available C++ ABIs are:\n");
320   cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
321                                                        "cp-abi-list");
322   for (i = 0; i < num_cp_abis; i++)
323     {
324       char pad[14];
325       int padcount;
326
327       ui_out_text (uiout, "  ");
328       ui_out_field_string (uiout, "cp-abi", cp_abis[i]->shortname);
329
330       padcount = 16 - 2 - strlen (cp_abis[i]->shortname);
331       pad[padcount] = 0;
332       while (padcount > 0)
333         pad[--padcount] = ' ';
334       ui_out_text (uiout, pad);
335
336       ui_out_field_string (uiout, "doc", cp_abis[i]->doc);
337       ui_out_text (uiout, "\n");
338     }
339   do_cleanups (cleanup_chain);
340 }
341
342 /* Set the current C++ ABI, or display the list of options if no
343    argument is given.  */
344
345 static void
346 set_cp_abi_cmd (char *args, int from_tty)
347 {
348   if (args == NULL)
349     {
350       list_cp_abis (from_tty);
351       return;
352     }
353
354   if (!switch_to_cp_abi (args))
355     error (_("Could not find \"%s\" in ABI list"), args);
356 }
357
358 /* A completion function for "set cp-abi".  */
359
360 static VEC (char_ptr) *
361 cp_abi_completer (struct cmd_list_element *ignore,
362                   const char *text, const char *word)
363 {
364   static const char **cp_abi_names;
365
366   if (cp_abi_names == NULL)
367     {
368       int i;
369
370       cp_abi_names = XNEWVEC (const char *, num_cp_abis + 1);
371       for (i = 0; i < num_cp_abis; ++i)
372         cp_abi_names[i] = cp_abis[i]->shortname;
373       cp_abi_names[i] = NULL;
374     }
375
376   return complete_on_enum (cp_abi_names, text, word);
377 }
378
379 /* Show the currently selected C++ ABI.  */
380
381 static void
382 show_cp_abi_cmd (char *args, int from_tty)
383 {
384   struct ui_out *uiout = current_uiout;
385
386   ui_out_text (uiout, "The currently selected C++ ABI is \"");
387
388   ui_out_field_string (uiout, "cp-abi", current_cp_abi.shortname);
389   ui_out_text (uiout, "\" (");
390   ui_out_field_string (uiout, "longname", current_cp_abi.longname);
391   ui_out_text (uiout, ").\n");
392 }
393
394 extern initialize_file_ftype _initialize_cp_abi; /* -Wmissing-prototypes */
395
396 void
397 _initialize_cp_abi (void)
398 {
399   struct cmd_list_element *c;
400
401   register_cp_abi (&auto_cp_abi);
402   switch_to_cp_abi ("auto");
403
404   c = add_cmd ("cp-abi", class_obscure, set_cp_abi_cmd, _("\
405 Set the ABI used for inspecting C++ objects.\n\
406 \"set cp-abi\" with no arguments will list the available ABIs."),
407                &setlist);
408   set_cmd_completer (c, cp_abi_completer);
409
410   add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd,
411            _("Show the ABI used for inspecting C++ objects."),
412            &showlist);
413 }