]> Git Repo - binutils.git/blob - gdb/cp-abi.c
gdb: remove SYMBOL_CLASS macro, add getter
[binutils.git] / gdb / cp-abi.c
1 /* Generic code for supporting multiple C++ ABI's
2
3    Copyright (C) 2001-2022 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 (const gdb_exception_error &ex)
83     {
84       if (ex.error != NOT_AVAILABLE_ERROR)
85         throw;
86
87       throw_error (NOT_AVAILABLE_ERROR,
88                    _("Cannot determine virtual baseclass offset "
89                      "of incomplete object"));
90     }
91
92   return res;
93 }
94
95 struct value *
96 value_virtual_fn_field (struct value **arg1p,
97                         struct fn_field *f, int j,
98                         struct type *type, int offset)
99 {
100   if ((current_cp_abi.virtual_fn_field) == NULL)
101     return NULL;
102   return (*current_cp_abi.virtual_fn_field) (arg1p, f, j,
103                                              type, offset);
104 }
105
106 struct type *
107 value_rtti_type (struct value *v, int *full,
108                  LONGEST *top, int *using_enc)
109 {
110   struct type *ret = NULL;
111
112   if ((current_cp_abi.rtti_type) == NULL
113       || !HAVE_CPLUS_STRUCT (check_typedef (value_type (v))))
114     return NULL;
115   try
116     {
117       ret = (*current_cp_abi.rtti_type) (v, full, top, using_enc);
118     }
119   catch (const gdb_exception_error &e)
120     {
121       return NULL;
122     }
123
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 std::string
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 /* See cp-abi.h.  */
224
225 struct language_pass_by_ref_info
226 cp_pass_by_reference (struct type *type)
227 {
228   if ((current_cp_abi.pass_by_reference) == NULL)
229     return {};
230   return (*current_cp_abi.pass_by_reference) (type);
231 }
232
233 /* Set the current C++ ABI to SHORT_NAME.  */
234
235 static int
236 switch_to_cp_abi (const char *short_name)
237 {
238   struct cp_abi_ops *abi;
239
240   abi = find_cp_abi (short_name);
241   if (abi == NULL)
242     return 0;
243
244   current_cp_abi = *abi;
245   return 1;
246 }
247
248 /* Add ABI to the list of supported C++ ABI's.  */
249
250 int
251 register_cp_abi (struct cp_abi_ops *abi)
252 {
253   if (num_cp_abis == CP_ABI_MAX)
254     internal_error (__FILE__, __LINE__,
255                     _("Too many C++ ABIs, please increase "
256                       "CP_ABI_MAX in cp-abi.c"));
257
258   cp_abis[num_cp_abis++] = abi;
259
260   return 1;
261 }
262
263 /* Set the ABI to use in "auto" mode to SHORT_NAME.  */
264
265 void
266 set_cp_abi_as_auto_default (const char *short_name)
267 {
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   xfree ((char *) auto_cp_abi.longname);
276   xfree ((char *) auto_cp_abi.doc);
277
278   auto_cp_abi = *abi;
279
280   auto_cp_abi.shortname = "auto";
281   auto_cp_abi.longname = xstrprintf ("currently \"%s\"",
282                                      abi->shortname).release ();
283   auto_cp_abi.doc = xstrprintf ("Automatically selected; currently \"%s\"",
284                                 abi->shortname).release ();
285
286   /* Since we copy the current ABI into current_cp_abi instead of
287      using a pointer, if auto is currently the default, we need to
288      reset it.  */
289   if (strcmp (current_cp_abi.shortname, "auto") == 0)
290     switch_to_cp_abi ("auto");
291 }
292
293 /* Return the ABI operations associated with SHORT_NAME.  */
294
295 static struct cp_abi_ops *
296 find_cp_abi (const char *short_name)
297 {
298   int i;
299
300   for (i = 0; i < num_cp_abis; i++)
301     if (strcmp (cp_abis[i]->shortname, short_name) == 0)
302       return cp_abis[i];
303
304   return NULL;
305 }
306
307 /* Display the list of registered C++ ABIs.  */
308
309 static void
310 list_cp_abis (int from_tty)
311 {
312   struct ui_out *uiout = current_uiout;
313   int i;
314
315   uiout->text ("The available C++ ABIs are:\n");
316   ui_out_emit_tuple tuple_emitter (uiout, "cp-abi-list");
317   for (i = 0; i < num_cp_abis; i++)
318     {
319       char pad[14];
320       int padcount;
321
322       uiout->text ("  ");
323       uiout->field_string ("cp-abi", cp_abis[i]->shortname);
324
325       padcount = 16 - 2 - strlen (cp_abis[i]->shortname);
326       pad[padcount] = 0;
327       while (padcount > 0)
328         pad[--padcount] = ' ';
329       uiout->text (pad);
330
331       uiout->field_string ("doc", cp_abis[i]->doc);
332       uiout->text ("\n");
333     }
334 }
335
336 /* Set the current C++ ABI, or display the list of options if no
337    argument is given.  */
338
339 static void
340 set_cp_abi_cmd (const char *args, int from_tty)
341 {
342   if (args == NULL)
343     {
344       list_cp_abis (from_tty);
345       return;
346     }
347
348   if (!switch_to_cp_abi (args))
349     error (_("Could not find \"%s\" in ABI list"), args);
350 }
351
352 /* A completion function for "set cp-abi".  */
353
354 static void
355 cp_abi_completer (struct cmd_list_element *ignore,
356                   completion_tracker &tracker,
357                   const char *text, const char *word)
358 {
359   static const char **cp_abi_names;
360
361   if (cp_abi_names == NULL)
362     {
363       int i;
364
365       cp_abi_names = XNEWVEC (const char *, num_cp_abis + 1);
366       for (i = 0; i < num_cp_abis; ++i)
367         cp_abi_names[i] = cp_abis[i]->shortname;
368       cp_abi_names[i] = NULL;
369     }
370
371   complete_on_enum (tracker, cp_abi_names, text, word);
372 }
373
374 /* Show the currently selected C++ ABI.  */
375
376 static void
377 show_cp_abi_cmd (const char *args, int from_tty)
378 {
379   struct ui_out *uiout = current_uiout;
380
381   uiout->text ("The currently selected C++ ABI is \"");
382
383   uiout->field_string ("cp-abi", current_cp_abi.shortname);
384   uiout->text ("\" (");
385   uiout->field_string ("longname", current_cp_abi.longname);
386   uiout->text (").\n");
387 }
388
389 void _initialize_cp_abi ();
390 void
391 _initialize_cp_abi ()
392 {
393   struct cmd_list_element *c;
394
395   register_cp_abi (&auto_cp_abi);
396   switch_to_cp_abi ("auto");
397
398   c = add_cmd ("cp-abi", class_obscure, set_cp_abi_cmd, _("\
399 Set the ABI used for inspecting C++ objects.\n\
400 \"set cp-abi\" with no arguments will list the available ABIs."),
401                &setlist);
402   set_cmd_completer (c, cp_abi_completer);
403
404   add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd,
405            _("Show the ABI used for inspecting C++ objects."),
406            &showlist);
407 }
This page took 0.049201 seconds and 4 git commands to generate.