GDB (xrefs)
Loading...
Searching...
No Matches
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-2023 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
37static int
38textual_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
56int
57c_textual_element_type (struct type *type, char format)
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 (true_type->code () == TYPE_CODE_CHAR)
70 return 1;
71
72 /* Any other character-like types must be integral. */
73 if (true_type->code () != 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 (iter_type->name () && textual_name (iter_type->name ()))
82 return 1;
83
84 if (iter_type->code () != 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 (iter_type->target_type ())
91 iter_type = iter_type->target_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 (true_type->code () == TYPE_CODE_INT
101 && true_type->length () == 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 (true_type->code () == TYPE_CODE_INT
110 && true_type->length () == 1
111 && !TYPE_NOTTEXT (true_type))
112 return 1;
113 }
114
115 return 0;
116}
117
118/* Decorations for C. */
119
121{
122 "",
123 " + ",
124 "i",
125 "true",
126 "false",
127 "void",
128 "{",
129 "}"
130};
131
132/* Print a pointer based on the type of its target.
133
134 Arguments to this functions are roughly the same as those in c_val_print.
135 A difference is that ADDRESS is the address to print, with embedded_offset
136 already added. UNRESOLVED_ELTTYPE and ELTTYPE represent the pointed type,
137 respectively before and after check_typedef. */
138
139static void
140print_unpacked_pointer (struct type *type, struct type *elttype,
141 struct type *unresolved_elttype,
142 const gdb_byte *valaddr, int embedded_offset,
143 CORE_ADDR address, struct ui_file *stream, int recurse,
144 const struct value_print_options *options)
145{
146 int want_space = 0;
147 struct gdbarch *gdbarch = type->arch ();
148
149 if (elttype->code () == TYPE_CODE_FUNC)
150 {
151 /* Try to print what function it points to. */
152 print_function_pointer_address (options, gdbarch, address, stream);
153 return;
154 }
155
156 if (options->symbol_print)
157 want_space = print_address_demangle (options, gdbarch, address, stream,
158 demangle);
159 else if (options->addressprint)
160 {
161 gdb_puts (paddress (gdbarch, address), stream);
162 want_space = 1;
163 }
164
165 /* For a pointer to a textual type, also print the string
166 pointed to, unless pointer is null. */
167
168 if (c_textual_element_type (unresolved_elttype, options->format)
169 && address != 0)
170 {
171 if (want_space)
172 gdb_puts (" ", stream);
173 val_print_string (unresolved_elttype, NULL, address, -1, stream, options);
174 }
175 else if (cp_is_vtbl_member (type))
176 {
177 /* Print vtbl's nicely. */
178 CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
179 struct bound_minimal_symbol msymbol =
180 lookup_minimal_symbol_by_pc (vt_address);
181
182 /* If 'symbol_print' is set, we did the work above. */
183 if (!options->symbol_print
184 && (msymbol.minsym != NULL)
185 && (vt_address == msymbol.value_address ()))
186 {
187 if (want_space)
188 gdb_puts (" ", stream);
189 gdb_puts (" <", stream);
190 gdb_puts (msymbol.minsym->print_name (), stream);
191 gdb_puts (">", stream);
192 want_space = 1;
193 }
194
195 if (vt_address && options->vtblprint)
196 {
197 struct value *vt_val;
198 struct symbol *wsym = NULL;
199 struct type *wtype;
200
201 if (want_space)
202 gdb_puts (" ", stream);
203
204 if (msymbol.minsym != NULL)
205 {
206 const char *search_name = msymbol.minsym->search_name ();
207 wsym = lookup_symbol_search_name (search_name, NULL,
209 }
210
211 if (wsym)
212 {
213 wtype = wsym->type ();
214 }
215 else
216 {
217 wtype = unresolved_elttype;
218 }
219 vt_val = value_at (wtype, vt_address);
220 common_val_print (vt_val, stream, recurse + 1, options,
222 if (options->prettyformat)
223 {
224 gdb_printf (stream, "\n");
225 print_spaces (2 + 2 * recurse, stream);
226 }
227 }
228 }
229}
230
231/* c_value_print helper for TYPE_CODE_ARRAY. */
232
233static void
235 struct ui_file *stream, int recurse,
236 const struct value_print_options *options)
237{
238 struct type *type = check_typedef (val->type ());
239 CORE_ADDR address = val->address ();
240 const gdb_byte *valaddr = val->contents_for_printing ().data ();
241 struct type *unresolved_elttype = type->target_type ();
242 struct type *elttype = check_typedef (unresolved_elttype);
243
244 if (type->length () > 0 && unresolved_elttype->length () > 0)
245 {
246 LONGEST low_bound, high_bound;
247 int eltlen, len;
248 enum bfd_endian byte_order = type_byte_order (type);
249
250 if (!get_array_bounds (type, &low_bound, &high_bound))
251 error (_("Could not determine the array high bound"));
252
253 eltlen = elttype->length ();
254 len = high_bound - low_bound + 1;
255
256 /* Print arrays of textual chars with a string syntax, as
257 long as the entire array is valid. */
258 if (c_textual_element_type (unresolved_elttype,
259 options->format)
260 && val->bytes_available (0, type->length ())
261 && !val->bits_any_optimized_out (0,
262 TARGET_CHAR_BIT * type->length ()))
263 {
264 int force_ellipses = 0;
265
266 /* If requested, look for the first null char and only
267 print elements up to it. */
268 if (options->stop_print_at_null)
269 {
270 unsigned int print_max_chars = get_print_max_chars (options);
271 unsigned int temp_len;
272
273 for (temp_len = 0;
274 (temp_len < len
275 && temp_len < print_max_chars
276 && extract_unsigned_integer (valaddr + temp_len * eltlen,
277 eltlen, byte_order) != 0);
278 ++temp_len)
279 ;
280
281 /* Force printstr to print ellipses if
282 we've printed the maximum characters and
283 the next character is not \000. */
284 if (temp_len == print_max_chars && temp_len < len)
285 {
286 ULONGEST ival
287 = extract_unsigned_integer (valaddr + temp_len * eltlen,
288 eltlen, byte_order);
289 if (ival != 0)
290 force_ellipses = 1;
291 }
292
293 len = temp_len;
294 }
295
296 current_language->printstr (stream, unresolved_elttype, valaddr, len,
297 NULL, force_ellipses, options);
298 }
299 else
300 {
301 unsigned int i = 0;
302 gdb_printf (stream, "{");
303 /* If this is a virtual function table, print the 0th
304 entry specially, and the rest of the members
305 normally. */
306 if (cp_is_vtbl_ptr_type (elttype))
307 {
308 i = 1;
309 gdb_printf (stream, _("%d vtable entries"),
310 len - 1);
311 }
312 value_print_array_elements (val, stream, recurse, options, i);
313 gdb_printf (stream, "}");
314 }
315 }
316 else
317 {
318 /* Array of unspecified length: treat like pointer to first elt. */
319 print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
320 0, address, stream, recurse, options);
321 }
322}
323
324/* c_value_print_inner helper for TYPE_CODE_PTR. */
325
326static void
327c_value_print_ptr (struct value *val, struct ui_file *stream, int recurse,
328 const struct value_print_options *options)
329{
330 if (options->format && options->format != 's')
331 {
332 value_print_scalar_formatted (val, options, 0, stream);
333 return;
334 }
335
336 struct type *type = check_typedef (val->type ());
337 const gdb_byte *valaddr = val->contents_for_printing ().data ();
338
339 if (options->vtblprint && cp_is_vtbl_ptr_type (type))
340 {
341 /* Print the unmangled name if desired. */
342 /* Print vtable entry - we only get here if we ARE using
343 -fvtable_thunks. (Otherwise, look under
344 TYPE_CODE_STRUCT.) */
345 CORE_ADDR addr = extract_typed_address (valaddr, type);
346
347 print_function_pointer_address (options, type->arch (), addr, stream);
348 }
349 else
350 {
351 struct type *unresolved_elttype = type->target_type ();
352 struct type *elttype = check_typedef (unresolved_elttype);
353 CORE_ADDR addr = unpack_pointer (type, valaddr);
354
355 print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
356 0, addr, stream, recurse, options);
357 }
358}
359
360/* c_value_print helper for TYPE_CODE_STRUCT and TYPE_CODE_UNION. */
361
362static void
363c_value_print_struct (struct value *val, struct ui_file *stream, int recurse,
364 const struct value_print_options *options)
365{
366 struct type *type = check_typedef (val->type ());
367
368 if (type->code () == TYPE_CODE_UNION && recurse && !options->unionprint)
369 gdb_printf (stream, "{...}");
370 else if (options->vtblprint && cp_is_vtbl_ptr_type (type))
371 {
372 /* Print the unmangled name if desired. */
373 /* Print vtable entry - we only get here if NOT using
374 -fvtable_thunks. (Otherwise, look under
375 TYPE_CODE_PTR.) */
376 int offset = type->field (VTBL_FNADDR_OFFSET).loc_bitpos () / 8;
377 struct type *field_type = type->field (VTBL_FNADDR_OFFSET).type ();
378 const gdb_byte *valaddr = val->contents_for_printing ().data ();
379 CORE_ADDR addr = extract_typed_address (valaddr + offset, field_type);
380
381 print_function_pointer_address (options, type->arch (), addr, stream);
382 }
383 else
384 cp_print_value_fields (val, stream, recurse, options, NULL, 0);
385}
386
387/* c_value_print helper for TYPE_CODE_INT. */
388
389static void
390c_value_print_int (struct value *val, struct ui_file *stream,
391 const struct value_print_options *options)
392{
393 if (options->format || options->output_format)
394 {
395 struct value_print_options opts = *options;
396
397 opts.format = (options->format ? options->format
398 : options->output_format);
399 value_print_scalar_formatted (val, &opts, 0, stream);
400 }
401 else
402 {
403 value_print_scalar_formatted (val, options, 0, stream);
404 /* C and C++ has no single byte int type, char is used
405 instead. Since we don't know whether the value is really
406 intended to be used as an integer or a character, print
407 the character equivalent as well. */
408 struct type *type = val->type ();
409 const gdb_byte *valaddr = val->contents_for_printing ().data ();
410 if (c_textual_element_type (type, options->format))
411 {
412 gdb_puts (" ", stream);
414 stream);
415 }
416 }
417}
418
419/* See c-lang.h. */
420
421void
422c_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
423 const struct value_print_options *options)
424{
425 struct type *type = val->type ();
426
428 switch (type->code ())
429 {
430 case TYPE_CODE_ARRAY:
431 c_value_print_array (val, stream, recurse, options);
432 break;
433
434 case TYPE_CODE_PTR:
435 c_value_print_ptr (val, stream, recurse, options);
436 break;
437
438 case TYPE_CODE_UNION:
439 case TYPE_CODE_STRUCT:
440 c_value_print_struct (val, stream, recurse, options);
441 break;
442
443 case TYPE_CODE_CHAR:
444 case TYPE_CODE_INT:
445 c_value_print_int (val, stream, options);
446 break;
447
448 case TYPE_CODE_METHODPTR:
449 case TYPE_CODE_MEMBERPTR:
450 case TYPE_CODE_REF:
451 case TYPE_CODE_RVALUE_REF:
452 case TYPE_CODE_ENUM:
453 case TYPE_CODE_FLAGS:
454 case TYPE_CODE_FUNC:
455 case TYPE_CODE_METHOD:
456 case TYPE_CODE_BOOL:
457 case TYPE_CODE_RANGE:
458 case TYPE_CODE_FLT:
459 case TYPE_CODE_DECFLOAT:
460 case TYPE_CODE_VOID:
461 case TYPE_CODE_ERROR:
462 case TYPE_CODE_UNDEF:
463 case TYPE_CODE_COMPLEX:
464 default:
465 generic_value_print (val, stream, recurse, options, &c_decorations);
466 break;
467 }
468}
469
470
471void
472c_value_print (struct value *val, struct ui_file *stream,
473 const struct value_print_options *options)
474{
475 struct type *type, *real_type;
476 int full, using_enc;
477 LONGEST top;
478 struct value_print_options opts = *options;
479
480 opts.deref_ref = true;
481
482 /* If it is a pointer, indicate what it points to.
483
484 Print type also if it is a reference.
485
486 C++: if it is a member pointer, we will take care
487 of that when we print it. */
488
489 type = check_typedef (val->type ());
490
492 {
493 struct type *original_type = val->type ();
494
495 /* Hack: remove (char *) for char strings. Their
496 type is indicated by the quoted string anyway.
497 (Don't use c_textual_element_type here; quoted strings
498 are always exactly (char *), (wchar_t *), or the like. */
499 if (original_type->code () == TYPE_CODE_PTR
500 && original_type->name () == NULL
501 && original_type->target_type ()->name () != NULL
502 && (strcmp (original_type->target_type ()->name (),
503 "char") == 0
504 || textual_name (original_type->target_type ()->name ())))
505 {
506 /* Print nothing. */
507 }
508 else if (options->objectprint
509 && (type->target_type ()->code () == TYPE_CODE_STRUCT))
510 {
511 int is_ref = TYPE_IS_REFERENCE (type);
512 enum type_code refcode = TYPE_CODE_UNDEF;
513
514 if (is_ref)
515 {
516 val = value_addr (val);
517 refcode = type->code ();
518 }
519
520 /* Pointer to class, check real type of object. */
521 gdb_printf (stream, "(");
522
523 if (val->entirely_available ())
524 {
525 real_type = value_rtti_indirect_type (val, &full, &top,
526 &using_enc);
527 if (real_type)
528 {
529 /* RTTI entry found. */
530
531 /* Need to adjust pointer value. */
532 val = value_from_pointer (real_type,
533 value_as_address (val) - top);
534
535 /* Note: When we look up RTTI entries, we don't get
536 any information on const or volatile
537 attributes. */
538 }
539 }
540
541 if (is_ref)
542 val = value_ref (value_ind (val), refcode);
543
544 type = val->type ();
545 type_print (type, "", stream, -1);
546 gdb_printf (stream, ") ");
547 }
548 else
549 {
550 /* normal case */
551 gdb_printf (stream, "(");
552 type_print (val->type (), "", stream, -1);
553 gdb_printf (stream, ") ");
554 }
555 }
556
557 if (!val->initialized ())
558 gdb_printf (stream, " [uninitialized] ");
559
560 if (options->objectprint && (type->code () == TYPE_CODE_STRUCT))
561 {
562 /* Attempt to determine real type of object. */
563 real_type = value_rtti_type (val, &full, &top, &using_enc);
564 if (real_type)
565 {
566 /* We have RTTI information, so use it. */
567 val = value_full_object (val, real_type,
568 full, top, using_enc);
569 /* In a destructor we might see a real type that is a
570 superclass of the object's type. In this case it is
571 better to leave the object as-is. */
572 if (!(full
573 && (real_type->length ()
574 < val->enclosing_type ()->length ())))
575 val = value_cast (real_type, val);
576 gdb_printf (stream, "(%s%s) ",
577 real_type->name (),
578 full ? "" : _(" [incomplete object]"));
579 }
580 else if (type != check_typedef (val->enclosing_type ()))
581 {
582 /* No RTTI information, so let's do our best. */
583 gdb_printf (stream, "(%s ?) ",
584 val->enclosing_type ()->name ());
585 val = value_cast (val->enclosing_type (), val);
586 }
587 }
588
589 common_val_print (val, stream, 0, &opts, current_language);
590}
const char *const name
void cp_print_value_fields(struct value *, struct ui_file *, int, const struct value_print_options *, struct type **, int)
int cp_is_vtbl_member(struct type *)
Definition cp-valprint.c:75
int cp_is_vtbl_ptr_type(struct type *)
Definition cp-valprint.c:64
static void c_value_print_int(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition c-valprint.c:390
void c_value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition c-valprint.c:472
static const struct generic_val_print_decorations c_decorations
Definition c-valprint.c:120
static void c_value_print_array(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options)
Definition c-valprint.c:234
static void c_value_print_struct(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options)
Definition c-valprint.c:363
static void print_unpacked_pointer(struct type *type, struct type *elttype, struct type *unresolved_elttype, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value_print_options *options)
Definition c-valprint.c:140
static int textual_name(const char *name)
Definition c-valprint.c:38
static void c_value_print_ptr(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options)
Definition c-valprint.c:327
int c_textual_element_type(struct type *type, char format)
Definition c-valprint.c:57
void c_value_print_inner(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options)
Definition c-valprint.c:422
struct type * value_rtti_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition cp-abi.c:108
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition findvar.c:152
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
bool demangle
enum bfd_endian type_byte_order(const struct type *type)
Definition gdbtypes.c:3900
bool get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition gdbtypes.c:1211
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:2966
#define TYPE_IS_REFERENCE(t)
Definition gdbtypes.h:139
type_code
Definition gdbtypes.h:82
@ TYPE_CODE_UNDEF
Definition gdbtypes.h:83
#define TYPE_NOTTEXT(t)
Definition gdbtypes.h:112
const struct language_defn * current_language
Definition language.c:82
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition minsyms.c:996
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:769
enum var_types type
Definition scm-param.c:142
struct symbol * symbol
Definition symtab.h:1533
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
LONGEST loc_bitpos() const
Definition gdbtypes.h:611
struct type * type() const
Definition gdbtypes.h:547
const char * print_name() const
Definition symtab.h:475
const char * search_name() const
Definition symtab.c:1106
virtual void printstr(struct ui_file *stream, struct type *elttype, const gdb_byte *string, unsigned int length, const char *encoding, int force_ellipses, const struct value_print_options *options) const
Definition c-lang.c:192
virtual void printchar(int ch, struct type *chtype, struct ui_file *stream) const
Definition c-lang.c:158
struct type * type() const
Definition symtab.h:1331
struct type * target_type() const
Definition gdbtypes.h:1037
type_code code() const
Definition gdbtypes.h:956
ULONGEST length() const
Definition gdbtypes.h:983
struct field & field(int idx) const
Definition gdbtypes.h:1012
gdbarch * arch() const
Definition gdbtypes.c:273
bool is_pointer_or_reference() const
Definition gdbtypes.h:1431
const char * name() const
Definition gdbtypes.h:968
enum val_prettyformat prettyformat
Definition valprint.h:41
Definition value.h:130
bool bits_any_optimized_out(int bit_offset, int bit_length) const
Definition value.c:201
bool bytes_available(LONGEST offset, ULONGEST length) const
Definition value.c:187
bool initialized() const
Definition value.h:342
struct type * enclosing_type() const
Definition value.h:312
bool entirely_available()
Definition value.c:209
struct type * type() const
Definition value.h:180
CORE_ADDR address
Definition value.h:658
gdb::array_view< const gdb_byte > contents_for_printing()
Definition value.c:1100
struct block_symbol lookup_symbol_search_name(const char *search_name, const struct block *block, domain_enum domain)
Definition symtab.c:1976
#define VTBL_FNADDR_OFFSET
Definition symtab.h:2019
@ VAR_DOMAIN
Definition symtab.h:910
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition typeprint.c:388
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void print_spaces(int n, struct ui_file *stream)
Definition utils.c:1968
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1809
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition valops.c:1015
struct type * value_rtti_indirect_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition valops.c:3849
struct value * value_full_object(struct value *argp, struct type *rtype, int xfull, int xtop, int xusing_enc)
Definition valops.c:3915
struct value * value_addr(struct value *arg1)
Definition valops.c:1551
struct value * value_cast(struct type *type, struct value *arg2)
Definition valops.c:403
struct value * value_ind(struct value *arg1)
Definition valops.c:1630
struct value * value_ref(struct value *arg1, enum type_code refcode)
Definition valops.c:1609
void generic_value_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct generic_val_print_decorations *decorations)
Definition valprint.c:907
void value_print_scalar_formatted(struct value *val, const struct value_print_options *options, int size, struct ui_file *stream)
Definition valprint.c:1278
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:2643
void value_print_array_elements(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, unsigned int i)
Definition valprint.c:1941
void common_val_print(struct value *value, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition valprint.c:1033
void print_function_pointer_address(const struct value_print_options *options, struct gdbarch *gdbarch, CORE_ADDR address, struct ui_file *stream)
Definition valprint.c:1904
static unsigned int get_print_max_chars(const struct value_print_options *options)
Definition valprint.h:131
CORE_ADDR unpack_pointer(struct type *type, const gdb_byte *valaddr)
Definition value.c:2843
CORE_ADDR value_as_address(struct value *val)
Definition value.c:2636
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition value.c:3500
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition value.c:2753