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 (value_type (val));
239 CORE_ADDR address = value_address (val);
240 const gdb_byte *valaddr = value_contents_for_printing (val).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 && value_bytes_available (val, 0, type->length ())
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 temp_len;
271
272 for (temp_len = 0;
273 (temp_len < len
274 && temp_len < options->print_max
275 && extract_unsigned_integer (valaddr + temp_len * eltlen,
276 eltlen, byte_order) != 0);
277 ++temp_len)
278 ;
279
280 /* Force printstr to print ellipses if
281 we've printed the maximum characters and
282 the next character is not \000. */
283 if (temp_len == options->print_max && temp_len < len)
284 {
285 ULONGEST ival
286 = extract_unsigned_integer (valaddr + temp_len * eltlen,
287 eltlen, byte_order);
288 if (ival != 0)
289 force_ellipses = 1;
290 }
291
292 len = temp_len;
293 }
294
295 current_language->printstr (stream, unresolved_elttype, valaddr, len,
296 NULL, force_ellipses, options);
297 }
298 else
299 {
300 unsigned int i = 0;
301 gdb_printf (stream, "{");
302 /* If this is a virtual function table, print the 0th
303 entry specially, and the rest of the members
304 normally. */
305 if (cp_is_vtbl_ptr_type (elttype))
306 {
307 i = 1;
308 gdb_printf (stream, _("%d vtable entries"),
309 len - 1);
310 }
311 value_print_array_elements (val, stream, recurse, options, i);
312 gdb_printf (stream, "}");
313 }
314 }
315 else
316 {
317 /* Array of unspecified length: treat like pointer to first elt. */
318 print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
319 0, address, stream, recurse, options);
320 }
321}
322
323/* c_value_print_inner helper for TYPE_CODE_PTR. */
324
325static void
326c_value_print_ptr (struct value *val, struct ui_file *stream, int recurse,
327 const struct value_print_options *options)
328{
329 if (options->format && options->format != 's')
330 {
331 value_print_scalar_formatted (val, options, 0, stream);
332 return;
333 }
334
335 struct type *type = check_typedef (value_type (val));
336 const gdb_byte *valaddr = value_contents_for_printing (val).data ();
337
338 if (options->vtblprint && cp_is_vtbl_ptr_type (type))
339 {
340 /* Print the unmangled name if desired. */
341 /* Print vtable entry - we only get here if we ARE using
342 -fvtable_thunks. (Otherwise, look under
343 TYPE_CODE_STRUCT.) */
344 CORE_ADDR addr = extract_typed_address (valaddr, type);
345
346 print_function_pointer_address (options, type->arch (), addr, stream);
347 }
348 else
349 {
350 struct type *unresolved_elttype = type->target_type ();
351 struct type *elttype = check_typedef (unresolved_elttype);
352 CORE_ADDR addr = unpack_pointer (type, valaddr);
353
354 print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
355 0, addr, stream, recurse, options);
356 }
357}
358
359/* c_value_print helper for TYPE_CODE_STRUCT and TYPE_CODE_UNION. */
360
361static void
362c_value_print_struct (struct value *val, struct ui_file *stream, int recurse,
363 const struct value_print_options *options)
364{
365 struct type *type = check_typedef (value_type (val));
366
367 if (type->code () == TYPE_CODE_UNION && recurse && !options->unionprint)
368 gdb_printf (stream, "{...}");
369 else if (options->vtblprint && cp_is_vtbl_ptr_type (type))
370 {
371 /* Print the unmangled name if desired. */
372 /* Print vtable entry - we only get here if NOT using
373 -fvtable_thunks. (Otherwise, look under
374 TYPE_CODE_PTR.) */
375 int offset = type->field (VTBL_FNADDR_OFFSET).loc_bitpos () / 8;
376 struct type *field_type = type->field (VTBL_FNADDR_OFFSET).type ();
377 const gdb_byte *valaddr = value_contents_for_printing (val).data ();
378 CORE_ADDR addr = extract_typed_address (valaddr + offset, field_type);
379
380 print_function_pointer_address (options, type->arch (), addr, stream);
381 }
382 else
383 cp_print_value_fields (val, stream, recurse, options, NULL, 0);
384}
385
386/* c_value_print helper for TYPE_CODE_INT. */
387
388static void
389c_value_print_int (struct value *val, struct ui_file *stream,
390 const struct value_print_options *options)
391{
392 if (options->format || options->output_format)
393 {
394 struct value_print_options opts = *options;
395
396 opts.format = (options->format ? options->format
397 : options->output_format);
398 value_print_scalar_formatted (val, &opts, 0, stream);
399 }
400 else
401 {
402 value_print_scalar_formatted (val, options, 0, stream);
403 /* C and C++ has no single byte int type, char is used
404 instead. Since we don't know whether the value is really
405 intended to be used as an integer or a character, print
406 the character equivalent as well. */
407 struct type *type = value_type (val);
408 const gdb_byte *valaddr = value_contents_for_printing (val).data ();
409 if (c_textual_element_type (type, options->format))
410 {
411 gdb_puts (" ", stream);
413 stream);
414 }
415 }
416}
417
418/* See c-lang.h. */
419
420void
421c_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
422 const struct value_print_options *options)
423{
424 struct type *type = value_type (val);
425
427 switch (type->code ())
428 {
429 case TYPE_CODE_ARRAY:
430 c_value_print_array (val, stream, recurse, options);
431 break;
432
433 case TYPE_CODE_PTR:
434 c_value_print_ptr (val, stream, recurse, options);
435 break;
436
437 case TYPE_CODE_UNION:
438 case TYPE_CODE_STRUCT:
439 c_value_print_struct (val, stream, recurse, options);
440 break;
441
442 case TYPE_CODE_CHAR:
443 case TYPE_CODE_INT:
444 c_value_print_int (val, stream, options);
445 break;
446
447 case TYPE_CODE_METHODPTR:
448 case TYPE_CODE_MEMBERPTR:
449 case TYPE_CODE_REF:
450 case TYPE_CODE_RVALUE_REF:
451 case TYPE_CODE_ENUM:
452 case TYPE_CODE_FLAGS:
453 case TYPE_CODE_FUNC:
454 case TYPE_CODE_METHOD:
455 case TYPE_CODE_BOOL:
456 case TYPE_CODE_RANGE:
457 case TYPE_CODE_FLT:
458 case TYPE_CODE_DECFLOAT:
459 case TYPE_CODE_VOID:
460 case TYPE_CODE_ERROR:
461 case TYPE_CODE_UNDEF:
462 case TYPE_CODE_COMPLEX:
463 default:
464 generic_value_print (val, stream, recurse, options, &c_decorations);
465 break;
466 }
467}
468
469
470void
471c_value_print (struct value *val, struct ui_file *stream,
472 const struct value_print_options *options)
473{
474 struct type *type, *real_type;
475 int full, using_enc;
476 LONGEST top;
477 struct value_print_options opts = *options;
478
479 opts.deref_ref = 1;
480
481 /* If it is a pointer, indicate what it points to.
482
483 Print type also if it is a reference.
484
485 C++: if it is a member pointer, we will take care
486 of that when we print it. */
487
488 type = check_typedef (value_type (val));
489
491 {
492 struct type *original_type = value_type (val);
493
494 /* Hack: remove (char *) for char strings. Their
495 type is indicated by the quoted string anyway.
496 (Don't use c_textual_element_type here; quoted strings
497 are always exactly (char *), (wchar_t *), or the like. */
498 if (original_type->code () == TYPE_CODE_PTR
499 && original_type->name () == NULL
500 && original_type->target_type ()->name () != NULL
501 && (strcmp (original_type->target_type ()->name (),
502 "char") == 0
503 || textual_name (original_type->target_type ()->name ())))
504 {
505 /* Print nothing. */
506 }
507 else if (options->objectprint
508 && (type->target_type ()->code () == TYPE_CODE_STRUCT))
509 {
510 int is_ref = TYPE_IS_REFERENCE (type);
511 enum type_code refcode = TYPE_CODE_UNDEF;
512
513 if (is_ref)
514 {
515 val = value_addr (val);
516 refcode = type->code ();
517 }
518
519 /* Pointer to class, check real type of object. */
520 gdb_printf (stream, "(");
521
522 if (value_entirely_available (val))
523 {
524 real_type = value_rtti_indirect_type (val, &full, &top,
525 &using_enc);
526 if (real_type)
527 {
528 /* RTTI entry found. */
529
530 /* Need to adjust pointer value. */
531 val = value_from_pointer (real_type,
532 value_as_address (val) - top);
533
534 /* Note: When we look up RTTI entries, we don't get
535 any information on const or volatile
536 attributes. */
537 }
538 }
539
540 if (is_ref)
541 val = value_ref (value_ind (val), refcode);
542
543 type = value_type (val);
544 type_print (type, "", stream, -1);
545 gdb_printf (stream, ") ");
546 }
547 else
548 {
549 /* normal case */
550 gdb_printf (stream, "(");
551 type_print (value_type (val), "", stream, -1);
552 gdb_printf (stream, ") ");
553 }
554 }
555
556 if (!value_initialized (val))
557 gdb_printf (stream, " [uninitialized] ");
558
559 if (options->objectprint && (type->code () == TYPE_CODE_STRUCT))
560 {
561 /* Attempt to determine real type of object. */
562 real_type = value_rtti_type (val, &full, &top, &using_enc);
563 if (real_type)
564 {
565 /* We have RTTI information, so use it. */
566 val = value_full_object (val, real_type,
567 full, top, using_enc);
568 /* In a destructor we might see a real type that is a
569 superclass of the object's type. In this case it is
570 better to leave the object as-is. */
571 if (!(full
572 && (real_type->length ()
573 < value_enclosing_type (val)->length ())))
574 val = value_cast (real_type, val);
575 gdb_printf (stream, "(%s%s) ",
576 real_type->name (),
577 full ? "" : _(" [incomplete object]"));
578 }
579 else if (type != check_typedef (value_enclosing_type (val)))
580 {
581 /* No RTTI information, so let's do our best. */
582 gdb_printf (stream, "(%s ?) ",
583 value_enclosing_type (val)->name ());
584 val = value_cast (value_enclosing_type (val), val);
585 }
586 }
587
588 common_val_print (val, stream, 0, &opts, current_language);
589}
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:389
void c_value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition c-valprint.c:471
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:362
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:326
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:421
struct type * value_rtti_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition cp-abi.c:107
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition findvar.c:153
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:526
bool demangle
enum bfd_endian type_byte_order(const struct type *type)
Definition gdbtypes.c:4018
bool get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition gdbtypes.c:1220
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:3010
#define TYPE_IS_REFERENCE(t)
Definition gdbtypes.h:156
type_code
Definition gdbtypes.h:99
@ TYPE_CODE_UNDEF
Definition gdbtypes.h:100
#define TYPE_NOTTEXT(t)
Definition gdbtypes.h:129
const struct language_defn * current_language
Definition language.c:83
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition minsyms.c:977
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:767
struct symbol * symbol
Definition symtab.h:1494
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
LONGEST loc_bitpos() const
Definition gdbtypes.h:586
struct type * type() const
Definition gdbtypes.h:559
const char * print_name() const
Definition symtab.h:474
const char * search_name() const
Definition symtab.c:1077
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:193
virtual void printchar(int ch, struct type *chtype, struct ui_file *stream) const
Definition c-lang.c:159
struct type * type() const
Definition symtab.h:1285
struct type * target_type() const
Definition gdbtypes.h:1000
type_code code() const
Definition gdbtypes.h:927
ULONGEST length() const
Definition gdbtypes.h:954
struct field & field(int idx) const
Definition gdbtypes.h:983
gdbarch * arch() const
Definition gdbtypes.c:245
bool is_pointer_or_reference() const
Definition gdbtypes.h:1394
const char * name() const
Definition gdbtypes.h:939
unsigned int print_max
Definition valprint.h:58
enum val_prettyformat prettyformat
Definition valprint.h:30
Definition value.c:181
struct block_symbol lookup_symbol_search_name(const char *search_name, const struct block *block, domain_enum domain)
Definition symtab.c:1979
#define VTBL_FNADDR_OFFSET
Definition symtab.h:1946
@ VAR_DOMAIN
Definition symtab.h:881
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition typeprint.c:391
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3114
void print_spaces(int n, struct ui_file *stream)
Definition utils.c:1947
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1788
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition valops.c:1017
struct type * value_rtti_indirect_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition valops.c:3850
struct value * value_full_object(struct value *argp, struct type *rtype, int xfull, int xtop, int xusing_enc)
Definition valops.c:3916
struct value * value_addr(struct value *arg1)
Definition valops.c:1543
struct value * value_cast(struct type *type, struct value *arg2)
Definition valops.c:408
struct value * value_ind(struct value *arg1)
Definition valops.c:1623
struct value * value_ref(struct value *arg1, enum type_code refcode)
Definition valops.c:1602
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:888
void value_print_scalar_formatted(struct value *val, const struct value_print_options *options, int size, struct ui_file *stream)
Definition valprint.c:1259
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:2598
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:1922
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:1014
void print_function_pointer_address(const struct value_print_options *options, struct gdbarch *gdbarch, CORE_ADDR address, struct ui_file *stream)
Definition valprint.c:1885
int value_bytes_available(const struct value *value, LONGEST offset, LONGEST length)
Definition value.c:391
struct type * value_type(const struct value *value)
Definition value.c:1109
int value_entirely_available(struct value *value)
Definition value.c:408
CORE_ADDR unpack_pointer(struct type *type, const gdb_byte *valaddr)
Definition value.c:3012
CORE_ADDR value_as_address(struct value *val)
Definition value.c:2804
int value_initialized(const struct value *val)
Definition value.c:3992
CORE_ADDR value_address(const struct value *value)
Definition value.c:1607
int value_bits_any_optimized_out(const struct value *value, int bit_offset, int bit_length)
Definition value.c:400
gdb::array_view< const gdb_byte > value_contents_for_printing(struct value *value)
Definition value.c:1265
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition value.c:3651
struct type * value_enclosing_type(const struct value *value)
Definition value.c:1189
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition value.c:2921