GDB (xrefs)
Loading...
Searching...
No Matches
f-valprint.c
Go to the documentation of this file.
1/* Support for printing Fortran values for GDB, the GNU debugger.
2
3 Copyright (C) 1993-2023 Free Software Foundation, Inc.
4
5 Contributed by Motorola. Adapted from the C definitions by Farooq Butt
6 (fmbutt@engage.sps.mot.com), additionally worked over by Stan Shebs.
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
23#include "defs.h"
24#include "annotate.h"
25#include "symtab.h"
26#include "gdbtypes.h"
27#include "expression.h"
28#include "value.h"
29#include "valprint.h"
30#include "language.h"
31#include "f-lang.h"
32#include "frame.h"
33#include "gdbcore.h"
34#include "command.h"
35#include "block.h"
36#include "dictionary.h"
37#include "cli/cli-style.h"
38#include "gdbarch.h"
39#include "f-array-walker.h"
40
41static void f77_get_dynamic_length_of_aggregate (struct type *);
42
43LONGEST
45{
46 if (!type->bounds ()->low.is_constant ())
47 error (_("Lower bound may not be '*' in F77"));
48
49 return type->bounds ()->low.const_val ();
50}
51
52LONGEST
54{
55 if (!type->bounds ()->high.is_constant ())
56 {
57 /* We have an assumed size array on our hands. Assume that
58 upper_bound == lower_bound so that we show at least 1 element.
59 If the user wants to see more elements, let him manually ask for 'em
60 and we'll subscript the array and show him. */
61
62 return f77_get_lowerbound (type);
63 }
64
65 return type->bounds ()->high.const_val ();
66}
67
68/* Obtain F77 adjustable array dimensions. */
69
70static void
72{
73 int upper_bound = -1;
74 int lower_bound = 1;
75
76 /* Recursively go all the way down into a possibly multi-dimensional
77 F77 array and get the bounds. For simple arrays, this is pretty
78 easy but when the bounds are dynamic, we must be very careful
79 to add up all the lengths correctly. Not doing this right
80 will lead to horrendous-looking arrays in parameter lists.
81
82 This function also works for strings which behave very
83 similarly to arrays. */
84
85 if (type->target_type ()->code () == TYPE_CODE_ARRAY
86 || type->target_type ()->code () == TYPE_CODE_STRING)
88
89 /* Recursion ends here, start setting up lengths. */
90 lower_bound = f77_get_lowerbound (type);
91 upper_bound = f77_get_upperbound (type);
92
93 /* Patch in a valid length value. */
94 type->set_length ((upper_bound - lower_bound + 1)
96}
97
98/* Per-dimension statistics. */
99
101{
102 /* The type of the index used to address elements in the dimension. */
104
105 /* Total number of elements in the dimension, counted as we go. */
106 int nelts;
107};
108
109/* A class used by FORTRAN_PRINT_ARRAY as a specialisation of the array
110 walking template. This specialisation prints Fortran arrays. */
111
113{
114public:
115 /* Constructor. TYPE is the array type being printed, ADDRESS is the
116 address in target memory for the object of TYPE being printed. VAL is
117 the GDB value (of TYPE) being printed. STREAM is where to print to,
118 RECOURSE is passed through (and prevents infinite recursion), and
119 OPTIONS are the printing control options. */
121 CORE_ADDR address,
122 struct value *val,
123 struct ui_file *stream,
124 int recurse,
125 const struct value_print_options *options)
126 : m_elts (0),
127 m_val (val),
128 m_stream (stream),
129 m_recurse (recurse),
130 m_options (options),
131 m_dimension (0),
132 m_nrepeats (0),
133 m_stats (0)
134 { /* Nothing. */ }
135
136 /* Called while iterating over the array bounds. When SHOULD_CONTINUE is
137 false then we must return false, as we have reached the end of the
138 array bounds for this dimension. However, we also return false if we
139 have printed too many elements (after printing '...'). In all other
140 cases, return true. */
141 bool continue_walking (bool should_continue)
142 {
143 bool cont = should_continue && (m_elts < m_options->print_max);
144 if (!cont && should_continue)
145 gdb_puts ("...", m_stream);
146 return cont;
147 }
148
149 /* Called when we start iterating over a dimension. If it's not the
150 inner most dimension then print an opening '(' character. */
151 void start_dimension (struct type *index_type, LONGEST nelts, bool inner_p)
152 {
153 size_t dim_indx = m_dimension++;
154
155 m_elt_type_prev = nullptr;
156 if (m_stats.size () < m_dimension)
157 {
158 m_stats.resize (m_dimension);
159 m_stats[dim_indx].index_type = index_type;
160 m_stats[dim_indx].nelts = nelts;
161 }
162
163 gdb_puts ("(", m_stream);
164 }
165
166 /* Called when we finish processing a batch of items within a dimension
167 of the array. Depending on whether this is the inner most dimension
168 or not we print different things, but this is all about adding
169 separators between elements, and dimensions of the array. */
170 void finish_dimension (bool inner_p, bool last_p)
171 {
172 gdb_puts (")", m_stream);
173 if (!last_p)
174 gdb_puts (" ", m_stream);
175
176 m_dimension--;
177 }
178
179 /* Called when processing dimensions of the array other than the
180 innermost one. WALK_1 is the walker to normally call, ELT_TYPE is
181 the type of the element being extracted, and ELT_OFF is the offset
182 of the element from the start of array being walked, INDEX_TYPE
183 and INDEX is the type and the value respectively of the element's
184 index in the dimension currently being walked and LAST_P is true
185 only when this is the last element that will be processed in this
186 dimension. */
187 void process_dimension (gdb::function_view<void (struct type *,
188 int, bool)> walk_1,
189 struct type *elt_type, LONGEST elt_off,
190 LONGEST index, bool last_p)
191 {
192 size_t dim_indx = m_dimension - 1;
193 struct type *elt_type_prev = m_elt_type_prev;
194 LONGEST elt_off_prev = m_elt_off_prev;
195 bool repeated = (m_options->repeat_count_threshold < UINT_MAX
196 && elt_type_prev != nullptr
197 && (m_elts + ((m_nrepeats + 1)
198 * m_stats[dim_indx + 1].nelts)
200 && dimension_contents_eq (m_val, elt_type,
201 elt_off_prev, elt_off));
202
203 if (repeated)
204 m_nrepeats++;
205 if (!repeated || last_p)
206 {
207 LONGEST nrepeats = m_nrepeats;
208
209 m_nrepeats = 0;
210 if (nrepeats >= m_options->repeat_count_threshold)
211 {
212 annotate_elt_rep (nrepeats + 1);
213 gdb_printf (m_stream, "%p[<repeats %s times>%p]",
215 plongest (nrepeats + 1),
216 nullptr);
218 if (!repeated)
219 gdb_puts (" ", m_stream);
220 m_elts += nrepeats * m_stats[dim_indx + 1].nelts;
221 }
222 else
223 for (LONGEST i = nrepeats; i > 0; i--)
224 {
225 maybe_print_array_index (m_stats[dim_indx].index_type,
226 index - nrepeats + repeated,
228 walk_1 (elt_type_prev, elt_off_prev, repeated && i == 1);
229 }
230
231 if (!repeated)
232 {
233 /* We need to specially handle the case of hitting `print_max'
234 exactly as recursing would cause lone `(...)' to be printed.
235 And we need to print `...' by hand if the skipped element
236 would be the last one processed, because the subsequent call
237 to `continue_walking' from our caller won't do that. */
238 if (m_elts < m_options->print_max)
239 {
240 maybe_print_array_index (m_stats[dim_indx].index_type, index,
242 walk_1 (elt_type, elt_off, last_p);
243 nrepeats++;
244 }
245 else if (last_p)
246 gdb_puts ("...", m_stream);
247 }
248 }
249
250 m_elt_type_prev = elt_type;
251 m_elt_off_prev = elt_off;
252 }
253
254 /* Called to process an element of ELT_TYPE at offset ELT_OFF from the
255 start of the parent object, where INDEX is the value of the element's
256 index in the dimension currently being walked and LAST_P is true only
257 when this is the last element to be processed in this dimension. */
258 void process_element (struct type *elt_type, LONGEST elt_off,
259 LONGEST index, bool last_p)
260 {
261 size_t dim_indx = m_dimension - 1;
262 struct type *elt_type_prev = m_elt_type_prev;
263 LONGEST elt_off_prev = m_elt_off_prev;
264 bool repeated = false;
265
266 if (m_options->repeat_count_threshold < UINT_MAX
267 && elt_type_prev != nullptr)
268 {
269 /* When printing large arrays this spot is called frequently, so clean
270 up temporary values asap to prevent allocating a large amount of
271 them. */
272 scoped_value_mark free_values;
273 struct value *e_val = value_from_component (m_val, elt_type, elt_off);
274 struct value *e_prev = value_from_component (m_val, elt_type,
275 elt_off_prev);
276 repeated = ((e_prev->entirely_available ()
277 && e_val->entirely_available ()
278 && e_prev->contents_eq (e_val))
279 || (e_prev->entirely_unavailable ()
280 && e_val->entirely_unavailable ()));
281 }
282
283 if (repeated)
284 m_nrepeats++;
285 if (!repeated || last_p || m_elts + 1 == m_options->print_max)
286 {
287 LONGEST nrepeats = m_nrepeats;
288 bool printed = false;
289
290 if (nrepeats != 0)
291 {
292 m_nrepeats = 0;
293 if (nrepeats >= m_options->repeat_count_threshold)
294 {
295 annotate_elt_rep (nrepeats + 1);
296 gdb_printf (m_stream, "%p[<repeats %s times>%p]",
298 plongest (nrepeats + 1),
299 nullptr);
301 }
302 else
303 {
304 /* Extract the element value from the parent value. */
305 struct value *e_val
306 = value_from_component (m_val, elt_type, elt_off_prev);
307
308 for (LONGEST i = nrepeats; i > 0; i--)
309 {
310 maybe_print_array_index (m_stats[dim_indx].index_type,
311 index - i + 1,
315 if (i > 1)
316 gdb_puts (", ", m_stream);
317 }
318 }
319 printed = true;
320 }
321
322 if (!repeated)
323 {
324 /* Extract the element value from the parent value. */
325 struct value *e_val
326 = value_from_component (m_val, elt_type, elt_off);
327
328 if (printed)
329 gdb_puts (", ", m_stream);
330 maybe_print_array_index (m_stats[dim_indx].index_type, index,
334 }
335 if (!last_p)
336 gdb_puts (", ", m_stream);
337 }
338
339 m_elt_type_prev = elt_type;
340 m_elt_off_prev = elt_off;
341 ++m_elts;
342 }
343
344private:
345 /* Called to compare two VAL elements of ELT_TYPE at offsets OFFSET1
346 and OFFSET2 each. Handle subarrays recursively, because they may
347 have been sliced and we do not want to compare any memory contents
348 present between the slices requested. */
349 bool
350 dimension_contents_eq (struct value *val, struct type *type,
351 LONGEST offset1, LONGEST offset2)
352 {
353 if (type->code () == TYPE_CODE_ARRAY
354 && type->target_type ()->code () != TYPE_CODE_CHAR)
355 {
356 /* Extract the range, and get lower and upper bounds. */
357 struct type *range_type = check_typedef (type)->index_type ();
358 LONGEST lowerbound, upperbound;
359 if (!get_discrete_bounds (range_type, &lowerbound, &upperbound))
360 error ("failed to get range bounds");
361
362 /* CALC is used to calculate the offsets for each element. */
364
365 struct type *subarray_type = check_typedef (type->target_type ());
366 for (LONGEST i = lowerbound; i < upperbound + 1; i++)
367 {
368 /* Use the index and the stride to work out a new offset. */
369 LONGEST index_offset = calc.index_offset (i);
370
371 if (!dimension_contents_eq (val, subarray_type,
372 offset1 + index_offset,
373 offset2 + index_offset))
374 return false;
375 }
376 return true;
377 }
378 else
379 {
380 struct value *e_val1 = value_from_component (val, type, offset1);
381 struct value *e_val2 = value_from_component (val, type, offset2);
382
383 return ((e_val1->entirely_available ()
384 && e_val2->entirely_available ()
385 && e_val1->contents_eq (e_val2))
386 || (e_val1->entirely_unavailable ()
387 && e_val2->entirely_unavailable ()));
388 }
389 }
390
391 /* The number of elements printed so far. */
393
394 /* The value from which we are printing elements. */
395 struct value *m_val;
396
397 /* The stream we should print too. */
399
400 /* The recursion counter, passed through when we print each element. */
402
403 /* The print control options. Gives us the maximum number of elements to
404 print, and is passed through to each element that we print. */
405 const struct value_print_options *m_options = nullptr;
406
407 /* The number of the current dimension being handled. */
408 LONGEST m_dimension;
409
410 /* The number of element repetitions in the current series. */
411 LONGEST m_nrepeats;
412
413 /* The type and offset from M_VAL of the element handled in the previous
414 iteration over the current dimension. */
417
418 /* Per-dimension stats. */
419 std::vector<struct dimension_stats> m_stats;
420};
421
422/* This function gets called to print a Fortran array. */
423
424static void
425fortran_print_array (struct type *type, CORE_ADDR address,
426 struct ui_file *stream, int recurse,
427 const struct value *val,
428 const struct value_print_options *options)
429{
431 (type, address, (struct value *) val, stream, recurse, options);
432 p.walk ();
433}
434
435
436/* Decorations for Fortran. */
437
439{
440 "(",
441 ",",
442 ")",
443 ".TRUE.",
444 ".FALSE.",
445 "void",
446 "{",
447 "}"
448};
449
450/* See f-lang.h. */
451
452void
453f_language::value_print_inner (struct value *val, struct ui_file *stream,
454 int recurse,
455 const struct value_print_options *options) const
456{
457 struct type *type = check_typedef (val->type ());
458 struct gdbarch *gdbarch = type->arch ();
459 int printed_field = 0; /* Number of fields printed. */
460 struct type *elttype;
461 CORE_ADDR addr;
462 int index;
463 const gdb_byte *valaddr = val->contents_for_printing ().data ();
464 const CORE_ADDR address = val->address ();
465
466 switch (type->code ())
467 {
468 case TYPE_CODE_STRING:
470 printstr (stream, builtin_type (gdbarch)->builtin_char, valaddr,
471 type->length (), NULL, 0, options);
472 break;
473
474 case TYPE_CODE_ARRAY:
475 if (type->target_type ()->code () != TYPE_CODE_CHAR)
476 fortran_print_array (type, address, stream, recurse, val, options);
477 else
478 {
479 struct type *ch_type = type->target_type ();
480
482 printstr (stream, ch_type, valaddr,
483 type->length () / ch_type->length (), NULL, 0,
484 options);
485 }
486 break;
487
488 case TYPE_CODE_PTR:
489 if (options->format && options->format != 's')
490 {
491 value_print_scalar_formatted (val, options, 0, stream);
492 break;
493 }
494 else
495 {
496 int want_space = 0;
497
498 addr = unpack_pointer (type, valaddr);
499 elttype = check_typedef (type->target_type ());
500
501 if (elttype->code () == TYPE_CODE_FUNC)
502 {
503 /* Try to print what function it points to. */
504 print_function_pointer_address (options, gdbarch, addr, stream);
505 return;
506 }
507
508 if (options->symbol_print)
509 want_space = print_address_demangle (options, gdbarch, addr,
510 stream, demangle);
511 else if (options->addressprint && options->format != 's')
512 {
513 gdb_puts (paddress (gdbarch, addr), stream);
514 want_space = 1;
515 }
516
517 /* For a pointer to char or unsigned char, also print the string
518 pointed to, unless pointer is null. */
519 if (elttype->length () == 1
520 && elttype->code () == TYPE_CODE_INT
521 && (options->format == 0 || options->format == 's')
522 && addr != 0)
523 {
524 if (want_space)
525 gdb_puts (" ", stream);
526 val_print_string (type->target_type (), NULL, addr, -1,
527 stream, options);
528 }
529 return;
530 }
531 break;
532
533 case TYPE_CODE_STRUCT:
534 case TYPE_CODE_UNION:
535 case TYPE_CODE_NAMELIST:
536 /* Starting from the Fortran 90 standard, Fortran supports derived
537 types. */
538 gdb_printf (stream, "( ");
539 for (index = 0; index < type->num_fields (); index++)
540 {
541 struct type *field_type
542 = check_typedef (type->field (index).type ());
543
544 if (field_type->code () != TYPE_CODE_FUNC)
545 {
546 const char *field_name = type->field (index).name ();
547 struct value *field;
548
549 if (type->code () == TYPE_CODE_NAMELIST)
550 {
551 /* While printing namelist items, fetch the appropriate
552 value field before printing its value. */
553 struct block_symbol sym
555 VAR_DOMAIN, nullptr);
556 if (sym.symbol == nullptr)
557 error (_("failed to find symbol for name list component %s"),
558 field_name);
559 field = value_of_variable (sym.symbol, sym.block);
560 }
561 else
562 field = value_field (val, index);
563
564 if (printed_field > 0)
565 gdb_puts (", ", stream);
566
567 if (field_name != NULL)
568 {
570 stream);
571 gdb_puts (" = ", stream);
572 }
573
574 common_val_print (field, stream, recurse + 1,
575 options, current_language);
576
577 ++printed_field;
578 }
579 }
580 gdb_printf (stream, " )");
581 break;
582
583 case TYPE_CODE_BOOL:
584 if (options->format || options->output_format)
585 {
586 struct value_print_options opts = *options;
587 opts.format = (options->format ? options->format
588 : options->output_format);
589 value_print_scalar_formatted (val, &opts, 0, stream);
590 }
591 else
592 {
593 LONGEST longval = value_as_long (val);
594 /* The Fortran standard doesn't specify how logical types are
595 represented. Different compilers use different non zero
596 values to represent logical true. */
597 if (longval == 0)
599 else
601 }
602 break;
603
604 case TYPE_CODE_INT:
605 case TYPE_CODE_REF:
606 case TYPE_CODE_FUNC:
607 case TYPE_CODE_FLAGS:
608 case TYPE_CODE_FLT:
609 case TYPE_CODE_VOID:
610 case TYPE_CODE_ERROR:
611 case TYPE_CODE_RANGE:
612 case TYPE_CODE_UNDEF:
613 case TYPE_CODE_COMPLEX:
614 case TYPE_CODE_CHAR:
615 default:
616 generic_value_print (val, stream, recurse, options, &f_decorations);
617 break;
618 }
619}
620
621static void
622info_common_command_for_block (const struct block *block, const char *comname,
623 int *any_printed)
624{
625 struct value_print_options opts;
626
628
629 for (struct symbol *sym : block_iterator_range (block))
630 if (sym->domain () == COMMON_BLOCK_DOMAIN)
631 {
632 const struct common_block *common = sym->value_common_block ();
633 size_t index;
634
635 gdb_assert (sym->aclass () == LOC_COMMON_BLOCK);
636
637 if (comname && (!sym->linkage_name ()
638 || strcmp (comname, sym->linkage_name ()) != 0))
639 continue;
640
641 if (*any_printed)
642 gdb_putc ('\n');
643 else
644 *any_printed = 1;
645 if (sym->print_name ())
646 gdb_printf (_("Contents of F77 COMMON block '%s':\n"),
647 sym->print_name ());
648 else
649 gdb_printf (_("Contents of blank COMMON block:\n"));
650
651 for (index = 0; index < common->n_entries; index++)
652 {
653 struct value *val = NULL;
654
655 gdb_printf ("%s = ",
656 common->contents[index]->print_name ());
657
658 try
659 {
660 val = value_of_variable (common->contents[index], block);
661 value_print (val, gdb_stdout, &opts);
662 }
663
664 catch (const gdb_exception_error &except)
665 {
667 "<error reading variable: %s>",
668 except.what ());
669 }
670
671 gdb_putc ('\n');
672 }
673 }
674}
675
676/* This function is used to print out the values in a given COMMON
677 block. It will always use the most local common block of the
678 given name. */
679
680static void
681info_common_command (const char *comname, int from_tty)
682{
684 const struct block *block;
685 int values_printed = 0;
686
687 /* We have been told to display the contents of F77 COMMON
688 block supposedly visible in this function. Let us
689 first make sure that it is visible and if so, let
690 us display its contents. */
691
692 fi = get_selected_frame (_("No frame selected"));
693
694 /* The following is generally ripped off from stack.c's routine
695 print_frame_info(). */
696
697 block = get_frame_block (fi, 0);
698 if (block == NULL)
699 {
700 gdb_printf (_("No symbol table info available.\n"));
701 return;
702 }
703
704 while (block)
705 {
706 info_common_command_for_block (block, comname, &values_printed);
707 /* After handling the function's top-level block, stop. Don't
708 continue to its superblock, the block of per-file symbols. */
709 if (block->function ())
710 break;
711 block = block->superblock ();
712 }
713
714 if (!values_printed)
715 {
716 if (comname)
717 gdb_printf (_("No common block '%s'.\n"), comname);
718 else
719 gdb_printf (_("No common blocks.\n"));
720 }
721}
722
724void
726{
727 add_info ("common", info_common_command,
728 _("Print out the values contained in a Fortran COMMON block."));
729}
void annotate_elt_rep_end(void)
Definition annotate.c:587
void annotate_elt_rep(unsigned int repcount)
Definition annotate.c:580
iterator_range< block_iterator_wrapper > block_iterator_range
Definition block.h:553
const struct block * get_frame_block(frame_info_ptr frame, CORE_ADDR *addr_in_block)
Definition blockframe.c:55
ui_file_style style() const
Definition cli-style.c:169
void value_print_inner(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options) const override
Definition f-valprint.c:453
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 override
Definition f-lang.h:172
LONGEST index_offset(LONGEST index)
const struct value_print_options * m_options
Definition f-valprint.c:405
fortran_array_printer_impl(struct type *type, CORE_ADDR address, struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options)
Definition f-valprint.c:120
bool continue_walking(bool should_continue)
Definition f-valprint.c:141
void process_element(struct type *elt_type, LONGEST elt_off, LONGEST index, bool last_p)
Definition f-valprint.c:258
std::vector< struct dimension_stats > m_stats
Definition f-valprint.c:419
void finish_dimension(bool inner_p, bool last_p)
Definition f-valprint.c:170
struct ui_file * m_stream
Definition f-valprint.c:398
struct type * m_elt_type_prev
Definition f-valprint.c:415
void process_dimension(gdb::function_view< void(struct type *, int, bool)> walk_1, struct type *elt_type, LONGEST elt_off, LONGEST index, bool last_p)
Definition f-valprint.c:187
void start_dimension(struct type *index_type, LONGEST nelts, bool inner_p)
Definition f-valprint.c:151
bool dimension_contents_eq(struct value *val, struct type *type, LONGEST offset1, LONGEST offset2)
Definition f-valprint.c:350
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
cli_style_option variable_name_style
cli_style_option metadata_style
void _initialize_f_valprint()
Definition f-valprint.c:725
LONGEST f77_get_lowerbound(struct type *type)
Definition f-valprint.c:44
LONGEST f77_get_upperbound(struct type *type)
Definition f-valprint.c:53
static void fortran_print_array(struct type *type, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *val, const struct value_print_options *options)
Definition f-valprint.c:425
static const struct generic_val_print_decorations f_decorations
Definition f-valprint.c:438
static void info_common_command_for_block(const struct block *block, const char *comname, int *any_printed)
Definition f-valprint.c:622
static void f77_get_dynamic_length_of_aggregate(struct type *)
Definition f-valprint.c:71
static void info_common_command(const char *comname, int from_tty)
Definition f-valprint.c:681
frame_info_ptr get_selected_frame(const char *message)
Definition frame.c:1888
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition stack.c:2570
bool demangle
bool get_discrete_bounds(struct type *type, LONGEST *lowp, LONGEST *highp)
Definition gdbtypes.c:1192
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:2966
@ TYPE_CODE_UNDEF
Definition gdbtypes.h:83
unsigned short offset1
Definition go32-nat.c:7
const struct language_defn * current_language
Definition language.c:82
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
static gdbpy_ref field_name(struct type *type, int field)
Definition py-type.c:234
const struct block * block
Definition symtab.h:1537
struct symbol * symbol
Definition symtab.h:1533
Definition block.h:109
const block * superblock() const
Definition block.h:135
symbol * function() const
Definition block.h:127
struct symbol * contents[1]
Definition f-lang.h:313
size_t n_entries
Definition f-lang.h:309
struct type * index_type
Definition f-valprint.c:103
LONGEST const_val() const
Definition gdbtypes.h:330
bool is_constant() const
Definition gdbtypes.h:345
const char * name() const
Definition gdbtypes.h:557
struct type * type() const
Definition gdbtypes.h:547
const char * print_name() const
Definition symtab.h:475
struct dynamic_prop high
Definition gdbtypes.h:721
struct dynamic_prop low
Definition gdbtypes.h:717
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
unsigned int num_fields() const
Definition gdbtypes.h:994
gdbarch * arch() const
Definition gdbtypes.c:273
void set_length(ULONGEST length)
Definition gdbtypes.h:988
range_bounds * bounds() const
Definition gdbtypes.h:1065
type * index_type() const
Definition gdbtypes.h:1032
const ui_file_style * ptr() const
Definition ui-style.h:233
unsigned int print_max
Definition valprint.h:68
unsigned int repeat_count_threshold
Definition valprint.h:76
Definition value.h:130
bool entirely_unavailable()
Definition value.h:506
bool entirely_available()
Definition value.c:209
struct type * type() const
Definition value.h:180
bool contents_eq(LONGEST offset1, const struct value *val2, LONGEST offset2, LONGEST length) const
Definition value.c:693
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(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition symtab.c:1964
@ LOC_COMMON_BLOCK
Definition symtab.h:1070
@ VAR_DOMAIN
Definition symtab.h:910
@ COMMON_BLOCK_DOMAIN
Definition symtab.h:928
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void gdb_putc(int c)
Definition utils.c:1862
void fprintf_styled(struct ui_file *stream, const ui_file_style &style, const char *format,...)
Definition utils.c:1898
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void fputs_styled(const char *linebuffer, const ui_file_style &style, struct ui_file *stream)
Definition utils.c:1817
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1809
#define gdb_stdout
Definition utils.h:182
struct value * value_of_variable(struct symbol *var, const struct block *b)
Definition valops.c:1386
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(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition valprint.c:1191
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 get_user_print_options(struct value_print_options *opts)
Definition valprint.c:135
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
void maybe_print_array_index(struct type *index_type, LONGEST index, struct ui_file *stream, const struct value_print_options *options)
Definition valprint.c:1928
struct value * value_from_component(struct value *whole, struct type *type, LONGEST offset)
Definition value.c:3657
struct value * value_field(struct value *arg1, int fieldno)
Definition value.c:3052
CORE_ADDR unpack_pointer(struct type *type, const gdb_byte *valaddr)
Definition value.c:2843
LONGEST value_as_long(struct value *val)
Definition value.c:2554