LONGEST embedded_offset = 0;
LONGEST pointed_to_offset = 0;
- /* Actual contents of the value. Target byte-order. NULL or not
- valid if lazy is nonzero. */
+ /* Actual contents of the value. Target byte-order.
+
+ May be nullptr if the value is lazy or is entirely optimized out.
+ Guaranteed to be non-nullptr otherwise. */
gdb::unique_xmalloc_ptr<gdb_byte> contents;
/* Unavailable ranges in CONTENTS. We mark unavailable ranges,
struct cmd_list_element *c, const char *value)
{
if (max_value_size == -1)
- fprintf_filtered (file, _("Maximum value size is unlimited.\n"));
+ gdb_printf (file, _("Maximum value size is unlimited.\n"));
else
- fprintf_filtered (file, _("Maximum value size is %d bytes.\n"),
- max_value_size);
+ gdb_printf (file, _("Maximum value size is %d bytes.\n"),
+ max_value_size);
}
/* Called before we attempt to allocate or reallocate a buffer for the
but it's a different block of storage. */
struct value *
-value_copy (struct value *arg)
+value_copy (const value *arg)
{
struct type *encl_type = value_enclosing_type (arg);
struct value *val;
else
val = allocate_value (encl_type);
val->type = arg->type;
- VALUE_LVAL (val) = VALUE_LVAL (arg);
+ VALUE_LVAL (val) = arg->lval;
val->location = arg->location;
val->offset = arg->offset;
val->bitpos = arg->bitpos;
val->stack = arg->stack;
val->is_zero = arg->is_zero;
val->initialized = arg->initialized;
-
- if (!value_lazy (val))
- copy (value_contents_all_raw (arg),
- value_contents_all_raw (val));
-
val->unavailable = arg->unavailable;
val->optimized_out = arg->optimized_out;
+
+ if (!value_lazy (val) && !value_entirely_optimized_out (val))
+ {
+ gdb_assert (arg->contents != nullptr);
+ ULONGEST length = TYPE_LENGTH (value_enclosing_type (arg));
+ const auto &arg_view
+ = gdb::make_array_view (arg->contents.get (), length);
+ copy (arg_view, value_contents_all_raw (val));
+ }
+
val->parent = arg->parent;
if (VALUE_LVAL (val) == lval_computed)
{
struct value_print_options opts;
val = access_value_history (i);
- printf_filtered (("$%d = "), i);
+ gdb_printf (("$%d = "), i);
get_user_print_options (&opts);
value_print (val, gdb_stdout, &opts);
- printf_filtered (("\n"));
+ gdb_printf (("\n"));
}
/* The next "show values +" should start after what we just printed. */
{
varseen = 1;
}
- printf_filtered (("$%s = "), var->name);
+ gdb_printf (("$%s = "), var->name);
try
{
_("<error: %s>"), ex.what ());
}
- printf_filtered (("\n"));
+ gdb_printf (("\n"));
}
if (!varseen)
{
The user can't create them except via Python, and if Python support
is installed this message will never be printed ($_streq will
exist). */
- printf_filtered (_("No debugger convenience variables now defined.\n"
- "Convenience variables have "
- "names starting with \"$\";\n"
- "use \"set\" as in \"set "
- "$foo = 5\" to define them.\n"));
+ gdb_printf (_("No debugger convenience variables now defined.\n"
+ "Convenience variables have "
+ "names starting with \"$\";\n"
+ "use \"set\" as in \"set "
+ "$foo = 5\" to define them.\n"));
}
}
\f
if (!msym.minsym)
retval = allocate_optimized_out_value (field_type);
else
- retval = value_at_lazy (field_type, BMSYMBOL_VALUE_ADDRESS (msym));
+ retval = value_at_lazy (field_type, msym.value_address ());
}
else
retval = value_of_variable (sym.symbol, sym.block);
VALUE_LVAL (v) = lval_memory;
if (sym)
{
- set_value_address (v, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)));
+ set_value_address (v, sym->value_block ()->entry_pc ());
}
else
{
set_value_address (v,
gdbarch_convert_from_func_ptr_addr
- (gdbarch, BMSYMBOL_VALUE_ADDRESS (msym),
+ (gdbarch, msym.value_address (),
current_inferior ()->top_target ()));
}
gdbarch = get_frame_arch (frame);
string_file debug_file;
- fprintf_unfiltered (&debug_file,
- "(frame=%d, regnum=%d(%s), ...) ",
- frame_relative_level (frame), regnum,
- user_reg_map_regnum_to_name (gdbarch, regnum));
+ gdb_printf (&debug_file,
+ "(frame=%d, regnum=%d(%s), ...) ",
+ frame_relative_level (frame), regnum,
+ user_reg_map_regnum_to_name (gdbarch, regnum));
- fprintf_unfiltered (&debug_file, "->");
+ gdb_printf (&debug_file, "->");
if (value_optimized_out (new_val))
{
- fprintf_unfiltered (&debug_file, " ");
+ gdb_printf (&debug_file, " ");
val_print_optimized_out (new_val, &debug_file);
}
else
gdb::array_view<const gdb_byte> buf = value_contents (new_val);
if (VALUE_LVAL (new_val) == lval_register)
- fprintf_unfiltered (&debug_file, " register=%d",
- VALUE_REGNUM (new_val));
+ gdb_printf (&debug_file, " register=%d",
+ VALUE_REGNUM (new_val));
else if (VALUE_LVAL (new_val) == lval_memory)
- fprintf_unfiltered (&debug_file, " address=%s",
- paddress (gdbarch,
- value_address (new_val)));
+ gdb_printf (&debug_file, " address=%s",
+ paddress (gdbarch,
+ value_address (new_val)));
else
- fprintf_unfiltered (&debug_file, " computed");
+ gdb_printf (&debug_file, " computed");
- fprintf_unfiltered (&debug_file, " bytes=");
- fprintf_unfiltered (&debug_file, "[");
+ gdb_printf (&debug_file, " bytes=");
+ gdb_printf (&debug_file, "[");
for (i = 0; i < register_size (gdbarch, regnum); i++)
- fprintf_unfiltered (&debug_file, "%02x", buf[i]);
- fprintf_unfiltered (&debug_file, "]");
+ gdb_printf (&debug_file, "%02x", buf[i]);
+ gdb_printf (&debug_file, "]");
}
frame_debug_printf ("%s", debug_file.c_str ());
}
}
+static void
+test_value_copy ()
+{
+ type *type = builtin_type (current_inferior ()->gdbarch)->builtin_int;
+
+ /* Verify that we can copy an entirely optimized out value, that may not have
+ its contents allocated. */
+ value_ref_ptr val = release_value (allocate_optimized_out_value (type));
+ value_ref_ptr copy = release_value (value_copy (val.get ()));
+
+ SELF_CHECK (value_entirely_optimized_out (val.get ()));
+ SELF_CHECK (value_entirely_optimized_out (copy.get ()));
+}
+
} /* namespace selftests */
#endif /* GDB_SELF_TEST */
selftests::register_test ("ranges_contain", selftests::test_ranges_contain);
selftests::register_test ("insert_into_bit_range_vector",
selftests::test_insert_into_bit_range_vector);
+ selftests::register_test ("value_copy", selftests::test_value_copy);
#endif
}
projects / binutils-gdb.git / blobdiff