Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009, 2010 Free Software Foundation, Inc.
+ 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
struct cmd_list_element *c,
const char *value)
{
- fprintf_filtered (file, _("\
-Overload resolution in evaluating C++ functions is %s.\n"),
+ fprintf_filtered (file, _("Overload resolution in evaluating "
+ "C++ functions is %s.\n"),
value);
}
else
{
if (!target_has_execution)
- error (_("evaluation of this expression requires the target program to be active"));
+ error (_("evaluation of this expression "
+ "requires the target program to be active"));
else
- error (_("evaluation of this expression requires the program to have a function \"%s\"."), name);
+ error (_("evaluation of this expression requires the "
+ "program to have a function \"%s\"."),
+ name);
}
}
}
if (value_logical_not (val))
{
if (!target_has_execution)
- error (_("No memory available to program now: you need to start the target first"));
+ error (_("No memory available to program now: "
+ "you need to start the target first"));
else
error (_("No memory available to program: call to malloc failed"));
}
v2 = coerce_ref (arg2);
else
v2 = value_ind (arg2);
- gdb_assert (TYPE_CODE (check_typedef (value_type (v2))) == TYPE_CODE_STRUCT
- && !!"Why did coercion fail?");
+ gdb_assert (TYPE_CODE (check_typedef (value_type (v2)))
+ == TYPE_CODE_STRUCT && !!"Why did coercion fail?");
v2 = value_cast_structs (t1, v2);
/* At this point we have what we can have, un-dereference if needed. */
if (v2)
/* No superclass found, just change the pointer type. */
arg2 = value_copy (arg2);
deprecated_set_value_type (arg2, type);
- arg2 = value_change_enclosing_type (arg2, type);
+ set_value_enclosing_type (arg2, type);
set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
return arg2;
}
if (code1 == TYPE_CODE_REF)
{
/* We dereference type; then we recurse and finally
- we generate value of the given reference. Nothing wrong with
+ we generate value of the given reference. Nothing wrong with
that. */
struct type *t1 = check_typedef (type);
struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
low_bound = 0, high_bound = 0;
new_length = val_length / element_length;
if (val_length % element_length != 0)
- warning (_("array element type size does not divide object size in cast"));
+ warning (_("array element type size does not "
+ "divide object size in cast"));
/* FIXME-type-allocation: need a way to free this type when
we are done with it. */
range_type = create_range_type ((struct type *) NULL,
/* Widen the scalar to a vector. */
struct type *eltype;
struct value *val;
- int i, n;
+ LONGEST low_bound, high_bound;
+ int i;
+
+ if (!get_array_bounds (type, &low_bound, &high_bound))
+ error (_("Could not determine the vector bounds"));
eltype = check_typedef (TYPE_TARGET_TYPE (type));
arg2 = value_cast (eltype, arg2);
val = allocate_value (type);
- n = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
- for (i = 0; i < n; i++)
+ for (i = 0; i < high_bound - low_bound + 1; i++)
{
/* Duplicate the contents of arg2 into the destination vector. */
memcpy (value_contents_writeable (val) + (i * TYPE_LENGTH (eltype)),
arg2 = value_copy (arg2);
deprecated_set_value_type (arg2, type);
- arg2 = value_change_enclosing_type (arg2, type);
+ set_value_enclosing_type (arg2, type);
set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
return arg2;
}
{
arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS)
- error (_("Argument to dynamic_cast does not have pointer to class type"));
+ error (_("Argument to dynamic_cast does "
+ "not have pointer to class type"));
}
/* Handle NULL pointers. */
{
val = value_from_longest (type, (LONGEST) 1);
}
+ else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+ {
+ struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1));
+ int i;
+ LONGEST low_bound, high_bound;
+ struct value *tmp;
+
+ if (!get_array_bounds (type1, &low_bound, &high_bound))
+ error (_("Could not determine the vector bounds"));
+
+ val = allocate_value (type);
+ for (i = 0; i < high_bound - low_bound + 1; i++)
+ {
+ tmp = value_one (eltype, lv);
+ memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
+ value_contents_all (tmp), TYPE_LENGTH (eltype));
+ }
+ }
else
{
error (_("Not a numeric type."));
regnum = VALUE_REGNUM (val);
gdbarch = get_frame_arch (frame);
- fprintf_unfiltered (gdb_stdlog, "\
-{ value_fetch_lazy (frame=%d,regnum=%d(%s),...) ",
+ fprintf_unfiltered (gdb_stdlog,
+ "{ value_fetch_lazy "
+ "(frame=%d,regnum=%d(%s),...) ",
frame_relative_level (frame), regnum,
user_reg_map_regnum_to_name (gdbarch, regnum));
}
else if (VALUE_LVAL (val) == lval_computed)
value_computed_funcs (val)->read (val);
+ else if (value_optimized_out (val))
+ /* Keep it optimized out. */;
else
- internal_error (__FILE__, __LINE__, "Unexpected lazy value type.");
+ internal_error (__FILE__, __LINE__, _("Unexpected lazy value type."));
set_value_lazy (val, 0);
return 0;
{
case lval_internalvar:
set_internalvar (VALUE_INTERNALVAR (toval), fromval);
- val = value_copy (fromval);
- val = value_change_enclosing_type (val,
- value_enclosing_type (fromval));
- set_value_embedded_offset (val, value_embedded_offset (fromval));
- set_value_pointed_to_offset (val,
- value_pointed_to_offset (fromval));
- return val;
+ return value_of_internalvar (get_type_arch (type),
+ VALUE_INTERNALVAR (toval));
case lval_internalvar_component:
set_internalvar_component (VALUE_INTERNALVAR (toval),
changed_len = TYPE_LENGTH (type);
if (changed_len > (int) sizeof (LONGEST))
- error (_("Can't handle bitfields which don't fit in a %d bit word."),
+ error (_("Can't handle bitfields which "
+ "don't fit in a %d bit word."),
(int) sizeof (LONGEST) * HOST_CHAR_BIT);
read_memory (changed_addr, buffer, changed_len);
/ HOST_CHAR_BIT;
if (changed_len > (int) sizeof (LONGEST))
- error (_("Can't handle bitfields which don't fit in a %d bit word."),
+ error (_("Can't handle bitfields which "
+ "don't fit in a %d bit word."),
(int) sizeof (LONGEST) * HOST_CHAR_BIT);
get_frame_register_bytes (frame, value_reg, offset,
fromval = value_from_longest (type, fieldval);
}
+ /* The return value is a copy of TOVAL so it shares its location
+ information, but its contents are updated from FROMVAL. This
+ implies the returned value is not lazy, even if TOVAL was. */
val = value_copy (toval);
+ set_value_lazy (val, 0);
memcpy (value_contents_raw (val), value_contents (fromval),
TYPE_LENGTH (type));
- deprecated_set_value_type (val, type);
- val = value_change_enclosing_type (val,
- value_enclosing_type (fromval));
- set_value_embedded_offset (val, value_embedded_offset (fromval));
- set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
+
+ /* We copy over the enclosing type and pointed-to offset from FROMVAL
+ in the case of pointer types. For object types, the enclosing type
+ and embedded offset must *not* be copied: the target object refered
+ to by TOVAL retains its original dynamic type after assignment. */
+ if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ {
+ set_value_enclosing_type (val, value_enclosing_type (fromval));
+ set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
+ }
return val;
}
struct value *val;
/* Evaluate it first; if the result is a memory address, we're fine.
- Lazy evaluation pays off here. */
+ Lazy evaluation pays off here. */
val = value_of_variable (var, b);
}
}
-/* Make sure that VAL lives in target memory if it's supposed to. For instance,
- strings are constructed as character arrays in GDB's storage, and this
- function copies them to the target. */
+/* Make sure that VAL lives in target memory if it's supposed to. For
+ instance, strings are constructed as character arrays in GDB's
+ storage, and this function copies them to the target. */
struct value *
value_coerce_to_target (struct value *val)
other than array subscripting, where the caller would get back a
value that had an address somewhere before the actual first element
of the array, and the information about the lower bound would be
- lost because of the coercion to pointer type.
- */
+ lost because of the coercion to pointer type. */
struct value *
value_coerce_array (struct value *arg1)
if (VALUE_LVAL (arg1) != lval_memory)
error (_("Attempt to take address of value not located in memory."));
- /* Get target memory address */
+ /* Get target memory address. */
arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
(value_address (arg1)
+ value_embedded_offset (arg1)));
/* This may be a pointer to a base subobject; so remember the
full derived object's type ... */
- arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (value_enclosing_type (arg1)));
+ set_value_enclosing_type (arg2,
+ lookup_pointer_type (value_enclosing_type (arg1)));
/* ... and also the relative position of the subobject in the full
object. */
set_value_pointed_to_offset (arg2, value_embedded_offset (arg1));
base_type = check_typedef (value_type (arg1));
+ if (VALUE_LVAL (arg1) == lval_computed)
+ {
+ struct lval_funcs *funcs = value_computed_funcs (arg1);
+
+ if (funcs->indirect)
+ {
+ struct value *result = funcs->indirect (arg1);
+
+ if (result)
+ return result;
+ }
+ }
+
if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
{
struct type *enc_type;
arg2 = value_at_lazy (enc_type,
find_function_addr (arg1, NULL));
else
- /* Retrieve the enclosing object pointed to */
+ /* Retrieve the enclosing object pointed to. */
arg2 = value_at_lazy (enc_type,
(value_as_address (arg1)
- value_pointed_to_offset (arg1)));
/* Re-adjust type. */
deprecated_set_value_type (arg2, TYPE_TARGET_TYPE (base_type));
/* Add embedding info. */
- arg2 = value_change_enclosing_type (arg2, enc_type);
+ set_value_enclosing_type (arg2, enc_type);
set_value_embedded_offset (arg2, value_pointed_to_offset (arg1));
/* We may be pointing to an object of some derived type. */
if (TYPE_CODE (tt1) == TYPE_CODE_REF
/* We should be doing hairy argument matching, as below. */
- && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
+ && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1)))
+ == TYPE_CODE (tt2)))
{
if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
t2[i] = value_coerce_array (t2[i]);
}
/* Helper function used by value_struct_elt to recurse through
- baseclasses. Look for a field NAME in ARG1. Adjust the address of
+ baseclasses. Look for a field NAME in ARG1. Adjust the address of
ARG1 by OFFSET bytes, and search in it assuming it has (class) type
TYPE. If found, return value, else return NULL.
{
v = value_static_field (type, i);
if (v == 0)
- error (_("field %s is nonexistent or has been optimized out"),
+ error (_("field %s is nonexistent or "
+ "has been optimized out"),
name);
}
else
error (_("virtual baseclass botch"));
/* The virtual base class pointer might have been clobbered
- by the user program. Make sure that it still points to a
+ by the user program. Make sure that it still points to a
valid memory location. */
boffset += value_embedded_offset (arg1) + offset;
}
/* Helper function used by value_struct_elt to recurse through
- baseclasses. Look for a field NAME in ARG1. Adjust the address of
+ baseclasses. Look for a field NAME in ARG1. Adjust the address of
ARG1 by OFFSET bytes, and search in it assuming it has (class) type
TYPE.
{
char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
- /* FIXME! May need to check for ARM demangling here */
+ /* FIXME! May need to check for ARM demangling here. */
if (strncmp (t_field_name, "__", 2) == 0 ||
strncmp (t_field_name, "op", 2) == 0 ||
strncmp (t_field_name, "type", 4) == 0)
name_matched = 1;
check_stub_method_group (type, i);
if (j > 0 && args == 0)
- error (_("cannot resolve overloaded method `%s': no arguments supplied"), name);
+ error (_("cannot resolve overloaded method "
+ "`%s': no arguments supplied"), name);
else if (j == 0 && args == 0)
{
v = value_fn_field (arg1p, f, j, type, offset);
const gdb_byte *base_valaddr;
/* The virtual base class pointer might have been
- clobbered by the user program. Make sure that it
+ clobbered by the user program. Make sure that it
still points to a valid memory location. */
if (offset < 0 || offset >= TYPE_LENGTH (type))
ERR is used in the error message if *ARGP's type is wrong.
C++: ARGS is a list of argument types to aid in the selection of
- an appropriate method. Also, handle derived types.
+ an appropriate method. Also, handle derived types.
STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
where the truthvalue of whether the function that was resolved was
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error (_("Attempt to extract a component of a value that is not a %s."), err);
+ error (_("Attempt to extract a component of a value that is not a %s."),
+ err);
/* Assume it's not, unless we see that it is. */
if (static_memfuncp)
if (v == (struct value *) - 1)
{
- error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name);
+ error (_("One of the arguments you tried to pass to %s could not "
+ "be converted to what the function wants."), name);
}
else if (v == 0)
{
NUM_FNS is the number of overloaded instances.
BASETYPE is set to the actual type of the subobject where the
method is found.
- BOFFSET is the offset of the base subobject where the method is found.
-*/
+ BOFFSET is the offset of the base subobject where the method is found. */
static struct fn_field *
find_method_list (struct value **argp, const char *method,
NUM_FNS is the number of overloaded instances.
BASETYPE is set to the type of the base subobject that defines the
method.
- BOFFSET is the offset of the base subobject which defines the method.
-*/
+ BOFFSET is the offset of the base subobject which defines the method. */
struct fn_field *
value_find_oload_method_list (struct value **argp, const char *method,
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error (_("Attempt to extract a component of a value that is not a struct or union"));
+ error (_("Attempt to extract a component of a "
+ "value that is not a struct or union"));
return find_method_list (argp, method, 0, t, num_fns,
basetype, boffset);
METHOD: for member functions.
BOTH: used for overload resolution of operators where the
candidates are expected to be either member or non member
- functions. In this case the first argument ARGTYPES
+ functions. In this case the first argument ARGTYPES
(representing 'this') is expected to be a reference to the
target object, and will be dereferenced when attempting the
non-member search.
Note: This function does *not* check the value of
overload_resolution. Caller must check it to see whether overload
- resolution is permitted.
-*/
+ resolution is permitted. */
int
find_overload_match (struct type **arg_types, int nargs,
the function part. Do not try this for non-functions (e.g.
function pointers). */
if (qualified_name
- && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) == TYPE_CODE_FUNC)
+ && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym)))
+ == TYPE_CODE_FUNC)
{
char *temp;
case 1: /* Incomparable top contenders. */
/* This is an error incompatible candidates
should not have been proposed. */
- error (_("Internal error: incompatible overload candidates proposed"));
+ error (_("Internal error: incompatible "
+ "overload candidates proposed"));
break;
case 2: /* Function champion. */
method_oload_champ = -1;
else if (match_quality == NON_STANDARD)
{
if (method == METHOD)
- warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
+ warning (_("Using non-standard conversion to match "
+ "method %s%s%s to supplied arguments"),
obj_type_name,
(obj_type_name && *obj_type_name) ? "::" : "",
name);
else
- warning (_("Using non-standard conversion to match function %s to supplied arguments"),
+ warning (_("Using non-standard conversion to match "
+ "function %s to supplied arguments"),
func_name);
}
*oload_syms = NULL;
*oload_champ_bv = NULL;
- /* First, see if we have a deeper namespace we can search in.
+ /* First, see if we have a deeper namespace we can search in.
If we get a good match there, use it. */
if (qualified_name[next_namespace_len] == ':')
{
if (method)
fprintf_filtered (gdb_stderr,
- "Overloaded method instance %s, # of parms %d\n",
+ "Overloaded method instance %s, # of parms %d\n",
fns_ptr[ix].physname, nparms);
else
fprintf_filtered (gdb_stderr,
- "Overloaded function instance %s # of parms %d\n",
+ "Overloaded function instance "
+ "%s # of parms %d\n",
SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
nparms);
for (jj = 0; jj < nargs - static_offset; jj++)
fprintf_filtered (gdb_stderr,
"...Badness @ %d : %d\n",
- jj, bv->rank[jj]);
- fprintf_filtered (gdb_stderr,
- "Overload resolution champion is %d, ambiguous? %d\n",
+ jj, bv->rank[jj].rank);
+ fprintf_filtered (gdb_stderr, "Overload resolution "
+ "champion is %d, ambiguous? %d\n",
oload_champ, oload_ambiguous);
}
}
for (ix = 1; ix <= nargs - static_offset; ix++)
{
- if (oload_champ_bv->rank[ix] >= 100)
+ /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
+ or worse return INCOMPATIBLE. */
+ if (compare_ranks (oload_champ_bv->rank[ix],
+ INCOMPATIBLE_TYPE_BADNESS) <= 0)
return INCOMPATIBLE; /* Truly mismatched types. */
- else if (oload_champ_bv->rank[ix] >= 10)
+ /* Otherwise If this conversion is as bad as
+ NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
+ else if (compare_ranks (oload_champ_bv->rank[ix],
+ NS_POINTER_CONVERSION_BADNESS) <= 0)
return NON_STANDARD; /* Non-standard type conversions
needed. */
}
++start;
/* If skipping artificial fields, find the first real field
- in T1. */
+ in T1. */
if (skip_artificial)
{
while (start < TYPE_NFIELDS (t1)
++start;
}
- /* Now compare parameters */
+ /* Now compare parameters. */
/* Special case: a method taking void. T1 will contain no
non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
for (i = 0; i < TYPE_NFIELDS (t2); ++i)
{
- if (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
- TYPE_FIELD_TYPE (t2, i))
- != 0)
+ if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
+ TYPE_FIELD_TYPE (t2, i)),
+ EXACT_MATCH_BADNESS) != 0)
return 0;
}
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
+ error (_("Internal error: non-aggregate type "
+ "to value_struct_elt_for_reference"));
for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
{
for (j = 0; j < len; ++j)
{
if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0)
- || compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 1))
+ || compare_parameters (TYPE_FN_FIELD_TYPE (f, j),
+ intype, 1))
break;
}
if (j == len)
- error (_("no member function matches that type instantiation"));
+ error (_("no member function matches "
+ "that type instantiation"));
}
else
{
/* Desired method is ambiguous if more than one
method is defined. */
if (j != -1)
- error (_("non-unique member `%s' requires type instantiation"), name);
+ error (_("non-unique member `%s' requires "
+ "type instantiation"), name);
j = ii;
}
/* pai: FIXME -- sounds iffy */
if (full)
{
- argp = value_change_enclosing_type (argp, real_type);
+ argp = value_copy (argp);
+ set_value_enclosing_type (argp, real_type);
return argp;
}
- /* Check if object is in memory */
+ /* Check if object is in memory. */
if (VALUE_LVAL (argp) != lval_memory)
{
- warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
+ warning (_("Couldn't retrieve complete object of RTTI "
+ "type %s; object may be in register(s)."),
TYPE_NAME (real_type));
return argp;
if (sym == NULL)
{
if (complain)
- error (_("current stack frame does not contain a variable named `%s'"),
+ error (_("current stack frame does not contain a variable named `%s'"),
name);
else
return NULL;