make exec_ops static
[external/binutils.git] / gdb / c-valprint.c
1 /* Support for printing C values for GDB, the GNU debugger.
2
3    Copyright (C) 1986-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 <string.h>
22 #include "symtab.h"
23 #include "gdbtypes.h"
24 #include "expression.h"
25 #include "value.h"
26 #include "valprint.h"
27 #include "language.h"
28 #include "c-lang.h"
29 #include "cp-abi.h"
30 #include "target.h"
31 #include "objfiles.h"
32 \f
33
34 /* A helper for c_textual_element_type.  This checks the name of the
35    typedef.  This is bogus but it isn't apparent that the compiler
36    provides us the help we may need.  */
37
38 static int
39 textual_name (const char *name)
40 {
41   return (!strcmp (name, "wchar_t")
42           || !strcmp (name, "char16_t")
43           || !strcmp (name, "char32_t"));
44 }
45
46 /* Apply a heuristic to decide whether an array of TYPE or a pointer
47    to TYPE should be printed as a textual string.  Return non-zero if
48    it should, or zero if it should be treated as an array of integers
49    or pointer to integers.  FORMAT is the current format letter, or 0
50    if none.
51
52    We guess that "char" is a character.  Explicitly signed and
53    unsigned character types are also characters.  Integer data from
54    vector types is not.  The user can override this by using the /s
55    format letter.  */
56
57 int
58 c_textual_element_type (struct type *type, char format)
59 {
60   struct type *true_type, *iter_type;
61
62   if (format != 0 && format != 's')
63     return 0;
64
65   /* We also rely on this for its side effect of setting up all the
66      typedef pointers.  */
67   true_type = check_typedef (type);
68
69   /* TYPE_CODE_CHAR is always textual.  */
70   if (TYPE_CODE (true_type) == TYPE_CODE_CHAR)
71     return 1;
72
73   /* Any other character-like types must be integral.  */
74   if (TYPE_CODE (true_type) != TYPE_CODE_INT)
75     return 0;
76
77   /* We peel typedefs one by one, looking for a match.  */
78   iter_type = type;
79   while (iter_type)
80     {
81       /* Check the name of the type.  */
82       if (TYPE_NAME (iter_type) && textual_name (TYPE_NAME (iter_type)))
83         return 1;
84
85       if (TYPE_CODE (iter_type) != TYPE_CODE_TYPEDEF)
86         break;
87
88       /* Peel a single typedef.  If the typedef doesn't have a target
89          type, we use check_typedef and hope the result is ok -- it
90          might be for C++, where wchar_t is a built-in type.  */
91       if (TYPE_TARGET_TYPE (iter_type))
92         iter_type = TYPE_TARGET_TYPE (iter_type);
93       else
94         iter_type = check_typedef (iter_type);
95     }
96
97   if (format == 's')
98     {
99       /* Print this as a string if we can manage it.  For now, no wide
100          character support.  */
101       if (TYPE_CODE (true_type) == TYPE_CODE_INT
102           && TYPE_LENGTH (true_type) == 1)
103         return 1;
104     }
105   else
106     {
107       /* If a one-byte TYPE_CODE_INT is missing the not-a-character
108          flag, then we treat it as text; otherwise, we assume it's
109          being used as data.  */
110       if (TYPE_CODE (true_type) == TYPE_CODE_INT
111           && TYPE_LENGTH (true_type) == 1
112           && !TYPE_NOTTEXT (true_type))
113         return 1;
114     }
115
116   return 0;
117 }
118
119 /* Decorations for C.  */
120
121 static const struct generic_val_print_decorations c_decorations =
122 {
123   "",
124   " + ",
125   " * I",
126   "true",
127   "false",
128   "void"
129 };
130
131 /* See val_print for a description of the various parameters of this
132    function; they are identical.  */
133
134 void
135 c_val_print (struct type *type, const gdb_byte *valaddr,
136              int embedded_offset, CORE_ADDR address,
137              struct ui_file *stream, int recurse,
138              const struct value *original_value,
139              const struct value_print_options *options)
140 {
141   struct gdbarch *gdbarch = get_type_arch (type);
142   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
143   unsigned int i = 0;   /* Number of characters printed.  */
144   unsigned len;
145   struct type *elttype, *unresolved_elttype;
146   struct type *unresolved_type = type;
147   unsigned eltlen;
148   CORE_ADDR addr;
149
150   CHECK_TYPEDEF (type);
151   switch (TYPE_CODE (type))
152     {
153     case TYPE_CODE_ARRAY:
154       unresolved_elttype = TYPE_TARGET_TYPE (type);
155       elttype = check_typedef (unresolved_elttype);
156       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
157         {
158           LONGEST low_bound, high_bound;
159
160           if (!get_array_bounds (type, &low_bound, &high_bound))
161             error (_("Could not determine the array high bound"));
162
163           eltlen = TYPE_LENGTH (elttype);
164           len = high_bound - low_bound + 1;
165           if (options->prettyformat_arrays)
166             {
167               print_spaces_filtered (2 + 2 * recurse, stream);
168             }
169
170           /* Print arrays of textual chars with a string syntax, as
171              long as the entire array is valid.  */
172           if (c_textual_element_type (unresolved_elttype,
173                                       options->format)
174               && value_bytes_available (original_value, embedded_offset,
175                                         TYPE_LENGTH (type))
176               && value_bits_valid (original_value,
177                                    TARGET_CHAR_BIT * embedded_offset,
178                                    TARGET_CHAR_BIT * TYPE_LENGTH (type)))
179             {
180               int force_ellipses = 0;
181
182               /* If requested, look for the first null char and only
183                  print elements up to it.  */
184               if (options->stop_print_at_null)
185                 {
186                   unsigned int temp_len;
187
188                   for (temp_len = 0;
189                        (temp_len < len
190                         && temp_len < options->print_max
191                         && extract_unsigned_integer (valaddr + embedded_offset
192                                                      + temp_len * eltlen,
193                                                      eltlen, byte_order) != 0);
194                        ++temp_len)
195                     ;
196
197                   /* Force LA_PRINT_STRING to print ellipses if
198                      we've printed the maximum characters and
199                      the next character is not \000.  */
200                   if (temp_len == options->print_max && temp_len < len)
201                     {
202                       ULONGEST val
203                         = extract_unsigned_integer (valaddr + embedded_offset
204                                                     + temp_len * eltlen,
205                                                     eltlen, byte_order);
206                       if (val != 0)
207                         force_ellipses = 1;
208                     }
209
210                   len = temp_len;
211                 }
212
213               LA_PRINT_STRING (stream, unresolved_elttype,
214                                valaddr + embedded_offset, len,
215                                NULL, force_ellipses, options);
216               i = len;
217             }
218           else
219             {
220               fprintf_filtered (stream, "{");
221               /* If this is a virtual function table, print the 0th
222                  entry specially, and the rest of the members
223                  normally.  */
224               if (cp_is_vtbl_ptr_type (elttype))
225                 {
226                   i = 1;
227                   fprintf_filtered (stream, _("%d vtable entries"),
228                                     len - 1);
229                 }
230               else
231                 {
232                   i = 0;
233                 }
234               val_print_array_elements (type, valaddr, embedded_offset,
235                                         address, stream,
236                                         recurse, original_value, options, i);
237               fprintf_filtered (stream, "}");
238             }
239           break;
240         }
241       /* Array of unspecified length: treat like pointer to first
242          elt.  */
243       addr = address + embedded_offset;
244       goto print_unpacked_pointer;
245
246     case TYPE_CODE_METHODPTR:
247       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
248       break;
249
250     case TYPE_CODE_PTR:
251       if (options->format && options->format != 's')
252         {
253           val_print_scalar_formatted (type, valaddr, embedded_offset,
254                                       original_value, options, 0, stream);
255           break;
256         }
257       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
258         {
259           /* Print the unmangled name if desired.  */
260           /* Print vtable entry - we only get here if we ARE using
261              -fvtable_thunks.  (Otherwise, look under
262              TYPE_CODE_STRUCT.)  */
263           CORE_ADDR addr
264             = extract_typed_address (valaddr + embedded_offset, type);
265
266           print_function_pointer_address (options, gdbarch, addr, stream);
267           break;
268         }
269       unresolved_elttype = TYPE_TARGET_TYPE (type);
270       elttype = check_typedef (unresolved_elttype);
271         {
272           int want_space;
273
274           addr = unpack_pointer (type, valaddr + embedded_offset);
275         print_unpacked_pointer:
276
277           want_space = 0;
278
279           if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
280             {
281               /* Try to print what function it points to.  */
282               print_function_pointer_address (options, gdbarch, addr, stream);
283               return;
284             }
285
286           if (options->symbol_print)
287             want_space = print_address_demangle (options, gdbarch, addr,
288                                                  stream, demangle);
289           else if (options->addressprint)
290             {
291               fputs_filtered (paddress (gdbarch, addr), stream);
292               want_space = 1;
293             }
294
295           /* For a pointer to a textual type, also print the string
296              pointed to, unless pointer is null.  */
297
298           if (c_textual_element_type (unresolved_elttype,
299                                       options->format)
300               && addr != 0)
301             {
302               if (want_space)
303                 fputs_filtered (" ", stream);
304               i = val_print_string (unresolved_elttype, NULL,
305                                     addr, -1,
306                                     stream, options);
307             }
308           else if (cp_is_vtbl_member (type))
309             {
310               /* Print vtbl's nicely.  */
311               CORE_ADDR vt_address = unpack_pointer (type,
312                                                      valaddr
313                                                      + embedded_offset);
314               struct bound_minimal_symbol msymbol =
315                 lookup_minimal_symbol_by_pc (vt_address);
316
317               /* If 'symbol_print' is set, we did the work above.  */
318               if (!options->symbol_print
319                   && (msymbol.minsym != NULL)
320                   && (vt_address == BMSYMBOL_VALUE_ADDRESS (msymbol)))
321                 {
322                   if (want_space)
323                     fputs_filtered (" ", stream);
324                   fputs_filtered (" <", stream);
325                   fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), stream);
326                   fputs_filtered (">", stream);
327                   want_space = 1;
328                 }
329
330               if (vt_address && options->vtblprint)
331                 {
332                   struct value *vt_val;
333                   struct symbol *wsym = (struct symbol *) NULL;
334                   struct type *wtype;
335                   struct block *block = (struct block *) NULL;
336                   struct field_of_this_result is_this_fld;
337
338                   if (want_space)
339                     fputs_filtered (" ", stream);
340
341                   if (msymbol.minsym != NULL)
342                     wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
343                                           block, VAR_DOMAIN,
344                                           &is_this_fld);
345
346                   if (wsym)
347                     {
348                       wtype = SYMBOL_TYPE (wsym);
349                     }
350                   else
351                     {
352                       wtype = unresolved_elttype;
353                     }
354                   vt_val = value_at (wtype, vt_address);
355                   common_val_print (vt_val, stream, recurse + 1,
356                                     options, current_language);
357                   if (options->prettyformat)
358                     {
359                       fprintf_filtered (stream, "\n");
360                       print_spaces_filtered (2 + 2 * recurse, stream);
361                     }
362                 }
363             }
364           return;
365         }
366       break;
367
368     case TYPE_CODE_UNION:
369       if (recurse && !options->unionprint)
370         {
371           fprintf_filtered (stream, "{...}");
372           break;
373         }
374       /* Fall through.  */
375     case TYPE_CODE_STRUCT:
376       /*FIXME: Abstract this away.  */
377       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
378         {
379           /* Print the unmangled name if desired.  */
380           /* Print vtable entry - we only get here if NOT using
381              -fvtable_thunks.  (Otherwise, look under
382              TYPE_CODE_PTR.)  */
383           int offset = (embedded_offset
384                         + TYPE_FIELD_BITPOS (type,
385                                              VTBL_FNADDR_OFFSET) / 8);
386           struct type *field_type = TYPE_FIELD_TYPE (type,
387                                                      VTBL_FNADDR_OFFSET);
388           CORE_ADDR addr
389             = extract_typed_address (valaddr + offset, field_type);
390
391           print_function_pointer_address (options, gdbarch, addr, stream);
392         }
393       else
394         cp_print_value_fields_rtti (type, valaddr,
395                                     embedded_offset, address,
396                                     stream, recurse,
397                                     original_value, options,
398                                     NULL, 0);
399       break;
400
401     case TYPE_CODE_INT:
402       if (options->format || options->output_format)
403         {
404           struct value_print_options opts = *options;
405
406           opts.format = (options->format ? options->format
407                          : options->output_format);
408           val_print_scalar_formatted (type, valaddr, embedded_offset,
409                                       original_value, &opts, 0, stream);
410         }
411       else
412         {
413           val_print_type_code_int (type, valaddr + embedded_offset,
414                                    stream);
415           /* C and C++ has no single byte int type, char is used
416              instead.  Since we don't know whether the value is really
417              intended to be used as an integer or a character, print
418              the character equivalent as well.  */
419           if (c_textual_element_type (unresolved_type, options->format))
420             {
421               fputs_filtered (" ", stream);
422               LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
423                              unresolved_type, stream);
424             }
425         }
426       break;
427
428     case TYPE_CODE_MEMBERPTR:
429       if (!options->format)
430         {
431           cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
432           break;
433         }
434       /* FALLTHROUGH */
435
436     case TYPE_CODE_REF:
437     case TYPE_CODE_ENUM:
438     case TYPE_CODE_FLAGS:
439     case TYPE_CODE_FUNC:
440     case TYPE_CODE_METHOD:
441     case TYPE_CODE_BOOL:
442     case TYPE_CODE_RANGE:
443     case TYPE_CODE_FLT:
444     case TYPE_CODE_DECFLOAT:
445     case TYPE_CODE_VOID:
446     case TYPE_CODE_ERROR:
447     case TYPE_CODE_UNDEF:
448     case TYPE_CODE_COMPLEX:
449     case TYPE_CODE_CHAR:
450     default:
451       generic_val_print (type, valaddr, embedded_offset, address,
452                          stream, recurse, original_value, options,
453                          &c_decorations);
454       break;
455     }
456   gdb_flush (stream);
457 }
458 \f
459 void
460 c_value_print (struct value *val, struct ui_file *stream, 
461                const struct value_print_options *options)
462 {
463   struct type *type, *real_type, *val_type;
464   int full, top, using_enc;
465   struct value_print_options opts = *options;
466
467   opts.deref_ref = 1;
468
469   /* If it is a pointer, indicate what it points to.
470
471      Print type also if it is a reference.
472
473      C++: if it is a member pointer, we will take care
474      of that when we print it.  */
475
476   /* Preserve the original type before stripping typedefs.  We prefer
477      to pass down the original type when possible, but for local
478      checks it is better to look past the typedefs.  */
479   val_type = value_type (val);
480   type = check_typedef (val_type);
481
482   if (TYPE_CODE (type) == TYPE_CODE_PTR
483       || TYPE_CODE (type) == TYPE_CODE_REF)
484     {
485       /* Hack:  remove (char *) for char strings.  Their
486          type is indicated by the quoted string anyway.
487          (Don't use c_textual_element_type here; quoted strings
488          are always exactly (char *), (wchar_t *), or the like.  */
489       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
490           && TYPE_NAME (val_type) == NULL
491           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
492           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
493                       "char") == 0
494               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
495         {
496           /* Print nothing.  */
497         }
498       else if (options->objectprint
499                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
500         {
501           int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
502
503           if (is_ref)
504             val = value_addr (val);
505
506           /* Pointer to class, check real type of object.  */
507           fprintf_filtered (stream, "(");
508
509           if (value_entirely_available (val))
510             {
511               real_type = value_rtti_indirect_type (val, &full, &top,
512                                                     &using_enc);
513               if (real_type)
514                 {
515                   /* RTTI entry found.  */
516                   type = real_type;
517
518                   /* Need to adjust pointer value.  */
519                   val = value_from_pointer (real_type,
520                                             value_as_address (val) - top);
521
522                   if (is_ref)
523                     {
524                       val = value_ref (value_ind (val));
525                       type = value_type (val);
526                     }
527
528                   /* Note: When we look up RTTI entries, we don't get
529                      any information on const or volatile
530                      attributes.  */
531                 }
532             }
533           type_print (type, "", stream, -1);
534           fprintf_filtered (stream, ") ");
535           val_type = type;
536         }
537       else
538         {
539           /* normal case */
540           fprintf_filtered (stream, "(");
541           type_print (value_type (val), "", stream, -1);
542           fprintf_filtered (stream, ") ");
543         }
544     }
545
546   if (!value_initialized (val))
547     fprintf_filtered (stream, " [uninitialized] ");
548
549   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
550     {
551       /* Attempt to determine real type of object.  */
552       real_type = value_rtti_type (val, &full, &top, &using_enc);
553       if (real_type)
554         {
555           /* We have RTTI information, so use it.  */
556           val = value_full_object (val, real_type, 
557                                    full, top, using_enc);
558           fprintf_filtered (stream, "(%s%s) ",
559                             TYPE_NAME (real_type),
560                             full ? "" : _(" [incomplete object]"));
561           /* Print out object: enclosing type is same as real_type if
562              full.  */
563           val_print (value_enclosing_type (val),
564                      value_contents_for_printing (val), 0,
565                      value_address (val), stream, 0,
566                      val, &opts, current_language);
567           return;
568           /* Note: When we look up RTTI entries, we don't get any
569              information on const or volatile attributes.  */
570         }
571       else if (type != check_typedef (value_enclosing_type (val)))
572         {
573           /* No RTTI information, so let's do our best.  */
574           fprintf_filtered (stream, "(%s ?) ",
575                             TYPE_NAME (value_enclosing_type (val)));
576           val_print (value_enclosing_type (val),
577                      value_contents_for_printing (val), 0,
578                      value_address (val), stream, 0,
579                      val, &opts, current_language);
580           return;
581         }
582       /* Otherwise, we end up at the return outside this "if".  */
583     }
584
585   val_print (val_type, value_contents_for_printing (val),
586              value_embedded_offset (val),
587              value_address (val),
588              stream, 0,
589              val, &opts, current_language);
590 }