12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103 |
- /* Find a variable's value in memory, for GDB, the GNU debugger.
- Copyright (C) 1986-2022 Free Software Foundation, Inc.
- This file is part of GDB.
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- (at your option) any later version.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
- #include "defs.h"
- #include "symtab.h"
- #include "gdbtypes.h"
- #include "frame.h"
- #include "value.h"
- #include "gdbcore.h"
- #include "inferior.h"
- #include "target.h"
- #include "symfile.h" /* for overlay functions */
- #include "regcache.h"
- #include "user-regs.h"
- #include "block.h"
- #include "objfiles.h"
- #include "language.h"
- #include "dwarf2/loc.h"
- #include "gdbsupport/selftest.h"
- /* Basic byte-swapping routines. All 'extract' functions return a
- host-format integer from a target-format integer at ADDR which is
- LEN bytes long. */
- #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
- /* 8 bit characters are a pretty safe assumption these days, so we
- assume it throughout all these swapping routines. If we had to deal with
- 9 bit characters, we would need to make len be in bits and would have
- to re-write these routines... */
- you lose
- #endif
- template<typename T, typename>
- T
- extract_integer (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order)
- {
- typename std::make_unsigned<T>::type retval = 0;
- if (buf.size () > (int) sizeof (T))
- error (_("\
- That operation is not available on integers of more than %d bytes."),
- (int) sizeof (T));
- /* Start at the most significant end of the integer, and work towards
- the least significant. */
- if (byte_order == BFD_ENDIAN_BIG)
- {
- size_t i = 0;
- if (std::is_signed<T>::value)
- {
- /* Do the sign extension once at the start. */
- retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
- ++i;
- }
- for (; i < buf.size (); ++i)
- retval = (retval << 8) | buf[i];
- }
- else
- {
- ssize_t i = buf.size () - 1;
- if (std::is_signed<T>::value)
- {
- /* Do the sign extension once at the start. */
- retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
- --i;
- }
- for (; i >= 0; --i)
- retval = (retval << 8) | buf[i];
- }
- return retval;
- }
- /* Explicit instantiations. */
- template LONGEST extract_integer<LONGEST> (gdb::array_view<const gdb_byte> buf,
- enum bfd_endian byte_order);
- template ULONGEST extract_integer<ULONGEST>
- (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order);
- /* Sometimes a long long unsigned integer can be extracted as a
- LONGEST value. This is done so that we can print these values
- better. If this integer can be converted to a LONGEST, this
- function returns 1 and sets *PVAL. Otherwise it returns 0. */
- int
- extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
- enum bfd_endian byte_order, LONGEST *pval)
- {
- const gdb_byte *p;
- const gdb_byte *first_addr;
- int len;
- len = orig_len;
- if (byte_order == BFD_ENDIAN_BIG)
- {
- for (p = addr;
- len > (int) sizeof (LONGEST) && p < addr + orig_len;
- p++)
- {
- if (*p == 0)
- len--;
- else
- break;
- }
- first_addr = p;
- }
- else
- {
- first_addr = addr;
- for (p = addr + orig_len - 1;
- len > (int) sizeof (LONGEST) && p >= addr;
- p--)
- {
- if (*p == 0)
- len--;
- else
- break;
- }
- }
- if (len <= (int) sizeof (LONGEST))
- {
- *pval = (LONGEST) extract_unsigned_integer (first_addr,
- sizeof (LONGEST),
- byte_order);
- return 1;
- }
- return 0;
- }
- /* Treat the bytes at BUF as a pointer of type TYPE, and return the
- address it represents. */
- CORE_ADDR
- extract_typed_address (const gdb_byte *buf, struct type *type)
- {
- if (!type->is_pointer_or_reference ())
- internal_error (__FILE__, __LINE__,
- _("extract_typed_address: "
- "type is not a pointer or reference"));
- return gdbarch_pointer_to_address (type->arch (), type, buf);
- }
- /* All 'store' functions accept a host-format integer and store a
- target-format integer at ADDR which is LEN bytes long. */
- template<typename T, typename>
- void
- store_integer (gdb_byte *addr, int len, enum bfd_endian byte_order,
- T val)
- {
- gdb_byte *p;
- gdb_byte *startaddr = addr;
- gdb_byte *endaddr = startaddr + len;
- /* Start at the least significant end of the integer, and work towards
- the most significant. */
- if (byte_order == BFD_ENDIAN_BIG)
- {
- for (p = endaddr - 1; p >= startaddr; --p)
- {
- *p = val & 0xff;
- val >>= 8;
- }
- }
- else
- {
- for (p = startaddr; p < endaddr; ++p)
- {
- *p = val & 0xff;
- val >>= 8;
- }
- }
- }
- /* Explicit instantiations. */
- template void store_integer (gdb_byte *addr, int len,
- enum bfd_endian byte_order,
- LONGEST val);
- template void store_integer (gdb_byte *addr, int len,
- enum bfd_endian byte_order,
- ULONGEST val);
- /* Store the address ADDR as a pointer of type TYPE at BUF, in target
- form. */
- void
- store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
- {
- if (!type->is_pointer_or_reference ())
- internal_error (__FILE__, __LINE__,
- _("store_typed_address: "
- "type is not a pointer or reference"));
- gdbarch_address_to_pointer (type->arch (), type, buf, addr);
- }
- /* Copy a value from SOURCE of size SOURCE_SIZE bytes to DEST of size DEST_SIZE
- bytes. If SOURCE_SIZE is greater than DEST_SIZE, then truncate the most
- significant bytes. If SOURCE_SIZE is less than DEST_SIZE then either sign
- or zero extended according to IS_SIGNED. Values are stored in memory with
- endianness BYTE_ORDER. */
- void
- copy_integer_to_size (gdb_byte *dest, int dest_size, const gdb_byte *source,
- int source_size, bool is_signed,
- enum bfd_endian byte_order)
- {
- signed int size_diff = dest_size - source_size;
- /* Copy across everything from SOURCE that can fit into DEST. */
- if (byte_order == BFD_ENDIAN_BIG && size_diff > 0)
- memcpy (dest + size_diff, source, source_size);
- else if (byte_order == BFD_ENDIAN_BIG && size_diff < 0)
- memcpy (dest, source - size_diff, dest_size);
- else
- memcpy (dest, source, std::min (source_size, dest_size));
- /* Fill the remaining space in DEST by either zero extending or sign
- extending. */
- if (size_diff > 0)
- {
- gdb_byte extension = 0;
- if (is_signed
- && ((byte_order != BFD_ENDIAN_BIG && source[source_size - 1] & 0x80)
- || (byte_order == BFD_ENDIAN_BIG && source[0] & 0x80)))
- extension = 0xff;
- /* Extend into MSBs of SOURCE. */
- if (byte_order == BFD_ENDIAN_BIG)
- memset (dest, extension, size_diff);
- else
- memset (dest + source_size, extension, size_diff);
- }
- }
- /* Return a `value' with the contents of (virtual or cooked) register
- REGNUM as found in the specified FRAME. The register's type is
- determined by register_type (). */
- struct value *
- value_of_register (int regnum, struct frame_info *frame)
- {
- struct gdbarch *gdbarch = get_frame_arch (frame);
- struct value *reg_val;
- /* User registers lie completely outside of the range of normal
- registers. Catch them early so that the target never sees them. */
- if (regnum >= gdbarch_num_cooked_regs (gdbarch))
- return value_of_user_reg (regnum, frame);
- reg_val = value_of_register_lazy (frame, regnum);
- value_fetch_lazy (reg_val);
- return reg_val;
- }
- /* Return a `value' with the contents of (virtual or cooked) register
- REGNUM as found in the specified FRAME. The register's type is
- determined by register_type (). The value is not fetched. */
- struct value *
- value_of_register_lazy (struct frame_info *frame, int regnum)
- {
- struct gdbarch *gdbarch = get_frame_arch (frame);
- struct value *reg_val;
- struct frame_info *next_frame;
- gdb_assert (regnum < gdbarch_num_cooked_regs (gdbarch));
- gdb_assert (frame != NULL);
- next_frame = get_next_frame_sentinel_okay (frame);
- /* In some cases NEXT_FRAME may not have a valid frame-id yet. This can
- happen if we end up trying to unwind a register as part of the frame
- sniffer. The only time that we get here without a valid frame-id is
- if NEXT_FRAME is an inline frame. If this is the case then we can
- avoid getting into trouble here by skipping past the inline frames. */
- while (get_frame_type (next_frame) == INLINE_FRAME)
- next_frame = get_next_frame_sentinel_okay (next_frame);
- /* We should have a valid next frame. */
- gdb_assert (frame_id_p (get_frame_id (next_frame)));
- reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
- VALUE_LVAL (reg_val) = lval_register;
- VALUE_REGNUM (reg_val) = regnum;
- VALUE_NEXT_FRAME_ID (reg_val) = get_frame_id (next_frame);
- return reg_val;
- }
- /* Given a pointer of type TYPE in target form in BUF, return the
- address it represents. */
- CORE_ADDR
- unsigned_pointer_to_address (struct gdbarch *gdbarch,
- struct type *type, const gdb_byte *buf)
- {
- enum bfd_endian byte_order = type_byte_order (type);
- return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
- }
- CORE_ADDR
- signed_pointer_to_address (struct gdbarch *gdbarch,
- struct type *type, const gdb_byte *buf)
- {
- enum bfd_endian byte_order = type_byte_order (type);
- return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
- }
- /* Given an address, store it as a pointer of type TYPE in target
- format in BUF. */
- void
- unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
- gdb_byte *buf, CORE_ADDR addr)
- {
- enum bfd_endian byte_order = type_byte_order (type);
- store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
- }
- void
- address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
- gdb_byte *buf, CORE_ADDR addr)
- {
- enum bfd_endian byte_order = type_byte_order (type);
- store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
- }
- /* See value.h. */
- enum symbol_needs_kind
- symbol_read_needs (struct symbol *sym)
- {
- if (SYMBOL_COMPUTED_OPS (sym) != NULL)
- return SYMBOL_COMPUTED_OPS (sym)->get_symbol_read_needs (sym);
- switch (sym->aclass ())
- {
- /* All cases listed explicitly so that gcc -Wall will detect it if
- we failed to consider one. */
- case LOC_COMPUTED:
- gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
- case LOC_REGISTER:
- case LOC_ARG:
- case LOC_REF_ARG:
- case LOC_REGPARM_ADDR:
- case LOC_LOCAL:
- return SYMBOL_NEEDS_FRAME;
- case LOC_UNDEF:
- case LOC_CONST:
- case LOC_STATIC:
- case LOC_TYPEDEF:
- case LOC_LABEL:
- /* Getting the address of a label can be done independently of the block,
- even if some *uses* of that address wouldn't work so well without
- the right frame. */
- case LOC_BLOCK:
- case LOC_CONST_BYTES:
- case LOC_UNRESOLVED:
- case LOC_OPTIMIZED_OUT:
- return SYMBOL_NEEDS_NONE;
- }
- return SYMBOL_NEEDS_FRAME;
- }
- /* See value.h. */
- int
- symbol_read_needs_frame (struct symbol *sym)
- {
- return symbol_read_needs (sym) == SYMBOL_NEEDS_FRAME;
- }
- /* Private data to be used with minsym_lookup_iterator_cb. */
- struct minsym_lookup_data
- {
- /* The name of the minimal symbol we are searching for. */
- const char *name = nullptr;
- /* The field where the callback should store the minimal symbol
- if found. It should be initialized to NULL before the search
- is started. */
- struct bound_minimal_symbol result;
- };
- /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
- It searches by name for a minimal symbol within the given OBJFILE.
- The arguments are passed via CB_DATA, which in reality is a pointer
- to struct minsym_lookup_data. */
- static int
- minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
- {
- struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
- gdb_assert (data->result.minsym == NULL);
- data->result = lookup_minimal_symbol (data->name, NULL, objfile);
- /* The iterator should stop iff a match was found. */
- return (data->result.minsym != NULL);
- }
- /* Given static link expression and the frame it lives in, look for the frame
- the static links points to and return it. Return NULL if we could not find
- such a frame. */
- static struct frame_info *
- follow_static_link (struct frame_info *frame,
- const struct dynamic_prop *static_link)
- {
- CORE_ADDR upper_frame_base;
- if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base))
- return NULL;
- /* Now climb up the stack frame until we reach the frame we are interested
- in. */
- for (; frame != NULL; frame = get_prev_frame (frame))
- {
- struct symbol *framefunc = get_frame_function (frame);
- /* Stacks can be quite deep: give the user a chance to stop this. */
- QUIT;
- /* If we don't know how to compute FRAME's base address, don't give up:
- maybe the frame we are looking for is upper in the stack frame. */
- if (framefunc != NULL
- && SYMBOL_BLOCK_OPS (framefunc) != NULL
- && SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL
- && (SYMBOL_BLOCK_OPS (framefunc)->get_frame_base (framefunc, frame)
- == upper_frame_base))
- break;
- }
- return frame;
- }
- /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
- rules, look for the frame that is actually hosting VAR and return it. If,
- for some reason, we found no such frame, return NULL.
- This kind of computation is necessary to correctly handle lexically nested
- functions.
- Note that in some cases, we know what scope VAR comes from but we cannot
- reach the specific frame that hosts the instance of VAR we are looking for.
- For backward compatibility purposes (with old compilers), we then look for
- the first frame that can host it. */
- static struct frame_info *
- get_hosting_frame (struct symbol *var, const struct block *var_block,
- struct frame_info *frame)
- {
- const struct block *frame_block = NULL;
- if (!symbol_read_needs_frame (var))
- return NULL;
- /* Some symbols for local variables have no block: this happens when they are
- not produced by a debug information reader, for instance when GDB creates
- synthetic symbols. Without block information, we must assume they are
- local to FRAME. In this case, there is nothing to do. */
- else if (var_block == NULL)
- return frame;
- /* We currently assume that all symbols with a location list need a frame.
- This is true in practice because selecting the location description
- requires to compute the CFA, hence requires a frame. However we have
- tests that embed global/static symbols with null location lists.
- We want to get <optimized out> instead of <frame required> when evaluating
- them so return a frame instead of raising an error. */
- else if (var_block == block_global_block (var_block)
- || var_block == block_static_block (var_block))
- return frame;
- /* We have to handle the "my_func::my_local_var" notation. This requires us
- to look for upper frames when we find no block for the current frame: here
- and below, handle when frame_block == NULL. */
- if (frame != NULL)
- frame_block = get_frame_block (frame, NULL);
- /* Climb up the call stack until reaching the frame we are looking for. */
- while (frame != NULL && frame_block != var_block)
- {
- /* Stacks can be quite deep: give the user a chance to stop this. */
- QUIT;
- if (frame_block == NULL)
- {
- frame = get_prev_frame (frame);
- if (frame == NULL)
- break;
- frame_block = get_frame_block (frame, NULL);
- }
- /* If we failed to find the proper frame, fallback to the heuristic
- method below. */
- else if (frame_block == block_global_block (frame_block))
- {
- frame = NULL;
- break;
- }
- /* Assuming we have a block for this frame: if we are at the function
- level, the immediate upper lexical block is in an outer function:
- follow the static link. */
- else if (BLOCK_FUNCTION (frame_block))
- {
- const struct dynamic_prop *static_link
- = block_static_link (frame_block);
- int could_climb_up = 0;
- if (static_link != NULL)
- {
- frame = follow_static_link (frame, static_link);
- if (frame != NULL)
- {
- frame_block = get_frame_block (frame, NULL);
- could_climb_up = frame_block != NULL;
- }
- }
- if (!could_climb_up)
- {
- frame = NULL;
- break;
- }
- }
- else
- /* We must be in some function nested lexical block. Just get the
- outer block: both must share the same frame. */
- frame_block = BLOCK_SUPERBLOCK (frame_block);
- }
- /* Old compilers may not provide a static link, or they may provide an
- invalid one. For such cases, fallback on the old way to evaluate
- non-local references: just climb up the call stack and pick the first
- frame that contains the variable we are looking for. */
- if (frame == NULL)
- {
- frame = block_innermost_frame (var_block);
- if (frame == NULL)
- {
- if (BLOCK_FUNCTION (var_block)
- && !block_inlined_p (var_block)
- && BLOCK_FUNCTION (var_block)->print_name ())
- error (_("No frame is currently executing in block %s."),
- BLOCK_FUNCTION (var_block)->print_name ());
- else
- error (_("No frame is currently executing in specified"
- " block"));
- }
- }
- return frame;
- }
- /* See language.h. */
- struct value *
- language_defn::read_var_value (struct symbol *var,
- const struct block *var_block,
- struct frame_info *frame) const
- {
- struct value *v;
- struct type *type = var->type ();
- CORE_ADDR addr;
- enum symbol_needs_kind sym_need;
- /* Call check_typedef on our type to make sure that, if TYPE is
- a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
- instead of zero. However, we do not replace the typedef type by the
- target type, because we want to keep the typedef in order to be able to
- set the returned value type description correctly. */
- check_typedef (type);
- sym_need = symbol_read_needs (var);
- if (sym_need == SYMBOL_NEEDS_FRAME)
- gdb_assert (frame != NULL);
- else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers ())
- error (_("Cannot read `%s' without registers"), var->print_name ());
- if (frame != NULL)
- frame = get_hosting_frame (var, var_block, frame);
- if (SYMBOL_COMPUTED_OPS (var) != NULL)
- return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
- switch (var->aclass ())
- {
- case LOC_CONST:
- if (is_dynamic_type (type))
- {
- /* Value is a constant byte-sequence and needs no memory access. */
- type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
- }
- /* Put the constant back in target format. */
- v = allocate_value (type);
- store_signed_integer (value_contents_raw (v).data (), TYPE_LENGTH (type),
- type_byte_order (type),
- (LONGEST) SYMBOL_VALUE (var));
- VALUE_LVAL (v) = not_lval;
- return v;
- case LOC_LABEL:
- /* Put the constant back in target format. */
- v = allocate_value (type);
- if (overlay_debugging)
- {
- struct objfile *var_objfile = symbol_objfile (var);
- addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- var->obj_section (var_objfile));
- store_typed_address (value_contents_raw (v).data (), type, addr);
- }
- else
- store_typed_address (value_contents_raw (v).data (), type,
- SYMBOL_VALUE_ADDRESS (var));
- VALUE_LVAL (v) = not_lval;
- return v;
- case LOC_CONST_BYTES:
- if (is_dynamic_type (type))
- {
- /* Value is a constant byte-sequence and needs no memory access. */
- type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
- }
- v = allocate_value (type);
- memcpy (value_contents_raw (v).data (), SYMBOL_VALUE_BYTES (var),
- TYPE_LENGTH (type));
- VALUE_LVAL (v) = not_lval;
- return v;
- case LOC_STATIC:
- if (overlay_debugging)
- addr
- = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- var->obj_section (symbol_objfile (var)));
- else
- addr = SYMBOL_VALUE_ADDRESS (var);
- break;
- case LOC_ARG:
- addr = get_frame_args_address (frame);
- if (!addr)
- error (_("Unknown argument list address for `%s'."),
- var->print_name ());
- addr += SYMBOL_VALUE (var);
- break;
- case LOC_REF_ARG:
- {
- struct value *ref;
- CORE_ADDR argref;
- argref = get_frame_args_address (frame);
- if (!argref)
- error (_("Unknown argument list address for `%s'."),
- var->print_name ());
- argref += SYMBOL_VALUE (var);
- ref = value_at (lookup_pointer_type (type), argref);
- addr = value_as_address (ref);
- break;
- }
- case LOC_LOCAL:
- addr = get_frame_locals_address (frame);
- addr += SYMBOL_VALUE (var);
- break;
- case LOC_TYPEDEF:
- error (_("Cannot look up value of a typedef `%s'."),
- var->print_name ());
- break;
- case LOC_BLOCK:
- if (overlay_debugging)
- addr = symbol_overlayed_address
- (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var)),
- var->obj_section (symbol_objfile (var)));
- else
- addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var));
- break;
- case LOC_REGISTER:
- case LOC_REGPARM_ADDR:
- {
- int regno = SYMBOL_REGISTER_OPS (var)
- ->register_number (var, get_frame_arch (frame));
- struct value *regval;
- if (var->aclass () == LOC_REGPARM_ADDR)
- {
- regval = value_from_register (lookup_pointer_type (type),
- regno,
- frame);
- if (regval == NULL)
- error (_("Value of register variable not available for `%s'."),
- var->print_name ());
- addr = value_as_address (regval);
- }
- else
- {
- regval = value_from_register (type, regno, frame);
- if (regval == NULL)
- error (_("Value of register variable not available for `%s'."),
- var->print_name ());
- return regval;
- }
- }
- break;
- case LOC_COMPUTED:
- gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
- case LOC_UNRESOLVED:
- {
- struct minsym_lookup_data lookup_data;
- struct minimal_symbol *msym;
- struct obj_section *obj_section;
- lookup_data.name = var->linkage_name ();
- gdbarch_iterate_over_objfiles_in_search_order
- (symbol_arch (var),
- minsym_lookup_iterator_cb, &lookup_data,
- symbol_objfile (var));
- msym = lookup_data.result.minsym;
- /* If we can't find the minsym there's a problem in the symbol info.
- The symbol exists in the debug info, but it's missing in the minsym
- table. */
- if (msym == NULL)
- {
- const char *flavour_name
- = objfile_flavour_name (symbol_objfile (var));
- /* We can't get here unless we've opened the file, so flavour_name
- can't be NULL. */
- gdb_assert (flavour_name != NULL);
- error (_("Missing %s symbol \"%s\"."),
- flavour_name, var->linkage_name ());
- }
- obj_section = msym->obj_section (lookup_data.result.objfile);
- /* Relocate address, unless there is no section or the variable is
- a TLS variable. */
- if (obj_section == NULL
- || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
- addr = MSYMBOL_VALUE_RAW_ADDRESS (msym);
- else
- addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
- if (overlay_debugging)
- addr = symbol_overlayed_address (addr, obj_section);
- /* Determine address of TLS variable. */
- if (obj_section
- && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
- addr = target_translate_tls_address (obj_section->objfile, addr);
- }
- break;
- case LOC_OPTIMIZED_OUT:
- if (is_dynamic_type (type))
- type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
- return allocate_optimized_out_value (type);
- default:
- error (_("Cannot look up value of a botched symbol `%s'."),
- var->print_name ());
- break;
- }
- v = value_at_lazy (type, addr);
- return v;
- }
- /* Calls VAR's language read_var_value hook with the given arguments. */
- struct value *
- read_var_value (struct symbol *var, const struct block *var_block,
- struct frame_info *frame)
- {
- const struct language_defn *lang = language_def (var->language ());
- gdb_assert (lang != NULL);
- return lang->read_var_value (var, var_block, frame);
- }
- /* Install default attributes for register values. */
- struct value *
- default_value_from_register (struct gdbarch *gdbarch, struct type *type,
- int regnum, struct frame_id frame_id)
- {
- int len = TYPE_LENGTH (type);
- struct value *value = allocate_value (type);
- struct frame_info *frame;
- VALUE_LVAL (value) = lval_register;
- frame = frame_find_by_id (frame_id);
- if (frame == NULL)
- frame_id = null_frame_id;
- else
- frame_id = get_frame_id (get_next_frame_sentinel_okay (frame));
- VALUE_NEXT_FRAME_ID (value) = frame_id;
- VALUE_REGNUM (value) = regnum;
- /* Any structure stored in more than one register will always be
- an integral number of registers. Otherwise, you need to do
- some fiddling with the last register copied here for little
- endian machines. */
- if (type_byte_order (type) == BFD_ENDIAN_BIG
- && len < register_size (gdbarch, regnum))
- /* Big-endian, and we want less than full size. */
- set_value_offset (value, register_size (gdbarch, regnum) - len);
- else
- set_value_offset (value, 0);
- return value;
- }
- /* VALUE must be an lval_register value. If regnum is the value's
- associated register number, and len the length of the values type,
- read one or more registers in FRAME, starting with register REGNUM,
- until we've read LEN bytes.
- If any of the registers we try to read are optimized out, then mark the
- complete resulting value as optimized out. */
- void
- read_frame_register_value (struct value *value, struct frame_info *frame)
- {
- struct gdbarch *gdbarch = get_frame_arch (frame);
- LONGEST offset = 0;
- LONGEST reg_offset = value_offset (value);
- int regnum = VALUE_REGNUM (value);
- int len = type_length_units (check_typedef (value_type (value)));
- gdb_assert (VALUE_LVAL (value) == lval_register);
- /* Skip registers wholly inside of REG_OFFSET. */
- while (reg_offset >= register_size (gdbarch, regnum))
- {
- reg_offset -= register_size (gdbarch, regnum);
- regnum++;
- }
- /* Copy the data. */
- while (len > 0)
- {
- struct value *regval = get_frame_register_value (frame, regnum);
- int reg_len = type_length_units (value_type (regval)) - reg_offset;
- /* If the register length is larger than the number of bytes
- remaining to copy, then only copy the appropriate bytes. */
- if (reg_len > len)
- reg_len = len;
- value_contents_copy (value, offset, regval, reg_offset, reg_len);
- offset += reg_len;
- len -= reg_len;
- reg_offset = 0;
- regnum++;
- }
- }
- /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
- struct value *
- value_from_register (struct type *type, int regnum, struct frame_info *frame)
- {
- struct gdbarch *gdbarch = get_frame_arch (frame);
- struct type *type1 = check_typedef (type);
- struct value *v;
- if (gdbarch_convert_register_p (gdbarch, regnum, type1))
- {
- int optim, unavail, ok;
- /* The ISA/ABI need to something weird when obtaining the
- specified value from this register. It might need to
- re-order non-adjacent, starting with REGNUM (see MIPS and
- i386). It might need to convert the [float] register into
- the corresponding [integer] type (see Alpha). The assumption
- is that gdbarch_register_to_value populates the entire value
- including the location. */
- v = allocate_value (type);
- VALUE_LVAL (v) = lval_register;
- VALUE_NEXT_FRAME_ID (v) = get_frame_id (get_next_frame_sentinel_okay (frame));
- VALUE_REGNUM (v) = regnum;
- ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
- value_contents_raw (v).data (), &optim,
- &unavail);
- if (!ok)
- {
- if (optim)
- mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
- if (unavail)
- mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
- }
- }
- else
- {
- /* Construct the value. */
- v = gdbarch_value_from_register (gdbarch, type,
- regnum, get_frame_id (frame));
- /* Get the data. */
- read_frame_register_value (v, frame);
- }
- return v;
- }
- /* Return contents of register REGNUM in frame FRAME as address.
- Will abort if register value is not available. */
- CORE_ADDR
- address_from_register (int regnum, struct frame_info *frame)
- {
- struct gdbarch *gdbarch = get_frame_arch (frame);
- struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
- struct value *value;
- CORE_ADDR result;
- int regnum_max_excl = gdbarch_num_cooked_regs (gdbarch);
- if (regnum < 0 || regnum >= regnum_max_excl)
- error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum,
- regnum_max_excl);
- /* This routine may be called during early unwinding, at a time
- where the ID of FRAME is not yet known. Calling value_from_register
- would therefore abort in get_frame_id. However, since we only need
- a temporary value that is never used as lvalue, we actually do not
- really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
- the core of value_from_register, but use the null_frame_id. */
- /* Some targets require a special conversion routine even for plain
- pointer types. Avoid constructing a value object in those cases. */
- if (gdbarch_convert_register_p (gdbarch, regnum, type))
- {
- gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
- int optim, unavail, ok;
- ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
- buf, &optim, &unavail);
- if (!ok)
- {
- /* This function is used while computing a location expression.
- Complain about the value being optimized out, rather than
- letting value_as_address complain about some random register
- the expression depends on not being saved. */
- error_value_optimized_out ();
- }
- return unpack_long (type, buf);
- }
- value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
- read_frame_register_value (value, frame);
- if (value_optimized_out (value))
- {
- /* This function is used while computing a location expression.
- Complain about the value being optimized out, rather than
- letting value_as_address complain about some random register
- the expression depends on not being saved. */
- error_value_optimized_out ();
- }
- result = value_as_address (value);
- release_value (value);
- return result;
- }
- #if GDB_SELF_TEST
- namespace selftests {
- namespace findvar_tests {
- /* Function to test copy_integer_to_size. Store SOURCE_VAL with size
- SOURCE_SIZE to a buffer, making sure no sign extending happens at this
- stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
- copied value and compare to DEST_VALU. Copy again with a signed
- copy_integer_to_size and compare to DEST_VALS. Do everything for both
- LITTLE and BIG target endians. Use unsigned values throughout to make
- sure there are no implicit sign extensions. */
- static void
- do_cint_test (ULONGEST dest_valu, ULONGEST dest_vals, int dest_size,
- ULONGEST src_val, int src_size)
- {
- for (int i = 0; i < 2 ; i++)
- {
- gdb_byte srcbuf[sizeof (ULONGEST)] = {};
- gdb_byte destbuf[sizeof (ULONGEST)] = {};
- enum bfd_endian byte_order = i ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
- /* Fill the src buffer (and later the dest buffer) with non-zero junk,
- to ensure zero extensions aren't hidden. */
- memset (srcbuf, 0xaa, sizeof (srcbuf));
- /* Store (and later extract) using unsigned to ensure there are no sign
- extensions. */
- store_unsigned_integer (srcbuf, src_size, byte_order, src_val);
- /* Test unsigned. */
- memset (destbuf, 0xaa, sizeof (destbuf));
- copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, false,
- byte_order);
- SELF_CHECK (dest_valu == extract_unsigned_integer (destbuf, dest_size,
- byte_order));
- /* Test signed. */
- memset (destbuf, 0xaa, sizeof (destbuf));
- copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, true,
- byte_order);
- SELF_CHECK (dest_vals == extract_unsigned_integer (destbuf, dest_size,
- byte_order));
- }
- }
- static void
- copy_integer_to_size_test ()
- {
- /* Destination is bigger than the source, which has the signed bit unset. */
- do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
- do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
- /* Destination is bigger than the source, which has the signed bit set. */
- do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
- do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
- /* Destination is smaller than the source. */
- do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
- do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
- /* Destination and source are the same size. */
- do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
- 8);
- do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
- do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
- 8);
- do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
- /* Destination is bigger than the source. Source is bigger than 32bits. */
- do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
- do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
- do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
- do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
- }
- } // namespace findvar_test
- } // namespace selftests
- #endif
- void _initialize_findvar ();
- void
- _initialize_findvar ()
- {
- #if GDB_SELF_TEST
- selftests::register_test
- ("copy_integer_to_size",
- selftests::findvar_tests::copy_integer_to_size_test);
- #endif
- }
|