1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright (C) 1986-2021 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 (SYMBOL_CLASS (sym
))
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. */
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
= SYMBOL_TYPE (var
);
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 (SYMBOL_CLASS (var
))
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 (SYMBOL_CLASS (var
) == 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 memset (&lookup_data
, 0, sizeof (lookup_data
));
755 lookup_data
.name
= var
->linkage_name ();
757 gdbarch_iterate_over_objfiles_in_search_order
759 minsym_lookup_iterator_cb
, &lookup_data
,
760 symbol_objfile (var
));
761 msym
= lookup_data
.result
.minsym
;
763 /* If we can't find the minsym there's a problem in the symbol info.
764 The symbol exists in the debug info, but it's missing in the minsym
768 const char *flavour_name
769 = objfile_flavour_name (symbol_objfile (var
));
771 /* We can't get here unless we've opened the file, so flavour_name
773 gdb_assert (flavour_name
!= NULL
);
774 error (_("Missing %s symbol \"%s\"."),
775 flavour_name
, var
->linkage_name ());
777 obj_section
= msym
->obj_section (lookup_data
.result
.objfile
);
778 /* Relocate address, unless there is no section or the variable is
780 if (obj_section
== NULL
781 || (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
782 addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
);
784 addr
= BMSYMBOL_VALUE_ADDRESS (lookup_data
.result
);
785 if (overlay_debugging
)
786 addr
= symbol_overlayed_address (addr
, obj_section
);
787 /* Determine address of TLS variable. */
789 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
790 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
794 case LOC_OPTIMIZED_OUT
:
795 if (is_dynamic_type (type
))
796 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
797 return allocate_optimized_out_value (type
);
800 error (_("Cannot look up value of a botched symbol `%s'."),
805 v
= value_at_lazy (type
, addr
);
809 /* Calls VAR's language read_var_value hook with the given arguments. */
812 read_var_value (struct symbol
*var
, const struct block
*var_block
,
813 struct frame_info
*frame
)
815 const struct language_defn
*lang
= language_def (var
->language ());
817 gdb_assert (lang
!= NULL
);
819 return lang
->read_var_value (var
, var_block
, frame
);
822 /* Install default attributes for register values. */
825 default_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
826 int regnum
, struct frame_id frame_id
)
828 int len
= TYPE_LENGTH (type
);
829 struct value
*value
= allocate_value (type
);
830 struct frame_info
*frame
;
832 VALUE_LVAL (value
) = lval_register
;
833 frame
= frame_find_by_id (frame_id
);
836 frame_id
= null_frame_id
;
838 frame_id
= get_frame_id (get_next_frame_sentinel_okay (frame
));
840 VALUE_NEXT_FRAME_ID (value
) = frame_id
;
841 VALUE_REGNUM (value
) = regnum
;
843 /* Any structure stored in more than one register will always be
844 an integral number of registers. Otherwise, you need to do
845 some fiddling with the last register copied here for little
847 if (type_byte_order (type
) == BFD_ENDIAN_BIG
848 && len
< register_size (gdbarch
, regnum
))
849 /* Big-endian, and we want less than full size. */
850 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
852 set_value_offset (value
, 0);
857 /* VALUE must be an lval_register value. If regnum is the value's
858 associated register number, and len the length of the values type,
859 read one or more registers in FRAME, starting with register REGNUM,
860 until we've read LEN bytes.
862 If any of the registers we try to read are optimized out, then mark the
863 complete resulting value as optimized out. */
866 read_frame_register_value (struct value
*value
, struct frame_info
*frame
)
868 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
870 LONGEST reg_offset
= value_offset (value
);
871 int regnum
= VALUE_REGNUM (value
);
872 int len
= type_length_units (check_typedef (value_type (value
)));
874 gdb_assert (VALUE_LVAL (value
) == lval_register
);
876 /* Skip registers wholly inside of REG_OFFSET. */
877 while (reg_offset
>= register_size (gdbarch
, regnum
))
879 reg_offset
-= register_size (gdbarch
, regnum
);
886 struct value
*regval
= get_frame_register_value (frame
, regnum
);
887 int reg_len
= type_length_units (value_type (regval
)) - reg_offset
;
889 /* If the register length is larger than the number of bytes
890 remaining to copy, then only copy the appropriate bytes. */
894 value_contents_copy (value
, offset
, regval
, reg_offset
, reg_len
);
903 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
906 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
908 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
909 struct type
*type1
= check_typedef (type
);
912 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
914 int optim
, unavail
, ok
;
916 /* The ISA/ABI need to something weird when obtaining the
917 specified value from this register. It might need to
918 re-order non-adjacent, starting with REGNUM (see MIPS and
919 i386). It might need to convert the [float] register into
920 the corresponding [integer] type (see Alpha). The assumption
921 is that gdbarch_register_to_value populates the entire value
922 including the location. */
923 v
= allocate_value (type
);
924 VALUE_LVAL (v
) = lval_register
;
925 VALUE_NEXT_FRAME_ID (v
) = get_frame_id (get_next_frame_sentinel_okay (frame
));
926 VALUE_REGNUM (v
) = regnum
;
927 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
928 value_contents_raw (v
).data (), &optim
,
934 mark_value_bytes_optimized_out (v
, 0, TYPE_LENGTH (type
));
936 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
941 /* Construct the value. */
942 v
= gdbarch_value_from_register (gdbarch
, type
,
943 regnum
, get_frame_id (frame
));
946 read_frame_register_value (v
, frame
);
952 /* Return contents of register REGNUM in frame FRAME as address.
953 Will abort if register value is not available. */
956 address_from_register (int regnum
, struct frame_info
*frame
)
958 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
959 struct type
*type
= builtin_type (gdbarch
)->builtin_data_ptr
;
962 int regnum_max_excl
= gdbarch_num_cooked_regs (gdbarch
);
964 if (regnum
< 0 || regnum
>= regnum_max_excl
)
965 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum
,
968 /* This routine may be called during early unwinding, at a time
969 where the ID of FRAME is not yet known. Calling value_from_register
970 would therefore abort in get_frame_id. However, since we only need
971 a temporary value that is never used as lvalue, we actually do not
972 really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
973 the core of value_from_register, but use the null_frame_id. */
975 /* Some targets require a special conversion routine even for plain
976 pointer types. Avoid constructing a value object in those cases. */
977 if (gdbarch_convert_register_p (gdbarch
, regnum
, type
))
979 gdb_byte
*buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
980 int optim
, unavail
, ok
;
982 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type
,
983 buf
, &optim
, &unavail
);
986 /* This function is used while computing a location expression.
987 Complain about the value being optimized out, rather than
988 letting value_as_address complain about some random register
989 the expression depends on not being saved. */
990 error_value_optimized_out ();
993 return unpack_long (type
, buf
);
996 value
= gdbarch_value_from_register (gdbarch
, type
, regnum
, null_frame_id
);
997 read_frame_register_value (value
, frame
);
999 if (value_optimized_out (value
))
1001 /* This function is used while computing a location expression.
1002 Complain about the value being optimized out, rather than
1003 letting value_as_address complain about some random register
1004 the expression depends on not being saved. */
1005 error_value_optimized_out ();
1008 result
= value_as_address (value
);
1009 release_value (value
);
1015 namespace selftests
{
1016 namespace findvar_tests
{
1018 /* Function to test copy_integer_to_size. Store SOURCE_VAL with size
1019 SOURCE_SIZE to a buffer, making sure no sign extending happens at this
1020 stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
1021 copied value and compare to DEST_VALU. Copy again with a signed
1022 copy_integer_to_size and compare to DEST_VALS. Do everything for both
1023 LITTLE and BIG target endians. Use unsigned values throughout to make
1024 sure there are no implicit sign extensions. */
1027 do_cint_test (ULONGEST dest_valu
, ULONGEST dest_vals
, int dest_size
,
1028 ULONGEST src_val
, int src_size
)
1030 for (int i
= 0; i
< 2 ; i
++)
1032 gdb_byte srcbuf
[sizeof (ULONGEST
)] = {};
1033 gdb_byte destbuf
[sizeof (ULONGEST
)] = {};
1034 enum bfd_endian byte_order
= i
? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
1036 /* Fill the src buffer (and later the dest buffer) with non-zero junk,
1037 to ensure zero extensions aren't hidden. */
1038 memset (srcbuf
, 0xaa, sizeof (srcbuf
));
1040 /* Store (and later extract) using unsigned to ensure there are no sign
1042 store_unsigned_integer (srcbuf
, src_size
, byte_order
, src_val
);
1044 /* Test unsigned. */
1045 memset (destbuf
, 0xaa, sizeof (destbuf
));
1046 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, false,
1048 SELF_CHECK (dest_valu
== extract_unsigned_integer (destbuf
, dest_size
,
1052 memset (destbuf
, 0xaa, sizeof (destbuf
));
1053 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, true,
1055 SELF_CHECK (dest_vals
== extract_unsigned_integer (destbuf
, dest_size
,
1061 copy_integer_to_size_test ()
1063 /* Destination is bigger than the source, which has the signed bit unset. */
1064 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1065 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1067 /* Destination is bigger than the source, which has the signed bit set. */
1068 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1069 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1071 /* Destination is smaller than the source. */
1072 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1073 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1075 /* Destination and source are the same size. */
1076 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1078 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1079 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1081 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1083 /* Destination is bigger than the source. Source is bigger than 32bits. */
1084 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1085 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1086 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1087 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1090 } // namespace findvar_test
1091 } // namespace selftests
1095 void _initialize_findvar ();
1097 _initialize_findvar ()
1100 selftests::register_test
1101 ("copy_integer_to_size",
1102 selftests::findvar_tests::copy_integer_to_size_test
);