GDB (xrefs)
Loading...
Searching...
No Matches
findvar.c
Go to the documentation of this file.
1/* Find a variable's value in memory, 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 "frame.h"
24#include "value.h"
25#include "gdbcore.h"
26#include "inferior.h"
27#include "target.h"
28#include "symfile.h"
29#include "regcache.h"
30#include "user-regs.h"
31#include "block.h"
32#include "objfiles.h"
33#include "language.h"
34#include "gdbsupport/selftest.h"
35
36/* Basic byte-swapping routines. All 'extract' functions return a
37 host-format integer from a target-format integer at ADDR which is
38 LEN bytes long. */
39
40#if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
41 /* 8 bit characters are a pretty safe assumption these days, so we
42 assume it throughout all these swapping routines. If we had to deal with
43 9 bit characters, we would need to make len be in bits and would have
44 to re-write these routines... */
45you lose
46#endif
47
48template<typename T, typename>
49T
50extract_integer (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order)
51{
52 typename std::make_unsigned<T>::type retval = 0;
53
54 if (buf.size () > (int) sizeof (T))
55 error (_("\
56That operation is not available on integers of more than %d bytes."),
57 (int) sizeof (T));
58
59 /* Start at the most significant end of the integer, and work towards
60 the least significant. */
61 if (byte_order == BFD_ENDIAN_BIG)
62 {
63 size_t i = 0;
64
65 if (std::is_signed<T>::value)
66 {
67 /* Do the sign extension once at the start. */
68 retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
69 ++i;
70 }
71 for (; i < buf.size (); ++i)
72 retval = (retval << 8) | buf[i];
73 }
74 else
75 {
76 ssize_t i = buf.size () - 1;
77
78 if (std::is_signed<T>::value)
79 {
80 /* Do the sign extension once at the start. */
81 retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
82 --i;
83 }
84 for (; i >= 0; --i)
85 retval = (retval << 8) | buf[i];
86 }
87 return retval;
88}
89
90/* Explicit instantiations. */
91template LONGEST extract_integer<LONGEST> (gdb::array_view<const gdb_byte> buf,
92 enum bfd_endian byte_order);
94 (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order);
95
96/* Sometimes a long long unsigned integer can be extracted as a
97 LONGEST value. This is done so that we can print these values
98 better. If this integer can be converted to a LONGEST, this
99 function returns 1 and sets *PVAL. Otherwise it returns 0. */
100
101int
102extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
103 enum bfd_endian byte_order, LONGEST *pval)
104{
105 const gdb_byte *p;
106 const gdb_byte *first_addr;
107 int len;
108
109 len = orig_len;
110 if (byte_order == BFD_ENDIAN_BIG)
111 {
112 for (p = addr;
113 len > (int) sizeof (LONGEST) && p < addr + orig_len;
114 p++)
115 {
116 if (*p == 0)
117 len--;
118 else
119 break;
120 }
121 first_addr = p;
122 }
123 else
124 {
125 first_addr = addr;
126 for (p = addr + orig_len - 1;
127 len > (int) sizeof (LONGEST) && p >= addr;
128 p--)
129 {
130 if (*p == 0)
131 len--;
132 else
133 break;
134 }
135 }
136
137 if (len <= (int) sizeof (LONGEST))
138 {
139 *pval = (LONGEST) extract_unsigned_integer (first_addr,
140 sizeof (LONGEST),
141 byte_order);
142 return 1;
143 }
144
145 return 0;
146}
147
148
149/* Treat the bytes at BUF as a pointer of type TYPE, and return the
150 address it represents. */
151CORE_ADDR
152extract_typed_address (const gdb_byte *buf, struct type *type)
153{
154 gdb_assert (type->is_pointer_or_reference ());
155 return gdbarch_pointer_to_address (type->arch (), type, buf);
156}
157
158/* All 'store' functions accept a host-format integer and store a
159 target-format integer at ADDR which is LEN bytes long. */
160template<typename T, typename>
161void
162store_integer (gdb_byte *addr, int len, enum bfd_endian byte_order,
163 T val)
164{
165 gdb_byte *p;
166 gdb_byte *startaddr = addr;
167 gdb_byte *endaddr = startaddr + len;
168
169 /* Start at the least significant end of the integer, and work towards
170 the most significant. */
171 if (byte_order == BFD_ENDIAN_BIG)
172 {
173 for (p = endaddr - 1; p >= startaddr; --p)
174 {
175 *p = val & 0xff;
176 val >>= 8;
177 }
178 }
179 else
180 {
181 for (p = startaddr; p < endaddr; ++p)
182 {
183 *p = val & 0xff;
184 val >>= 8;
185 }
186 }
187}
188
189/* Explicit instantiations. */
190template void store_integer (gdb_byte *addr, int len,
191 enum bfd_endian byte_order,
192 LONGEST val);
193
194template void store_integer (gdb_byte *addr, int len,
195 enum bfd_endian byte_order,
196 ULONGEST val);
197
198/* Store the address ADDR as a pointer of type TYPE at BUF, in target
199 form. */
200void
201store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
202{
203 gdb_assert (type->is_pointer_or_reference ());
204 gdbarch_address_to_pointer (type->arch (), type, buf, addr);
205}
206
207/* Copy a value from SOURCE of size SOURCE_SIZE bytes to DEST of size DEST_SIZE
208 bytes. If SOURCE_SIZE is greater than DEST_SIZE, then truncate the most
209 significant bytes. If SOURCE_SIZE is less than DEST_SIZE then either sign
210 or zero extended according to IS_SIGNED. Values are stored in memory with
211 endianness BYTE_ORDER. */
212
213void
214copy_integer_to_size (gdb_byte *dest, int dest_size, const gdb_byte *source,
215 int source_size, bool is_signed,
216 enum bfd_endian byte_order)
217{
218 signed int size_diff = dest_size - source_size;
219
220 /* Copy across everything from SOURCE that can fit into DEST. */
221
222 if (byte_order == BFD_ENDIAN_BIG && size_diff > 0)
223 memcpy (dest + size_diff, source, source_size);
224 else if (byte_order == BFD_ENDIAN_BIG && size_diff < 0)
225 memcpy (dest, source - size_diff, dest_size);
226 else
227 memcpy (dest, source, std::min (source_size, dest_size));
228
229 /* Fill the remaining space in DEST by either zero extending or sign
230 extending. */
231
232 if (size_diff > 0)
233 {
234 gdb_byte extension = 0;
235 if (is_signed
236 && ((byte_order != BFD_ENDIAN_BIG && source[source_size - 1] & 0x80)
237 || (byte_order == BFD_ENDIAN_BIG && source[0] & 0x80)))
238 extension = 0xff;
239
240 /* Extend into MSBs of SOURCE. */
241 if (byte_order == BFD_ENDIAN_BIG)
242 memset (dest, extension, size_diff);
243 else
244 memset (dest + source_size, extension, size_diff);
245 }
246}
247
248/* Return a `value' with the contents of (virtual or cooked) register
249 REGNUM as found in the specified FRAME. The register's type is
250 determined by register_type (). */
251
252struct value *
254{
255 struct gdbarch *gdbarch = get_frame_arch (frame);
256 struct value *reg_val;
257
258 /* User registers lie completely outside of the range of normal
259 registers. Catch them early so that the target never sees them. */
261 return value_of_user_reg (regnum, frame);
262
263 reg_val = value_of_register_lazy (frame, regnum);
264 reg_val->fetch_lazy ();
265 return reg_val;
266}
267
268/* Return a `value' with the contents of (virtual or cooked) register
269 REGNUM as found in the specified FRAME. The register's type is
270 determined by register_type (). The value is not fetched. */
271
272struct value *
274{
275 struct gdbarch *gdbarch = get_frame_arch (frame);
276 struct value *reg_val;
277 frame_info_ptr next_frame;
278
279 gdb_assert (regnum < gdbarch_num_cooked_regs (gdbarch));
280
281 gdb_assert (frame != NULL);
282
283 next_frame = get_next_frame_sentinel_okay (frame);
284
285 /* In some cases NEXT_FRAME may not have a valid frame-id yet. This can
286 happen if we end up trying to unwind a register as part of the frame
287 sniffer. The only time that we get here without a valid frame-id is
288 if NEXT_FRAME is an inline frame. If this is the case then we can
289 avoid getting into trouble here by skipping past the inline frames. */
290 while (get_frame_type (next_frame) == INLINE_FRAME)
291 next_frame = get_next_frame_sentinel_okay (next_frame);
292
293 /* We should have a valid next frame. */
294 gdb_assert (frame_id_p (get_frame_id (next_frame)));
295
297 reg_val->set_lval (lval_register);
298 VALUE_REGNUM (reg_val) = regnum;
299 VALUE_NEXT_FRAME_ID (reg_val) = get_frame_id (next_frame);
300
301 return reg_val;
302}
303
304/* Given a pointer of type TYPE in target form in BUF, return the
305 address it represents. */
306CORE_ADDR
308 struct type *type, const gdb_byte *buf)
309{
310 enum bfd_endian byte_order = type_byte_order (type);
311
312 return extract_unsigned_integer (buf, type->length (), byte_order);
313}
314
315CORE_ADDR
317 struct type *type, const gdb_byte *buf)
318{
319 enum bfd_endian byte_order = type_byte_order (type);
320
321 return extract_signed_integer (buf, type->length (), byte_order);
322}
323
324/* Given an address, store it as a pointer of type TYPE in target
325 format in BUF. */
326void
328 gdb_byte *buf, CORE_ADDR addr)
329{
330 enum bfd_endian byte_order = type_byte_order (type);
331
332 store_unsigned_integer (buf, type->length (), byte_order, addr);
333}
334
335void
337 gdb_byte *buf, CORE_ADDR addr)
338{
339 enum bfd_endian byte_order = type_byte_order (type);
340
341 store_signed_integer (buf, type->length (), byte_order, addr);
342}
343
344/* See value.h. */
345
348{
349 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
350 return SYMBOL_COMPUTED_OPS (sym)->get_symbol_read_needs (sym);
351
352 switch (sym->aclass ())
353 {
354 /* All cases listed explicitly so that gcc -Wall will detect it if
355 we failed to consider one. */
356 case LOC_COMPUTED:
357 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
358
359 case LOC_REGISTER:
360 case LOC_ARG:
361 case LOC_REF_ARG:
362 case LOC_REGPARM_ADDR:
363 case LOC_LOCAL:
364 return SYMBOL_NEEDS_FRAME;
365
366 case LOC_UNDEF:
367 case LOC_CONST:
368 case LOC_STATIC:
369 case LOC_TYPEDEF:
370
371 case LOC_LABEL:
372 /* Getting the address of a label can be done independently of the block,
373 even if some *uses* of that address wouldn't work so well without
374 the right frame. */
375
376 case LOC_BLOCK:
377 case LOC_CONST_BYTES:
378 case LOC_UNRESOLVED:
380 return SYMBOL_NEEDS_NONE;
381 }
382 return SYMBOL_NEEDS_FRAME;
383}
384
385/* See value.h. */
386
387int
389{
391}
392
393/* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
394 rules, look for the frame that is actually hosting VAR and return it. If,
395 for some reason, we found no such frame, return NULL.
396
397 This kind of computation is necessary to correctly handle lexically nested
398 functions.
399
400 Note that in some cases, we know what scope VAR comes from but we cannot
401 reach the specific frame that hosts the instance of VAR we are looking for.
402 For backward compatibility purposes (with old compilers), we then look for
403 the first frame that can host it. */
404
405static frame_info_ptr
406get_hosting_frame (struct symbol *var, const struct block *var_block,
407 frame_info_ptr frame)
408{
409 const struct block *frame_block = NULL;
410
411 if (!symbol_read_needs_frame (var))
412 return NULL;
413
414 /* Some symbols for local variables have no block: this happens when they are
415 not produced by a debug information reader, for instance when GDB creates
416 synthetic symbols. Without block information, we must assume they are
417 local to FRAME. In this case, there is nothing to do. */
418 else if (var_block == NULL)
419 return frame;
420
421 /* We currently assume that all symbols with a location list need a frame.
422 This is true in practice because selecting the location description
423 requires to compute the CFA, hence requires a frame. However we have
424 tests that embed global/static symbols with null location lists.
425 We want to get <optimized out> instead of <frame required> when evaluating
426 them so return a frame instead of raising an error. */
427 else if (var_block->is_global_block () || var_block->is_static_block ())
428 return frame;
429
430 /* We have to handle the "my_func::my_local_var" notation. This requires us
431 to look for upper frames when we find no block for the current frame: here
432 and below, handle when frame_block == NULL. */
433 if (frame != NULL)
434 frame_block = get_frame_block (frame, NULL);
435
436 /* Climb up the call stack until reaching the frame we are looking for. */
437 while (frame != NULL && frame_block != var_block)
438 {
439 /* Stacks can be quite deep: give the user a chance to stop this. */
440 QUIT;
441
442 if (frame_block == NULL)
443 {
444 frame = get_prev_frame (frame);
445 if (frame == NULL)
446 break;
447 frame_block = get_frame_block (frame, NULL);
448 }
449
450 /* If we failed to find the proper frame, fallback to the heuristic
451 method below. */
452 else if (frame_block->is_global_block ())
453 {
454 frame = NULL;
455 break;
456 }
457
458 /* Assuming we have a block for this frame: if we are at the function
459 level, the immediate upper lexical block is in an outer function:
460 follow the static link. */
461 else if (frame_block->function () != nullptr)
462 {
463 frame = frame_follow_static_link (frame);
464 if (frame != nullptr)
465 {
466 frame_block = get_frame_block (frame, nullptr);
467 if (frame_block == nullptr)
468 frame = nullptr;
469 }
470 }
471
472 else
473 /* We must be in some function nested lexical block. Just get the
474 outer block: both must share the same frame. */
475 frame_block = frame_block->superblock ();
476 }
477
478 /* Old compilers may not provide a static link, or they may provide an
479 invalid one. For such cases, fallback on the old way to evaluate
480 non-local references: just climb up the call stack and pick the first
481 frame that contains the variable we are looking for. */
482 if (frame == NULL)
483 {
484 frame = block_innermost_frame (var_block);
485 if (frame == NULL)
486 {
487 if (var_block->function ()
488 && !var_block->inlined_p ()
489 && var_block->function ()->print_name ())
490 error (_("No frame is currently executing in block %s."),
491 var_block->function ()->print_name ());
492 else
493 error (_("No frame is currently executing in specified"
494 " block"));
495 }
496 }
497
498 return frame;
499}
500
501/* See language.h. */
502
503struct value *
505 const struct block *var_block,
506 frame_info_ptr frame) const
507{
508 struct value *v;
509 struct type *type = var->type ();
510 CORE_ADDR addr;
511 enum symbol_needs_kind sym_need;
512
513 /* Call check_typedef on our type to make sure that, if TYPE is
514 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
515 instead of zero. However, we do not replace the typedef type by the
516 target type, because we want to keep the typedef in order to be able to
517 set the returned value type description correctly. */
519
520 sym_need = symbol_read_needs (var);
521 if (sym_need == SYMBOL_NEEDS_FRAME)
522 gdb_assert (frame != NULL);
523 else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers ())
524 error (_("Cannot read `%s' without registers"), var->print_name ());
525
526 if (frame != NULL)
527 frame = get_hosting_frame (var, var_block, frame);
528
529 if (SYMBOL_COMPUTED_OPS (var) != NULL)
530 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
531
532 switch (var->aclass ())
533 {
534 case LOC_CONST:
535 if (is_dynamic_type (type))
536 {
537 /* Value is a constant byte-sequence and needs no memory access. */
538 type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
539 }
540 /* Put the constant back in target format. */
541 v = value::allocate (type);
542 store_signed_integer (v->contents_raw ().data (), type->length (),
544 v->set_lval (not_lval);
545 return v;
546
547 case LOC_LABEL:
548 {
549 /* Put the constant back in target format. */
551 {
552 struct objfile *var_objfile = var->objfile ();
554 var->obj_section (var_objfile));
555 }
556 else
557 addr = var->value_address ();
558
559 /* First convert the CORE_ADDR to a function pointer type, this
560 ensures the gdbarch knows what type of pointer we are
561 manipulating when value_from_pointer is called. */
563 v = value_from_pointer (type, addr);
564
565 /* But we want to present the value as 'void *', so cast it to the
566 required type now, this will not change the values bit
567 representation. */
568 struct type *void_ptr_type
570 v = value_cast_pointers (void_ptr_type, v, 0);
571 v->set_lval (not_lval);
572 return v;
573 }
574
575 case LOC_CONST_BYTES:
576 if (is_dynamic_type (type))
577 {
578 /* Value is a constant byte-sequence and needs no memory access. */
579 type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
580 }
581 v = value::allocate (type);
582 memcpy (v->contents_raw ().data (), var->value_bytes (),
583 type->length ());
584 v->set_lval (not_lval);
585 return v;
586
587 case LOC_STATIC:
589 addr
591 var->obj_section (var->objfile ()));
592 else
593 addr = var->value_address ();
594 break;
595
596 case LOC_ARG:
597 addr = get_frame_args_address (frame);
598 if (!addr)
599 error (_("Unknown argument list address for `%s'."),
600 var->print_name ());
601 addr += var->value_longest ();
602 break;
603
604 case LOC_REF_ARG:
605 {
606 struct value *ref;
607 CORE_ADDR argref;
608
609 argref = get_frame_args_address (frame);
610 if (!argref)
611 error (_("Unknown argument list address for `%s'."),
612 var->print_name ());
613 argref += var->value_longest ();
614 ref = value_at (lookup_pointer_type (type), argref);
615 addr = value_as_address (ref);
616 break;
617 }
618
619 case LOC_LOCAL:
620 addr = get_frame_locals_address (frame);
621 addr += var->value_longest ();
622 break;
623
624 case LOC_TYPEDEF:
625 error (_("Cannot look up value of a typedef `%s'."),
626 var->print_name ());
627 break;
628
629 case LOC_BLOCK:
632 (var->value_block ()->entry_pc (),
633 var->obj_section (var->objfile ()));
634 else
635 addr = var->value_block ()->entry_pc ();
636 break;
637
638 case LOC_REGISTER:
639 case LOC_REGPARM_ADDR:
640 {
641 int regno = SYMBOL_REGISTER_OPS (var)
642 ->register_number (var, get_frame_arch (frame));
643 struct value *regval;
644
645 if (var->aclass () == LOC_REGPARM_ADDR)
646 {
648 regno,
649 frame);
650
651 if (regval == NULL)
652 error (_("Value of register variable not available for `%s'."),
653 var->print_name ());
654
655 addr = value_as_address (regval);
656 }
657 else
658 {
659 regval = value_from_register (type, regno, frame);
660
661 if (regval == NULL)
662 error (_("Value of register variable not available for `%s'."),
663 var->print_name ());
664 return regval;
665 }
666 }
667 break;
668
669 case LOC_COMPUTED:
670 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
671
672 case LOC_UNRESOLVED:
673 {
674 struct obj_section *obj_section;
676
678 (var->arch (),
679 [var, &bmsym] (objfile *objfile)
680 {
681 bmsym = lookup_minimal_symbol (var->linkage_name (), nullptr,
682 objfile);
683
684 /* Stop if a match is found. */
685 return bmsym.minsym != nullptr;
686 },
687 var->objfile ());
688
689 /* If we can't find the minsym there's a problem in the symbol info.
690 The symbol exists in the debug info, but it's missing in the minsym
691 table. */
692 if (bmsym.minsym == nullptr)
693 {
694 const char *flavour_name
695 = objfile_flavour_name (var->objfile ());
696
697 /* We can't get here unless we've opened the file, so flavour_name
698 can't be NULL. */
699 gdb_assert (flavour_name != NULL);
700 error (_("Missing %s symbol \"%s\"."),
701 flavour_name, var->linkage_name ());
702 }
703
704 obj_section = bmsym.minsym->obj_section (bmsym.objfile);
705 /* Relocate address, unless there is no section or the variable is
706 a TLS variable. */
707 if (obj_section == NULL
708 || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
709 addr = CORE_ADDR (bmsym.minsym->unrelocated_address ());
710 else
711 addr = bmsym.value_address ();
714 /* Determine address of TLS variable. */
715 if (obj_section
716 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
718 }
719 break;
720
722 if (is_dynamic_type (type))
723 type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
725
726 default:
727 error (_("Cannot look up value of a botched symbol `%s'."),
728 var->print_name ());
729 break;
730 }
731
732 v = value_at_lazy (type, addr);
733 return v;
734}
735
736/* Calls VAR's language read_var_value hook with the given arguments. */
737
738struct value *
739read_var_value (struct symbol *var, const struct block *var_block,
740 frame_info_ptr frame)
741{
742 const struct language_defn *lang = language_def (var->language ());
743
744 gdb_assert (lang != NULL);
745
746 return lang->read_var_value (var, var_block, frame);
747}
748
749/* Install default attributes for register values. */
750
751struct value *
753 int regnum, struct frame_id frame_id)
754{
755 int len = type->length ();
756 struct value *value = value::allocate (type);
757 frame_info_ptr frame;
758
760 frame = frame_find_by_id (frame_id);
761
762 if (frame == NULL)
764 else
766
769
770 /* Any structure stored in more than one register will always be
771 an integral number of registers. Otherwise, you need to do
772 some fiddling with the last register copied here for little
773 endian machines. */
774 if (type_byte_order (type) == BFD_ENDIAN_BIG
775 && len < register_size (gdbarch, regnum))
776 /* Big-endian, and we want less than full size. */
778 else
779 value->set_offset (0);
780
781 return value;
782}
783
784/* VALUE must be an lval_register value. If regnum is the value's
785 associated register number, and len the length of the values type,
786 read one or more registers in FRAME, starting with register REGNUM,
787 until we've read LEN bytes.
788
789 If any of the registers we try to read are optimized out, then mark the
790 complete resulting value as optimized out. */
791
792void
794{
795 struct gdbarch *gdbarch = get_frame_arch (frame);
796 LONGEST offset = 0;
797 LONGEST reg_offset = value->offset ();
798 int regnum = VALUE_REGNUM (value);
799 int len = type_length_units (check_typedef (value->type ()));
800
801 gdb_assert (value->lval () == lval_register);
802
803 /* Skip registers wholly inside of REG_OFFSET. */
805 {
807 regnum++;
808 }
809
810 /* Copy the data. */
811 while (len > 0)
812 {
813 struct value *regval = get_frame_register_value (frame, regnum);
814 int reg_len = type_length_units (regval->type ()) - reg_offset;
815
816 /* If the register length is larger than the number of bytes
817 remaining to copy, then only copy the appropriate bytes. */
818 if (reg_len > len)
819 reg_len = len;
820
821 regval->contents_copy (value, offset, reg_offset, reg_len);
822
823 offset += reg_len;
824 len -= reg_len;
825 reg_offset = 0;
826 regnum++;
827 }
828}
829
830/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
831
832struct value *
834{
835 struct gdbarch *gdbarch = get_frame_arch (frame);
836 struct type *type1 = check_typedef (type);
837 struct value *v;
838
840 {
841 int optim, unavail, ok;
842
843 /* The ISA/ABI need to something weird when obtaining the
844 specified value from this register. It might need to
845 re-order non-adjacent, starting with REGNUM (see MIPS and
846 i386). It might need to convert the [float] register into
847 the corresponding [integer] type (see Alpha). The assumption
848 is that gdbarch_register_to_value populates the entire value
849 including the location. */
850 v = value::allocate (type);
853 VALUE_REGNUM (v) = regnum;
854 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
855 v->contents_raw ().data (), &optim,
856 &unavail);
857
858 if (!ok)
859 {
860 if (optim)
862 if (unavail)
864 }
865 }
866 else
867 {
868 /* Construct the value. */
870 regnum, get_frame_id (frame));
871
872 /* Get the data. */
873 read_frame_register_value (v, frame);
874 }
875
876 return v;
877}
878
879/* Return contents of register REGNUM in frame FRAME as address.
880 Will abort if register value is not available. */
881
882CORE_ADDR
884{
885 struct gdbarch *gdbarch = get_frame_arch (frame);
887 struct value *value;
888 CORE_ADDR result;
889 int regnum_max_excl = gdbarch_num_cooked_regs (gdbarch);
890
891 if (regnum < 0 || regnum >= regnum_max_excl)
892 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum,
893 regnum_max_excl);
894
895 /* This routine may be called during early unwinding, at a time
896 where the ID of FRAME is not yet known. Calling value_from_register
897 would therefore abort in get_frame_id. However, since we only need
898 a temporary value that is never used as lvalue, we actually do not
899 really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
900 the core of value_from_register, but use the null_frame_id. */
901
902 /* Some targets require a special conversion routine even for plain
903 pointer types. Avoid constructing a value object in those cases. */
905 {
906 gdb_byte *buf = (gdb_byte *) alloca (type->length ());
907 int optim, unavail, ok;
908
910 buf, &optim, &unavail);
911 if (!ok)
912 {
913 /* This function is used while computing a location expression.
914 Complain about the value being optimized out, rather than
915 letting value_as_address complain about some random register
916 the expression depends on not being saved. */
918 }
919
920 return unpack_long (type, buf);
921 }
922
925
926 if (value->optimized_out ())
927 {
928 /* This function is used while computing a location expression.
929 Complain about the value being optimized out, rather than
930 letting value_as_address complain about some random register
931 the expression depends on not being saved. */
933 }
934
935 result = value_as_address (value);
937
938 return result;
939}
940
941#if GDB_SELF_TEST
942namespace selftests {
943namespace findvar_tests {
944
945/* Function to test copy_integer_to_size. Store SOURCE_VAL with size
946 SOURCE_SIZE to a buffer, making sure no sign extending happens at this
947 stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
948 copied value and compare to DEST_VALU. Copy again with a signed
949 copy_integer_to_size and compare to DEST_VALS. Do everything for both
950 LITTLE and BIG target endians. Use unsigned values throughout to make
951 sure there are no implicit sign extensions. */
952
953static void
954do_cint_test (ULONGEST dest_valu, ULONGEST dest_vals, int dest_size,
955 ULONGEST src_val, int src_size)
956{
957 for (int i = 0; i < 2 ; i++)
958 {
959 gdb_byte srcbuf[sizeof (ULONGEST)] = {};
960 gdb_byte destbuf[sizeof (ULONGEST)] = {};
961 enum bfd_endian byte_order = i ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
962
963 /* Fill the src buffer (and later the dest buffer) with non-zero junk,
964 to ensure zero extensions aren't hidden. */
965 memset (srcbuf, 0xaa, sizeof (srcbuf));
966
967 /* Store (and later extract) using unsigned to ensure there are no sign
968 extensions. */
969 store_unsigned_integer (srcbuf, src_size, byte_order, src_val);
970
971 /* Test unsigned. */
972 memset (destbuf, 0xaa, sizeof (destbuf));
973 copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, false,
974 byte_order);
975 SELF_CHECK (dest_valu == extract_unsigned_integer (destbuf, dest_size,
976 byte_order));
977
978 /* Test signed. */
979 memset (destbuf, 0xaa, sizeof (destbuf));
980 copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, true,
981 byte_order);
982 SELF_CHECK (dest_vals == extract_unsigned_integer (destbuf, dest_size,
983 byte_order));
984 }
985}
986
987static void
988copy_integer_to_size_test ()
989{
990 /* Destination is bigger than the source, which has the signed bit unset. */
991 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
992 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
993
994 /* Destination is bigger than the source, which has the signed bit set. */
995 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
996 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
997
998 /* Destination is smaller than the source. */
999 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1000 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1001
1002 /* Destination and source are the same size. */
1003 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1004 8);
1005 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1006 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1007 8);
1008 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1009
1010 /* Destination is bigger than the source. Source is bigger than 32bits. */
1011 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1012 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1013 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1014 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1015}
1016
1017} // namespace findvar_test
1018} // namespace selftests
1019
1020#endif
1021
1022void _initialize_findvar ();
1023void
1025{
1026#if GDB_SELF_TEST
1027 selftests::register_test
1028 ("copy_integer_to_size",
1029 selftests::findvar_tests::copy_integer_to_size_test);
1030#endif
1031}
int regnum
const struct block * get_frame_block(frame_info_ptr frame, CORE_ADDR *addr_in_block)
Definition blockframe.c:55
frame_info_ptr block_innermost_frame(const struct block *block)
Definition blockframe.c:463
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
Definition defs.h:508
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
@ not_lval
Definition defs.h:361
@ lval_register
Definition defs.h:365
symbol_needs_kind
Definition defs.h:448
@ SYMBOL_NEEDS_REGISTERS
Definition defs.h:453
@ SYMBOL_NEEDS_FRAME
Definition defs.h:456
@ SYMBOL_NEEDS_NONE
Definition defs.h:450
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:465
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
#define QUIT
Definition defs.h:187
void store_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, T val)
Definition findvar.c:162
struct value * value_from_register(struct type *type, int regnum, frame_info_ptr frame)
Definition findvar.c:833
CORE_ADDR unsigned_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition findvar.c:307
void address_to_signed_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
Definition findvar.c:336
struct value * default_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
Definition findvar.c:752
int symbol_read_needs_frame(struct symbol *sym)
Definition findvar.c:388
struct value * value_of_register_lazy(frame_info_ptr frame, int regnum)
Definition findvar.c:273
struct value * value_of_register(int regnum, frame_info_ptr frame)
Definition findvar.c:253
CORE_ADDR signed_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition findvar.c:316
enum symbol_needs_kind symbol_read_needs(struct symbol *sym)
Definition findvar.c:347
void store_typed_address(gdb_byte *buf, struct type *type, CORE_ADDR addr)
Definition findvar.c:201
CORE_ADDR address_from_register(int regnum, frame_info_ptr frame)
Definition findvar.c:883
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition findvar.c:152
void _initialize_findvar()
Definition findvar.c:1024
template LONGEST extract_integer< LONGEST >(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
void read_frame_register_value(struct value *value, frame_info_ptr frame)
Definition findvar.c:793
you lose T extract_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition findvar.c:50
static frame_info_ptr get_hosting_frame(struct symbol *var, const struct block *var_block, frame_info_ptr frame)
Definition findvar.c:406
struct value * read_var_value(struct symbol *var, const struct block *var_block, frame_info_ptr frame)
Definition findvar.c:739
void copy_integer_to_size(gdb_byte *dest, int dest_size, const gdb_byte *source, int source_size, bool is_signed, enum bfd_endian byte_order)
Definition findvar.c:214
int extract_long_unsigned_integer(const gdb_byte *addr, int orig_len, enum bfd_endian byte_order, LONGEST *pval)
Definition findvar.c:102
template ULONGEST extract_integer< ULONGEST >(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
void unsigned_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
Definition findvar.c:327
const struct frame_id null_frame_id
Definition frame.c:688
struct value * get_frame_register_value(frame_info_ptr frame, int regnum)
Definition frame.c:1333
frame_info_ptr frame_follow_static_link(frame_info_ptr frame)
Definition frame.c:3127
bool frame_id_p(frame_id l)
Definition frame.c:781
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
enum frame_type get_frame_type(frame_info_ptr frame)
Definition frame.c:2955
CORE_ADDR get_frame_args_address(frame_info_ptr fi)
Definition frame.c:2916
CORE_ADDR get_frame_locals_address(frame_info_ptr fi)
Definition frame.c:2901
frame_info_ptr frame_find_by_id(struct frame_id id)
Definition frame.c:916
struct frame_id get_frame_id(frame_info_ptr fi)
Definition frame.c:631
frame_info_ptr get_prev_frame(frame_info_ptr this_frame)
Definition frame.c:2614
frame_info_ptr get_next_frame_sentinel_okay(frame_info_ptr this_frame)
Definition frame.c:2081
@ INLINE_FRAME
Definition frame.h:193
void gdbarch_iterate_over_objfiles_in_search_order(struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype cb, struct objfile *current_objfile)
Definition gdbarch.c:5072
CORE_ADDR gdbarch_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition gdbarch.c:2545
struct value * gdbarch_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
Definition gdbarch.c:2528
int gdbarch_register_to_value(struct gdbarch *gdbarch, frame_info_ptr frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
Definition gdbarch.c:2494
void gdbarch_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
Definition gdbarch.c:2562
int gdbarch_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
Definition gdbarch.c:2477
static int gdbarch_num_cooked_regs(gdbarch *arch)
Definition gdbarch.h:390
enum bfd_endian type_byte_order(const struct type *type)
Definition gdbtypes.c:3900
struct type * lookup_pointer_type(struct type *type)
Definition gdbtypes.c:430
int is_dynamic_type(struct type *type)
Definition gdbtypes.c:2140
struct type * resolve_dynamic_type(struct type *type, gdb::array_view< const gdb_byte > valaddr, CORE_ADDR addr, const frame_info_ptr *in_frame)
Definition gdbtypes.c:2857
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
unsigned int type_length_units(struct type *type)
Definition gdbtypes.c:308
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:2966
static int reg_offset[]
const struct language_defn * language_def(enum language lang)
Definition language.c:439
const char * objfile_flavour_name(struct objfile *objfile)
Definition objfiles.c:1289
int value
Definition py-param.c:79
int register_size(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:170
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:158
Definition 1.cc:26
Definition block.h:109
const block * superblock() const
Definition block.h:135
CORE_ADDR entry_pc() const
Definition block.h:195
bool is_static_block() const
Definition block.h:259
bool inlined_p() const
Definition block.c:118
symbol * function() const
Definition block.h:127
bool is_global_block() const
Definition block.h:273
struct objfile * objfile
Definition minsyms.h:54
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
struct type * builtin_func_ptr
Definition gdbtypes.h:2146
struct type * builtin_data_ptr
Definition gdbtypes.h:2135
const char * print_name() const
Definition symtab.h:475
enum language language() const
Definition symtab.h:502
struct obj_section * obj_section(const struct objfile *objfile) const
Definition symtab.c:1117
const char * linkage_name() const
Definition symtab.h:460
virtual struct value * read_var_value(struct symbol *var, const struct block *var_block, frame_info_ptr frame) const
Definition findvar.c:504
unrelocated_addr unrelocated_address() const
Definition symtab.h:756
struct objfile * objfile
Definition objfiles.h:401
struct bfd_section * the_bfd_section
Definition objfiles.h:398
const block * value_block() const
Definition symtab.h:1549
address_class aclass() const
Definition symtab.h:1274
struct type * type() const
Definition symtab.h:1331
LONGEST value_longest() const
Definition symtab.h:1351
const gdb_byte * value_bytes() const
Definition symtab.h:1374
CORE_ADDR value_address() const
Definition symtab.h:1361
struct objfile * objfile() const
Definition symtab.c:6482
struct gdbarch * arch
Definition symtab.h:1460
ULONGEST length() const
Definition gdbtypes.h:983
gdbarch * arch() const
Definition gdbtypes.c:273
bool is_pointer_or_reference() const
Definition gdbtypes.h:1431
Definition value.h:130
static struct value * allocate_optimized_out(struct type *type)
Definition value.c:997
void contents_copy(struct value *dst, LONGEST dst_offset, LONGEST src_offset, LONGEST length)
Definition value.c:1252
void mark_bytes_optimized_out(int offset, int length)
Definition value.c:1324
static struct value * allocate(struct type *type)
Definition value.c:957
void set_lval(lval_type val)
Definition value.h:336
void mark_bytes_unavailable(LONGEST offset, ULONGEST length)
Definition value.c:419
gdb::array_view< gdb_byte > contents_raw()
Definition value.c:1009
struct type * type() const
Definition value.h:180
void set_offset(LONGEST offset)
Definition value.h:225
LONGEST offset() const
Definition value.h:222
enum lval_type lval() const
Definition value.h:332
void fetch_lazy()
Definition value.c:4001
static struct value * allocate_lazy(struct type *type)
Definition value.c:729
bool optimized_out()
Definition value.c:1279
enum overlay_debugging_state overlay_debugging
Definition symfile.c:2975
CORE_ADDR symbol_overlayed_address(CORE_ADDR address, struct obj_section *section)
Definition symfile.c:3144
@ LOC_STATIC
Definition symtab.h:979
@ LOC_BLOCK
Definition symtab.h:1028
@ LOC_LABEL
Definition symtab.h:1022
@ LOC_REGISTER
Definition symtab.h:993
@ LOC_REF_ARG
Definition symtab.h:1001
@ LOC_UNRESOLVED
Definition symtab.h:1057
@ LOC_LOCAL
Definition symtab.h:1013
@ LOC_CONST
Definition symtab.h:975
@ LOC_CONST_BYTES
Definition symtab.h:1033
@ LOC_UNDEF
Definition symtab.h:971
@ LOC_OPTIMIZED_OUT
Definition symtab.h:1062
@ LOC_TYPEDEF
Definition symtab.h:1018
@ LOC_REGPARM_ADDR
Definition symtab.h:1009
@ LOC_COMPUTED
Definition symtab.h:1066
@ LOC_ARG
Definition symtab.h:997
#define SYMBOL_COMPUTED_OPS(symbol)
Definition symtab.h:1543
#define SYMBOL_REGISTER_OPS(symbol)
Definition symtab.h:1545
int target_has_registers()
Definition target.c:189
CORE_ADDR target_translate_tls_address(struct objfile *objfile, CORE_ADDR offset)
Definition target.c:1280
struct value * value_of_user_reg(int regnum, frame_info_ptr frame)
Definition user-regs.c:206
struct value * value_cast_pointers(struct type *type, struct value *arg2, int subclass_check)
Definition valops.c:296
struct value * value_at_lazy(struct type *type, CORE_ADDR addr, frame_info_ptr frame)
Definition valops.c:1036
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition valops.c:1015
CORE_ADDR value_as_address(struct value *val)
Definition value.c:2636
void error_value_optimized_out(void)
Definition value.c:1074
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition value.c:3500
value_ref_ptr release_value(struct value *val)
Definition value.c:1450
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition value.c:2753
#define VALUE_NEXT_FRAME_ID(val)
Definition value.h:959
#define VALUE_REGNUM(val)
Definition value.h:962