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