1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 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 "floatformat.h"
29 #include "symfile.h" /* for overlay functions */
31 #include "user-regs.h"
35 #include "dwarf2loc.h"
38 /* Basic byte-swapping routines. All 'extract' functions return a
39 host-format integer from a target-format integer at ADDR which is
42 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
43 /* 8 bit characters are a pretty safe assumption these days, so we
44 assume it throughout all these swapping routines. If we had to deal with
45 9 bit characters, we would need to make len be in bits and would have
46 to re-write these routines... */
51 extract_signed_integer (const gdb_byte *addr, int len,
52 enum bfd_endian byte_order)
55 const unsigned char *p;
56 const unsigned char *startaddr = addr;
57 const unsigned char *endaddr = startaddr + len;
59 if (len > (int) sizeof (LONGEST))
61 That operation is not available on integers of more than %d bytes."),
62 (int) sizeof (LONGEST));
64 /* Start at the most significant end of the integer, and work towards
65 the least significant. */
66 if (byte_order == BFD_ENDIAN_BIG)
69 /* Do the sign extension once at the start. */
70 retval = ((LONGEST) * p ^ 0x80) - 0x80;
71 for (++p; p < endaddr; ++p)
72 retval = (retval << 8) | *p;
77 /* Do the sign extension once at the start. */
78 retval = ((LONGEST) * p ^ 0x80) - 0x80;
79 for (--p; p >= startaddr; --p)
80 retval = (retval << 8) | *p;
86 extract_unsigned_integer (const gdb_byte *addr, int len,
87 enum bfd_endian byte_order)
90 const unsigned char *p;
91 const unsigned char *startaddr = addr;
92 const unsigned char *endaddr = startaddr + len;
94 if (len > (int) sizeof (ULONGEST))
96 That operation is not available on integers of more than %d bytes."),
97 (int) sizeof (ULONGEST));
99 /* Start at the most significant end of the integer, and work towards
100 the least significant. */
102 if (byte_order == BFD_ENDIAN_BIG)
104 for (p = startaddr; p < endaddr; ++p)
105 retval = (retval << 8) | *p;
109 for (p = endaddr - 1; p >= startaddr; --p)
110 retval = (retval << 8) | *p;
115 /* Sometimes a long long unsigned integer can be extracted as a
116 LONGEST value. This is done so that we can print these values
117 better. If this integer can be converted to a LONGEST, this
118 function returns 1 and sets *PVAL. Otherwise it returns 0. */
121 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
122 enum bfd_endian byte_order, LONGEST *pval)
125 const gdb_byte *first_addr;
129 if (byte_order == BFD_ENDIAN_BIG)
132 len > (int) sizeof (LONGEST) && p < addr + orig_len;
145 for (p = addr + orig_len - 1;
146 len > (int) sizeof (LONGEST) && p >= addr;
156 if (len <= (int) sizeof (LONGEST))
158 *pval = (LONGEST) extract_unsigned_integer (first_addr,
168 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
169 address it represents. */
171 extract_typed_address (const gdb_byte *buf, struct type *type)
173 if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
174 internal_error (__FILE__, __LINE__,
175 _("extract_typed_address: "
176 "type is not a pointer or reference"));
178 return gdbarch_pointer_to_address (get_type_arch (type), type, buf);
181 /* All 'store' functions accept a host-format integer and store a
182 target-format integer at ADDR which is LEN bytes long. */
185 store_signed_integer (gdb_byte *addr, int len,
186 enum bfd_endian byte_order, LONGEST val)
189 gdb_byte *startaddr = addr;
190 gdb_byte *endaddr = startaddr + len;
192 /* Start at the least significant end of the integer, and work towards
193 the most significant. */
194 if (byte_order == BFD_ENDIAN_BIG)
196 for (p = endaddr - 1; p >= startaddr; --p)
204 for (p = startaddr; p < endaddr; ++p)
213 store_unsigned_integer (gdb_byte *addr, int len,
214 enum bfd_endian byte_order, ULONGEST val)
217 unsigned char *startaddr = (unsigned char *) addr;
218 unsigned char *endaddr = startaddr + len;
220 /* Start at the least significant end of the integer, and work towards
221 the most significant. */
222 if (byte_order == BFD_ENDIAN_BIG)
224 for (p = endaddr - 1; p >= startaddr; --p)
232 for (p = startaddr; p < endaddr; ++p)
240 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
243 store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
245 if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
246 internal_error (__FILE__, __LINE__,
247 _("store_typed_address: "
248 "type is not a pointer or reference"));
250 gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr);
253 /* Copy a value from SOURCE of size SOURCE_SIZE bytes to DEST of size DEST_SIZE
254 bytes. If SOURCE_SIZE is greater than DEST_SIZE, then truncate the most
255 significant bytes. If SOURCE_SIZE is less than DEST_SIZE then either sign
256 or zero extended according to IS_SIGNED. Values are stored in memory with
257 endianess BYTE_ORDER. */
260 copy_integer_to_size (gdb_byte *dest, int dest_size, const gdb_byte *source,
261 int source_size, bool is_signed,
262 enum bfd_endian byte_order)
264 signed int size_diff = dest_size - source_size;
266 /* Copy across everything from SOURCE that can fit into DEST. */
268 if (byte_order == BFD_ENDIAN_BIG && size_diff > 0)
269 memcpy (dest + size_diff, source, source_size);
270 else if (byte_order == BFD_ENDIAN_BIG && size_diff < 0)
271 memcpy (dest, source - size_diff, dest_size);
273 memcpy (dest, source, std::min (source_size, dest_size));
275 /* Fill the remaining space in DEST by either zero extending or sign
280 gdb_byte extension = 0;
282 && ((byte_order != BFD_ENDIAN_BIG && source[source_size - 1] & 0x80)
283 || (byte_order == BFD_ENDIAN_BIG && source[0] & 0x80)))
286 /* Extend into MSBs of SOURCE. */
287 if (byte_order == BFD_ENDIAN_BIG)
288 memset (dest, extension, size_diff);
290 memset (dest + source_size, extension, size_diff);
294 /* Return a `value' with the contents of (virtual or cooked) register
295 REGNUM as found in the specified FRAME. The register's type is
296 determined by register_type(). */
299 value_of_register (int regnum, struct frame_info *frame)
301 struct gdbarch *gdbarch = get_frame_arch (frame);
302 struct value *reg_val;
304 /* User registers lie completely outside of the range of normal
305 registers. Catch them early so that the target never sees them. */
306 if (regnum >= gdbarch_num_regs (gdbarch)
307 + gdbarch_num_pseudo_regs (gdbarch))
308 return value_of_user_reg (regnum, frame);
310 reg_val = value_of_register_lazy (frame, regnum);
311 value_fetch_lazy (reg_val);
315 /* Return a `value' with the contents of (virtual or cooked) register
316 REGNUM as found in the specified FRAME. The register's type is
317 determined by register_type(). The value is not fetched. */
320 value_of_register_lazy (struct frame_info *frame, int regnum)
322 struct gdbarch *gdbarch = get_frame_arch (frame);
323 struct value *reg_val;
324 struct frame_info *next_frame;
326 gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
327 + gdbarch_num_pseudo_regs (gdbarch)));
329 gdb_assert (frame != NULL);
331 next_frame = get_next_frame_sentinel_okay (frame);
333 /* We should have a valid next frame. */
334 gdb_assert (frame_id_p (get_frame_id (next_frame)));
336 reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
337 VALUE_LVAL (reg_val) = lval_register;
338 VALUE_REGNUM (reg_val) = regnum;
339 VALUE_NEXT_FRAME_ID (reg_val) = get_frame_id (next_frame);
344 /* Given a pointer of type TYPE in target form in BUF, return the
345 address it represents. */
347 unsigned_pointer_to_address (struct gdbarch *gdbarch,
348 struct type *type, const gdb_byte *buf)
350 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
352 return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
356 signed_pointer_to_address (struct gdbarch *gdbarch,
357 struct type *type, const gdb_byte *buf)
359 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
361 return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
364 /* Given an address, store it as a pointer of type TYPE in target
367 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
368 gdb_byte *buf, CORE_ADDR addr)
370 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
372 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
376 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
377 gdb_byte *buf, CORE_ADDR addr)
379 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
381 store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
386 enum symbol_needs_kind
387 symbol_read_needs (struct symbol *sym)
389 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
390 return SYMBOL_COMPUTED_OPS (sym)->get_symbol_read_needs (sym);
392 switch (SYMBOL_CLASS (sym))
394 /* All cases listed explicitly so that gcc -Wall will detect it if
395 we failed to consider one. */
397 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
402 case LOC_REGPARM_ADDR:
404 return SYMBOL_NEEDS_FRAME;
412 /* Getting the address of a label can be done independently of the block,
413 even if some *uses* of that address wouldn't work so well without
417 case LOC_CONST_BYTES:
419 case LOC_OPTIMIZED_OUT:
420 return SYMBOL_NEEDS_NONE;
422 return SYMBOL_NEEDS_FRAME;
428 symbol_read_needs_frame (struct symbol *sym)
430 return symbol_read_needs (sym) == SYMBOL_NEEDS_FRAME;
433 /* Private data to be used with minsym_lookup_iterator_cb. */
435 struct minsym_lookup_data
437 /* The name of the minimal symbol we are searching for. */
440 /* The field where the callback should store the minimal symbol
441 if found. It should be initialized to NULL before the search
443 struct bound_minimal_symbol result;
446 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
447 It searches by name for a minimal symbol within the given OBJFILE.
448 The arguments are passed via CB_DATA, which in reality is a pointer
449 to struct minsym_lookup_data. */
452 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
454 struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
456 gdb_assert (data->result.minsym == NULL);
458 data->result = lookup_minimal_symbol (data->name, NULL, objfile);
460 /* The iterator should stop iff a match was found. */
461 return (data->result.minsym != NULL);
464 /* Given static link expression and the frame it lives in, look for the frame
465 the static links points to and return it. Return NULL if we could not find
468 static struct frame_info *
469 follow_static_link (struct frame_info *frame,
470 const struct dynamic_prop *static_link)
472 CORE_ADDR upper_frame_base;
474 if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base))
477 /* Now climb up the stack frame until we reach the frame we are interested
479 for (; frame != NULL; frame = get_prev_frame (frame))
481 struct symbol *framefunc = get_frame_function (frame);
483 /* Stacks can be quite deep: give the user a chance to stop this. */
486 /* If we don't know how to compute FRAME's base address, don't give up:
487 maybe the frame we are looking for is upper in the stace frame. */
488 if (framefunc != NULL
489 && SYMBOL_BLOCK_OPS (framefunc) != NULL
490 && SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL
491 && (SYMBOL_BLOCK_OPS (framefunc)->get_frame_base (framefunc, frame)
492 == upper_frame_base))
499 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
500 rules, look for the frame that is actually hosting VAR and return it. If,
501 for some reason, we found no such frame, return NULL.
503 This kind of computation is necessary to correctly handle lexically nested
506 Note that in some cases, we know what scope VAR comes from but we cannot
507 reach the specific frame that hosts the instance of VAR we are looking for.
508 For backward compatibility purposes (with old compilers), we then look for
509 the first frame that can host it. */
511 static struct frame_info *
512 get_hosting_frame (struct symbol *var, const struct block *var_block,
513 struct frame_info *frame)
515 const struct block *frame_block = NULL;
517 if (!symbol_read_needs_frame (var))
520 /* Some symbols for local variables have no block: this happens when they are
521 not produced by a debug information reader, for instance when GDB creates
522 synthetic symbols. Without block information, we must assume they are
523 local to FRAME. In this case, there is nothing to do. */
524 else if (var_block == NULL)
527 /* We currently assume that all symbols with a location list need a frame.
528 This is true in practice because selecting the location description
529 requires to compute the CFA, hence requires a frame. However we have
530 tests that embed global/static symbols with null location lists.
531 We want to get <optimized out> instead of <frame required> when evaluating
532 them so return a frame instead of raising an error. */
533 else if (var_block == block_global_block (var_block)
534 || var_block == block_static_block (var_block))
537 /* We have to handle the "my_func::my_local_var" notation. This requires us
538 to look for upper frames when we find no block for the current frame: here
539 and below, handle when frame_block == NULL. */
541 frame_block = get_frame_block (frame, NULL);
543 /* Climb up the call stack until reaching the frame we are looking for. */
544 while (frame != NULL && frame_block != var_block)
546 /* Stacks can be quite deep: give the user a chance to stop this. */
549 if (frame_block == NULL)
551 frame = get_prev_frame (frame);
554 frame_block = get_frame_block (frame, NULL);
557 /* If we failed to find the proper frame, fallback to the heuristic
559 else if (frame_block == block_global_block (frame_block))
565 /* Assuming we have a block for this frame: if we are at the function
566 level, the immediate upper lexical block is in an outer function:
567 follow the static link. */
568 else if (BLOCK_FUNCTION (frame_block))
570 const struct dynamic_prop *static_link
571 = block_static_link (frame_block);
572 int could_climb_up = 0;
574 if (static_link != NULL)
576 frame = follow_static_link (frame, static_link);
579 frame_block = get_frame_block (frame, NULL);
580 could_climb_up = frame_block != NULL;
591 /* We must be in some function nested lexical block. Just get the
592 outer block: both must share the same frame. */
593 frame_block = BLOCK_SUPERBLOCK (frame_block);
596 /* Old compilers may not provide a static link, or they may provide an
597 invalid one. For such cases, fallback on the old way to evaluate
598 non-local references: just climb up the call stack and pick the first
599 frame that contains the variable we are looking for. */
602 frame = block_innermost_frame (var_block);
605 if (BLOCK_FUNCTION (var_block)
606 && !block_inlined_p (var_block)
607 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)))
608 error (_("No frame is currently executing in block %s."),
609 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)));
611 error (_("No frame is currently executing in specified"
619 /* A default implementation for the "la_read_var_value" hook in
620 the language vector which should work in most situations. */
623 default_read_var_value (struct symbol *var, const struct block *var_block,
624 struct frame_info *frame)
627 struct type *type = SYMBOL_TYPE (var);
629 enum symbol_needs_kind sym_need;
631 /* Call check_typedef on our type to make sure that, if TYPE is
632 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
633 instead of zero. However, we do not replace the typedef type by the
634 target type, because we want to keep the typedef in order to be able to
635 set the returned value type description correctly. */
636 check_typedef (type);
638 sym_need = symbol_read_needs (var);
639 if (sym_need == SYMBOL_NEEDS_FRAME)
640 gdb_assert (frame != NULL);
641 else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers)
642 error (_("Cannot read `%s' without registers"), SYMBOL_PRINT_NAME (var));
645 frame = get_hosting_frame (var, var_block, frame);
647 if (SYMBOL_COMPUTED_OPS (var) != NULL)
648 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
650 switch (SYMBOL_CLASS (var))
653 if (is_dynamic_type (type))
655 /* Value is a constant byte-sequence and needs no memory access. */
656 type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0);
658 /* Put the constant back in target format. */
659 v = allocate_value (type);
660 store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
661 gdbarch_byte_order (get_type_arch (type)),
662 (LONGEST) SYMBOL_VALUE (var));
663 VALUE_LVAL (v) = not_lval;
667 /* Put the constant back in target format. */
668 v = allocate_value (type);
669 if (overlay_debugging)
672 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
673 SYMBOL_OBJ_SECTION (symbol_objfile (var),
676 store_typed_address (value_contents_raw (v), type, addr);
679 store_typed_address (value_contents_raw (v), type,
680 SYMBOL_VALUE_ADDRESS (var));
681 VALUE_LVAL (v) = not_lval;
684 case LOC_CONST_BYTES:
685 if (is_dynamic_type (type))
687 /* Value is a constant byte-sequence and needs no memory access. */
688 type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0);
690 v = allocate_value (type);
691 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
693 VALUE_LVAL (v) = not_lval;
697 if (overlay_debugging)
698 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
699 SYMBOL_OBJ_SECTION (symbol_objfile (var),
702 addr = SYMBOL_VALUE_ADDRESS (var);
706 addr = get_frame_args_address (frame);
708 error (_("Unknown argument list address for `%s'."),
709 SYMBOL_PRINT_NAME (var));
710 addr += SYMBOL_VALUE (var);
718 argref = get_frame_args_address (frame);
720 error (_("Unknown argument list address for `%s'."),
721 SYMBOL_PRINT_NAME (var));
722 argref += SYMBOL_VALUE (var);
723 ref = value_at (lookup_pointer_type (type), argref);
724 addr = value_as_address (ref);
729 addr = get_frame_locals_address (frame);
730 addr += SYMBOL_VALUE (var);
734 error (_("Cannot look up value of a typedef `%s'."),
735 SYMBOL_PRINT_NAME (var));
739 if (overlay_debugging)
740 addr = symbol_overlayed_address
741 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)),
742 SYMBOL_OBJ_SECTION (symbol_objfile (var), var));
744 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
748 case LOC_REGPARM_ADDR:
750 int regno = SYMBOL_REGISTER_OPS (var)
751 ->register_number (var, get_frame_arch (frame));
752 struct value *regval;
754 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
756 regval = value_from_register (lookup_pointer_type (type),
761 error (_("Value of register variable not available for `%s'."),
762 SYMBOL_PRINT_NAME (var));
764 addr = value_as_address (regval);
768 regval = value_from_register (type, regno, frame);
771 error (_("Value of register variable not available for `%s'."),
772 SYMBOL_PRINT_NAME (var));
779 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
783 struct minsym_lookup_data lookup_data;
784 struct minimal_symbol *msym;
785 struct obj_section *obj_section;
787 memset (&lookup_data, 0, sizeof (lookup_data));
788 lookup_data.name = SYMBOL_LINKAGE_NAME (var);
790 gdbarch_iterate_over_objfiles_in_search_order
792 minsym_lookup_iterator_cb, &lookup_data,
793 symbol_objfile (var));
794 msym = lookup_data.result.minsym;
796 /* If we can't find the minsym there's a problem in the symbol info.
797 The symbol exists in the debug info, but it's missing in the minsym
801 const char *flavour_name
802 = objfile_flavour_name (symbol_objfile (var));
804 /* We can't get here unless we've opened the file, so flavour_name
806 gdb_assert (flavour_name != NULL);
807 error (_("Missing %s symbol \"%s\"."),
808 flavour_name, SYMBOL_LINKAGE_NAME (var));
810 obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
811 /* Relocate address, unless there is no section or the variable is
813 if (obj_section == NULL
814 || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
815 addr = MSYMBOL_VALUE_RAW_ADDRESS (msym);
817 addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
818 if (overlay_debugging)
819 addr = symbol_overlayed_address (addr, obj_section);
820 /* Determine address of TLS variable. */
822 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
823 addr = target_translate_tls_address (obj_section->objfile, addr);
827 case LOC_OPTIMIZED_OUT:
828 return allocate_optimized_out_value (type);
831 error (_("Cannot look up value of a botched symbol `%s'."),
832 SYMBOL_PRINT_NAME (var));
836 v = value_at_lazy (type, addr);
840 /* Calls VAR's language la_read_var_value hook with the given arguments. */
843 read_var_value (struct symbol *var, const struct block *var_block,
844 struct frame_info *frame)
846 const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
848 gdb_assert (lang != NULL);
849 gdb_assert (lang->la_read_var_value != NULL);
851 return lang->la_read_var_value (var, var_block, frame);
854 /* Install default attributes for register values. */
857 default_value_from_register (struct gdbarch *gdbarch, struct type *type,
858 int regnum, struct frame_id frame_id)
860 int len = TYPE_LENGTH (type);
861 struct value *value = allocate_value (type);
862 struct frame_info *frame;
864 VALUE_LVAL (value) = lval_register;
865 frame = frame_find_by_id (frame_id);
868 frame_id = null_frame_id;
870 frame_id = get_frame_id (get_next_frame_sentinel_okay (frame));
872 VALUE_NEXT_FRAME_ID (value) = frame_id;
873 VALUE_REGNUM (value) = regnum;
875 /* Any structure stored in more than one register will always be
876 an integral number of registers. Otherwise, you need to do
877 some fiddling with the last register copied here for little
879 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
880 && len < register_size (gdbarch, regnum))
881 /* Big-endian, and we want less than full size. */
882 set_value_offset (value, register_size (gdbarch, regnum) - len);
884 set_value_offset (value, 0);
889 /* VALUE must be an lval_register value. If regnum is the value's
890 associated register number, and len the length of the values type,
891 read one or more registers in FRAME, starting with register REGNUM,
892 until we've read LEN bytes.
894 If any of the registers we try to read are optimized out, then mark the
895 complete resulting value as optimized out. */
898 read_frame_register_value (struct value *value, struct frame_info *frame)
900 struct gdbarch *gdbarch = get_frame_arch (frame);
902 LONGEST reg_offset = value_offset (value);
903 int regnum = VALUE_REGNUM (value);
904 int len = type_length_units (check_typedef (value_type (value)));
906 gdb_assert (VALUE_LVAL (value) == lval_register);
908 /* Skip registers wholly inside of REG_OFFSET. */
909 while (reg_offset >= register_size (gdbarch, regnum))
911 reg_offset -= register_size (gdbarch, regnum);
918 struct value *regval = get_frame_register_value (frame, regnum);
919 int reg_len = type_length_units (value_type (regval)) - reg_offset;
921 /* If the register length is larger than the number of bytes
922 remaining to copy, then only copy the appropriate bytes. */
926 value_contents_copy (value, offset, regval, reg_offset, reg_len);
935 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
938 value_from_register (struct type *type, int regnum, struct frame_info *frame)
940 struct gdbarch *gdbarch = get_frame_arch (frame);
941 struct type *type1 = check_typedef (type);
944 if (gdbarch_convert_register_p (gdbarch, regnum, type1))
946 int optim, unavail, ok;
948 /* The ISA/ABI need to something weird when obtaining the
949 specified value from this register. It might need to
950 re-order non-adjacent, starting with REGNUM (see MIPS and
951 i386). It might need to convert the [float] register into
952 the corresponding [integer] type (see Alpha). The assumption
953 is that gdbarch_register_to_value populates the entire value
954 including the location. */
955 v = allocate_value (type);
956 VALUE_LVAL (v) = lval_register;
957 VALUE_NEXT_FRAME_ID (v) = get_frame_id (get_next_frame_sentinel_okay (frame));
958 VALUE_REGNUM (v) = regnum;
959 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
960 value_contents_raw (v), &optim,
966 mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
968 mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
973 /* Construct the value. */
974 v = gdbarch_value_from_register (gdbarch, type,
975 regnum, get_frame_id (frame));
978 read_frame_register_value (v, frame);
984 /* Return contents of register REGNUM in frame FRAME as address.
985 Will abort if register value is not available. */
988 address_from_register (int regnum, struct frame_info *frame)
990 struct gdbarch *gdbarch = get_frame_arch (frame);
991 struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
994 int regnum_max_excl = (gdbarch_num_regs (gdbarch)
995 + gdbarch_num_pseudo_regs (gdbarch));
997 if (regnum < 0 || regnum >= regnum_max_excl)
998 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum,
1001 /* This routine may be called during early unwinding, at a time
1002 where the ID of FRAME is not yet known. Calling value_from_register
1003 would therefore abort in get_frame_id. However, since we only need
1004 a temporary value that is never used as lvalue, we actually do not
1005 really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
1006 the core of value_from_register, but use the null_frame_id. */
1008 /* Some targets require a special conversion routine even for plain
1009 pointer types. Avoid constructing a value object in those cases. */
1010 if (gdbarch_convert_register_p (gdbarch, regnum, type))
1012 gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
1013 int optim, unavail, ok;
1015 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
1016 buf, &optim, &unavail);
1019 /* This function is used while computing a location expression.
1020 Complain about the value being optimized out, rather than
1021 letting value_as_address complain about some random register
1022 the expression depends on not being saved. */
1023 error_value_optimized_out ();
1026 return unpack_long (type, buf);
1029 value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
1030 read_frame_register_value (value, frame);
1032 if (value_optimized_out (value))
1034 /* This function is used while computing a location expression.
1035 Complain about the value being optimized out, rather than
1036 letting value_as_address complain about some random register
1037 the expression depends on not being saved. */
1038 error_value_optimized_out ();
1041 result = value_as_address (value);
1042 release_value (value);
1049 namespace selftests {
1050 namespace findvar_tests {
1052 /* Function to test copy_integer_to_size. Store SOURCE_VAL with size
1053 SOURCE_SIZE to a buffer, making sure no sign extending happens at this
1054 stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
1055 copied value and compare to DEST_VALU. Copy again with a signed
1056 copy_integer_to_size and compare to DEST_VALS. Do everything for both
1057 LITTLE and BIG target endians. Use unsigned values throughout to make
1058 sure there are no implicit sign extensions. */
1061 do_cint_test (ULONGEST dest_valu, ULONGEST dest_vals, int dest_size,
1062 ULONGEST src_val, int src_size)
1064 for (int i = 0; i < 2 ; i++)
1066 gdb_byte srcbuf[sizeof (ULONGEST)] = {};
1067 gdb_byte destbuf[sizeof (ULONGEST)] = {};
1068 enum bfd_endian byte_order = i ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
1070 /* Fill the src buffer (and later the dest buffer) with non-zero junk,
1071 to ensure zero extensions aren't hidden. */
1072 memset (srcbuf, 0xaa, sizeof (srcbuf));
1074 /* Store (and later extract) using unsigned to ensure there are no sign
1076 store_unsigned_integer (srcbuf, src_size, byte_order, src_val);
1078 /* Test unsigned. */
1079 memset (destbuf, 0xaa, sizeof (destbuf));
1080 copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, false,
1082 SELF_CHECK (dest_valu == extract_unsigned_integer (destbuf, dest_size,
1086 memset (destbuf, 0xaa, sizeof (destbuf));
1087 copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, true,
1089 SELF_CHECK (dest_vals == extract_unsigned_integer (destbuf, dest_size,
1095 copy_integer_to_size_test ()
1097 /* Destination is bigger than the source, which has the signed bit unset. */
1098 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1099 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1101 /* Destination is bigger than the source, which has the signed bit set. */
1102 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1103 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1105 /* Destination is smaller than the source. */
1106 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1107 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1109 /* Destination and source are the same size. */
1110 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1112 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1113 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1115 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1117 /* Destination is bigger than the source. Source is bigger than 32bits. */
1118 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1119 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1120 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1121 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1124 } // namespace findvar_test
1125 } // namespace selftests
1130 _initialize_findvar (void)
1133 register_self_test (selftests::findvar_tests::copy_integer_to_size_test);