Support structure offsets that are 512K or larger.
[external/binutils.git] / gdb / cp-abi.c
1 /* Generic code for supporting multiple C++ ABI's
2
3    Copyright (C) 2001-2016 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 char *
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   struct cleanup *cleanup_chain;
318   int i;
319
320   ui_out_text (uiout, "The available C++ ABIs are:\n");
321   cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
322                                                        "cp-abi-list");
323   for (i = 0; i < num_cp_abis; i++)
324     {
325       char pad[14];
326       int padcount;
327
328       ui_out_text (uiout, "  ");
329       ui_out_field_string (uiout, "cp-abi", cp_abis[i]->shortname);
330
331       padcount = 16 - 2 - strlen (cp_abis[i]->shortname);
332       pad[padcount] = 0;
333       while (padcount > 0)
334         pad[--padcount] = ' ';
335       ui_out_text (uiout, pad);
336
337       ui_out_field_string (uiout, "doc", cp_abis[i]->doc);
338       ui_out_text (uiout, "\n");
339     }
340   do_cleanups (cleanup_chain);
341 }
342
343 /* Set the current C++ ABI, or display the list of options if no
344    argument is given.  */
345
346 static void
347 set_cp_abi_cmd (char *args, int from_tty)
348 {
349   if (args == NULL)
350     {
351       list_cp_abis (from_tty);
352       return;
353     }
354
355   if (!switch_to_cp_abi (args))
356     error (_("Could not find \"%s\" in ABI list"), args);
357 }
358
359 /* A completion function for "set cp-abi".  */
360
361 static VEC (char_ptr) *
362 cp_abi_completer (struct cmd_list_element *ignore,
363                   const char *text, const char *word)
364 {
365   static const char **cp_abi_names;
366
367   if (cp_abi_names == NULL)
368     {
369       int i;
370
371       cp_abi_names = XNEWVEC (const char *, num_cp_abis + 1);
372       for (i = 0; i < num_cp_abis; ++i)
373         cp_abi_names[i] = cp_abis[i]->shortname;
374       cp_abi_names[i] = NULL;
375     }
376
377   return complete_on_enum (cp_abi_names, text, word);
378 }
379
380 /* Show the currently selected C++ ABI.  */
381
382 static void
383 show_cp_abi_cmd (char *args, int from_tty)
384 {
385   struct ui_out *uiout = current_uiout;
386
387   ui_out_text (uiout, "The currently selected C++ ABI is \"");
388
389   ui_out_field_string (uiout, "cp-abi", current_cp_abi.shortname);
390   ui_out_text (uiout, "\" (");
391   ui_out_field_string (uiout, "longname", current_cp_abi.longname);
392   ui_out_text (uiout, ").\n");
393 }
394
395 extern initialize_file_ftype _initialize_cp_abi; /* -Wmissing-prototypes */
396
397 void
398 _initialize_cp_abi (void)
399 {
400   struct cmd_list_element *c;
401
402   register_cp_abi (&auto_cp_abi);
403   switch_to_cp_abi ("auto");
404
405   c = add_cmd ("cp-abi", class_obscure, set_cp_abi_cmd, _("\
406 Set the ABI used for inspecting C++ objects.\n\
407 \"set cp-abi\" with no arguments will list the available ABIs."),
408                &setlist);
409   set_cmd_completer (c, cp_abi_completer);
410
411   add_cmd ("cp-abi", class_obscure, show_cp_abi_cmd,
412            _("Show the ABI used for inspecting C++ objects."),
413            &showlist);
414 }