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
),
631 (LONGEST
) SYMBOL_VALUE (var
));
632 VALUE_LVAL (v
) = not_lval
;
636 /* Put the constant back in target format. */
637 v
= allocate_value (type
);
638 if (overlay_debugging
)
640 struct objfile
*var_objfile
= symbol_objfile (var
);
641 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
642 var
->obj_section (var_objfile
));
643 store_typed_address (value_contents_raw (v
).data (), type
, addr
);
646 store_typed_address (value_contents_raw (v
).data (), type
,
647 SYMBOL_VALUE_ADDRESS (var
));
648 VALUE_LVAL (v
) = not_lval
;
651 case LOC_CONST_BYTES
:
652 if (is_dynamic_type (type
))
654 /* Value is a constant byte-sequence and needs no memory access. */
655 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
657 v
= allocate_value (type
);
658 memcpy (value_contents_raw (v
).data (), SYMBOL_VALUE_BYTES (var
),
660 VALUE_LVAL (v
) = not_lval
;
664 if (overlay_debugging
)
666 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
667 var
->obj_section (symbol_objfile (var
)));
669 addr
= SYMBOL_VALUE_ADDRESS (var
);
673 addr
= get_frame_args_address (frame
);
675 error (_("Unknown argument list address for `%s'."),
677 addr
+= SYMBOL_VALUE (var
);
685 argref
= get_frame_args_address (frame
);
687 error (_("Unknown argument list address for `%s'."),
689 argref
+= SYMBOL_VALUE (var
);
690 ref
= value_at (lookup_pointer_type (type
), argref
);
691 addr
= value_as_address (ref
);
696 addr
= get_frame_locals_address (frame
);
697 addr
+= SYMBOL_VALUE (var
);
701 error (_("Cannot look up value of a typedef `%s'."),
706 if (overlay_debugging
)
707 addr
= symbol_overlayed_address
708 (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var
)),
709 var
->obj_section (symbol_objfile (var
)));
711 addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var
));
715 case LOC_REGPARM_ADDR
:
717 int regno
= SYMBOL_REGISTER_OPS (var
)
718 ->register_number (var
, get_frame_arch (frame
));
719 struct value
*regval
;
721 if (var
->aclass () == LOC_REGPARM_ADDR
)
723 regval
= value_from_register (lookup_pointer_type (type
),
728 error (_("Value of register variable not available for `%s'."),
731 addr
= value_as_address (regval
);
735 regval
= value_from_register (type
, regno
, frame
);
738 error (_("Value of register variable not available for `%s'."),
746 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
750 struct minsym_lookup_data lookup_data
;
751 struct minimal_symbol
*msym
;
752 struct obj_section
*obj_section
;
754 lookup_data
.name
= var
->linkage_name ();
756 gdbarch_iterate_over_objfiles_in_search_order
758 minsym_lookup_iterator_cb
, &lookup_data
,
759 symbol_objfile (var
));
760 msym
= lookup_data
.result
.minsym
;
762 /* If we can't find the minsym there's a problem in the symbol info.
763 The symbol exists in the debug info, but it's missing in the minsym
767 const char *flavour_name
768 = objfile_flavour_name (symbol_objfile (var
));
770 /* We can't get here unless we've opened the file, so flavour_name
772 gdb_assert (flavour_name
!= NULL
);
773 error (_("Missing %s symbol \"%s\"."),
774 flavour_name
, var
->linkage_name ());
776 obj_section
= msym
->obj_section (lookup_data
.result
.objfile
);
777 /* Relocate address, unless there is no section or the variable is
779 if (obj_section
== NULL
780 || (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
781 addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
);
783 addr
= BMSYMBOL_VALUE_ADDRESS (lookup_data
.result
);
784 if (overlay_debugging
)
785 addr
= symbol_overlayed_address (addr
, obj_section
);
786 /* Determine address of TLS variable. */
788 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
789 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
793 case LOC_OPTIMIZED_OUT
:
794 if (is_dynamic_type (type
))
795 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
796 return allocate_optimized_out_value (type
);
799 error (_("Cannot look up value of a botched symbol `%s'."),
804 v
= value_at_lazy (type
, addr
);
808 /* Calls VAR's language read_var_value hook with the given arguments. */
811 read_var_value (struct symbol
*var
, const struct block
*var_block
,
812 struct frame_info
*frame
)
814 const struct language_defn
*lang
= language_def (var
->language ());
816 gdb_assert (lang
!= NULL
);
818 return lang
->read_var_value (var
, var_block
, frame
);
821 /* Install default attributes for register values. */
824 default_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
825 int regnum
, struct frame_id frame_id
)
827 int len
= TYPE_LENGTH (type
);
828 struct value
*value
= allocate_value (type
);
829 struct frame_info
*frame
;
831 VALUE_LVAL (value
) = lval_register
;
832 frame
= frame_find_by_id (frame_id
);
835 frame_id
= null_frame_id
;
837 frame_id
= get_frame_id (get_next_frame_sentinel_okay (frame
));
839 VALUE_NEXT_FRAME_ID (value
) = frame_id
;
840 VALUE_REGNUM (value
) = regnum
;
842 /* Any structure stored in more than one register will always be
843 an integral number of registers. Otherwise, you need to do
844 some fiddling with the last register copied here for little
846 if (type_byte_order (type
) == BFD_ENDIAN_BIG
847 && len
< register_size (gdbarch
, regnum
))
848 /* Big-endian, and we want less than full size. */
849 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
851 set_value_offset (value
, 0);
856 /* VALUE must be an lval_register value. If regnum is the value's
857 associated register number, and len the length of the values type,
858 read one or more registers in FRAME, starting with register REGNUM,
859 until we've read LEN bytes.
861 If any of the registers we try to read are optimized out, then mark the
862 complete resulting value as optimized out. */
865 read_frame_register_value (struct value
*value
, struct frame_info
*frame
)
867 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
869 LONGEST reg_offset
= value_offset (value
);
870 int regnum
= VALUE_REGNUM (value
);
871 int len
= type_length_units (check_typedef (value_type (value
)));
873 gdb_assert (VALUE_LVAL (value
) == lval_register
);
875 /* Skip registers wholly inside of REG_OFFSET. */
876 while (reg_offset
>= register_size (gdbarch
, regnum
))
878 reg_offset
-= register_size (gdbarch
, regnum
);
885 struct value
*regval
= get_frame_register_value (frame
, regnum
);
886 int reg_len
= type_length_units (value_type (regval
)) - reg_offset
;
888 /* If the register length is larger than the number of bytes
889 remaining to copy, then only copy the appropriate bytes. */
893 value_contents_copy (value
, offset
, regval
, reg_offset
, reg_len
);
902 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
905 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
907 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
908 struct type
*type1
= check_typedef (type
);
911 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
913 int optim
, unavail
, ok
;
915 /* The ISA/ABI need to something weird when obtaining the
916 specified value from this register. It might need to
917 re-order non-adjacent, starting with REGNUM (see MIPS and
918 i386). It might need to convert the [float] register into
919 the corresponding [integer] type (see Alpha). The assumption
920 is that gdbarch_register_to_value populates the entire value
921 including the location. */
922 v
= allocate_value (type
);
923 VALUE_LVAL (v
) = lval_register
;
924 VALUE_NEXT_FRAME_ID (v
) = get_frame_id (get_next_frame_sentinel_okay (frame
));
925 VALUE_REGNUM (v
) = regnum
;
926 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
927 value_contents_raw (v
).data (), &optim
,
933 mark_value_bytes_optimized_out (v
, 0, TYPE_LENGTH (type
));
935 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
940 /* Construct the value. */
941 v
= gdbarch_value_from_register (gdbarch
, type
,
942 regnum
, get_frame_id (frame
));
945 read_frame_register_value (v
, frame
);
951 /* Return contents of register REGNUM in frame FRAME as address.
952 Will abort if register value is not available. */
955 address_from_register (int regnum
, struct frame_info
*frame
)
957 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
958 struct type
*type
= builtin_type (gdbarch
)->builtin_data_ptr
;
961 int regnum_max_excl
= gdbarch_num_cooked_regs (gdbarch
);
963 if (regnum
< 0 || regnum
>= regnum_max_excl
)
964 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum
,
967 /* This routine may be called during early unwinding, at a time
968 where the ID of FRAME is not yet known. Calling value_from_register
969 would therefore abort in get_frame_id. However, since we only need
970 a temporary value that is never used as lvalue, we actually do not
971 really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
972 the core of value_from_register, but use the null_frame_id. */
974 /* Some targets require a special conversion routine even for plain
975 pointer types. Avoid constructing a value object in those cases. */
976 if (gdbarch_convert_register_p (gdbarch
, regnum
, type
))
978 gdb_byte
*buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
979 int optim
, unavail
, ok
;
981 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type
,
982 buf
, &optim
, &unavail
);
985 /* This function is used while computing a location expression.
986 Complain about the value being optimized out, rather than
987 letting value_as_address complain about some random register
988 the expression depends on not being saved. */
989 error_value_optimized_out ();
992 return unpack_long (type
, buf
);
995 value
= gdbarch_value_from_register (gdbarch
, type
, regnum
, null_frame_id
);
996 read_frame_register_value (value
, frame
);
998 if (value_optimized_out (value
))
1000 /* This function is used while computing a location expression.
1001 Complain about the value being optimized out, rather than
1002 letting value_as_address complain about some random register
1003 the expression depends on not being saved. */
1004 error_value_optimized_out ();
1007 result
= value_as_address (value
);
1008 release_value (value
);
1014 namespace selftests
{
1015 namespace findvar_tests
{
1017 /* Function to test copy_integer_to_size. Store SOURCE_VAL with size
1018 SOURCE_SIZE to a buffer, making sure no sign extending happens at this
1019 stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
1020 copied value and compare to DEST_VALU. Copy again with a signed
1021 copy_integer_to_size and compare to DEST_VALS. Do everything for both
1022 LITTLE and BIG target endians. Use unsigned values throughout to make
1023 sure there are no implicit sign extensions. */
1026 do_cint_test (ULONGEST dest_valu
, ULONGEST dest_vals
, int dest_size
,
1027 ULONGEST src_val
, int src_size
)
1029 for (int i
= 0; i
< 2 ; i
++)
1031 gdb_byte srcbuf
[sizeof (ULONGEST
)] = {};
1032 gdb_byte destbuf
[sizeof (ULONGEST
)] = {};
1033 enum bfd_endian byte_order
= i
? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
1035 /* Fill the src buffer (and later the dest buffer) with non-zero junk,
1036 to ensure zero extensions aren't hidden. */
1037 memset (srcbuf
, 0xaa, sizeof (srcbuf
));
1039 /* Store (and later extract) using unsigned to ensure there are no sign
1041 store_unsigned_integer (srcbuf
, src_size
, byte_order
, src_val
);
1043 /* Test unsigned. */
1044 memset (destbuf
, 0xaa, sizeof (destbuf
));
1045 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, false,
1047 SELF_CHECK (dest_valu
== extract_unsigned_integer (destbuf
, dest_size
,
1051 memset (destbuf
, 0xaa, sizeof (destbuf
));
1052 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, true,
1054 SELF_CHECK (dest_vals
== extract_unsigned_integer (destbuf
, dest_size
,
1060 copy_integer_to_size_test ()
1062 /* Destination is bigger than the source, which has the signed bit unset. */
1063 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1064 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1066 /* Destination is bigger than the source, which has the signed bit set. */
1067 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1068 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1070 /* Destination is smaller than the source. */
1071 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1072 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1074 /* Destination and source are the same size. */
1075 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1077 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1078 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1080 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1082 /* Destination is bigger than the source. Source is bigger than 32bits. */
1083 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1084 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1085 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1086 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1089 } // namespace findvar_test
1090 } // namespace selftests
1094 void _initialize_findvar ();
1096 _initialize_findvar ()
1099 selftests::register_test
1100 ("copy_integer_to_size",
1101 selftests::findvar_tests::copy_integer_to_size_test
);