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