Automatic date update in version.in
[binutils-gdb.git] / gdb / findvar.c
blob36c094534be3adeb77d79c6ac5338c4f940764a6
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/>. */
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "frame.h"
24 #include "value.h"
25 #include "gdbcore.h"
26 #include "inferior.h"
27 #include "target.h"
28 #include "symfile.h" /* for overlay functions */
29 #include "regcache.h"
30 #include "user-regs.h"
31 #include "block.h"
32 #include "objfiles.h"
33 #include "language.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
39 LEN bytes long. */
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... */
46 you lose
47 #endif
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))
56 error (_("\
57 That operation is not available on integers of more than %d bytes."),
58 (int) sizeof (T));
60 /* Start at the most significant end of the integer, and work towards
61 the least significant. */
62 if (byte_order == BFD_ENDIAN_BIG)
64 size_t i = 0;
66 if (std::is_signed<T>::value)
68 /* Do the sign extension once at the start. */
69 retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
70 ++i;
72 for (; i < buf.size (); ++i)
73 retval = (retval << 8) | buf[i];
75 else
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;
83 --i;
85 for (; i >= 0; --i)
86 retval = (retval << 8) | buf[i];
88 return retval;
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)
106 const gdb_byte *p;
107 const gdb_byte *first_addr;
108 int len;
110 len = orig_len;
111 if (byte_order == BFD_ENDIAN_BIG)
113 for (p = addr;
114 len > (int) sizeof (LONGEST) && p < addr + orig_len;
115 p++)
117 if (*p == 0)
118 len--;
119 else
120 break;
122 first_addr = p;
124 else
126 first_addr = addr;
127 for (p = addr + orig_len - 1;
128 len > (int) sizeof (LONGEST) && p >= addr;
129 p--)
131 if (*p == 0)
132 len--;
133 else
134 break;
138 if (len <= (int) sizeof (LONGEST))
140 *pval = (LONGEST) extract_unsigned_integer (first_addr,
141 sizeof (LONGEST),
142 byte_order);
143 return 1;
146 return 0;
150 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
151 address it represents. */
152 CORE_ADDR
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>
166 void
167 store_integer (gdb_byte *addr, int len, enum bfd_endian byte_order,
168 T val)
170 gdb_byte *p;
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)
180 *p = val & 0xff;
181 val >>= 8;
184 else
186 for (p = startaddr; p < endaddr; ++p)
188 *p = val & 0xff;
189 val >>= 8;
194 /* Explicit instantiations. */
195 template void store_integer (gdb_byte *addr, int len,
196 enum bfd_endian byte_order,
197 LONGEST val);
199 template void store_integer (gdb_byte *addr, int len,
200 enum bfd_endian byte_order,
201 ULONGEST val);
203 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
204 form. */
205 void
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. */
222 void
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);
235 else
236 memcpy (dest, source, std::min (source_size, dest_size));
238 /* Fill the remaining space in DEST by either zero extending or sign
239 extending. */
241 if (size_diff > 0)
243 gdb_byte extension = 0;
244 if (is_signed
245 && ((byte_order != BFD_ENDIAN_BIG && source[source_size - 1] & 0x80)
246 || (byte_order == BFD_ENDIAN_BIG && source[0] & 0x80)))
247 extension = 0xff;
249 /* Extend into MSBs of SOURCE. */
250 if (byte_order == BFD_ENDIAN_BIG)
251 memset (dest, extension, size_diff);
252 else
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 (). */
261 struct value *
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);
274 return 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. */
281 struct value *
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);
310 return reg_val;
313 /* Given a pointer of type TYPE in target form in BUF, return the
314 address it represents. */
315 CORE_ADDR
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);
324 CORE_ADDR
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
334 format in BUF. */
335 void
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);
344 void
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);
353 /* See value.h. */
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. */
365 case LOC_COMPUTED:
366 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
368 case LOC_REGISTER:
369 case LOC_ARG:
370 case LOC_REF_ARG:
371 case LOC_REGPARM_ADDR:
372 case LOC_LOCAL:
373 return SYMBOL_NEEDS_FRAME;
375 case LOC_UNDEF:
376 case LOC_CONST:
377 case LOC_STATIC:
378 case LOC_TYPEDEF:
380 case LOC_LABEL:
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
383 the right frame. */
385 case LOC_BLOCK:
386 case LOC_CONST_BYTES:
387 case LOC_UNRESOLVED:
388 case LOC_OPTIMIZED_OUT:
389 return SYMBOL_NEEDS_NONE;
391 return SYMBOL_NEEDS_FRAME;
394 /* See value.h. */
397 symbol_read_needs_frame (struct symbol *sym)
399 return symbol_read_needs (sym) == SYMBOL_NEEDS_FRAME;
402 /* Given static link expression and the frame it lives in, look for the frame
403 the static links points to and return it. Return NULL if we could not find
404 such a frame. */
406 static struct frame_info *
407 follow_static_link (struct frame_info *frame,
408 const struct dynamic_prop *static_link)
410 CORE_ADDR upper_frame_base;
412 if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base))
413 return NULL;
415 /* Now climb up the stack frame until we reach the frame we are interested
416 in. */
417 for (; frame != NULL; frame = get_prev_frame (frame))
419 struct symbol *framefunc = get_frame_function (frame);
421 /* Stacks can be quite deep: give the user a chance to stop this. */
422 QUIT;
424 /* If we don't know how to compute FRAME's base address, don't give up:
425 maybe the frame we are looking for is upper in the stack frame. */
426 if (framefunc != NULL
427 && SYMBOL_BLOCK_OPS (framefunc) != NULL
428 && SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL
429 && (SYMBOL_BLOCK_OPS (framefunc)->get_frame_base (framefunc, frame)
430 == upper_frame_base))
431 break;
434 return frame;
437 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
438 rules, look for the frame that is actually hosting VAR and return it. If,
439 for some reason, we found no such frame, return NULL.
441 This kind of computation is necessary to correctly handle lexically nested
442 functions.
444 Note that in some cases, we know what scope VAR comes from but we cannot
445 reach the specific frame that hosts the instance of VAR we are looking for.
446 For backward compatibility purposes (with old compilers), we then look for
447 the first frame that can host it. */
449 static struct frame_info *
450 get_hosting_frame (struct symbol *var, const struct block *var_block,
451 struct frame_info *frame)
453 const struct block *frame_block = NULL;
455 if (!symbol_read_needs_frame (var))
456 return NULL;
458 /* Some symbols for local variables have no block: this happens when they are
459 not produced by a debug information reader, for instance when GDB creates
460 synthetic symbols. Without block information, we must assume they are
461 local to FRAME. In this case, there is nothing to do. */
462 else if (var_block == NULL)
463 return frame;
465 /* We currently assume that all symbols with a location list need a frame.
466 This is true in practice because selecting the location description
467 requires to compute the CFA, hence requires a frame. However we have
468 tests that embed global/static symbols with null location lists.
469 We want to get <optimized out> instead of <frame required> when evaluating
470 them so return a frame instead of raising an error. */
471 else if (var_block == block_global_block (var_block)
472 || var_block == block_static_block (var_block))
473 return frame;
475 /* We have to handle the "my_func::my_local_var" notation. This requires us
476 to look for upper frames when we find no block for the current frame: here
477 and below, handle when frame_block == NULL. */
478 if (frame != NULL)
479 frame_block = get_frame_block (frame, NULL);
481 /* Climb up the call stack until reaching the frame we are looking for. */
482 while (frame != NULL && frame_block != var_block)
484 /* Stacks can be quite deep: give the user a chance to stop this. */
485 QUIT;
487 if (frame_block == NULL)
489 frame = get_prev_frame (frame);
490 if (frame == NULL)
491 break;
492 frame_block = get_frame_block (frame, NULL);
495 /* If we failed to find the proper frame, fallback to the heuristic
496 method below. */
497 else if (frame_block == block_global_block (frame_block))
499 frame = NULL;
500 break;
503 /* Assuming we have a block for this frame: if we are at the function
504 level, the immediate upper lexical block is in an outer function:
505 follow the static link. */
506 else if (frame_block->function ())
508 const struct dynamic_prop *static_link
509 = block_static_link (frame_block);
510 int could_climb_up = 0;
512 if (static_link != NULL)
514 frame = follow_static_link (frame, static_link);
515 if (frame != NULL)
517 frame_block = get_frame_block (frame, NULL);
518 could_climb_up = frame_block != NULL;
521 if (!could_climb_up)
523 frame = NULL;
524 break;
528 else
529 /* We must be in some function nested lexical block. Just get the
530 outer block: both must share the same frame. */
531 frame_block = frame_block->superblock ();
534 /* Old compilers may not provide a static link, or they may provide an
535 invalid one. For such cases, fallback on the old way to evaluate
536 non-local references: just climb up the call stack and pick the first
537 frame that contains the variable we are looking for. */
538 if (frame == NULL)
540 frame = block_innermost_frame (var_block);
541 if (frame == NULL)
543 if (var_block->function ()
544 && !block_inlined_p (var_block)
545 && var_block->function ()->print_name ())
546 error (_("No frame is currently executing in block %s."),
547 var_block->function ()->print_name ());
548 else
549 error (_("No frame is currently executing in specified"
550 " block"));
554 return frame;
557 /* See language.h. */
559 struct value *
560 language_defn::read_var_value (struct symbol *var,
561 const struct block *var_block,
562 struct frame_info *frame) const
564 struct value *v;
565 struct type *type = var->type ();
566 CORE_ADDR addr;
567 enum symbol_needs_kind sym_need;
569 /* Call check_typedef on our type to make sure that, if TYPE is
570 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
571 instead of zero. However, we do not replace the typedef type by the
572 target type, because we want to keep the typedef in order to be able to
573 set the returned value type description correctly. */
574 check_typedef (type);
576 sym_need = symbol_read_needs (var);
577 if (sym_need == SYMBOL_NEEDS_FRAME)
578 gdb_assert (frame != NULL);
579 else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers ())
580 error (_("Cannot read `%s' without registers"), var->print_name ());
582 if (frame != NULL)
583 frame = get_hosting_frame (var, var_block, frame);
585 if (SYMBOL_COMPUTED_OPS (var) != NULL)
586 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
588 switch (var->aclass ())
590 case LOC_CONST:
591 if (is_dynamic_type (type))
593 /* Value is a constant byte-sequence and needs no memory access. */
594 type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
596 /* Put the constant back in target format. */
597 v = allocate_value (type);
598 store_signed_integer (value_contents_raw (v).data (), TYPE_LENGTH (type),
599 type_byte_order (type), var->value_longest ());
600 VALUE_LVAL (v) = not_lval;
601 return v;
603 case LOC_LABEL:
604 /* Put the constant back in target format. */
605 v = allocate_value (type);
606 if (overlay_debugging)
608 struct objfile *var_objfile = var->objfile ();
609 addr = symbol_overlayed_address (var->value_address (),
610 var->obj_section (var_objfile));
611 store_typed_address (value_contents_raw (v).data (), type, addr);
613 else
614 store_typed_address (value_contents_raw (v).data (), type,
615 var->value_address ());
616 VALUE_LVAL (v) = not_lval;
617 return v;
619 case LOC_CONST_BYTES:
620 if (is_dynamic_type (type))
622 /* Value is a constant byte-sequence and needs no memory access. */
623 type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
625 v = allocate_value (type);
626 memcpy (value_contents_raw (v).data (), var->value_bytes (),
627 TYPE_LENGTH (type));
628 VALUE_LVAL (v) = not_lval;
629 return v;
631 case LOC_STATIC:
632 if (overlay_debugging)
633 addr
634 = symbol_overlayed_address (var->value_address (),
635 var->obj_section (var->objfile ()));
636 else
637 addr = var->value_address ();
638 break;
640 case LOC_ARG:
641 addr = get_frame_args_address (frame);
642 if (!addr)
643 error (_("Unknown argument list address for `%s'."),
644 var->print_name ());
645 addr += var->value_longest ();
646 break;
648 case LOC_REF_ARG:
650 struct value *ref;
651 CORE_ADDR argref;
653 argref = get_frame_args_address (frame);
654 if (!argref)
655 error (_("Unknown argument list address for `%s'."),
656 var->print_name ());
657 argref += var->value_longest ();
658 ref = value_at (lookup_pointer_type (type), argref);
659 addr = value_as_address (ref);
660 break;
663 case LOC_LOCAL:
664 addr = get_frame_locals_address (frame);
665 addr += var->value_longest ();
666 break;
668 case LOC_TYPEDEF:
669 error (_("Cannot look up value of a typedef `%s'."),
670 var->print_name ());
671 break;
673 case LOC_BLOCK:
674 if (overlay_debugging)
675 addr = symbol_overlayed_address
676 (var->value_block ()->entry_pc (),
677 var->obj_section (var->objfile ()));
678 else
679 addr = var->value_block ()->entry_pc ();
680 break;
682 case LOC_REGISTER:
683 case LOC_REGPARM_ADDR:
685 int regno = SYMBOL_REGISTER_OPS (var)
686 ->register_number (var, get_frame_arch (frame));
687 struct value *regval;
689 if (var->aclass () == LOC_REGPARM_ADDR)
691 regval = value_from_register (lookup_pointer_type (type),
692 regno,
693 frame);
695 if (regval == NULL)
696 error (_("Value of register variable not available for `%s'."),
697 var->print_name ());
699 addr = value_as_address (regval);
701 else
703 regval = value_from_register (type, regno, frame);
705 if (regval == NULL)
706 error (_("Value of register variable not available for `%s'."),
707 var->print_name ());
708 return regval;
711 break;
713 case LOC_COMPUTED:
714 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
716 case LOC_UNRESOLVED:
718 struct obj_section *obj_section;
719 bound_minimal_symbol bmsym;
721 gdbarch_iterate_over_objfiles_in_search_order
722 (var->arch (),
723 [var, &bmsym] (objfile *objfile)
725 bmsym = lookup_minimal_symbol (var->linkage_name (), nullptr,
726 objfile);
728 /* Stop if a match is found. */
729 return bmsym.minsym != nullptr;
731 var->objfile ());
733 /* If we can't find the minsym there's a problem in the symbol info.
734 The symbol exists in the debug info, but it's missing in the minsym
735 table. */
736 if (bmsym.minsym == nullptr)
738 const char *flavour_name
739 = objfile_flavour_name (var->objfile ());
741 /* We can't get here unless we've opened the file, so flavour_name
742 can't be NULL. */
743 gdb_assert (flavour_name != NULL);
744 error (_("Missing %s symbol \"%s\"."),
745 flavour_name, var->linkage_name ());
748 obj_section = bmsym.minsym->obj_section (bmsym.objfile);
749 /* Relocate address, unless there is no section or the variable is
750 a TLS variable. */
751 if (obj_section == NULL
752 || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
753 addr = bmsym.minsym->value_raw_address ();
754 else
755 addr = bmsym.value_address ();
756 if (overlay_debugging)
757 addr = symbol_overlayed_address (addr, obj_section);
758 /* Determine address of TLS variable. */
759 if (obj_section
760 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
761 addr = target_translate_tls_address (obj_section->objfile, addr);
763 break;
765 case LOC_OPTIMIZED_OUT:
766 if (is_dynamic_type (type))
767 type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
768 return allocate_optimized_out_value (type);
770 default:
771 error (_("Cannot look up value of a botched symbol `%s'."),
772 var->print_name ());
773 break;
776 v = value_at_lazy (type, addr);
777 return v;
780 /* Calls VAR's language read_var_value hook with the given arguments. */
782 struct value *
783 read_var_value (struct symbol *var, const struct block *var_block,
784 struct frame_info *frame)
786 const struct language_defn *lang = language_def (var->language ());
788 gdb_assert (lang != NULL);
790 return lang->read_var_value (var, var_block, frame);
793 /* Install default attributes for register values. */
795 struct value *
796 default_value_from_register (struct gdbarch *gdbarch, struct type *type,
797 int regnum, struct frame_id frame_id)
799 int len = TYPE_LENGTH (type);
800 struct value *value = allocate_value (type);
801 struct frame_info *frame;
803 VALUE_LVAL (value) = lval_register;
804 frame = frame_find_by_id (frame_id);
806 if (frame == NULL)
807 frame_id = null_frame_id;
808 else
809 frame_id = get_frame_id (get_next_frame_sentinel_okay (frame));
811 VALUE_NEXT_FRAME_ID (value) = frame_id;
812 VALUE_REGNUM (value) = regnum;
814 /* Any structure stored in more than one register will always be
815 an integral number of registers. Otherwise, you need to do
816 some fiddling with the last register copied here for little
817 endian machines. */
818 if (type_byte_order (type) == BFD_ENDIAN_BIG
819 && len < register_size (gdbarch, regnum))
820 /* Big-endian, and we want less than full size. */
821 set_value_offset (value, register_size (gdbarch, regnum) - len);
822 else
823 set_value_offset (value, 0);
825 return value;
828 /* VALUE must be an lval_register value. If regnum is the value's
829 associated register number, and len the length of the values type,
830 read one or more registers in FRAME, starting with register REGNUM,
831 until we've read LEN bytes.
833 If any of the registers we try to read are optimized out, then mark the
834 complete resulting value as optimized out. */
836 void
837 read_frame_register_value (struct value *value, struct frame_info *frame)
839 struct gdbarch *gdbarch = get_frame_arch (frame);
840 LONGEST offset = 0;
841 LONGEST reg_offset = value_offset (value);
842 int regnum = VALUE_REGNUM (value);
843 int len = type_length_units (check_typedef (value_type (value)));
845 gdb_assert (VALUE_LVAL (value) == lval_register);
847 /* Skip registers wholly inside of REG_OFFSET. */
848 while (reg_offset >= register_size (gdbarch, regnum))
850 reg_offset -= register_size (gdbarch, regnum);
851 regnum++;
854 /* Copy the data. */
855 while (len > 0)
857 struct value *regval = get_frame_register_value (frame, regnum);
858 int reg_len = type_length_units (value_type (regval)) - reg_offset;
860 /* If the register length is larger than the number of bytes
861 remaining to copy, then only copy the appropriate bytes. */
862 if (reg_len > len)
863 reg_len = len;
865 value_contents_copy (value, offset, regval, reg_offset, reg_len);
867 offset += reg_len;
868 len -= reg_len;
869 reg_offset = 0;
870 regnum++;
874 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
876 struct value *
877 value_from_register (struct type *type, int regnum, struct frame_info *frame)
879 struct gdbarch *gdbarch = get_frame_arch (frame);
880 struct type *type1 = check_typedef (type);
881 struct value *v;
883 if (gdbarch_convert_register_p (gdbarch, regnum, type1))
885 int optim, unavail, ok;
887 /* The ISA/ABI need to something weird when obtaining the
888 specified value from this register. It might need to
889 re-order non-adjacent, starting with REGNUM (see MIPS and
890 i386). It might need to convert the [float] register into
891 the corresponding [integer] type (see Alpha). The assumption
892 is that gdbarch_register_to_value populates the entire value
893 including the location. */
894 v = allocate_value (type);
895 VALUE_LVAL (v) = lval_register;
896 VALUE_NEXT_FRAME_ID (v) = get_frame_id (get_next_frame_sentinel_okay (frame));
897 VALUE_REGNUM (v) = regnum;
898 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
899 value_contents_raw (v).data (), &optim,
900 &unavail);
902 if (!ok)
904 if (optim)
905 mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
906 if (unavail)
907 mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
910 else
912 /* Construct the value. */
913 v = gdbarch_value_from_register (gdbarch, type,
914 regnum, get_frame_id (frame));
916 /* Get the data. */
917 read_frame_register_value (v, frame);
920 return v;
923 /* Return contents of register REGNUM in frame FRAME as address.
924 Will abort if register value is not available. */
926 CORE_ADDR
927 address_from_register (int regnum, struct frame_info *frame)
929 struct gdbarch *gdbarch = get_frame_arch (frame);
930 struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
931 struct value *value;
932 CORE_ADDR result;
933 int regnum_max_excl = gdbarch_num_cooked_regs (gdbarch);
935 if (regnum < 0 || regnum >= regnum_max_excl)
936 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum,
937 regnum_max_excl);
939 /* This routine may be called during early unwinding, at a time
940 where the ID of FRAME is not yet known. Calling value_from_register
941 would therefore abort in get_frame_id. However, since we only need
942 a temporary value that is never used as lvalue, we actually do not
943 really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
944 the core of value_from_register, but use the null_frame_id. */
946 /* Some targets require a special conversion routine even for plain
947 pointer types. Avoid constructing a value object in those cases. */
948 if (gdbarch_convert_register_p (gdbarch, regnum, type))
950 gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
951 int optim, unavail, ok;
953 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
954 buf, &optim, &unavail);
955 if (!ok)
957 /* This function is used while computing a location expression.
958 Complain about the value being optimized out, rather than
959 letting value_as_address complain about some random register
960 the expression depends on not being saved. */
961 error_value_optimized_out ();
964 return unpack_long (type, buf);
967 value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
968 read_frame_register_value (value, frame);
970 if (value_optimized_out (value))
972 /* This function is used while computing a location expression.
973 Complain about the value being optimized out, rather than
974 letting value_as_address complain about some random register
975 the expression depends on not being saved. */
976 error_value_optimized_out ();
979 result = value_as_address (value);
980 release_value (value);
982 return result;
985 #if GDB_SELF_TEST
986 namespace selftests {
987 namespace findvar_tests {
989 /* Function to test copy_integer_to_size. Store SOURCE_VAL with size
990 SOURCE_SIZE to a buffer, making sure no sign extending happens at this
991 stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
992 copied value and compare to DEST_VALU. Copy again with a signed
993 copy_integer_to_size and compare to DEST_VALS. Do everything for both
994 LITTLE and BIG target endians. Use unsigned values throughout to make
995 sure there are no implicit sign extensions. */
997 static void
998 do_cint_test (ULONGEST dest_valu, ULONGEST dest_vals, int dest_size,
999 ULONGEST src_val, int src_size)
1001 for (int i = 0; i < 2 ; i++)
1003 gdb_byte srcbuf[sizeof (ULONGEST)] = {};
1004 gdb_byte destbuf[sizeof (ULONGEST)] = {};
1005 enum bfd_endian byte_order = i ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
1007 /* Fill the src buffer (and later the dest buffer) with non-zero junk,
1008 to ensure zero extensions aren't hidden. */
1009 memset (srcbuf, 0xaa, sizeof (srcbuf));
1011 /* Store (and later extract) using unsigned to ensure there are no sign
1012 extensions. */
1013 store_unsigned_integer (srcbuf, src_size, byte_order, src_val);
1015 /* Test unsigned. */
1016 memset (destbuf, 0xaa, sizeof (destbuf));
1017 copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, false,
1018 byte_order);
1019 SELF_CHECK (dest_valu == extract_unsigned_integer (destbuf, dest_size,
1020 byte_order));
1022 /* Test signed. */
1023 memset (destbuf, 0xaa, sizeof (destbuf));
1024 copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, true,
1025 byte_order);
1026 SELF_CHECK (dest_vals == extract_unsigned_integer (destbuf, dest_size,
1027 byte_order));
1031 static void
1032 copy_integer_to_size_test ()
1034 /* Destination is bigger than the source, which has the signed bit unset. */
1035 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1036 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1038 /* Destination is bigger than the source, which has the signed bit set. */
1039 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1040 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1042 /* Destination is smaller than the source. */
1043 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1044 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1046 /* Destination and source are the same size. */
1047 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1049 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1050 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1052 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1054 /* Destination is bigger than the source. Source is bigger than 32bits. */
1055 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1056 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1057 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1058 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1061 } // namespace findvar_test
1062 } // namespace selftests
1064 #endif
1066 void _initialize_findvar ();
1067 void
1068 _initialize_findvar ()
1070 #if GDB_SELF_TEST
1071 selftests::register_test
1072 ("copy_integer_to_size",
1073 selftests::findvar_tests::copy_integer_to_size_test);
1074 #endif