1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright (C) 1986-2023 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/>. */
30 #include "user-regs.h"
34 #include "gdbsupport/selftest.h"
36 /* Basic byte-swapping routines. All 'extract' functions return a
37 host-format integer from a target-format integer at ADDR which is
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... */
48 template<typename T
, typename
>
50 extract_integer (gdb::array_view
<const gdb_byte
> buf
, enum bfd_endian byte_order
)
52 typename
std::make_unsigned
<T
>::type retval
= 0;
54 if (buf
.size () > (int) sizeof (T
))
56 That operation is not available on integers of more than %d bytes."),
59 /* Start at the most significant end of the integer, and work towards
60 the least significant. */
61 if (byte_order
== BFD_ENDIAN_BIG
)
65 if (std::is_signed
<T
>::value
)
67 /* Do the sign extension once at the start. */
68 retval
= ((LONGEST
) buf
[i
] ^ 0x80) - 0x80;
71 for (; i
< buf
.size (); ++i
)
72 retval
= (retval
<< 8) | buf
[i
];
76 ssize_t i
= buf
.size () - 1;
78 if (std::is_signed
<T
>::value
)
80 /* Do the sign extension once at the start. */
81 retval
= ((LONGEST
) buf
[i
] ^ 0x80) - 0x80;
85 retval
= (retval
<< 8) | buf
[i
];
90 /* Explicit instantiations. */
91 template LONGEST extract_integer
<LONGEST
> (gdb::array_view
<const gdb_byte
> buf
,
92 enum bfd_endian byte_order
);
93 template ULONGEST extract_integer
<ULONGEST
>
94 (gdb::array_view
<const gdb_byte
> buf
, enum bfd_endian byte_order
);
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. */
102 extract_long_unsigned_integer (const gdb_byte
*addr
, int orig_len
,
103 enum bfd_endian byte_order
, LONGEST
*pval
)
106 const gdb_byte
*first_addr
;
110 if (byte_order
== BFD_ENDIAN_BIG
)
113 len
> (int) sizeof (LONGEST
) && p
< addr
+ orig_len
;
126 for (p
= addr
+ orig_len
- 1;
127 len
> (int) sizeof (LONGEST
) && p
>= addr
;
137 if (len
<= (int) sizeof (LONGEST
))
139 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
149 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
150 address it represents. */
152 extract_typed_address (const gdb_byte
*buf
, struct type
*type
)
154 gdb_assert (type
->is_pointer_or_reference ());
155 return gdbarch_pointer_to_address (type
->arch (), type
, buf
);
158 /* All 'store' functions accept a host-format integer and store a
159 target-format integer at ADDR which is LEN bytes long. */
160 template<typename T
, typename
>
162 store_integer (gdb_byte
*addr
, int len
, enum bfd_endian byte_order
,
166 gdb_byte
*startaddr
= addr
;
167 gdb_byte
*endaddr
= startaddr
+ len
;
169 /* Start at the least significant end of the integer, and work towards
170 the most significant. */
171 if (byte_order
== BFD_ENDIAN_BIG
)
173 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
181 for (p
= startaddr
; p
< endaddr
; ++p
)
189 /* Explicit instantiations. */
190 template void store_integer (gdb_byte
*addr
, int len
,
191 enum bfd_endian byte_order
,
194 template void store_integer (gdb_byte
*addr
, int len
,
195 enum bfd_endian byte_order
,
198 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
201 store_typed_address (gdb_byte
*buf
, struct type
*type
, CORE_ADDR addr
)
203 gdb_assert (type
->is_pointer_or_reference ());
204 gdbarch_address_to_pointer (type
->arch (), type
, buf
, addr
);
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. */
214 copy_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
)
218 signed int size_diff
= dest_size
- source_size
;
220 /* Copy across everything from SOURCE that can fit into DEST. */
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
);
227 memcpy (dest
, source
, std::min (source_size
, dest_size
));
229 /* Fill the remaining space in DEST by either zero extending or sign
234 gdb_byte extension
= 0;
236 && ((byte_order
!= BFD_ENDIAN_BIG
&& source
[source_size
- 1] & 0x80)
237 || (byte_order
== BFD_ENDIAN_BIG
&& source
[0] & 0x80)))
240 /* Extend into MSBs of SOURCE. */
241 if (byte_order
== BFD_ENDIAN_BIG
)
242 memset (dest
, extension
, size_diff
);
244 memset (dest
+ source_size
, extension
, size_diff
);
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 (). */
253 value_of_register (int regnum
, frame_info_ptr frame
)
255 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
256 struct value
*reg_val
;
258 /* User registers lie completely outside of the range of normal
259 registers. Catch them early so that the target never sees them. */
260 if (regnum
>= gdbarch_num_cooked_regs (gdbarch
))
261 return value_of_user_reg (regnum
, frame
);
263 reg_val
= value_of_register_lazy (frame
, regnum
);
264 reg_val
->fetch_lazy ();
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. */
273 value_of_register_lazy (frame_info_ptr frame
, int regnum
)
275 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
276 struct value
*reg_val
;
277 frame_info_ptr next_frame
;
279 gdb_assert (regnum
< gdbarch_num_cooked_regs (gdbarch
));
281 gdb_assert (frame
!= NULL
);
283 next_frame
= get_next_frame_sentinel_okay (frame
);
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
);
293 /* We should have a valid next frame. */
294 gdb_assert (frame_id_p (get_frame_id (next_frame
)));
296 reg_val
= value::allocate_lazy (register_type (gdbarch
, regnum
));
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
);
304 /* Given a pointer of type TYPE in target form in BUF, return the
305 address it represents. */
307 unsigned_pointer_to_address (struct gdbarch
*gdbarch
,
308 struct type
*type
, const gdb_byte
*buf
)
310 enum bfd_endian byte_order
= type_byte_order (type
);
312 return extract_unsigned_integer (buf
, type
->length (), byte_order
);
316 signed_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_signed_integer (buf
, type
->length (), byte_order
);
324 /* Given an address, store it as a pointer of type TYPE in target
327 unsigned_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
328 gdb_byte
*buf
, CORE_ADDR addr
)
330 enum bfd_endian byte_order
= type_byte_order (type
);
332 store_unsigned_integer (buf
, type
->length (), byte_order
, addr
);
336 address_to_signed_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_signed_integer (buf
, type
->length (), byte_order
, addr
);
346 enum symbol_needs_kind
347 symbol_read_needs (struct symbol
*sym
)
349 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
350 return SYMBOL_COMPUTED_OPS (sym
)->get_symbol_read_needs (sym
);
352 switch (sym
->aclass ())
354 /* All cases listed explicitly so that gcc -Wall will detect it if
355 we failed to consider one. */
357 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
362 case LOC_REGPARM_ADDR
:
364 return SYMBOL_NEEDS_FRAME
;
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
377 case LOC_CONST_BYTES
:
379 case LOC_OPTIMIZED_OUT
:
380 return SYMBOL_NEEDS_NONE
;
382 return SYMBOL_NEEDS_FRAME
;
388 symbol_read_needs_frame (struct symbol
*sym
)
390 return symbol_read_needs (sym
) == SYMBOL_NEEDS_FRAME
;
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.
397 This kind of computation is necessary to correctly handle lexically nested
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. */
405 static frame_info_ptr
406 get_hosting_frame (struct symbol
*var
, const struct block
*var_block
,
407 frame_info_ptr frame
)
409 const struct block
*frame_block
= NULL
;
411 if (!symbol_read_needs_frame (var
))
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
)
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 ())
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. */
434 frame_block
= get_frame_block (frame
, NULL
);
436 /* Climb up the call stack until reaching the frame we are looking for. */
437 while (frame
!= NULL
&& frame_block
!= var_block
)
439 /* Stacks can be quite deep: give the user a chance to stop this. */
442 if (frame_block
== NULL
)
444 frame
= get_prev_frame (frame
);
447 frame_block
= get_frame_block (frame
, NULL
);
450 /* If we failed to find the proper frame, fallback to the heuristic
452 else if (frame_block
->is_global_block ())
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)
463 frame
= frame_follow_static_link (frame
);
464 if (frame
!= nullptr)
466 frame_block
= get_frame_block (frame
, nullptr);
467 if (frame_block
== nullptr)
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 ();
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. */
484 frame
= block_innermost_frame (var_block
);
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 ());
493 error (_("No frame is currently executing in specified"
501 /* See language.h. */
504 language_defn::read_var_value (struct symbol
*var
,
505 const struct block
*var_block
,
506 frame_info_ptr frame
) const
509 struct type
*type
= var
->type ();
511 enum symbol_needs_kind sym_need
;
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. */
518 check_typedef (type
);
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 ());
527 frame
= get_hosting_frame (var
, var_block
, frame
);
529 if (SYMBOL_COMPUTED_OPS (var
) != NULL
)
530 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
532 switch (var
->aclass ())
535 if (is_dynamic_type (type
))
537 /* Value is a constant byte-sequence and needs no memory access. */
538 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
540 /* Put the constant back in target format. */
541 v
= value::allocate (type
);
542 store_signed_integer (v
->contents_raw ().data (), type
->length (),
543 type_byte_order (type
), var
->value_longest ());
544 v
->set_lval (not_lval
);
549 /* Put the constant back in target format. */
550 if (overlay_debugging
)
552 struct objfile
*var_objfile
= var
->objfile ();
553 addr
= symbol_overlayed_address (var
->value_address (),
554 var
->obj_section (var_objfile
));
557 addr
= var
->value_address ();
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. */
562 type
= builtin_type (var
->arch ())->builtin_func_ptr
;
563 v
= value_from_pointer (type
, addr
);
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
568 struct type
*void_ptr_type
569 = builtin_type (var
->arch ())->builtin_data_ptr
;
570 v
= value_cast_pointers (void_ptr_type
, v
, 0);
571 v
->set_lval (not_lval
);
575 case LOC_CONST_BYTES
:
576 if (is_dynamic_type (type
))
578 /* Value is a constant byte-sequence and needs no memory access. */
579 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
581 v
= value::allocate (type
);
582 memcpy (v
->contents_raw ().data (), var
->value_bytes (),
584 v
->set_lval (not_lval
);
588 if (overlay_debugging
)
590 = symbol_overlayed_address (var
->value_address (),
591 var
->obj_section (var
->objfile ()));
593 addr
= var
->value_address ();
597 addr
= get_frame_args_address (frame
);
599 error (_("Unknown argument list address for `%s'."),
601 addr
+= var
->value_longest ();
609 argref
= get_frame_args_address (frame
);
611 error (_("Unknown argument list address for `%s'."),
613 argref
+= var
->value_longest ();
614 ref
= value_at (lookup_pointer_type (type
), argref
);
615 addr
= value_as_address (ref
);
620 addr
= get_frame_locals_address (frame
);
621 addr
+= var
->value_longest ();
625 error (_("Cannot look up value of a typedef `%s'."),
630 if (overlay_debugging
)
631 addr
= symbol_overlayed_address
632 (var
->value_block ()->entry_pc (),
633 var
->obj_section (var
->objfile ()));
635 addr
= var
->value_block ()->entry_pc ();
639 case LOC_REGPARM_ADDR
:
641 int regno
= SYMBOL_REGISTER_OPS (var
)
642 ->register_number (var
, get_frame_arch (frame
));
643 struct value
*regval
;
645 if (var
->aclass () == LOC_REGPARM_ADDR
)
647 regval
= value_from_register (lookup_pointer_type (type
),
652 error (_("Value of register variable not available for `%s'."),
655 addr
= value_as_address (regval
);
659 regval
= value_from_register (type
, regno
, frame
);
662 error (_("Value of register variable not available for `%s'."),
670 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
674 struct obj_section
*obj_section
;
675 bound_minimal_symbol bmsym
;
677 gdbarch_iterate_over_objfiles_in_search_order
679 [var
, &bmsym
] (objfile
*objfile
)
681 bmsym
= lookup_minimal_symbol (var
->linkage_name (), nullptr,
684 /* Stop if a match is found. */
685 return bmsym
.minsym
!= nullptr;
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
692 if (bmsym
.minsym
== nullptr)
694 const char *flavour_name
695 = objfile_flavour_name (var
->objfile ());
697 /* We can't get here unless we've opened the file, so flavour_name
699 gdb_assert (flavour_name
!= NULL
);
700 error (_("Missing %s symbol \"%s\"."),
701 flavour_name
, var
->linkage_name ());
704 obj_section
= bmsym
.minsym
->obj_section (bmsym
.objfile
);
705 /* Relocate address, unless there is no section or the variable is
707 if (obj_section
== NULL
708 || (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
709 addr
= CORE_ADDR (bmsym
.minsym
->unrelocated_address ());
711 addr
= bmsym
.value_address ();
712 if (overlay_debugging
)
713 addr
= symbol_overlayed_address (addr
, obj_section
);
714 /* Determine address of TLS variable. */
716 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
717 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
721 case LOC_OPTIMIZED_OUT
:
722 if (is_dynamic_type (type
))
723 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
724 return value::allocate_optimized_out (type
);
727 error (_("Cannot look up value of a botched symbol `%s'."),
732 v
= value_at_lazy (type
, addr
);
736 /* Calls VAR's language read_var_value hook with the given arguments. */
739 read_var_value (struct symbol
*var
, const struct block
*var_block
,
740 frame_info_ptr frame
)
742 const struct language_defn
*lang
= language_def (var
->language ());
744 gdb_assert (lang
!= NULL
);
746 return lang
->read_var_value (var
, var_block
, frame
);
749 /* Install default attributes for register values. */
752 default_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
753 int regnum
, struct frame_id frame_id
)
755 int len
= type
->length ();
756 struct value
*value
= value::allocate (type
);
757 frame_info_ptr frame
;
759 value
->set_lval (lval_register
);
760 frame
= frame_find_by_id (frame_id
);
763 frame_id
= null_frame_id
;
765 frame_id
= get_frame_id (get_next_frame_sentinel_okay (frame
));
767 VALUE_NEXT_FRAME_ID (value
) = frame_id
;
768 VALUE_REGNUM (value
) = regnum
;
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
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. */
777 value
->set_offset (register_size (gdbarch
, regnum
) - len
);
779 value
->set_offset (0);
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.
789 If any of the registers we try to read are optimized out, then mark the
790 complete resulting value as optimized out. */
793 read_frame_register_value (struct value
*value
, frame_info_ptr frame
)
795 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
797 LONGEST reg_offset
= value
->offset ();
798 int regnum
= VALUE_REGNUM (value
);
799 int len
= type_length_units (check_typedef (value
->type ()));
801 gdb_assert (value
->lval () == lval_register
);
803 /* Skip registers wholly inside of REG_OFFSET. */
804 while (reg_offset
>= register_size (gdbarch
, regnum
))
806 reg_offset
-= register_size (gdbarch
, regnum
);
813 struct value
*regval
= get_frame_register_value (frame
, regnum
);
814 int reg_len
= type_length_units (regval
->type ()) - reg_offset
;
816 /* If the register length is larger than the number of bytes
817 remaining to copy, then only copy the appropriate bytes. */
821 regval
->contents_copy (value
, offset
, reg_offset
, reg_len
);
830 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
833 value_from_register (struct type
*type
, int regnum
, frame_info_ptr frame
)
835 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
836 struct type
*type1
= check_typedef (type
);
839 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
841 int optim
, unavail
, ok
;
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
);
851 v
->set_lval (lval_register
);
852 VALUE_NEXT_FRAME_ID (v
) = get_frame_id (get_next_frame_sentinel_okay (frame
));
853 VALUE_REGNUM (v
) = regnum
;
854 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
855 v
->contents_raw ().data (), &optim
,
861 v
->mark_bytes_optimized_out (0, type
->length ());
863 v
->mark_bytes_unavailable (0, type
->length ());
868 /* Construct the value. */
869 v
= gdbarch_value_from_register (gdbarch
, type
,
870 regnum
, get_frame_id (frame
));
873 read_frame_register_value (v
, frame
);
879 /* Return contents of register REGNUM in frame FRAME as address.
880 Will abort if register value is not available. */
883 address_from_register (int regnum
, frame_info_ptr frame
)
885 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
886 struct type
*type
= builtin_type (gdbarch
)->builtin_data_ptr
;
889 int regnum_max_excl
= gdbarch_num_cooked_regs (gdbarch
);
891 if (regnum
< 0 || regnum
>= regnum_max_excl
)
892 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum
,
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. */
902 /* Some targets require a special conversion routine even for plain
903 pointer types. Avoid constructing a value object in those cases. */
904 if (gdbarch_convert_register_p (gdbarch
, regnum
, type
))
906 gdb_byte
*buf
= (gdb_byte
*) alloca (type
->length ());
907 int optim
, unavail
, ok
;
909 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type
,
910 buf
, &optim
, &unavail
);
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. */
917 error_value_optimized_out ();
920 return unpack_long (type
, buf
);
923 value
= gdbarch_value_from_register (gdbarch
, type
, regnum
, null_frame_id
);
924 read_frame_register_value (value
, frame
);
926 if (value
->optimized_out ())
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. */
932 error_value_optimized_out ();
935 result
= value_as_address (value
);
936 release_value (value
);
942 namespace selftests
{
943 namespace findvar_tests
{
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. */
954 do_cint_test (ULONGEST dest_valu
, ULONGEST dest_vals
, int dest_size
,
955 ULONGEST src_val
, int src_size
)
957 for (int i
= 0; i
< 2 ; i
++)
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
;
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
));
967 /* Store (and later extract) using unsigned to ensure there are no sign
969 store_unsigned_integer (srcbuf
, src_size
, byte_order
, src_val
);
972 memset (destbuf
, 0xaa, sizeof (destbuf
));
973 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, false,
975 SELF_CHECK (dest_valu
== extract_unsigned_integer (destbuf
, dest_size
,
979 memset (destbuf
, 0xaa, sizeof (destbuf
));
980 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, true,
982 SELF_CHECK (dest_vals
== extract_unsigned_integer (destbuf
, dest_size
,
988 copy_integer_to_size_test ()
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);
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);
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);
1002 /* Destination and source are the same size. */
1003 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1005 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1006 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1008 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
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);
1017 } // namespace findvar_test
1018 } // namespace selftests
1022 void _initialize_findvar ();
1024 _initialize_findvar ()
1027 selftests::register_test
1028 ("copy_integer_to_size",
1029 selftests::findvar_tests::copy_integer_to_size_test
);