1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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 "dwarf2loc.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_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
157 internal_error (__FILE__
, __LINE__
,
158 _("extract_typed_address: "
159 "type is not a pointer or reference"));
161 return gdbarch_pointer_to_address (get_type_arch (type
), 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_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
210 internal_error (__FILE__
, __LINE__
,
211 _("store_typed_address: "
212 "type is not a pointer or reference"));
214 gdbarch_address_to_pointer (get_type_arch (type
), 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 endianess 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 /* We should have a valid next frame. */
296 gdb_assert (frame_id_p (get_frame_id (next_frame
)));
298 reg_val
= allocate_value_lazy (register_type (gdbarch
, regnum
));
299 VALUE_LVAL (reg_val
) = lval_register
;
300 VALUE_REGNUM (reg_val
) = regnum
;
301 VALUE_NEXT_FRAME_ID (reg_val
) = get_frame_id (next_frame
);
306 /* Given a pointer of type TYPE in target form in BUF, return the
307 address it represents. */
309 unsigned_pointer_to_address (struct gdbarch
*gdbarch
,
310 struct type
*type
, const gdb_byte
*buf
)
312 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
314 return extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
318 signed_pointer_to_address (struct gdbarch
*gdbarch
,
319 struct type
*type
, const gdb_byte
*buf
)
321 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
323 return extract_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
);
326 /* Given an address, store it as a pointer of type TYPE in target
329 unsigned_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
330 gdb_byte
*buf
, CORE_ADDR addr
)
332 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
334 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
338 address_to_signed_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
339 gdb_byte
*buf
, CORE_ADDR addr
)
341 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
343 store_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
348 enum symbol_needs_kind
349 symbol_read_needs (struct symbol
*sym
)
351 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
352 return SYMBOL_COMPUTED_OPS (sym
)->get_symbol_read_needs (sym
);
354 switch (SYMBOL_CLASS (sym
))
356 /* All cases listed explicitly so that gcc -Wall will detect it if
357 we failed to consider one. */
359 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
364 case LOC_REGPARM_ADDR
:
366 return SYMBOL_NEEDS_FRAME
;
374 /* Getting the address of a label can be done independently of the block,
375 even if some *uses* of that address wouldn't work so well without
379 case LOC_CONST_BYTES
:
381 case LOC_OPTIMIZED_OUT
:
382 return SYMBOL_NEEDS_NONE
;
384 return SYMBOL_NEEDS_FRAME
;
390 symbol_read_needs_frame (struct symbol
*sym
)
392 return symbol_read_needs (sym
) == SYMBOL_NEEDS_FRAME
;
395 /* Private data to be used with minsym_lookup_iterator_cb. */
397 struct minsym_lookup_data
399 /* The name of the minimal symbol we are searching for. */
402 /* The field where the callback should store the minimal symbol
403 if found. It should be initialized to NULL before the search
405 struct bound_minimal_symbol result
;
408 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
409 It searches by name for a minimal symbol within the given OBJFILE.
410 The arguments are passed via CB_DATA, which in reality is a pointer
411 to struct minsym_lookup_data. */
414 minsym_lookup_iterator_cb (struct objfile
*objfile
, void *cb_data
)
416 struct minsym_lookup_data
*data
= (struct minsym_lookup_data
*) cb_data
;
418 gdb_assert (data
->result
.minsym
== NULL
);
420 data
->result
= lookup_minimal_symbol (data
->name
, NULL
, objfile
);
422 /* The iterator should stop iff a match was found. */
423 return (data
->result
.minsym
!= NULL
);
426 /* Given static link expression and the frame it lives in, look for the frame
427 the static links points to and return it. Return NULL if we could not find
430 static struct frame_info
*
431 follow_static_link (struct frame_info
*frame
,
432 const struct dynamic_prop
*static_link
)
434 CORE_ADDR upper_frame_base
;
436 if (!dwarf2_evaluate_property (static_link
, frame
, NULL
, &upper_frame_base
))
439 /* Now climb up the stack frame until we reach the frame we are interested
441 for (; frame
!= NULL
; frame
= get_prev_frame (frame
))
443 struct symbol
*framefunc
= get_frame_function (frame
);
445 /* Stacks can be quite deep: give the user a chance to stop this. */
448 /* If we don't know how to compute FRAME's base address, don't give up:
449 maybe the frame we are looking for is upper in the stace frame. */
450 if (framefunc
!= NULL
451 && SYMBOL_BLOCK_OPS (framefunc
) != NULL
452 && SYMBOL_BLOCK_OPS (framefunc
)->get_frame_base
!= NULL
453 && (SYMBOL_BLOCK_OPS (framefunc
)->get_frame_base (framefunc
, frame
)
454 == upper_frame_base
))
461 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
462 rules, look for the frame that is actually hosting VAR and return it. If,
463 for some reason, we found no such frame, return NULL.
465 This kind of computation is necessary to correctly handle lexically nested
468 Note that in some cases, we know what scope VAR comes from but we cannot
469 reach the specific frame that hosts the instance of VAR we are looking for.
470 For backward compatibility purposes (with old compilers), we then look for
471 the first frame that can host it. */
473 static struct frame_info
*
474 get_hosting_frame (struct symbol
*var
, const struct block
*var_block
,
475 struct frame_info
*frame
)
477 const struct block
*frame_block
= NULL
;
479 if (!symbol_read_needs_frame (var
))
482 /* Some symbols for local variables have no block: this happens when they are
483 not produced by a debug information reader, for instance when GDB creates
484 synthetic symbols. Without block information, we must assume they are
485 local to FRAME. In this case, there is nothing to do. */
486 else if (var_block
== NULL
)
489 /* We currently assume that all symbols with a location list need a frame.
490 This is true in practice because selecting the location description
491 requires to compute the CFA, hence requires a frame. However we have
492 tests that embed global/static symbols with null location lists.
493 We want to get <optimized out> instead of <frame required> when evaluating
494 them so return a frame instead of raising an error. */
495 else if (var_block
== block_global_block (var_block
)
496 || var_block
== block_static_block (var_block
))
499 /* We have to handle the "my_func::my_local_var" notation. This requires us
500 to look for upper frames when we find no block for the current frame: here
501 and below, handle when frame_block == NULL. */
503 frame_block
= get_frame_block (frame
, NULL
);
505 /* Climb up the call stack until reaching the frame we are looking for. */
506 while (frame
!= NULL
&& frame_block
!= var_block
)
508 /* Stacks can be quite deep: give the user a chance to stop this. */
511 if (frame_block
== NULL
)
513 frame
= get_prev_frame (frame
);
516 frame_block
= get_frame_block (frame
, NULL
);
519 /* If we failed to find the proper frame, fallback to the heuristic
521 else if (frame_block
== block_global_block (frame_block
))
527 /* Assuming we have a block for this frame: if we are at the function
528 level, the immediate upper lexical block is in an outer function:
529 follow the static link. */
530 else if (BLOCK_FUNCTION (frame_block
))
532 const struct dynamic_prop
*static_link
533 = block_static_link (frame_block
);
534 int could_climb_up
= 0;
536 if (static_link
!= NULL
)
538 frame
= follow_static_link (frame
, static_link
);
541 frame_block
= get_frame_block (frame
, NULL
);
542 could_climb_up
= frame_block
!= NULL
;
553 /* We must be in some function nested lexical block. Just get the
554 outer block: both must share the same frame. */
555 frame_block
= BLOCK_SUPERBLOCK (frame_block
);
558 /* Old compilers may not provide a static link, or they may provide an
559 invalid one. For such cases, fallback on the old way to evaluate
560 non-local references: just climb up the call stack and pick the first
561 frame that contains the variable we are looking for. */
564 frame
= block_innermost_frame (var_block
);
567 if (BLOCK_FUNCTION (var_block
)
568 && !block_inlined_p (var_block
)
569 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block
)))
570 error (_("No frame is currently executing in block %s."),
571 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block
)));
573 error (_("No frame is currently executing in specified"
581 /* A default implementation for the "la_read_var_value" hook in
582 the language vector which should work in most situations. */
585 default_read_var_value (struct symbol
*var
, const struct block
*var_block
,
586 struct frame_info
*frame
)
589 struct type
*type
= SYMBOL_TYPE (var
);
591 enum symbol_needs_kind sym_need
;
593 /* Call check_typedef on our type to make sure that, if TYPE is
594 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
595 instead of zero. However, we do not replace the typedef type by the
596 target type, because we want to keep the typedef in order to be able to
597 set the returned value type description correctly. */
598 check_typedef (type
);
600 sym_need
= symbol_read_needs (var
);
601 if (sym_need
== SYMBOL_NEEDS_FRAME
)
602 gdb_assert (frame
!= NULL
);
603 else if (sym_need
== SYMBOL_NEEDS_REGISTERS
&& !target_has_registers
)
604 error (_("Cannot read `%s' without registers"), SYMBOL_PRINT_NAME (var
));
607 frame
= get_hosting_frame (var
, var_block
, frame
);
609 if (SYMBOL_COMPUTED_OPS (var
) != NULL
)
610 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
612 switch (SYMBOL_CLASS (var
))
615 if (is_dynamic_type (type
))
617 /* Value is a constant byte-sequence and needs no memory access. */
618 type
= resolve_dynamic_type (type
, NULL
, /* Unused address. */ 0);
620 /* Put the constant back in target format. */
621 v
= allocate_value (type
);
622 store_signed_integer (value_contents_raw (v
), TYPE_LENGTH (type
),
623 gdbarch_byte_order (get_type_arch (type
)),
624 (LONGEST
) SYMBOL_VALUE (var
));
625 VALUE_LVAL (v
) = not_lval
;
629 /* Put the constant back in target format. */
630 v
= allocate_value (type
);
631 if (overlay_debugging
)
634 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
635 SYMBOL_OBJ_SECTION (symbol_objfile (var
),
638 store_typed_address (value_contents_raw (v
), type
, addr
);
641 store_typed_address (value_contents_raw (v
), type
,
642 SYMBOL_VALUE_ADDRESS (var
));
643 VALUE_LVAL (v
) = not_lval
;
646 case LOC_CONST_BYTES
:
647 if (is_dynamic_type (type
))
649 /* Value is a constant byte-sequence and needs no memory access. */
650 type
= resolve_dynamic_type (type
, NULL
, /* Unused address. */ 0);
652 v
= allocate_value (type
);
653 memcpy (value_contents_raw (v
), SYMBOL_VALUE_BYTES (var
),
655 VALUE_LVAL (v
) = not_lval
;
659 if (overlay_debugging
)
660 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
661 SYMBOL_OBJ_SECTION (symbol_objfile (var
),
664 addr
= SYMBOL_VALUE_ADDRESS (var
);
668 addr
= get_frame_args_address (frame
);
670 error (_("Unknown argument list address for `%s'."),
671 SYMBOL_PRINT_NAME (var
));
672 addr
+= SYMBOL_VALUE (var
);
680 argref
= get_frame_args_address (frame
);
682 error (_("Unknown argument list address for `%s'."),
683 SYMBOL_PRINT_NAME (var
));
684 argref
+= SYMBOL_VALUE (var
);
685 ref
= value_at (lookup_pointer_type (type
), argref
);
686 addr
= value_as_address (ref
);
691 addr
= get_frame_locals_address (frame
);
692 addr
+= SYMBOL_VALUE (var
);
696 error (_("Cannot look up value of a typedef `%s'."),
697 SYMBOL_PRINT_NAME (var
));
701 if (overlay_debugging
)
702 addr
= symbol_overlayed_address
703 (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var
)),
704 SYMBOL_OBJ_SECTION (symbol_objfile (var
), var
));
706 addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var
));
710 case LOC_REGPARM_ADDR
:
712 int regno
= SYMBOL_REGISTER_OPS (var
)
713 ->register_number (var
, get_frame_arch (frame
));
714 struct value
*regval
;
716 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
718 regval
= value_from_register (lookup_pointer_type (type
),
723 error (_("Value of register variable not available for `%s'."),
724 SYMBOL_PRINT_NAME (var
));
726 addr
= value_as_address (regval
);
730 regval
= value_from_register (type
, regno
, frame
);
733 error (_("Value of register variable not available for `%s'."),
734 SYMBOL_PRINT_NAME (var
));
741 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
745 struct minsym_lookup_data lookup_data
;
746 struct minimal_symbol
*msym
;
747 struct obj_section
*obj_section
;
749 memset (&lookup_data
, 0, sizeof (lookup_data
));
750 lookup_data
.name
= SYMBOL_LINKAGE_NAME (var
);
752 gdbarch_iterate_over_objfiles_in_search_order
754 minsym_lookup_iterator_cb
, &lookup_data
,
755 symbol_objfile (var
));
756 msym
= lookup_data
.result
.minsym
;
758 /* If we can't find the minsym there's a problem in the symbol info.
759 The symbol exists in the debug info, but it's missing in the minsym
763 const char *flavour_name
764 = objfile_flavour_name (symbol_objfile (var
));
766 /* We can't get here unless we've opened the file, so flavour_name
768 gdb_assert (flavour_name
!= NULL
);
769 error (_("Missing %s symbol \"%s\"."),
770 flavour_name
, SYMBOL_LINKAGE_NAME (var
));
772 obj_section
= MSYMBOL_OBJ_SECTION (lookup_data
.result
.objfile
, msym
);
773 /* Relocate address, unless there is no section or the variable is
775 if (obj_section
== NULL
776 || (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
777 addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
);
779 addr
= BMSYMBOL_VALUE_ADDRESS (lookup_data
.result
);
780 if (overlay_debugging
)
781 addr
= symbol_overlayed_address (addr
, obj_section
);
782 /* Determine address of TLS variable. */
784 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
785 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
789 case LOC_OPTIMIZED_OUT
:
790 if (is_dynamic_type (type
))
791 type
= resolve_dynamic_type (type
, NULL
, /* Unused address. */ 0);
792 return allocate_optimized_out_value (type
);
795 error (_("Cannot look up value of a botched symbol `%s'."),
796 SYMBOL_PRINT_NAME (var
));
800 v
= value_at_lazy (type
, addr
);
804 /* Calls VAR's language la_read_var_value hook with the given arguments. */
807 read_var_value (struct symbol
*var
, const struct block
*var_block
,
808 struct frame_info
*frame
)
810 const struct language_defn
*lang
= language_def (SYMBOL_LANGUAGE (var
));
812 gdb_assert (lang
!= NULL
);
813 gdb_assert (lang
->la_read_var_value
!= NULL
);
815 return lang
->la_read_var_value (var
, var_block
, frame
);
818 /* Install default attributes for register values. */
821 default_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
822 int regnum
, struct frame_id frame_id
)
824 int len
= TYPE_LENGTH (type
);
825 struct value
*value
= allocate_value (type
);
826 struct frame_info
*frame
;
828 VALUE_LVAL (value
) = lval_register
;
829 frame
= frame_find_by_id (frame_id
);
832 frame_id
= null_frame_id
;
834 frame_id
= get_frame_id (get_next_frame_sentinel_okay (frame
));
836 VALUE_NEXT_FRAME_ID (value
) = frame_id
;
837 VALUE_REGNUM (value
) = regnum
;
839 /* Any structure stored in more than one register will always be
840 an integral number of registers. Otherwise, you need to do
841 some fiddling with the last register copied here for little
843 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
844 && len
< register_size (gdbarch
, regnum
))
845 /* Big-endian, and we want less than full size. */
846 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
848 set_value_offset (value
, 0);
853 /* VALUE must be an lval_register value. If regnum is the value's
854 associated register number, and len the length of the values type,
855 read one or more registers in FRAME, starting with register REGNUM,
856 until we've read LEN bytes.
858 If any of the registers we try to read are optimized out, then mark the
859 complete resulting value as optimized out. */
862 read_frame_register_value (struct value
*value
, struct frame_info
*frame
)
864 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
866 LONGEST reg_offset
= value_offset (value
);
867 int regnum
= VALUE_REGNUM (value
);
868 int len
= type_length_units (check_typedef (value_type (value
)));
870 gdb_assert (VALUE_LVAL (value
) == lval_register
);
872 /* Skip registers wholly inside of REG_OFFSET. */
873 while (reg_offset
>= register_size (gdbarch
, regnum
))
875 reg_offset
-= register_size (gdbarch
, regnum
);
882 struct value
*regval
= get_frame_register_value (frame
, regnum
);
883 int reg_len
= type_length_units (value_type (regval
)) - reg_offset
;
885 /* If the register length is larger than the number of bytes
886 remaining to copy, then only copy the appropriate bytes. */
890 value_contents_copy (value
, offset
, regval
, reg_offset
, reg_len
);
899 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
902 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
904 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
905 struct type
*type1
= check_typedef (type
);
908 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
910 int optim
, unavail
, ok
;
912 /* The ISA/ABI need to something weird when obtaining the
913 specified value from this register. It might need to
914 re-order non-adjacent, starting with REGNUM (see MIPS and
915 i386). It might need to convert the [float] register into
916 the corresponding [integer] type (see Alpha). The assumption
917 is that gdbarch_register_to_value populates the entire value
918 including the location. */
919 v
= allocate_value (type
);
920 VALUE_LVAL (v
) = lval_register
;
921 VALUE_NEXT_FRAME_ID (v
) = get_frame_id (get_next_frame_sentinel_okay (frame
));
922 VALUE_REGNUM (v
) = regnum
;
923 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
924 value_contents_raw (v
), &optim
,
930 mark_value_bytes_optimized_out (v
, 0, TYPE_LENGTH (type
));
932 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
937 /* Construct the value. */
938 v
= gdbarch_value_from_register (gdbarch
, type
,
939 regnum
, get_frame_id (frame
));
942 read_frame_register_value (v
, frame
);
948 /* Return contents of register REGNUM in frame FRAME as address.
949 Will abort if register value is not available. */
952 address_from_register (int regnum
, struct frame_info
*frame
)
954 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
955 struct type
*type
= builtin_type (gdbarch
)->builtin_data_ptr
;
958 int regnum_max_excl
= gdbarch_num_cooked_regs (gdbarch
);
960 if (regnum
< 0 || regnum
>= regnum_max_excl
)
961 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum
,
964 /* This routine may be called during early unwinding, at a time
965 where the ID of FRAME is not yet known. Calling value_from_register
966 would therefore abort in get_frame_id. However, since we only need
967 a temporary value that is never used as lvalue, we actually do not
968 really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
969 the core of value_from_register, but use the null_frame_id. */
971 /* Some targets require a special conversion routine even for plain
972 pointer types. Avoid constructing a value object in those cases. */
973 if (gdbarch_convert_register_p (gdbarch
, regnum
, type
))
975 gdb_byte
*buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
976 int optim
, unavail
, ok
;
978 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type
,
979 buf
, &optim
, &unavail
);
982 /* This function is used while computing a location expression.
983 Complain about the value being optimized out, rather than
984 letting value_as_address complain about some random register
985 the expression depends on not being saved. */
986 error_value_optimized_out ();
989 return unpack_long (type
, buf
);
992 value
= gdbarch_value_from_register (gdbarch
, type
, regnum
, null_frame_id
);
993 read_frame_register_value (value
, frame
);
995 if (value_optimized_out (value
))
997 /* This function is used while computing a location expression.
998 Complain about the value being optimized out, rather than
999 letting value_as_address complain about some random register
1000 the expression depends on not being saved. */
1001 error_value_optimized_out ();
1004 result
= value_as_address (value
);
1005 release_value (value
);
1011 namespace selftests
{
1012 namespace findvar_tests
{
1014 /* Function to test copy_integer_to_size. Store SOURCE_VAL with size
1015 SOURCE_SIZE to a buffer, making sure no sign extending happens at this
1016 stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
1017 copied value and compare to DEST_VALU. Copy again with a signed
1018 copy_integer_to_size and compare to DEST_VALS. Do everything for both
1019 LITTLE and BIG target endians. Use unsigned values throughout to make
1020 sure there are no implicit sign extensions. */
1023 do_cint_test (ULONGEST dest_valu
, ULONGEST dest_vals
, int dest_size
,
1024 ULONGEST src_val
, int src_size
)
1026 for (int i
= 0; i
< 2 ; i
++)
1028 gdb_byte srcbuf
[sizeof (ULONGEST
)] = {};
1029 gdb_byte destbuf
[sizeof (ULONGEST
)] = {};
1030 enum bfd_endian byte_order
= i
? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
1032 /* Fill the src buffer (and later the dest buffer) with non-zero junk,
1033 to ensure zero extensions aren't hidden. */
1034 memset (srcbuf
, 0xaa, sizeof (srcbuf
));
1036 /* Store (and later extract) using unsigned to ensure there are no sign
1038 store_unsigned_integer (srcbuf
, src_size
, byte_order
, src_val
);
1040 /* Test unsigned. */
1041 memset (destbuf
, 0xaa, sizeof (destbuf
));
1042 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, false,
1044 SELF_CHECK (dest_valu
== extract_unsigned_integer (destbuf
, dest_size
,
1048 memset (destbuf
, 0xaa, sizeof (destbuf
));
1049 copy_integer_to_size (destbuf
, dest_size
, srcbuf
, src_size
, true,
1051 SELF_CHECK (dest_vals
== extract_unsigned_integer (destbuf
, dest_size
,
1057 copy_integer_to_size_test ()
1059 /* Destination is bigger than the source, which has the signed bit unset. */
1060 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1061 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1063 /* Destination is bigger than the source, which has the signed bit set. */
1064 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1065 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1067 /* Destination is smaller than the source. */
1068 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1069 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1071 /* Destination and source are the same size. */
1072 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1074 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1075 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1077 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1079 /* Destination is bigger than the source. Source is bigger than 32bits. */
1080 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1081 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1082 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1083 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1086 } // namespace findvar_test
1087 } // namespace selftests
1092 _initialize_findvar (void)
1095 selftests::register_test
1096 ("copy_integer_to_size",
1097 selftests::findvar_tests::copy_integer_to_size_test
);