/* Perform non-arithmetic operations on values, for GDB.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
This file is part of GDB.
ULONGEST xfered_total = 0;
struct gdbarch *arch = get_value_arch (val);
int unit_size = gdbarch_addressable_memory_unit_size (arch);
+ enum target_object object;
+
+ object = stack ? TARGET_OBJECT_STACK_MEMORY : TARGET_OBJECT_MEMORY;
while (xfered_total < length)
{
ULONGEST xfered_partial;
status = target_xfer_partial (current_target.beneath,
- TARGET_OBJECT_MEMORY, NULL,
+ object, NULL,
buffer + xfered_total * unit_size, NULL,
memaddr + xfered_total,
length - xfered_total,
struct value *
value_of_variable (struct symbol *var, const struct block *b)
{
- struct frame_info *frame;
+ struct frame_info *frame = NULL;
- if (!symbol_read_needs_frame (var))
- frame = NULL;
- else if (!b)
+ if (symbol_read_needs_frame (var))
frame = get_selected_frame (_("No frame selected."));
- else
- {
- frame = block_innermost_frame (b);
- if (!frame)
- {
- if (BLOCK_FUNCTION (b) && !block_inlined_p (b)
- && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
- error (_("No frame is currently executing in block %s."),
- SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
- else
- error (_("No frame is currently executing in specified block"));
- }
- }
- return read_var_value (var, frame);
+ return read_var_value (var, b, frame);
}
struct value *
if (TYPE_CODE (type) == TYPE_CODE_REF)
{
/* Copy the value, but change the type from (T&) to (T*). We
- keep the same location information, which is efficient, and
- allows &(&X) to get the location containing the reference. */
+ keep the same location information, which is efficient, and
+ allows &(&X) to get the location containing the reference.
+ Do the same to its enclosing type for consistency. */
+ struct type *type_ptr
+ = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+ struct type *enclosing_type
+ = check_typedef (value_enclosing_type (arg1));
+ struct type *enclosing_type_ptr
+ = lookup_pointer_type (TYPE_TARGET_TYPE (enclosing_type));
+
arg2 = value_copy (arg1);
- deprecated_set_value_type (arg2,
- lookup_pointer_type (TYPE_TARGET_TYPE (type)));
+ deprecated_set_value_type (arg2, type_ptr);
+ set_value_enclosing_type (arg2, enclosing_type_ptr);
+
return arg2;
}
if (TYPE_CODE (type) == TYPE_CODE_FUNC)
}
struct value *
-value_cstring (char *ptr, ssize_t len, struct type *char_type)
+value_cstring (const char *ptr, ssize_t len, struct type *char_type)
{
struct value *val;
int lowbound = current_language->string_lower_bound;
string may contain embedded null bytes. */
struct value *
-value_string (char *ptr, ssize_t len, struct type *char_type)
+value_string (const char *ptr, ssize_t len, struct type *char_type)
{
struct value *val;
int lowbound = current_language->string_lower_bound;
struct cleanup *back_to;
CORE_ADDR address;
- tmp = xmalloc (TYPE_LENGTH (baseclass));
+ tmp = (gdb_byte *) xmalloc (TYPE_LENGTH (baseclass));
back_to = make_cleanup (xfree, tmp);
address = value_address (*arg1p);
const char *err)
{
struct type *t;
- struct value *v;
int i;
- int nbases;
*argp = coerce_array (*argp);
int method_oload_champ = -1;
int src_method_oload_champ = -1;
int ext_method_oload_champ = -1;
- int src_and_ext_equal = 0;
/* The measure for the current best match. */
struct badness_vector *method_badness = NULL;
switch (compare_badness (ext_method_badness, src_method_badness))
{
case 0: /* Src method and xmethod are equally good. */
- src_and_ext_equal = 1;
/* If src method and xmethod are equally good, then
xmethod should be the winner. Hence, fall through to the
case where a xmethod is better than the source
old_cleanups = make_cleanup (xfree, *oload_syms);
make_cleanup (xfree, *oload_champ_bv);
- new_namespace = alloca (namespace_len + 1);
+ new_namespace = (char *) alloca (namespace_len + 1);
strncpy (new_namespace, qualified_name, namespace_len);
new_namespace[namespace_len] = '\0';
new_oload_syms = make_symbol_overload_list (func_name,
{
int ix;
int fn_count;
- int xm_worker_vec_n = VEC_length (xmethod_worker_ptr, xm_worker_vec);
/* A measure of how good an overloaded instance is. */
struct badness_vector *bv;
/* Index of best overloaded function. */
else
nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
- parm_types = (struct type **)
- xmalloc (nparms * (sizeof (struct type *)));
+ parm_types = XNEWVEC (struct type *, nparms);
for (jj = 0; jj < nparms; jj++)
parm_types[jj] = (fns_ptr != NULL
? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
return NULL;
if (want_address)
- return value_addr (read_var_value (s, 0));
+ return value_addr (read_var_value (s, 0, 0));
else
- return read_var_value (s, 0);
+ return read_var_value (s, 0, 0);
}
if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
if (s == NULL)
return NULL;
- v = read_var_value (s, 0);
+ v = read_var_value (s, 0, 0);
if (!want_address)
result = v;
else
struct value *
value_of_this (const struct language_defn *lang)
{
- struct symbol *sym;
+ struct block_symbol sym;
const struct block *b;
struct frame_info *frame;
b = get_frame_block (frame, NULL);
- sym = lookup_language_this (lang, b).symbol;
- if (sym == NULL)
+ sym = lookup_language_this (lang, b);
+ if (sym.symbol == NULL)
error (_("current stack frame does not contain a variable named `%s'"),
lang->la_name_of_this);
- return read_var_value (sym, frame);
+ return read_var_value (sym.symbol, sym.block, frame);
}
/* Return the value of the local variable, if one exists. Return NULL