void _initialize_valops (void);
-#define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
-
/* Flag for whether we want to abandon failed expression evals by default. */
#if 0
/* Find the address of function name NAME in the inferior. */
value_ptr
-find_function_in_inferior (name)
- char *name;
+find_function_in_inferior (char *name)
{
register struct symbol *sym;
sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
and return a value that is a pointer to the allocated space. */
value_ptr
-value_allocate_space_in_inferior (len)
- int len;
+value_allocate_space_in_inferior (int len)
{
value_ptr blocklen;
register value_ptr val = find_function_in_inferior ("malloc");
}
static CORE_ADDR
-allocate_space_in_inferior (len)
- int len;
+allocate_space_in_inferior (int len)
{
return value_as_long (value_allocate_space_in_inferior (len));
}
/* In C++, casts may change pointer or object representations. */
value_ptr
-value_cast (type, arg2)
- struct type *type;
- register value_ptr arg2;
+value_cast (struct type *type, register value_ptr arg2)
{
register enum type_code code1;
register enum type_code code2;
case TYPE_CODE_MEMBER:
retvalp = value_from_longest (type, value_as_long (arg2));
/* force evaluation */
- ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
+ ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
*ptr &= ~0x20000000; /* zap 29th bit to remove bias */
return retvalp;
}
}
longest = value_as_long (arg2);
- return value_from_longest (type, convert_to_boolean ?
+ return value_from_longest (type, convert_to_boolean ?
(LONGEST) (longest ? 1 : 0) : longest);
}
+ else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT ||
+ code2 == TYPE_CODE_ENUM ||
+ code2 == TYPE_CODE_RANGE))
+ {
+ int ptr_bit = HOST_CHAR_BIT * TYPE_LENGTH (type);
+ LONGEST longest = value_as_long (arg2);
+ if (ptr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
+ {
+ if (longest >= ((LONGEST) 1 << ptr_bit)
+ || longest <= -((LONGEST) 1 << ptr_bit))
+ warning ("value truncated");
+ }
+ return value_from_longest (type, longest);
+ }
else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
{
if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
/* Create a value of type TYPE that is zero, and return it. */
value_ptr
-value_zero (type, lv)
- struct type *type;
- enum lval_type lv;
+value_zero (struct type *type, enum lval_type lv)
{
register value_ptr val = allocate_value (type);
adjustments before or after calling it. */
value_ptr
-value_at (type, addr, sect)
- struct type *type;
- CORE_ADDR addr;
- asection *sect;
+value_at (struct type *type, CORE_ADDR addr, asection *sect)
{
register value_ptr val;
/* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
value_ptr
-value_at_lazy (type, addr, sect)
- struct type *type;
- CORE_ADDR addr;
- asection *sect;
+value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
{
register value_ptr val;
value is ignored. */
int
-value_fetch_lazy (val)
- register value_ptr val;
+value_fetch_lazy (register value_ptr val)
{
CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
}
else if (length)
read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
-
+
VALUE_LAZY (val) = 0;
return 0;
}
Return a new value with the location of TOVAL and contents of FROMVAL. */
value_ptr
-value_assign (toval, fromval)
- register value_ptr toval, fromval;
+value_assign (register value_ptr toval, register value_ptr fromval)
{
register struct type *type;
register value_ptr val;
if (VALUE_BITSIZE (toval))
{
char buffer[sizeof (LONGEST)];
- int len =
+ int len =
REGISTER_RAW_SIZE (VALUE_REGNO (toval)) - VALUE_OFFSET (toval);
if (len > (int) sizeof (LONGEST))
/* Extend a value VAL to COUNT repetitions of its type. */
value_ptr
-value_repeat (arg1, count)
- value_ptr arg1;
- int count;
+value_repeat (value_ptr arg1, int count)
{
register value_ptr val;
}
value_ptr
-value_of_variable (var, b)
- struct symbol *var;
- struct block *b;
+value_of_variable (struct symbol *var, struct block *b)
{
value_ptr val;
struct frame_info *frame = NULL;
*/
value_ptr
-value_coerce_array (arg1)
- value_ptr arg1;
+value_coerce_array (value_ptr arg1)
{
register struct type *type = check_typedef (VALUE_TYPE (arg1));
to it. */
value_ptr
-value_coerce_function (arg1)
- value_ptr arg1;
+value_coerce_function (value_ptr arg1)
{
value_ptr retval;
/* Return a pointer value for the object for which ARG1 is the contents. */
value_ptr
-value_addr (arg1)
- value_ptr arg1;
+value_addr (value_ptr arg1)
{
value_ptr arg2;
/* Given a value of a pointer type, apply the C unary * operator to it. */
value_ptr
-value_ind (arg1)
- value_ptr arg1;
+value_ind (value_ptr arg1)
{
struct type *base_type;
value_ptr arg2;
/* Push one word (the size of object that a register holds). */
CORE_ADDR
-push_word (sp, word)
- CORE_ADDR sp;
- ULONGEST word;
+push_word (CORE_ADDR sp, ULONGEST word)
{
register int len = REGISTER_SIZE;
char buffer[MAX_REGISTER_RAW_SIZE];
/* Push LEN bytes with data at BUFFER. */
CORE_ADDR
-push_bytes (sp, buffer, len)
- CORE_ADDR sp;
- char *buffer;
- int len;
+push_bytes (CORE_ADDR sp, char *buffer, int len)
{
if (INNER_THAN (1, 2))
{
it to be an argument to a function. */
static CORE_ADDR
-value_push (sp, arg)
- register CORE_ADDR sp;
- value_ptr arg;
+value_push (register CORE_ADDR sp, value_ptr arg)
{
register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
register int container_len = len;
#endif
CORE_ADDR
-default_push_arguments (nargs, args, sp, struct_return, struct_addr)
- int nargs;
- value_ptr *args;
- CORE_ADDR sp;
- int struct_return;
- CORE_ADDR struct_addr;
+default_push_arguments (int nargs, value_ptr *args, CORE_ADDR sp,
+ int struct_return, CORE_ADDR struct_addr)
{
/* ASSERT ( !struct_return); */
int i;
IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
static value_ptr
-value_arg_coerce (arg, param_type, is_prototyped)
- value_ptr arg;
- struct type *param_type;
- int is_prototyped;
+value_arg_coerce (value_ptr arg, struct type *param_type, int is_prototyped)
{
register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
register struct type *type
Calls error() if the function is not valid for calling. */
static CORE_ADDR
-find_function_addr (function, retval_type)
- value_ptr function;
- struct type **retval_type;
+find_function_addr (value_ptr function, struct type **retval_type)
{
register struct type *ftype = check_typedef (VALUE_TYPE (function));
register enum type_code code = TYPE_CODE (ftype);
if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
|| TYPE_CODE (ftype) == TYPE_CODE_METHOD)
{
-#ifdef CONVERT_FROM_FUNC_PTR_ADDR
- /* FIXME: This is a workaround for the unusual function
- pointer representation on the RS/6000, see comment
- in config/rs6000/tm-rs6000.h */
funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
-#endif
value_type = TYPE_TARGET_TYPE (ftype);
}
else
static value_ptr hand_function_call (value_ptr function, int nargs,
value_ptr * args);
static value_ptr
-hand_function_call (function, nargs, args)
- value_ptr function;
- int nargs;
- value_ptr *args;
+hand_function_call (value_ptr function, int nargs, value_ptr *args)
{
register CORE_ADDR sp;
register int i;
}
}
-/* elz: on HPPA no need for this extra alignment, maybe it is needed
- on other architectures. This is because all the alignment is taken care
- of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in
- hppa_push_arguments */
-#ifndef NO_EXTRA_ALIGNMENT_NEEDED
-
- /* MVS 11/22/96: I think at least some of this stack_align code is
- really broken. Better to let PUSH_ARGUMENTS adjust the stack in
- a target-defined manner. */
- if (STACK_ALIGN_P () && INNER_THAN (1, 2))
+ /* elz: on HPPA no need for this extra alignment, maybe it is needed
+ on other architectures. This is because all the alignment is
+ taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
+ in hppa_push_arguments */
+ if (EXTRA_STACK_ALIGNMENT_NEEDED)
{
- /* If stack grows down, we must leave a hole at the top. */
- int len = 0;
-
- for (i = nargs - 1; i >= 0; i--)
- len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
- if (CALL_DUMMY_STACK_ADJUST_P)
- len += CALL_DUMMY_STACK_ADJUST;
- sp -= STACK_ALIGN (len) - len;
+ /* MVS 11/22/96: I think at least some of this stack_align code
+ is really broken. Better to let PUSH_ARGUMENTS adjust the
+ stack in a target-defined manner. */
+ if (STACK_ALIGN_P () && INNER_THAN (1, 2))
+ {
+ /* If stack grows down, we must leave a hole at the top. */
+ int len = 0;
+
+ for (i = nargs - 1; i >= 0; i--)
+ len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
+ if (CALL_DUMMY_STACK_ADJUST_P)
+ len += CALL_DUMMY_STACK_ADJUST;
+ sp -= STACK_ALIGN (len) - len;
+ }
}
-#endif /* NO_EXTRA_ALIGNMENT_NEEDED */
sp = PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr);
}
value_ptr
-call_function_by_hand (function, nargs, args)
- value_ptr function;
- int nargs;
- value_ptr *args;
+call_function_by_hand (value_ptr function, int nargs, value_ptr *args)
{
if (CALL_DUMMY_P)
{
don't currently enforce any restriction on their types). */
value_ptr
-value_array (lowbound, highbound, elemvec)
- int lowbound;
- int highbound;
- value_ptr *elemvec;
+value_array (int lowbound, int highbound, value_ptr *elemvec)
{
int nelem;
int idx;
embedded null bytes. */
value_ptr
-value_string (ptr, len)
- char *ptr;
- int len;
+value_string (char *ptr, int len)
{
value_ptr val;
int lowbound = current_language->string_lower_bound;
}
value_ptr
-value_bitstring (ptr, len)
- char *ptr;
- int len;
+value_bitstring (char *ptr, int len)
{
value_ptr val;
struct type *domain_type = create_range_type (NULL, builtin_type_int,
requested operation is type secure, shouldn't we? FIXME. */
static int
-typecmp (staticp, t1, t2)
- int staticp;
- struct type *t1[];
- value_ptr t2[];
+typecmp (int staticp, struct type *t1[], value_ptr t2[])
{
int i;
continue;
}
- while (TYPE_CODE (tt1) == TYPE_CODE_PTR
- && (TYPE_CODE (tt2) == TYPE_CODE_ARRAY
- || TYPE_CODE (tt2) == TYPE_CODE_PTR))
+ /* djb - 20000715 - Until the new type structure is in the
+ place, and we can attempt things like implicit conversions,
+ we need to do this so you can take something like a map<const
+ char *>, and properly access map["hello"], because the
+ argument to [] will be a reference to a pointer to a char,
+ and the argument will be a pointer to a char. */
+ while ( TYPE_CODE(tt1) == TYPE_CODE_REF ||
+ TYPE_CODE (tt1) == TYPE_CODE_PTR)
+ {
+ tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
+ }
+ while ( TYPE_CODE(tt2) == TYPE_CODE_ARRAY ||
+ TYPE_CODE(tt2) == TYPE_CODE_PTR ||
+ TYPE_CODE(tt2) == TYPE_CODE_REF)
{
- tt1 = check_typedef (TYPE_TARGET_TYPE (tt1));
- tt2 = check_typedef (TYPE_TARGET_TYPE (tt2));
+ tt2 = check_typedef( TYPE_TARGET_TYPE(tt2) );
}
if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
continue;
look for a baseclass named NAME. */
static value_ptr
-search_struct_field (name, arg1, offset, type, looking_for_baseclass)
- char *name;
- register value_ptr arg1;
- int offset;
- register struct type *type;
- int looking_for_baseclass;
+search_struct_field (char *name, register value_ptr arg1, int offset,
+ register struct type *type, int looking_for_baseclass)
{
int i;
int nbases = TYPE_N_BASECLASSES (type);
* conventions. */
void
-find_rt_vbase_offset (type, basetype, valaddr, offset, boffset_p, skip_p)
- struct type *type;
- struct type *basetype;
- char *valaddr;
- int offset;
- int *boffset_p;
- int *skip_p;
+find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
+ int offset, int *boffset_p, int *skip_p)
{
int boffset; /* offset of virtual base */
int index; /* displacement to use in virtual table */
else return NULL. */
static value_ptr
-search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
- char *name;
- register value_ptr *arg1p, *args;
- int offset, *static_memfuncp;
- register struct type *type;
+search_struct_method (char *name, register value_ptr *arg1p,
+ register value_ptr *args, int offset,
+ int *static_memfuncp, register struct type *type)
{
int i;
value_ptr v;
*static_memfuncp = 1;
v = value_fn_field (arg1p, f, j, type, offset);
if (v != NULL)
- return v;
+ return v;
}
j--;
}
ERR is an error message to be printed in case the field is not found. */
value_ptr
-value_struct_elt (argp, args, name, static_memfuncp, err)
- register value_ptr *argp, *args;
- char *name;
- int *static_memfuncp;
- char *err;
+value_struct_elt (register value_ptr *argp, register value_ptr *args,
+ char *name, int *static_memfuncp, char *err)
{
register struct type *t;
value_ptr v;
}
else
v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
-
+
if (v == (value_ptr) - 1)
{
- error ("Argument list of %s mismatch with component in the structure.", 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)
{
* BOFFSET is the offset of the base subobject where the method is found */
static struct fn_field *
-find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset)
- value_ptr *argp;
- char *method;
- int offset;
- int *static_memfuncp;
- struct type *type;
- int *num_fns;
- struct type **basetype;
- int *boffset;
+find_method_list (value_ptr *argp, char *method, int offset,
+ int *static_memfuncp, struct type *type, int *num_fns,
+ struct type **basetype, int *boffset)
{
int i;
struct fn_field *f;
* BOFFSET is the offset of the base subobject which defines the method */
struct fn_field *
-value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, basetype, boffset)
- value_ptr *argp;
- char *method;
- int offset;
- int *static_memfuncp;
- int *num_fns;
- struct type **basetype;
- int *boffset;
+value_find_oload_method_list (value_ptr *argp, char *method, int offset,
+ int *static_memfuncp, int *num_fns,
+ struct type **basetype, int *boffset)
{
struct type *t;
*/
int
-find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, staticp)
- struct type **arg_types;
- int nargs;
- char *name;
- int method;
- int lax;
- value_ptr obj;
- struct symbol *fsym;
- value_ptr *valp;
- struct symbol **symp;
- int *staticp;
+find_overload_match (struct type **arg_types, int nargs, char *name, int method,
+ int lax, value_ptr obj, struct symbol *fsym,
+ value_ptr *valp, struct symbol **symp, int *staticp)
{
int nparms;
struct type **parm_types;
default:
break;
}
- free (parm_types);
-if (overload_debug)
-{
- if (method)
- fprintf_filtered (gdb_stderr,"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", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
- for (jj = 0; jj < nargs; 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", oload_champ, oload_ambiguous);
-}
+ xfree (parm_types);
+ if (overload_debug)
+ {
+ if (method)
+ fprintf_filtered (gdb_stderr,"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", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
+ for (jj = 0; jj < nargs; 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", oload_champ, oload_ambiguous);
+ }
} /* end loop over all candidates */
/* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
if they have the exact same goodness. This is because there is no
/* Check how bad the best match is */
for (ix = 1; ix <= nargs; ix++)
{
- switch (oload_champ_bv->rank[ix])
- {
- case 10:
- oload_non_standard = 1; /* non-standard type conversions needed */
- break;
- case 100:
- oload_incompatible = 1; /* truly mismatched types */
- break;
- }
+ if (oload_champ_bv->rank[ix] >= 100)
+ oload_incompatible = 1; /* truly mismatched types */
+
+ else if (oload_champ_bv->rank[ix] >= 10)
+ oload_non_standard = 1; /* non-standard type conversions needed */
}
if (oload_incompatible)
{
else
{
*symp = oload_syms[oload_champ];
- free (func_name);
+ xfree (func_name);
}
return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
of type TYPE. If TYPE does not have a destructor, or
if NAME is inappropriate for TYPE, an error is signaled. */
int
-destructor_name_p (name, type)
- const char *name;
- const struct type *type;
+destructor_name_p (const char *name, const struct type *type)
{
/* destructors are a special case. */
target structure/union is defined, otherwise, return 0. */
static int
-check_field_in (type, name)
- register struct type *type;
- const char *name;
+check_field_in (register struct type *type, const char *name)
{
register int i;
target structure/union is defined, otherwise, return 0. */
int
-check_field (arg1, name)
- register value_ptr arg1;
- const char *name;
+check_field (register value_ptr arg1, const char *name)
{
register struct type *t;
to resolve user expressions of the form "DOMAIN::NAME". */
value_ptr
-value_struct_elt_for_reference (domain, offset, curtype, name, intype)
- struct type *domain, *curtype, *intype;
- int offset;
- char *name;
+value_struct_elt_for_reference (struct type *domain, int offset,
+ struct type *curtype, char *name,
+ struct type *intype)
{
register struct type *t = curtype;
register int i;
*/
struct type *
-value_rtti_type (v, full, top, using_enc)
- value_ptr v;
- int *full;
- int *top;
- int *using_enc;
+value_rtti_type (value_ptr v, int *full, int *top, int *using_enc)
{
struct type *known_type;
struct type *rtti_type;
/*
Right now this is G++ RTTI. Plan on this changing in the
future as i get around to setting the vtables properly for G++
- compiled stuff. Also, i'll be using the type info functions,
+ compiled stuff. Also, i'll be using the type info functions,
which are always right. Deal with it until then.
*/
{
*using_enc=1;
}
/*
- We can't use value_ind here, because it would want to use RTTI, and
+ We can't use value_ind here, because it would want to use RTTI, and
we'd waste a bunch of time figuring out we already know the type.
Besides, we don't care about the type, just the actual pointer
*/
and refer to the values computed for the object pointed to. */
struct type *
-value_rtti_target_type (v, full, top, using_enc)
- value_ptr v;
- int *full;
- int *top;
- int *using_enc;
+value_rtti_target_type (value_ptr v, int *full, int *top, int *using_enc)
{
value_ptr target;
(Pass RTYPE == NULL if they're not available */
value_ptr
-value_full_object (argp, rtype, xfull, xtop, xusing_enc)
- value_ptr argp;
- struct type *rtype;
- int xfull;
- int xtop;
- int xusing_enc;
-
+value_full_object (value_ptr argp, struct type *rtype, int xfull, int xtop,
+ int xusing_enc)
{
struct type *real_type;
int full = 0;
inappropriate context. */
value_ptr
-value_of_this (complain)
- int complain;
+value_of_this (int complain)
{
struct symbol *func, *sym;
struct block *b;
the original ARRAY. */
value_ptr
-value_slice (array, lowbound, length)
- value_ptr array;
- int lowbound, length;
+value_slice (value_ptr array, int lowbound, int length)
{
struct type *slice_range_type, *slice_type, *range_type;
LONGEST lowerbound, upperbound, offset;
value as a fixed-length array. */
value_ptr
-varying_to_slice (varray)
- value_ptr varray;
+varying_to_slice (value_ptr varray)
{
struct type *vtype = check_typedef (VALUE_TYPE (varray));
LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
doubles. FIXME: fmb */
value_ptr
-value_literal_complex (arg1, arg2, type)
- value_ptr arg1;
- value_ptr arg2;
- struct type *type;
+value_literal_complex (value_ptr arg1, value_ptr arg2, struct type *type)
{
register value_ptr val;
struct type *real_type = TYPE_TARGET_TYPE (type);
/* Cast a value into the appropriate complex data type. */
static value_ptr
-cast_into_complex (type, val)
- struct type *type;
- register value_ptr val;
+cast_into_complex (struct type *type, register value_ptr val)
{
struct type *real_type = TYPE_TARGET_TYPE (type);
if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
}
void
-_initialize_valops ()
+_initialize_valops (void)
{
#if 0
add_show_from_set