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 (const gdb_byte
*addr
, int len
, enum bfd_endian byte_order
)
53 typename
std::make_unsigned
<T
>::type retval
= 0;
54 const unsigned char *p
;
55 const unsigned char *startaddr
= addr
;
56 const unsigned char *endaddr
= startaddr
+ len
;
58 if (len
> (int) sizeof (T
))
60 That operation is not available on integers of more than %d bytes."),
63 /* Start at the most significant end of the integer, and work towards
64 the least significant. */
65 if (byte_order
== BFD_ENDIAN_BIG
)
68 if (std::is_signed
<T
>::value
)
70 /* Do the sign extension once at the start. */
71 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
74 for (; p
< endaddr
; ++p
)
75 retval
= (retval
<< 8) | *p
;
80 if (std::is_signed
<T
>::value
)
82 /* Do the sign extension once at the start. */
83 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
86 for (; p
>= startaddr
; --p
)
87 retval
= (retval
<< 8) | *p
;
92 /* Explicit instantiations. */
93 template LONGEST extract_integer
<LONGEST
> (const gdb_byte
*addr
, int len
,
94 enum bfd_endian byte_order
);
95 template ULONGEST extract_integer
<ULONGEST
> (const gdb_byte
*addr
, int len
,
96 enum bfd_endian byte_order
);
98 /* Sometimes a long long unsigned integer can be extracted as a
99 LONGEST value. This is done so that we can print these values
100 better. If this integer can be converted to a LONGEST, this
101 function returns 1 and sets *PVAL. Otherwise it returns 0. */
104 extract_long_unsigned_integer (const gdb_byte
*addr
, int orig_len
,
105 enum bfd_endian byte_order
, LONGEST
*pval
)
108 const gdb_byte
*first_addr
;
112 if (byte_order
== BFD_ENDIAN_BIG
)
115 len
> (int) sizeof (LONGEST
) && p
< addr
+ orig_len
;
128 for (p
= addr
+ orig_len
- 1;
129 len
> (int) sizeof (LONGEST
) && p
>= addr
;
139 if (len
<= (int) sizeof (LONGEST
))
141 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
151 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
152 address it represents. */
154 extract_typed_address (const gdb_byte
*buf
, struct type
*type
)
156 if (!type
->is_pointer_or_reference ())
157 internal_error (__FILE__
, __LINE__
,
158 _("extract_typed_address: "
159 "type is not a pointer or reference"));
161 return gdbarch_pointer_to_address (type
->arch (), type
, buf
);
164 /* All 'store' functions accept a host-format integer and store a
165 target-format integer at ADDR which is LEN bytes long. */
166 template<typename T
, typename
>
168 store_integer (gdb_byte
*addr
, int len
, enum bfd_endian byte_order
,
172 gdb_byte
*startaddr
= addr
;
173 gdb_byte
*endaddr
= startaddr
+ len
;
175 /* Start at the least significant end of the integer, and work towards
176 the most significant. */
177 if (byte_order
== BFD_ENDIAN_BIG
)
179 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
187 for (p
= startaddr
; p
< endaddr
; ++p
)
195 /* Explicit instantiations. */
196 template void store_integer (gdb_byte
*addr
, int len
,
197 enum bfd_endian byte_order
,
200 template void store_integer (gdb_byte
*addr
, int len
,
201 enum bfd_endian byte_order
,
204 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
207 store_typed_address (gdb_byte
*buf
, struct type
*type
, CORE_ADDR addr
)
209 if (!type
->is_pointer_or_reference ())
210 internal_error (__FILE__
, __LINE__
,
211 _("store_typed_address: "
212 "type is not a pointer or reference"));
214 gdbarch_address_to_pointer (type
->arch (), type
, buf
, addr
);
217 /* Copy a value from SOURCE of size SOURCE_SIZE bytes to DEST of size DEST_SIZE
218 bytes. If SOURCE_SIZE is greater than DEST_SIZE, then truncate the most
219 significant bytes. If SOURCE_SIZE is less than DEST_SIZE then either sign
220 or zero extended according to IS_SIGNED. Values are stored in memory with
221 endianness BYTE_ORDER. */
224 copy_integer_to_size (gdb_byte
*dest
, int dest_size
, const gdb_byte
*source
,
225 int source_size
, bool is_signed
,
226 enum bfd_endian byte_order
)
228 signed int size_diff
= dest_size
- source_size
;
230 /* Copy across everything from SOURCE that can fit into DEST. */
232 if (byte_order
== BFD_ENDIAN_BIG
&& size_diff
> 0)
233 memcpy (dest
+ size_diff
, source
, source_size
);
234 else if (byte_order
== BFD_ENDIAN_BIG
&& size_diff
< 0)
235 memcpy (dest
, source
- size_diff
, dest_size
);
237 memcpy (dest
, source
, std::min (source_size
, dest_size
));
239 /* Fill the remaining space in DEST by either zero extending or sign
244 gdb_byte extension
= 0;
246 && ((byte_order
!= BFD_ENDIAN_BIG
&& source
[source_size
- 1] & 0x80)
247 || (byte_order
== BFD_ENDIAN_BIG
&& source
[0] & 0x80)))
250 /* Extend into MSBs of SOURCE. */
251 if (byte_order
== BFD_ENDIAN_BIG
)
252 memset (dest
, extension
, size_diff
);
254 memset (dest
+ source_size
, extension
, size_diff
);
258 /* Return a `value' with the contents of (virtual or cooked) register
259 REGNUM as found in the specified FRAME. The register's type is
260 determined by register_type (). */
263 value_of_register (int regnum
, struct frame_info
*frame
)
265 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
266 struct value
*reg_val
;
268 /* User registers lie completely outside of the range of normal
269 registers. Catch them early so that the target never sees them. */
270 if (regnum
>= gdbarch_num_cooked_regs (gdbarch
))
271 return value_of_user_reg (regnum
, frame
);
273 reg_val
= value_of_register_lazy (frame
, regnum
);
274 value_fetch_lazy (reg_val
);
278 /* Return a `value' with the contents of (virtual or cooked) register
279 REGNUM as found in the specified FRAME. The register's type is
280 determined by register_type (). The value is not fetched. */
283 value_of_register_lazy (struct frame_info
*frame
, int regnum
)
285 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
286 struct value
*reg_val
;
287 struct frame_info
*next_frame
;
289 gdb_assert (regnum
< gdbarch_num_cooked_regs (gdbarch
));
291 gdb_assert (frame
!= NULL
);
293 next_frame
= get_next_frame_sentinel_okay (frame
);
295 /* In some cases NEXT_FRAME may not have a valid frame-id yet. This can
296 happen if we end up trying to unwind a register as part of the frame
297 sniffer. The only time that we get here without a valid frame-id is
298 if NEXT_FRAME is an inline frame. If this is the case then we can
299 avoid getting into trouble here by skipping past the inline frames. */
300 while (get_frame_type (next_frame
) == INLINE_FRAME
)
301 next_frame
= get_next_frame_sentinel_okay (next_frame
);
303 /* We should have a valid next frame. */
304 gdb_assert (frame_id_p (get_frame_id (next_frame
)));
306 reg_val
= allocate_value_lazy (register_type (gdbarch
, regnum
));
307 VALUE_LVAL (reg_val
) = lval_register
;
308 VALUE_REGNUM (reg_val
) = regnum
;
309 VALUE_NEXT_FRAME_ID (reg_val
) = get_frame_id (next_frame
);
314 /* Given a pointer of type TYPE in target form in BUF, return the
315 address it represents. */
317 unsigned_pointer_to_address (struct gdbarch
*gdbarch
,
318 struct type
*type
, const gdb_byte
*buf
)
320 enum bfd_endian byte_order
= type_byte_order (type
);
322 return extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
326 signed_pointer_to_address (struct gdbarch
*gdbarch
,
327 struct type
*type
, const gdb_byte
*buf
)
329 enum bfd_endian byte_order
= type_byte_order (type
);
331 return extract_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
);
334 /* Given an address, store it as a pointer of type TYPE in target
337 unsigned_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
338 gdb_byte
*buf
, CORE_ADDR addr
)
340 enum bfd_endian byte_order
= type_byte_order (type
);
342 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
346 address_to_signed_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
347 gdb_byte
*buf
, CORE_ADDR addr
)
349 enum bfd_endian byte_order
= type_byte_order (type
);
351 store_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
356 enum symbol_needs_kind
357 symbol_read_needs (struct symbol
*sym
)
359 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
360 return SYMBOL_COMPUTED_OPS (sym
)->get_symbol_read_needs (sym
);
362 switch (SYMBOL_CLASS (sym
))
364 /* All cases listed explicitly so that gcc -Wall will detect it if
365 we failed to consider one. */
367 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
372 case LOC_REGPARM_ADDR
:
374 return SYMBOL_NEEDS_FRAME
;
382 /* Getting the address of a label can be done independently of the block,
383 even if some *uses* of that address wouldn't work so well without
387 case LOC_CONST_BYTES
:
389 case LOC_OPTIMIZED_OUT
:
390 return SYMBOL_NEEDS_NONE
;
392 return SYMBOL_NEEDS_FRAME
;
398 symbol_read_needs_frame (struct symbol
*sym
)
400 return symbol_read_needs (sym
) == SYMBOL_NEEDS_FRAME
;
403 /* Private data to be used with minsym_lookup_iterator_cb. */
405 struct minsym_lookup_data
407 /* The name of the minimal symbol we are searching for. */
410 /* The field where the callback should store the minimal symbol
411 if found. It should be initialized to NULL before the search
413 struct bound_minimal_symbol result
;
416 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
417 It searches by name for a minimal symbol within the given OBJFILE.
418 The arguments are passed via CB_DATA, which in reality is a pointer
419 to struct minsym_lookup_data. */
422 minsym_lookup_iterator_cb (struct objfile
*objfile
, void *cb_data
)
424 struct minsym_lookup_data
*data
= (struct minsym_lookup_data
*) cb_data
;
426 gdb_assert (data
->result
.minsym
== NULL
);
428 data
->result
= lookup_minimal_symbol (data
->name
, NULL
, objfile
);
430 /* The iterator should stop iff a match was found. */
431 return (data
->result
.minsym
!= NULL
);
434 /* Given static link expression and the frame it lives in, look for the frame
435 the static links points to and return it. Return NULL if we could not find
438 static struct frame_info
*
439 follow_static_link (struct frame_info
*frame
,
440 const struct dynamic_prop
*static_link
)
442 CORE_ADDR upper_frame_base
;
444 if (!dwarf2_evaluate_property (static_link
, frame
, NULL
, &upper_frame_base
))
447 /* Now climb up the stack frame until we reach the frame we are interested
449 for (; frame
!= NULL
; frame
= get_prev_frame (frame
))
451 struct symbol
*framefunc
= get_frame_function (frame
);
453 /* Stacks can be quite deep: give the user a chance to stop this. */
456 /* If we don't know how to compute FRAME's base address, don't give up:
457 maybe the frame we are looking for is upper in the stack frame. */
458 if (framefunc
!= NULL
459 && SYMBOL_BLOCK_OPS (framefunc
) != NULL
460 && SYMBOL_BLOCK_OPS (framefunc
)->get_frame_base
!= NULL
461 && (SYMBOL_BLOCK_OPS (framefunc
)->get_frame_base (framefunc
, frame
)
462 == upper_frame_base
))
469 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
470 rules, look for the frame that is actually hosting VAR and return it. If,
471 for some reason, we found no such frame, return NULL.
473 This kind of computation is necessary to correctly handle lexically nested
476 Note that in some cases, we know what scope VAR comes from but we cannot
477 reach the specific frame that hosts the instance of VAR we are looking for.
478 For backward compatibility purposes (with old compilers), we then look for
479 the first frame that can host it. */
481 static struct frame_info
*
482 get_hosting_frame (struct symbol
*var
, const struct block
*var_block
,
483 struct frame_info
*frame
)
485 const struct block
*frame_block
= NULL
;
487 if (!symbol_read_needs_frame (var
))
490 /* Some symbols for local variables have no block: this happens when they are
491 not produced by a debug information reader, for instance when GDB creates
492 synthetic symbols. Without block information, we must assume they are
493 local to FRAME. In this case, there is nothing to do. */
494 else if (var_block
== NULL
)
497 /* We currently assume that all symbols with a location list need a frame.
498 This is true in practice because selecting the location description
499 requires to compute the CFA, hence requires a frame. However we have
500 tests that embed global/static symbols with null location lists.
501 We want to get <optimized out> instead of <frame required> when evaluating
502 them so return a frame instead of raising an error. */
503 else if (var_block
== block_global_block (var_block
)
504 || var_block
== block_static_block (var_block
))
507 /* We have to handle the "my_func::my_local_var" notation. This requires us
508 to look for upper frames when we find no block for the current frame: here
509 and below, handle when frame_block == NULL. */
511 frame_block
= get_frame_block (frame
, NULL
);
513 /* Climb up the call stack until reaching the frame we are looking for. */
514 while (frame
!= NULL
&& frame_block
!= var_block
)
516 /* Stacks can be quite deep: give the user a chance to stop this. */
519 if (frame_block
== NULL
)
521 frame
= get_prev_frame (frame
);
524 frame_block
= get_frame_block (frame
, NULL
);
527 /* If we failed to find the proper frame, fallback to the heuristic
529 else if (frame_block
== block_global_block (frame_block
))
535 /* Assuming we have a block for this frame: if we are at the function
536 level, the immediate upper lexical block is in an outer function:
537 follow the static link. */
538 else if (BLOCK_FUNCTION (frame_block
))
540 const struct dynamic_prop
*static_link
541 = block_static_link (frame_block
);
542 int could_climb_up
= 0;
544 if (static_link
!= NULL
)
546 frame
= follow_static_link (frame
, static_link
);
549 frame_block
= get_frame_block (frame
, NULL
);
550 could_climb_up
= frame_block
!= NULL
;
561 /* We must be in some function nested lexical block. Just get the
562 outer block: both must share the same frame. */
563 frame_block
= BLOCK_SUPERBLOCK (frame_block
);
566 /* Old compilers may not provide a static link, or they may provide an
567 invalid one. For such cases, fallback on the old way to evaluate
568 non-local references: just climb up the call stack and pick the first
569 frame that contains the variable we are looking for. */
572 frame
= block_innermost_frame (var_block
);
575 if (BLOCK_FUNCTION (var_block
)
576 && !block_inlined_p (var_block
)
577 && BLOCK_FUNCTION (var_block
)->print_name ())
578 error (_("No frame is currently executing in block %s."),
579 BLOCK_FUNCTION (var_block
)->print_name ());
581 error (_("No frame is currently executing in specified"
589 /* See language.h. */
592 language_defn::read_var_value (struct symbol
*var
,
593 const struct block
*var_block
,
594 struct frame_info
*frame
) const
597 struct type
*type
= SYMBOL_TYPE (var
);
599 enum symbol_needs_kind sym_need
;
601 /* Call check_typedef on our type to make sure that, if TYPE is
602 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
603 instead of zero. However, we do not replace the typedef type by the
604 target type, because we want to keep the typedef in order to be able to
605 set the returned value type description correctly. */
606 check_typedef (type
);
608 sym_need
= symbol_read_needs (var
);
609 if (sym_need
== SYMBOL_NEEDS_FRAME
)
610 gdb_assert (frame
!= NULL
);
611 else if (sym_need
== SYMBOL_NEEDS_REGISTERS
&& !target_has_registers ())
612 error (_("Cannot read `%s' without registers"), var
->print_name ());
615 frame
= get_hosting_frame (var
, var_block
, frame
);
617 if (SYMBOL_COMPUTED_OPS (var
) != NULL
)
618 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
620 switch (SYMBOL_CLASS (var
))
623 if (is_dynamic_type (type
))
625 /* Value is a constant byte-sequence and needs no memory access. */
626 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
628 /* Put the constant back in target format. */
629 v
= allocate_value (type
);
630 store_signed_integer (value_contents_raw (v
), TYPE_LENGTH (type
),
631 type_byte_order (type
),
632 (LONGEST
) SYMBOL_VALUE (var
));
633 VALUE_LVAL (v
) = not_lval
;
637 /* Put the constant back in target format. */
638 v
= allocate_value (type
);
639 if (overlay_debugging
)
641 struct objfile
*var_objfile
= symbol_objfile (var
);
642 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
643 var
->obj_section (var_objfile
));
644 store_typed_address (value_contents_raw (v
), type
, addr
);
647 store_typed_address (value_contents_raw (v
), type
,
648 SYMBOL_VALUE_ADDRESS (var
));
649 VALUE_LVAL (v
) = not_lval
;
652 case LOC_CONST_BYTES
:
653 if (is_dynamic_type (type
))
655 /* Value is a constant byte-sequence and needs no memory access. */
656 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
658 v
= allocate_value (type
);
659 memcpy (value_contents_raw (v
), SYMBOL_VALUE_BYTES (var
),
661 VALUE_LVAL (v
) = not_lval
;
665 if (overlay_debugging
)
667 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
668 var
->obj_section (symbol_objfile (var
)));
670 addr
= SYMBOL_VALUE_ADDRESS (var
);
674 addr
= get_frame_args_address (frame
);
676 error (_("Unknown argument list address for `%s'."),
678 addr
+= SYMBOL_VALUE (var
);
686 argref
= get_frame_args_address (frame
);
688 error (_("Unknown argument list address for `%s'."),
690 argref
+= SYMBOL_VALUE (var
);
691 ref
= value_at (lookup_pointer_type (type
), argref
);
692 addr
= value_as_address (ref
);
697 addr
= get_frame_locals_address (frame
);
698 addr
+= SYMBOL_VALUE (var
);
702 error (_("Cannot look up value of a typedef `%s'."),
707 if (overlay_debugging
)
708 addr
= symbol_overlayed_address
709 (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var
)),
710 var
->obj_section (symbol_objfile (var
)));
712 addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var
));
716 case LOC_REGPARM_ADDR
:
718 int regno
= SYMBOL_REGISTER_OPS (var
)
719 ->register_number (var
, get_frame_arch (frame
));
720 struct value
*regval
;
722 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
724 regval
= value_from_register (lookup_pointer_type (type
),
729 error (_("Value of register variable not available for `%s'."),
732 addr
= value_as_address (regval
);
736 regval
= value_from_register (type
, regno
, frame
);
739 error (_("Value of register variable not available for `%s'."),
747 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
751 struct minsym_lookup_data lookup_data
;
752 struct minimal_symbol
*msym
;
753 struct obj_section
*obj_section
;
755 memset (&lookup_data
, 0, sizeof (lookup_data
));
756 lookup_data
.name
= var
->linkage_name ();
758 gdbarch_iterate_over_objfiles_in_search_order
760 minsym_lookup_iterator_cb
, &lookup_data
,
761 symbol_objfile (var
));
762 msym
= lookup_data
.result
.minsym
;
764 /* If we can't find the minsym there's a problem in the symbol info.
765 The symbol exists in the debug info, but it's missing in the minsym
769 const char *flavour_name
770 = objfile_flavour_name (symbol_objfile (var
));
772 /* We can't get here unless we've opened the file, so flavour_name
774 gdb_assert (flavour_name
!= NULL
);
775 error (_("Missing %s symbol \"%s\"."),
776 flavour_name
, var
->linkage_name ());
778 obj_section
= msym
->obj_section (lookup_data
.result
.objfile
);
779 /* Relocate address, unless there is no section or the variable is
781 if (obj_section
== NULL
782 || (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
783 addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
);
785 addr
= BMSYMBOL_VALUE_ADDRESS (lookup_data
.result
);
786 if (overlay_debugging
)
787 addr
= symbol_overlayed_address (addr
, obj_section
);
788 /* Determine address of TLS variable. */
790 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
791 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
795 case LOC_OPTIMIZED_OUT
:
796 if (is_dynamic_type (type
))
797 type
= resolve_dynamic_type (type
, {}, /* Unused address. */ 0);
798 return allocate_optimized_out_value (type
);
801 error (_("Cannot look up value of a botched symbol `%s'."),
806 v
= value_at_lazy (type
, addr
);
810 /* Calls VAR's language read_var_value hook with the given arguments. */
813 read_var_value (struct symbol
*var
, const struct block
*var_block
,
814 struct frame_info
*frame
)
816 const struct language_defn
*lang
= language_def (var
->language ());
818 gdb_assert (lang
!= NULL
);
820 return lang
->read_var_value (var
, var_block
, frame
);
823 /* Install default attributes for register values. */
826 default_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
827 int regnum
, struct frame_id frame_id
)
829 int len
= TYPE_LENGTH (type
);
830 struct value
*value
= allocate_value (type
);
831 struct frame_info
*frame
;
833 VALUE_LVAL (value
) = lval_register
;
834 frame
= frame_find_by_id (frame_id
);
837 frame_id
= null_frame_id
;
839 frame_id
= get_frame_id (get_next_frame_sentinel_okay (frame
));
841 VALUE_NEXT_FRAME_ID (value
) = frame_id
;
842 VALUE_REGNUM (value
) = regnum
;
844 /* Any structure stored in more than one register will always be
845 an integral number of registers. Otherwise, you need to do
846 some fiddling with the last register copied here for little
848 if (type_byte_order (type
) == BFD_ENDIAN_BIG
849 && len
< register_size (gdbarch
, regnum
))
850 /* Big-endian, and we want less than full size. */
851 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
853 set_value_offset (value
, 0);
858 /* VALUE must be an lval_register value. If regnum is the value's
859 associated register number, and len the length of the values type,
860 read one or more registers in FRAME, starting with register REGNUM,
861 until we've read LEN bytes.
863 If any of the registers we try to read are optimized out, then mark the
864 complete resulting value as optimized out. */
867 read_frame_register_value (struct value
*value
, struct frame_info
*frame
)
869 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
871 LONGEST reg_offset
= value_offset (value
);
872 int regnum
= VALUE_REGNUM (value
);
873 int len
= type_length_units (check_typedef (value_type (value
)));
875 gdb_assert (VALUE_LVAL (value
) == lval_register
);
877 /* Skip registers wholly inside of REG_OFFSET. */
878 while (reg_offset
>= register_size (gdbarch
, regnum
))
880 reg_offset
-= register_size (gdbarch
, regnum
);
887 struct value
*regval
= get_frame_register_value (frame
, regnum
);
888 int reg_len
= type_length_units (value_type (regval
)) - reg_offset
;
890 /* If the register length is larger than the number of bytes
891 remaining to copy, then only copy the appropriate bytes. */
895 value_contents_copy (value
, offset
, regval
, reg_offset
, reg_len
);
904 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
907 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
909 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
910 struct type
*type1
= check_typedef (type
);
913 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
915 int optim
, unavail
, ok
;
917 /* The ISA/ABI need to something weird when obtaining the
918 specified value from this register. It might need to
919 re-order non-adjacent, starting with REGNUM (see MIPS and
920 i386). It might need to convert the [float] register into
921 the corresponding [integer] type (see Alpha). The assumption
922 is that gdbarch_register_to_value populates the entire value
923 including the location. */
924 v
= allocate_value (type
);
925 VALUE_LVAL (v
) = lval_register
;
926 VALUE_NEXT_FRAME_ID (v
) = get_frame_id (get_next_frame_sentinel_okay (frame
));
927 VALUE_REGNUM (v
) = regnum
;
928 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
929 value_contents_raw (v
), &optim
,
935 mark_value_bytes_optimized_out (v
, 0, TYPE_LENGTH (type
));
937 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
942 /* Construct the value. */
943 v
= gdbarch_value_from_register (gdbarch
, type
,
944 regnum
, get_frame_id (frame
));
947 read_frame_register_value (v
, frame
);
953 /* Return contents of register REGNUM in frame FRAME as address.
954 Will abort if register value is not available. */
957 address_from_register (int regnum
, struct frame_info
*frame
)
959 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
960 struct type
*type
= builtin_type (gdbarch
)->builtin_data_ptr
;
963 int regnum_max_excl
= gdbarch_num_cooked_regs (gdbarch
);
965 if (regnum
< 0 || regnum
>= regnum_max_excl
)
966 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum
,
969 /* This routine may be called during early unwinding, at a time
970 where the ID of FRAME is not yet known. Calling value_from_register
971 would therefore abort in get_frame_id. However, since we only need
972 a temporary value that is never used as lvalue, we actually do not
973 really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
974 the core of value_from_register, but use the null_frame_id. */
976 /* Some targets require a special conversion routine even for plain
977 pointer types. Avoid constructing a value object in those cases. */
978 if (gdbarch_convert_register_p (gdbarch
, regnum
, type
))
980 gdb_byte
*buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
981 int optim
, unavail
, ok
;
983 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type
,
984 buf
, &optim
, &unavail
);
987 /* This function is used while computing a location expression.
988 Complain about the value being optimized out, rather than
989 letting value_as_address complain about some random register
990 the expression depends on not being saved. */
991 error_value_optimized_out ();
994 return unpack_long (type
, buf
);
997 value
= gdbarch_value_from_register (gdbarch
, type
, regnum
, null_frame_id
);
998 read_frame_register_value (value
, frame
);
1000 if (value_optimized_out (value
))
1002 /* This function is used while computing a location expression.
1003 Complain about the value being optimized out, rather than
1004 letting value_as_address complain about some random register
1005 the expression depends on not being saved. */
1006 error_value_optimized_out ();
1009 result
= value_as_address (value
);
1010 release_value (value
);
1016 namespace selftests
{
1017 namespace findvar_tests
{
1019 /* Function to test copy_integer_to_size. Store SOURCE_VAL with size
1020 SOURCE_SIZE to a buffer, making sure no sign extending happens at this
1021 stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
1022 copied value and compare to DEST_VALU. Copy again with a signed
1023 copy_integer_to_size and compare to DEST_VALS. Do everything for both
1024 LITTLE and BIG target endians. Use unsigned values throughout to make
1025 sure there are no implicit sign extensions. */
1028 do_cint_test (ULONGEST dest_valu
, ULONGEST dest_vals
, int dest_size
,
1029 ULONGEST src_val
, int src_size
)
1031 for (int i
= 0; i
< 2 ; i
++)
1033 gdb_byte srcbuf
[sizeof (ULONGEST
)] = {};
1034 gdb_byte destbuf
[sizeof (ULONGEST
)] = {};
1035 enum bfd_endian byte_order
= i
? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
1037 /* Fill the src buffer (and later the dest buffer) with non-zero junk,
1038 to ensure zero extensions aren't hidden. */
1039 memset (srcbuf
, 0xaa, sizeof (srcbuf
));
1041 /* Store (and later extract) using unsigned to ensure there are no sign
1043 store_unsigned_integer (srcbuf
, src_size
, byte_order
, src_val
);
1045 /* Test unsigned. */
1046 memset (destbuf
, 0xaa, sizeof (destbuf
));
1047 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, false,
1049 SELF_CHECK (dest_valu
== extract_unsigned_integer (destbuf
, dest_size
,
1053 memset (destbuf
, 0xaa, sizeof (destbuf
));
1054 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, true,
1056 SELF_CHECK (dest_vals
== extract_unsigned_integer (destbuf
, dest_size
,
1062 copy_integer_to_size_test ()
1064 /* Destination is bigger than the source, which has the signed bit unset. */
1065 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1066 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1068 /* Destination is bigger than the source, which has the signed bit set. */
1069 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1070 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1072 /* Destination is smaller than the source. */
1073 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1074 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1076 /* Destination and source are the same size. */
1077 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1079 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1080 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1082 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1084 /* Destination is bigger than the source. Source is bigger than 32bits. */
1085 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1086 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1087 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1088 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1091 } // namespace findvar_test
1092 } // namespace selftests
1096 void _initialize_findvar ();
1098 _initialize_findvar ()
1101 selftests::register_test
1102 ("copy_integer_to_size",
1103 selftests::findvar_tests::copy_integer_to_size_test
);