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