1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright (C) 1986-2022 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
28 #include "symfile.h" /* for overlay functions */
30 #include "user-regs.h"
34 #include "dwarf2/loc.h"
35 #include "gdbsupport/selftest.h"
37 /* Basic byte-swapping routines. All 'extract' functions return a
38 host-format integer from a target-format integer at ADDR which is
41 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
42 /* 8 bit characters are a pretty safe assumption these days, so we
43 assume it throughout all these swapping routines. If we had to deal with
44 9 bit characters, we would need to make len be in bits and would have
45 to re-write these routines... */
49 template<typename T
, typename
>
51 extract_integer (gdb::array_view
<const gdb_byte
> buf
, enum bfd_endian byte_order
)
53 typename
std::make_unsigned
<T
>::type retval
= 0;
55 if (buf
.size () > (int) sizeof (T
))
57 That operation is not available on integers of more than %d bytes."),
60 /* Start at the most significant end of the integer, and work towards
61 the least significant. */
62 if (byte_order
== BFD_ENDIAN_BIG
)
66 if (std::is_signed
<T
>::value
)
68 /* Do the sign extension once at the start. */
69 retval
= ((LONGEST
) buf
[i
] ^ 0x80) - 0x80;
72 for (; i
< buf
.size (); ++i
)
73 retval
= (retval
<< 8) | buf
[i
];
77 ssize_t i
= buf
.size () - 1;
79 if (std::is_signed
<T
>::value
)
81 /* Do the sign extension once at the start. */
82 retval
= ((LONGEST
) buf
[i
] ^ 0x80) - 0x80;
86 retval
= (retval
<< 8) | buf
[i
];
91 /* Explicit instantiations. */
92 template LONGEST extract_integer
<LONGEST
> (gdb::array_view
<const gdb_byte
> buf
,
93 enum bfd_endian byte_order
);
94 template ULONGEST extract_integer
<ULONGEST
>
95 (gdb::array_view
<const gdb_byte
> buf
, enum bfd_endian byte_order
);
97 /* Sometimes a long long unsigned integer can be extracted as a
98 LONGEST value. This is done so that we can print these values
99 better. If this integer can be converted to a LONGEST, this
100 function returns 1 and sets *PVAL. Otherwise it returns 0. */
103 extract_long_unsigned_integer (const gdb_byte
*addr
, int orig_len
,
104 enum bfd_endian byte_order
, LONGEST
*pval
)
107 const gdb_byte
*first_addr
;
111 if (byte_order
== BFD_ENDIAN_BIG
)
114 len
> (int) sizeof (LONGEST
) && p
< addr
+ orig_len
;
127 for (p
= addr
+ orig_len
- 1;
128 len
> (int) sizeof (LONGEST
) && p
>= addr
;
138 if (len
<= (int) sizeof (LONGEST
))
140 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
150 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
151 address it represents. */
153 extract_typed_address (const gdb_byte
*buf
, struct type
*type
)
155 if (!type
->is_pointer_or_reference ())
156 internal_error (__FILE__
, __LINE__
,
157 _("extract_typed_address: "
158 "type is not a pointer or reference"));
160 return gdbarch_pointer_to_address (type
->arch (), type
, buf
);
163 /* All 'store' functions accept a host-format integer and store a
164 target-format integer at ADDR which is LEN bytes long. */
165 template<typename T
, typename
>
167 store_integer (gdb_byte
*addr
, int len
, enum bfd_endian byte_order
,
171 gdb_byte
*startaddr
= addr
;
172 gdb_byte
*endaddr
= startaddr
+ len
;
174 /* Start at the least significant end of the integer, and work towards
175 the most significant. */
176 if (byte_order
== BFD_ENDIAN_BIG
)
178 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
186 for (p
= startaddr
; p
< endaddr
; ++p
)
194 /* Explicit instantiations. */
195 template void store_integer (gdb_byte
*addr
, int len
,
196 enum bfd_endian byte_order
,
199 template void store_integer (gdb_byte
*addr
, int len
,
200 enum bfd_endian byte_order
,
203 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
206 store_typed_address (gdb_byte
*buf
, struct type
*type
, CORE_ADDR addr
)
208 if (!type
->is_pointer_or_reference ())
209 internal_error (__FILE__
, __LINE__
,
210 _("store_typed_address: "
211 "type is not a pointer or reference"));
213 gdbarch_address_to_pointer (type
->arch (), type
, buf
, addr
);
216 /* Copy a value from SOURCE of size SOURCE_SIZE bytes to DEST of size DEST_SIZE
217 bytes. If SOURCE_SIZE is greater than DEST_SIZE, then truncate the most
218 significant bytes. If SOURCE_SIZE is less than DEST_SIZE then either sign
219 or zero extended according to IS_SIGNED. Values are stored in memory with
220 endianness BYTE_ORDER. */
223 copy_integer_to_size (gdb_byte
*dest
, int dest_size
, const gdb_byte
*source
,
224 int source_size
, bool is_signed
,
225 enum bfd_endian byte_order
)
227 signed int size_diff
= dest_size
- source_size
;
229 /* Copy across everything from SOURCE that can fit into DEST. */
231 if (byte_order
== BFD_ENDIAN_BIG
&& size_diff
> 0)
232 memcpy (dest
+ size_diff
, source
, source_size
);
233 else if (byte_order
== BFD_ENDIAN_BIG
&& size_diff
< 0)
234 memcpy (dest
, source
- size_diff
, dest_size
);
236 memcpy (dest
, source
, std::min (source_size
, dest_size
));
238 /* Fill the remaining space in DEST by either zero extending or sign
243 gdb_byte extension
= 0;
245 && ((byte_order
!= BFD_ENDIAN_BIG
&& source
[source_size
- 1] & 0x80)
246 || (byte_order
== BFD_ENDIAN_BIG
&& source
[0] & 0x80)))
249 /* Extend into MSBs of SOURCE. */
250 if (byte_order
== BFD_ENDIAN_BIG
)
251 memset (dest
, extension
, size_diff
);
253 memset (dest
+ source_size
, extension
, size_diff
);
257 /* Return a `value' with the contents of (virtual or cooked) register
258 REGNUM as found in the specified FRAME. The register's type is
259 determined by register_type (). */
262 value_of_register (int regnum
, struct frame_info
*frame
)
264 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
265 struct value
*reg_val
;
267 /* User registers lie completely outside of the range of normal
268 registers. Catch them early so that the target never sees them. */
269 if (regnum
>= gdbarch_num_cooked_regs (gdbarch
))
270 return value_of_user_reg (regnum
, frame
);
272 reg_val
= value_of_register_lazy (frame
, regnum
);
273 value_fetch_lazy (reg_val
);
277 /* Return a `value' with the contents of (virtual or cooked) register
278 REGNUM as found in the specified FRAME. The register's type is
279 determined by register_type (). The value is not fetched. */
282 value_of_register_lazy (struct frame_info
*frame
, int regnum
)
284 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
285 struct value
*reg_val
;
286 struct frame_info
*next_frame
;
288 gdb_assert (regnum
< gdbarch_num_cooked_regs (gdbarch
));
290 gdb_assert (frame
!= NULL
);
292 next_frame
= get_next_frame_sentinel_okay (frame
);
294 /* In some cases NEXT_FRAME may not have a valid frame-id yet. This can
295 happen if we end up trying to unwind a register as part of the frame
296 sniffer. The only time that we get here without a valid frame-id is
297 if NEXT_FRAME is an inline frame. If this is the case then we can
298 avoid getting into trouble here by skipping past the inline frames. */
299 while (get_frame_type (next_frame
) == INLINE_FRAME
)
300 next_frame
= get_next_frame_sentinel_okay (next_frame
);
302 /* We should have a valid next frame. */
303 gdb_assert (frame_id_p (get_frame_id (next_frame
)));
305 reg_val
= allocate_value_lazy (register_type (gdbarch
, regnum
));
306 VALUE_LVAL (reg_val
) = lval_register
;
307 VALUE_REGNUM (reg_val
) = regnum
;
308 VALUE_NEXT_FRAME_ID (reg_val
) = get_frame_id (next_frame
);
313 /* Given a pointer of type TYPE in target form in BUF, return the
314 address it represents. */
316 unsigned_pointer_to_address (struct gdbarch
*gdbarch
,
317 struct type
*type
, const gdb_byte
*buf
)
319 enum bfd_endian byte_order
= type_byte_order (type
);
321 return extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
325 signed_pointer_to_address (struct gdbarch
*gdbarch
,
326 struct type
*type
, const gdb_byte
*buf
)
328 enum bfd_endian byte_order
= type_byte_order (type
);
330 return extract_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
);
333 /* Given an address, store it as a pointer of type TYPE in target
336 unsigned_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
337 gdb_byte
*buf
, CORE_ADDR addr
)
339 enum bfd_endian byte_order
= type_byte_order (type
);
341 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
345 address_to_signed_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
346 gdb_byte
*buf
, CORE_ADDR addr
)
348 enum bfd_endian byte_order
= type_byte_order (type
);
350 store_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
355 enum symbol_needs_kind
356 symbol_read_needs (struct symbol
*sym
)
358 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
359 return SYMBOL_COMPUTED_OPS (sym
)->get_symbol_read_needs (sym
);
361 switch (sym
->aclass ())
363 /* All cases listed explicitly so that gcc -Wall will detect it if
364 we failed to consider one. */
366 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
371 case LOC_REGPARM_ADDR
:
373 return SYMBOL_NEEDS_FRAME
;
381 /* Getting the address of a label can be done independently of the block,
382 even if some *uses* of that address wouldn't work so well without
386 case LOC_CONST_BYTES
:
388 case LOC_OPTIMIZED_OUT
:
389 return SYMBOL_NEEDS_NONE
;
391 return SYMBOL_NEEDS_FRAME
;
397 symbol_read_needs_frame (struct symbol
*sym
)
399 return symbol_read_needs (sym
) == SYMBOL_NEEDS_FRAME
;
402 /* Private data to be used with minsym_lookup_iterator_cb. */
404 struct minsym_lookup_data
406 /* The name of the minimal symbol we are searching for. */
407 const char *name
= nullptr;
409 /* The field where the callback should store the minimal symbol
410 if found. It should be initialized to NULL before the search
412 struct bound_minimal_symbol result
;
415 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
416 It searches by name for a minimal symbol within the given OBJFILE.
417 The arguments are passed via CB_DATA, which in reality is a pointer
418 to struct minsym_lookup_data. */
421 minsym_lookup_iterator_cb (struct objfile
*objfile
, void *cb_data
)
423 struct minsym_lookup_data
*data
= (struct minsym_lookup_data
*) cb_data
;
425 gdb_assert (data
->result
.minsym
== NULL
);
427 data
->result
= lookup_minimal_symbol (data
->name
, NULL
, objfile
);
429 /* The iterator should stop iff a match was found. */
430 return (data
->result
.minsym
!= NULL
);
433 /* Given static link expression and the frame it lives in, look for the frame
434 the static links points to and return it. Return NULL if we could not find
437 static struct frame_info
*
438 follow_static_link (struct frame_info
*frame
,
439 const struct dynamic_prop
*static_link
)
441 CORE_ADDR upper_frame_base
;
443 if (!dwarf2_evaluate_property (static_link
, frame
, NULL
, &upper_frame_base
))
446 /* Now climb up the stack frame until we reach the frame we are interested
448 for (; frame
!= NULL
; frame
= get_prev_frame (frame
))
450 struct symbol
*framefunc
= get_frame_function (frame
);
452 /* Stacks can be quite deep: give the user a chance to stop this. */
455 /* If we don't know how to compute FRAME's base address, don't give up:
456 maybe the frame we are looking for is upper in the stack frame. */
457 if (framefunc
!= NULL
458 && SYMBOL_BLOCK_OPS (framefunc
) != NULL
459 && SYMBOL_BLOCK_OPS (framefunc
)->get_frame_base
!= NULL
460 && (SYMBOL_BLOCK_OPS (framefunc
)->get_frame_base (framefunc
, frame
)
461 == upper_frame_base
))
468 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
469 rules, look for the frame that is actually hosting VAR and return it. If,
470 for some reason, we found no such frame, return NULL.
472 This kind of computation is necessary to correctly handle lexically nested
475 Note that in some cases, we know what scope VAR comes from but we cannot
476 reach the specific frame that hosts the instance of VAR we are looking for.
477 For backward compatibility purposes (with old compilers), we then look for
478 the first frame that can host it. */
480 static struct frame_info
*
481 get_hosting_frame (struct symbol
*var
, const struct block
*var_block
,
482 struct frame_info
*frame
)
484 const struct block
*frame_block
= NULL
;
486 if (!symbol_read_needs_frame (var
))
489 /* Some symbols for local variables have no block: this happens when they are
490 not produced by a debug information reader, for instance when GDB creates
491 synthetic symbols. Without block information, we must assume they are
492 local to FRAME. In this case, there is nothing to do. */
493 else if (var_block
== NULL
)
496 /* We currently assume that all symbols with a location list need a frame.
497 This is true in practice because selecting the location description
498 requires to compute the CFA, hence requires a frame. However we have
499 tests that embed global/static symbols with null location lists.
500 We want to get <optimized out> instead of <frame required> when evaluating
501 them so return a frame instead of raising an error. */
502 else if (var_block
== block_global_block (var_block
)
503 || var_block
== block_static_block (var_block
))
506 /* We have to handle the "my_func::my_local_var" notation. This requires us
507 to look for upper frames when we find no block for the current frame: here
508 and below, handle when frame_block == NULL. */
510 frame_block
= get_frame_block (frame
, NULL
);
512 /* Climb up the call stack until reaching the frame we are looking for. */
513 while (frame
!= NULL
&& frame_block
!= var_block
)
515 /* Stacks can be quite deep: give the user a chance to stop this. */
518 if (frame_block
== NULL
)
520 frame
= get_prev_frame (frame
);
523 frame_block
= get_frame_block (frame
, NULL
);
526 /* If we failed to find the proper frame, fallback to the heuristic
528 else if (frame_block
== block_global_block (frame_block
))
534 /* Assuming we have a block for this frame: if we are at the function
535 level, the immediate upper lexical block is in an outer function:
536 follow the static link. */
537 else if (BLOCK_FUNCTION (frame_block
))
539 const struct dynamic_prop
*static_link
540 = block_static_link (frame_block
);
541 int could_climb_up
= 0;
543 if (static_link
!= NULL
)
545 frame
= follow_static_link (frame
, static_link
);
548 frame_block
= get_frame_block (frame
, NULL
);
549 could_climb_up
= frame_block
!= NULL
;
560 /* We must be in some function nested lexical block. Just get the
561 outer block: both must share the same frame. */
562 frame_block
= BLOCK_SUPERBLOCK (frame_block
);
565 /* Old compilers may not provide a static link, or they may provide an
566 invalid one. For such cases, fallback on the old way to evaluate
567 non-local references: just climb up the call stack and pick the first
568 frame that contains the variable we are looking for. */
571 frame
= block_innermost_frame (var_block
);
574 if (BLOCK_FUNCTION (var_block
)
575 && !block_inlined_p (var_block
)
576 && BLOCK_FUNCTION (var_block
)->print_name ())
577 error (_("No frame is currently executing in block %s."),
578 BLOCK_FUNCTION (var_block
)->print_name ());
580 error (_("No frame is currently executing in specified"
588 /* See language.h. */
591 language_defn::read_var_value (struct symbol
*var
,
592 const struct block
*var_block
,
593 struct frame_info
*frame
) const
596 struct type
*type
= var
->type ();
598 enum symbol_needs_kind sym_need
;
600 /* Call check_typedef on our type to make sure that, if TYPE is
601 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
602 instead of zero. However, we do not replace the typedef type by the
603 target type, because we want to keep the typedef in order to be able to
604 set the returned value type description correctly. */
605 check_typedef (type
);
607 sym_need
= symbol_read_needs (var
);
608 if (sym_need
== SYMBOL_NEEDS_FRAME
)
609 gdb_assert (frame
!= NULL
);
610 else if (sym_need
== SYMBOL_NEEDS_REGISTERS
&& !target_has_registers ())
611 error (_("Cannot read `%s' without registers"), var
->print_name ());
614 frame
= get_hosting_frame (var
, var_block
, frame
);
616 if (SYMBOL_COMPUTED_OPS (var
) != NULL
)
617 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
619 switch (var
->aclass ())
622 if (is_dynamic_type (type
))
624 /* Value is a constant byte-sequence and needs no memory access. */
625 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
627 /* Put the constant back in target format. */
628 v
= allocate_value (type
);
629 store_signed_integer (value_contents_raw (v
).data (), TYPE_LENGTH (type
),
630 type_byte_order (type
), var
->value_longest ());
631 VALUE_LVAL (v
) = not_lval
;
635 /* Put the constant back in target format. */
636 v
= allocate_value (type
);
637 if (overlay_debugging
)
639 struct objfile
*var_objfile
= var
->objfile ();
640 addr
= symbol_overlayed_address (var
->value_address (),
641 var
->obj_section (var_objfile
));
642 store_typed_address (value_contents_raw (v
).data (), type
, addr
);
645 store_typed_address (value_contents_raw (v
).data (), type
,
646 var
->value_address ());
647 VALUE_LVAL (v
) = not_lval
;
650 case LOC_CONST_BYTES
:
651 if (is_dynamic_type (type
))
653 /* Value is a constant byte-sequence and needs no memory access. */
654 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
656 v
= allocate_value (type
);
657 memcpy (value_contents_raw (v
).data (), var
->value_bytes (),
659 VALUE_LVAL (v
) = not_lval
;
663 if (overlay_debugging
)
665 = symbol_overlayed_address (var
->value_address (),
666 var
->obj_section (var
->objfile ()));
668 addr
= var
->value_address ();
672 addr
= get_frame_args_address (frame
);
674 error (_("Unknown argument list address for `%s'."),
676 addr
+= var
->value_longest ();
684 argref
= get_frame_args_address (frame
);
686 error (_("Unknown argument list address for `%s'."),
688 argref
+= var
->value_longest ();
689 ref
= value_at (lookup_pointer_type (type
), argref
);
690 addr
= value_as_address (ref
);
695 addr
= get_frame_locals_address (frame
);
696 addr
+= var
->value_longest ();
700 error (_("Cannot look up value of a typedef `%s'."),
705 if (overlay_debugging
)
706 addr
= symbol_overlayed_address
707 (BLOCK_ENTRY_PC (var
->value_block ()),
708 var
->obj_section (var
->objfile ()));
710 addr
= BLOCK_ENTRY_PC (var
->value_block ());
714 case LOC_REGPARM_ADDR
:
716 int regno
= SYMBOL_REGISTER_OPS (var
)
717 ->register_number (var
, get_frame_arch (frame
));
718 struct value
*regval
;
720 if (var
->aclass () == LOC_REGPARM_ADDR
)
722 regval
= value_from_register (lookup_pointer_type (type
),
727 error (_("Value of register variable not available for `%s'."),
730 addr
= value_as_address (regval
);
734 regval
= value_from_register (type
, regno
, frame
);
737 error (_("Value of register variable not available for `%s'."),
745 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
749 struct minsym_lookup_data lookup_data
;
750 struct minimal_symbol
*msym
;
751 struct obj_section
*obj_section
;
753 lookup_data
.name
= var
->linkage_name ();
755 gdbarch_iterate_over_objfiles_in_search_order
757 minsym_lookup_iterator_cb
, &lookup_data
,
759 msym
= lookup_data
.result
.minsym
;
761 /* If we can't find the minsym there's a problem in the symbol info.
762 The symbol exists in the debug info, but it's missing in the minsym
766 const char *flavour_name
767 = objfile_flavour_name (var
->objfile ());
769 /* We can't get here unless we've opened the file, so flavour_name
771 gdb_assert (flavour_name
!= NULL
);
772 error (_("Missing %s symbol \"%s\"."),
773 flavour_name
, var
->linkage_name ());
775 obj_section
= msym
->obj_section (lookup_data
.result
.objfile
);
776 /* Relocate address, unless there is no section or the variable is
778 if (obj_section
== NULL
779 || (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
780 addr
= msym
->value_raw_address ();
782 addr
= lookup_data
.result
.value_address ();
783 if (overlay_debugging
)
784 addr
= symbol_overlayed_address (addr
, obj_section
);
785 /* Determine address of TLS variable. */
787 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
788 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
792 case LOC_OPTIMIZED_OUT
:
793 if (is_dynamic_type (type
))
794 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
795 return allocate_optimized_out_value (type
);
798 error (_("Cannot look up value of a botched symbol `%s'."),
803 v
= value_at_lazy (type
, addr
);
807 /* Calls VAR's language read_var_value hook with the given arguments. */
810 read_var_value (struct symbol
*var
, const struct block
*var_block
,
811 struct frame_info
*frame
)
813 const struct language_defn
*lang
= language_def (var
->language ());
815 gdb_assert (lang
!= NULL
);
817 return lang
->read_var_value (var
, var_block
, frame
);
820 /* Install default attributes for register values. */
823 default_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
824 int regnum
, struct frame_id frame_id
)
826 int len
= TYPE_LENGTH (type
);
827 struct value
*value
= allocate_value (type
);
828 struct frame_info
*frame
;
830 VALUE_LVAL (value
) = lval_register
;
831 frame
= frame_find_by_id (frame_id
);
834 frame_id
= null_frame_id
;
836 frame_id
= get_frame_id (get_next_frame_sentinel_okay (frame
));
838 VALUE_NEXT_FRAME_ID (value
) = frame_id
;
839 VALUE_REGNUM (value
) = regnum
;
841 /* Any structure stored in more than one register will always be
842 an integral number of registers. Otherwise, you need to do
843 some fiddling with the last register copied here for little
845 if (type_byte_order (type
) == BFD_ENDIAN_BIG
846 && len
< register_size (gdbarch
, regnum
))
847 /* Big-endian, and we want less than full size. */
848 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
850 set_value_offset (value
, 0);
855 /* VALUE must be an lval_register value. If regnum is the value's
856 associated register number, and len the length of the values type,
857 read one or more registers in FRAME, starting with register REGNUM,
858 until we've read LEN bytes.
860 If any of the registers we try to read are optimized out, then mark the
861 complete resulting value as optimized out. */
864 read_frame_register_value (struct value
*value
, struct frame_info
*frame
)
866 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
868 LONGEST reg_offset
= value_offset (value
);
869 int regnum
= VALUE_REGNUM (value
);
870 int len
= type_length_units (check_typedef (value_type (value
)));
872 gdb_assert (VALUE_LVAL (value
) == lval_register
);
874 /* Skip registers wholly inside of REG_OFFSET. */
875 while (reg_offset
>= register_size (gdbarch
, regnum
))
877 reg_offset
-= register_size (gdbarch
, regnum
);
884 struct value
*regval
= get_frame_register_value (frame
, regnum
);
885 int reg_len
= type_length_units (value_type (regval
)) - reg_offset
;
887 /* If the register length is larger than the number of bytes
888 remaining to copy, then only copy the appropriate bytes. */
892 value_contents_copy (value
, offset
, regval
, reg_offset
, reg_len
);
901 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
904 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
906 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
907 struct type
*type1
= check_typedef (type
);
910 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
912 int optim
, unavail
, ok
;
914 /* The ISA/ABI need to something weird when obtaining the
915 specified value from this register. It might need to
916 re-order non-adjacent, starting with REGNUM (see MIPS and
917 i386). It might need to convert the [float] register into
918 the corresponding [integer] type (see Alpha). The assumption
919 is that gdbarch_register_to_value populates the entire value
920 including the location. */
921 v
= allocate_value (type
);
922 VALUE_LVAL (v
) = lval_register
;
923 VALUE_NEXT_FRAME_ID (v
) = get_frame_id (get_next_frame_sentinel_okay (frame
));
924 VALUE_REGNUM (v
) = regnum
;
925 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
926 value_contents_raw (v
).data (), &optim
,
932 mark_value_bytes_optimized_out (v
, 0, TYPE_LENGTH (type
));
934 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
939 /* Construct the value. */
940 v
= gdbarch_value_from_register (gdbarch
, type
,
941 regnum
, get_frame_id (frame
));
944 read_frame_register_value (v
, frame
);
950 /* Return contents of register REGNUM in frame FRAME as address.
951 Will abort if register value is not available. */
954 address_from_register (int regnum
, struct frame_info
*frame
)
956 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
957 struct type
*type
= builtin_type (gdbarch
)->builtin_data_ptr
;
960 int regnum_max_excl
= gdbarch_num_cooked_regs (gdbarch
);
962 if (regnum
< 0 || regnum
>= regnum_max_excl
)
963 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum
,
966 /* This routine may be called during early unwinding, at a time
967 where the ID of FRAME is not yet known. Calling value_from_register
968 would therefore abort in get_frame_id. However, since we only need
969 a temporary value that is never used as lvalue, we actually do not
970 really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
971 the core of value_from_register, but use the null_frame_id. */
973 /* Some targets require a special conversion routine even for plain
974 pointer types. Avoid constructing a value object in those cases. */
975 if (gdbarch_convert_register_p (gdbarch
, regnum
, type
))
977 gdb_byte
*buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
978 int optim
, unavail
, ok
;
980 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type
,
981 buf
, &optim
, &unavail
);
984 /* This function is used while computing a location expression.
985 Complain about the value being optimized out, rather than
986 letting value_as_address complain about some random register
987 the expression depends on not being saved. */
988 error_value_optimized_out ();
991 return unpack_long (type
, buf
);
994 value
= gdbarch_value_from_register (gdbarch
, type
, regnum
, null_frame_id
);
995 read_frame_register_value (value
, frame
);
997 if (value_optimized_out (value
))
999 /* This function is used while computing a location expression.
1000 Complain about the value being optimized out, rather than
1001 letting value_as_address complain about some random register
1002 the expression depends on not being saved. */
1003 error_value_optimized_out ();
1006 result
= value_as_address (value
);
1007 release_value (value
);
1013 namespace selftests
{
1014 namespace findvar_tests
{
1016 /* Function to test copy_integer_to_size. Store SOURCE_VAL with size
1017 SOURCE_SIZE to a buffer, making sure no sign extending happens at this
1018 stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
1019 copied value and compare to DEST_VALU. Copy again with a signed
1020 copy_integer_to_size and compare to DEST_VALS. Do everything for both
1021 LITTLE and BIG target endians. Use unsigned values throughout to make
1022 sure there are no implicit sign extensions. */
1025 do_cint_test (ULONGEST dest_valu
, ULONGEST dest_vals
, int dest_size
,
1026 ULONGEST src_val
, int src_size
)
1028 for (int i
= 0; i
< 2 ; i
++)
1030 gdb_byte srcbuf
[sizeof (ULONGEST
)] = {};
1031 gdb_byte destbuf
[sizeof (ULONGEST
)] = {};
1032 enum bfd_endian byte_order
= i
? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
1034 /* Fill the src buffer (and later the dest buffer) with non-zero junk,
1035 to ensure zero extensions aren't hidden. */
1036 memset (srcbuf
, 0xaa, sizeof (srcbuf
));
1038 /* Store (and later extract) using unsigned to ensure there are no sign
1040 store_unsigned_integer (srcbuf
, src_size
, byte_order
, src_val
);
1042 /* Test unsigned. */
1043 memset (destbuf
, 0xaa, sizeof (destbuf
));
1044 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, false,
1046 SELF_CHECK (dest_valu
== extract_unsigned_integer (destbuf
, dest_size
,
1050 memset (destbuf
, 0xaa, sizeof (destbuf
));
1051 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, true,
1053 SELF_CHECK (dest_vals
== extract_unsigned_integer (destbuf
, dest_size
,
1059 copy_integer_to_size_test ()
1061 /* Destination is bigger than the source, which has the signed bit unset. */
1062 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1063 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1065 /* Destination is bigger than the source, which has the signed bit set. */
1066 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1067 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1069 /* Destination is smaller than the source. */
1070 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1071 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1073 /* Destination and source are the same size. */
1074 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1076 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1077 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1079 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1081 /* Destination is bigger than the source. Source is bigger than 32bits. */
1082 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1083 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1084 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1085 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1088 } // namespace findvar_test
1089 } // namespace selftests
1093 void _initialize_findvar ();
1095 _initialize_findvar ()
1098 selftests::register_test
1099 ("copy_integer_to_size",
1100 selftests::findvar_tests::copy_integer_to_size_test
);