old-cross-binutils/gdb/valarith.c

1420 lines
37 KiB
C
Raw Normal View History

/* Perform arithmetic and other operations on values, for GDB.
2002-01-04 05:20:09 +00:00
Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
Foundation, Inc.
1999-07-07 20:19:36 +00:00
This file is part of GDB.
1999-07-07 20:19:36 +00:00
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 2 of the License, or
(at your option) any later version.
1999-07-07 20:19:36 +00:00
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.
1999-07-07 20:19:36 +00:00
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "value.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "target.h"
#include "language.h"
#include "gdb_string.h"
2001-08-01 18:39:27 +00:00
#include "doublest.h"
1999-12-14 01:06:04 +00:00
#include <math.h>
2003-04-21 16:48:41 +00:00
#include "infcall.h"
/* Define whether or not the C operator '/' truncates towards zero for
differently signed operands (truncation direction is undefined in C). */
#ifndef TRUNCATION_TOWARDS_ZERO
#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
#endif
2002-01-04 05:20:09 +00:00
static struct value *value_subscripted_rvalue (struct value *, struct value *, int);
2000-05-28 01:12:42 +00:00
void _initialize_valarith (void);
1999-07-07 20:19:36 +00:00
/* Given a pointer, return the size of its target.
If the pointer type is void *, then return 1.
If the target type is incomplete, then error out.
This isn't a general purpose function, but just a
helper for value_sub & value_add.
*/
static LONGEST
find_size_for_pointer_math (struct type *ptr_type)
{
LONGEST sz = -1;
struct type *ptr_target;
ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
sz = TYPE_LENGTH (ptr_target);
if (sz == 0)
{
if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
sz = 1;
else
{
char *name;
name = TYPE_NAME (ptr_target);
if (name == NULL)
name = TYPE_TAG_NAME (ptr_target);
if (name == NULL)
error ("Cannot perform pointer math on incomplete types, "
"try casting to a known type, or void *.");
else
error ("Cannot perform pointer math on incomplete type \"%s\", "
"try casting to a known type, or void *.", name);
}
}
return sz;
}
2002-01-04 05:20:09 +00:00
struct value *
value_add (struct value *arg1, struct value *arg2)
{
2002-01-04 05:20:09 +00:00
struct value *valint;
struct value *valptr;
LONGEST sz;
struct type *type1, *type2, *valptrtype;
COERCE_NUMBER (arg1);
COERCE_NUMBER (arg2);
type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2));
if ((TYPE_CODE (type1) == TYPE_CODE_PTR
|| TYPE_CODE (type2) == TYPE_CODE_PTR)
&&
(TYPE_CODE (type1) == TYPE_CODE_INT
|| TYPE_CODE (type2) == TYPE_CODE_INT))
/* Exactly one argument is a pointer, and one is an integer. */
{
2002-01-04 05:20:09 +00:00
struct value *retval;
if (TYPE_CODE (type1) == TYPE_CODE_PTR)
{
valptr = arg1;
valint = arg2;
valptrtype = type1;
}
else
{
valptr = arg2;
valint = arg1;
valptrtype = type2;
}
sz = find_size_for_pointer_math (valptrtype);
* gdbarch.sh (POINTER_TO_ADDRESS, ADDRESS_TO_POINTER): Two new functions which architectures can redefine, defaulting to generic_pointer_to_address and generic_address_to_pointer. * findvar.c (extract_typed_address, store_typed_address, generic_pointer_to_address, generic_address_to_pointer): New functions. (POINTER_TO_ADDRESS, ADDRESS_TO_POINTER): Provide default definitions. (extract_address, store_address): Doc fixes. * values.c (value_as_pointer): Doc fix. (value_from_pointer): New function. * defs.h (extract_typed_address, store_typed_address): New declarations. * inferior.h (generic_address_to_pointer, generic_pointer_to_address): New declarations. * value.h (value_from_pointer): New declaration. * ax-gdb.c (const_var_ref): Use value_from_pointer, not value_from_longest. * blockframe.c (generic_push_dummy_frame): Use read_pc and read_sp, not read_register. * c-valprint.c (c_val_print): Use extract_typed_address instead of extract_address to extract vtable entries and references. * cp-valprint.c (cp_print_value_fields): Use value_from_pointer instead of value_from_longest to extract the vtable's address. * eval.c (evaluate_subexp_standard): Use value_from_pointer instead of value_from_longest to compute `this', and for doing pointer-to-member dereferencing. * findvar.c (read_register): Use extract_unsigned_integer, not extract_address. (read_var_value): Use store_typed_address instead of store_address for building label values. (locate_var_value): Use value_from_pointer instead of value_from_longest. * hppa-tdep.c (find_stub_with_shl_get): Use value_from_pointer, instead of value_from_longest, to build arguments to __d_shl_get. * printcmd.c (set_next_address): Use value_from_pointer, not value_from_longest. (x_command): Use value_from_pointer, not value_from_longest. * tracepoint.c (set_traceframe_context): Use value_from_pointer, not value_from_longest. * valarith.c (value_add, value_sub): Use value_from_pointer, not value_from_longest. * valops.c (find_function_in_inferior, value_coerce_array, value_coerce_function, value_addr, hand_function_call): Same. * value.h (COERCE_REF): Use unpack_pointer, not unpack_long. * values.c (unpack_long): Use extract_typed_address to produce addresses from pointers and references, not extract_address. (value_from_longest): Use store_typed_address instead of store_address to produce pointer and reference values.
2000-04-14 18:43:41 +00:00
retval = value_from_pointer (valptrtype,
value_as_address (valptr)
+ (sz * value_as_long (valint)));
VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (valptr);
return retval;
}
return value_binop (arg1, arg2, BINOP_ADD);
}
2002-01-04 05:20:09 +00:00
struct value *
value_sub (struct value *arg1, struct value *arg2)
{
struct type *type1, *type2;
COERCE_NUMBER (arg1);
COERCE_NUMBER (arg2);
type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2));
if (TYPE_CODE (type1) == TYPE_CODE_PTR)
{
if (TYPE_CODE (type2) == TYPE_CODE_INT)
{
/* pointer - integer. */
LONGEST sz = find_size_for_pointer_math (type1);
return value_from_pointer (type1,
(value_as_address (arg1)
* gdbarch.sh (POINTER_TO_ADDRESS, ADDRESS_TO_POINTER): Two new functions which architectures can redefine, defaulting to generic_pointer_to_address and generic_address_to_pointer. * findvar.c (extract_typed_address, store_typed_address, generic_pointer_to_address, generic_address_to_pointer): New functions. (POINTER_TO_ADDRESS, ADDRESS_TO_POINTER): Provide default definitions. (extract_address, store_address): Doc fixes. * values.c (value_as_pointer): Doc fix. (value_from_pointer): New function. * defs.h (extract_typed_address, store_typed_address): New declarations. * inferior.h (generic_address_to_pointer, generic_pointer_to_address): New declarations. * value.h (value_from_pointer): New declaration. * ax-gdb.c (const_var_ref): Use value_from_pointer, not value_from_longest. * blockframe.c (generic_push_dummy_frame): Use read_pc and read_sp, not read_register. * c-valprint.c (c_val_print): Use extract_typed_address instead of extract_address to extract vtable entries and references. * cp-valprint.c (cp_print_value_fields): Use value_from_pointer instead of value_from_longest to extract the vtable's address. * eval.c (evaluate_subexp_standard): Use value_from_pointer instead of value_from_longest to compute `this', and for doing pointer-to-member dereferencing. * findvar.c (read_register): Use extract_unsigned_integer, not extract_address. (read_var_value): Use store_typed_address instead of store_address for building label values. (locate_var_value): Use value_from_pointer instead of value_from_longest. * hppa-tdep.c (find_stub_with_shl_get): Use value_from_pointer, instead of value_from_longest, to build arguments to __d_shl_get. * printcmd.c (set_next_address): Use value_from_pointer, not value_from_longest. (x_command): Use value_from_pointer, not value_from_longest. * tracepoint.c (set_traceframe_context): Use value_from_pointer, not value_from_longest. * valarith.c (value_add, value_sub): Use value_from_pointer, not value_from_longest. * valops.c (find_function_in_inferior, value_coerce_array, value_coerce_function, value_addr, hand_function_call): Same. * value.h (COERCE_REF): Use unpack_pointer, not unpack_long. * values.c (unpack_long): Use extract_typed_address to produce addresses from pointers and references, not extract_address. (value_from_longest): Use store_typed_address instead of store_address to produce pointer and reference values.
2000-04-14 18:43:41 +00:00
- (sz * value_as_long (arg2))));
}
else if (TYPE_CODE (type2) == TYPE_CODE_PTR
&& TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
== TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
{
/* pointer to <type x> - pointer to <type x>. */
LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
return value_from_longest
1999-07-07 20:19:36 +00:00
(builtin_type_long, /* FIXME -- should be ptrdiff_t */
(value_as_long (arg1) - value_as_long (arg2)) / sz);
}
else
{
error ("\
First argument of `-' is a pointer and second argument is neither\n\
an integer nor a pointer of the same type.");
}
}
return value_binop (arg1, arg2, BINOP_SUB);
}
/* Return the value of ARRAY[IDX].
See comments in value_coerce_array() for rationale for reason for
doing lower bounds adjustment here rather than there.
FIXME: Perhaps we should validate that the index is valid and if
verbosity is set, warn about invalid indices (but still use them). */
2002-01-04 05:20:09 +00:00
struct value *
value_subscript (struct value *array, struct value *idx)
{
2002-01-04 05:20:09 +00:00
struct value *bound;
int c_style = current_language->c_style_arrays;
struct type *tarray;
COERCE_REF (array);
tarray = check_typedef (VALUE_TYPE (array));
COERCE_VARYING_ARRAY (array, tarray);
if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
|| TYPE_CODE (tarray) == TYPE_CODE_STRING)
{
struct type *range_type = TYPE_INDEX_TYPE (tarray);
LONGEST lowerbound, upperbound;
get_discrete_bounds (range_type, &lowerbound, &upperbound);
if (VALUE_LVAL (array) != lval_memory)
return value_subscripted_rvalue (array, idx, lowerbound);
if (c_style == 0)
{
LONGEST index = value_as_long (idx);
if (index >= lowerbound && index <= upperbound)
return value_subscripted_rvalue (array, idx, lowerbound);
warning ("array or string index out of range");
/* fall doing C stuff */
c_style = 1;
}
if (lowerbound != 0)
{
bound = value_from_longest (builtin_type_int, (LONGEST) lowerbound);
idx = value_sub (idx, bound);
}
array = value_coerce_array (array);
}
if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
{
struct type *range_type = TYPE_INDEX_TYPE (tarray);
LONGEST index = value_as_long (idx);
2002-01-04 05:20:09 +00:00
struct value *v;
int offset, byte, bit_index;
LONGEST lowerbound, upperbound;
get_discrete_bounds (range_type, &lowerbound, &upperbound);
if (index < lowerbound || index > upperbound)
error ("bitstring index out of range");
index -= lowerbound;
offset = index / TARGET_CHAR_BIT;
1999-07-07 20:19:36 +00:00
byte = *((char *) VALUE_CONTENTS (array) + offset);
bit_index = index % TARGET_CHAR_BIT;
byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index);
v = value_from_longest (LA_BOOL_TYPE, byte & 1);
VALUE_BITPOS (v) = bit_index;
VALUE_BITSIZE (v) = 1;
VALUE_LVAL (v) = VALUE_LVAL (array);
if (VALUE_LVAL (array) == lval_internalvar)
VALUE_LVAL (v) = lval_internalvar_component;
VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
VALUE_OFFSET (v) = offset + VALUE_OFFSET (array);
return v;
}
if (c_style)
return value_ind (value_add (array, idx));
else
error ("not an array or string");
}
/* Return the value of EXPR[IDX], expr an aggregate rvalue
(eg, a vector register). This routine used to promote floats
to doubles, but no longer does. */
2002-01-04 05:20:09 +00:00
static struct value *
value_subscripted_rvalue (struct value *array, struct value *idx, int lowerbound)
{
struct type *array_type = check_typedef (VALUE_TYPE (array));
struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
unsigned int elt_size = TYPE_LENGTH (elt_type);
LONGEST index = value_as_long (idx);
unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
2002-01-04 05:20:09 +00:00
struct value *v;
if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
error ("no such vector element");
v = allocate_value (elt_type);
if (VALUE_LAZY (array))
VALUE_LAZY (v) = 1;
else
memcpy (VALUE_CONTENTS (v), VALUE_CONTENTS (array) + elt_offs, elt_size);
if (VALUE_LVAL (array) == lval_internalvar)
VALUE_LVAL (v) = lval_internalvar_component;
else
VALUE_LVAL (v) = VALUE_LVAL (array);
VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
VALUE_REGNO (v) = VALUE_REGNO (array);
VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
return v;
}
/* Check to see if either argument is a structure. This is called so
we know whether to go ahead with the normal binop or look for a
user defined function instead.
For now, we do not overload the `=' operator. */
int
2002-01-04 05:20:09 +00:00
binop_user_defined_p (enum exp_opcode op, struct value *arg1, struct value *arg2)
{
struct type *type1, *type2;
if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
return 0;
type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2));
return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
|| TYPE_CODE (type2) == TYPE_CODE_STRUCT
|| (TYPE_CODE (type1) == TYPE_CODE_REF
&& TYPE_CODE (TYPE_TARGET_TYPE (type1)) == TYPE_CODE_STRUCT)
|| (TYPE_CODE (type2) == TYPE_CODE_REF
&& TYPE_CODE (TYPE_TARGET_TYPE (type2)) == TYPE_CODE_STRUCT));
}
/* Check to see if argument is a structure. This is called so
we know whether to go ahead with the normal unop or look for a
user defined function instead.
For now, we do not overload the `&' operator. */
1999-07-07 20:19:36 +00:00
int
2002-01-04 05:20:09 +00:00
unop_user_defined_p (enum exp_opcode op, struct value *arg1)
{
struct type *type1;
if (op == UNOP_ADDR)
return 0;
type1 = check_typedef (VALUE_TYPE (arg1));
for (;;)
{
if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
return 1;
else if (TYPE_CODE (type1) == TYPE_CODE_REF)
type1 = TYPE_TARGET_TYPE (type1);
else
return 0;
}
}
/* We know either arg1 or arg2 is a structure, so try to find the right
user defined function. Create an argument vector that calls
arg1.operator @ (arg1,arg2) and return that value (where '@' is any
binary operator which is legal for GNU C++).
OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
is the opcode saying how to modify it. Otherwise, OTHEROP is
unused. */
2002-01-04 05:20:09 +00:00
struct value *
value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
2000-07-30 01:48:28 +00:00
enum exp_opcode otherop, enum noside noside)
{
2002-01-04 05:20:09 +00:00
struct value **argvec;
char *ptr;
char tstr[13];
int static_memfuncp;
COERCE_REF (arg1);
COERCE_REF (arg2);
COERCE_ENUM (arg1);
COERCE_ENUM (arg2);
/* now we know that what we have to do is construct our
arg vector and find the right function to call it with. */
if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
1999-07-07 20:19:36 +00:00
error ("Can't do that binary op on that type"); /* FIXME be explicit */
2002-01-04 05:20:09 +00:00
argvec = (struct value **) alloca (sizeof (struct value *) * 4);
argvec[1] = value_addr (arg1);
argvec[2] = arg2;
argvec[3] = 0;
1999-07-07 20:19:36 +00:00
/* make the right function name up */
strcpy (tstr, "operator__");
ptr = tstr + 8;
switch (op)
{
1999-07-07 20:19:36 +00:00
case BINOP_ADD:
strcpy (ptr, "+");
break;
case BINOP_SUB:
strcpy (ptr, "-");
break;
case BINOP_MUL:
strcpy (ptr, "*");
break;
case BINOP_DIV:
strcpy (ptr, "/");
break;
case BINOP_REM:
strcpy (ptr, "%");
break;
case BINOP_LSH:
strcpy (ptr, "<<");
break;
case BINOP_RSH:
strcpy (ptr, ">>");
break;
case BINOP_BITWISE_AND:
strcpy (ptr, "&");
break;
case BINOP_BITWISE_IOR:
strcpy (ptr, "|");
break;
case BINOP_BITWISE_XOR:
strcpy (ptr, "^");
break;
case BINOP_LOGICAL_AND:
strcpy (ptr, "&&");
break;
case BINOP_LOGICAL_OR:
strcpy (ptr, "||");
break;
case BINOP_MIN:
strcpy (ptr, "<?");
break;
case BINOP_MAX:
strcpy (ptr, ">?");
break;
case BINOP_ASSIGN:
strcpy (ptr, "=");
break;
case BINOP_ASSIGN_MODIFY:
switch (otherop)
{
1999-07-07 20:19:36 +00:00
case BINOP_ADD:
strcpy (ptr, "+=");
break;
case BINOP_SUB:
strcpy (ptr, "-=");
break;
case BINOP_MUL:
strcpy (ptr, "*=");
break;
case BINOP_DIV:
strcpy (ptr, "/=");
break;
case BINOP_REM:
strcpy (ptr, "%=");
break;
case BINOP_BITWISE_AND:
strcpy (ptr, "&=");
break;
case BINOP_BITWISE_IOR:
strcpy (ptr, "|=");
break;
case BINOP_BITWISE_XOR:
strcpy (ptr, "^=");
break;
case BINOP_MOD: /* invalid */
default:
error ("Invalid binary operation specified.");
}
break;
1999-07-07 20:19:36 +00:00
case BINOP_SUBSCRIPT:
strcpy (ptr, "[]");
break;
case BINOP_EQUAL:
strcpy (ptr, "==");
break;
case BINOP_NOTEQUAL:
strcpy (ptr, "!=");
break;
case BINOP_LESS:
strcpy (ptr, "<");
break;
case BINOP_GTR:
strcpy (ptr, ">");
break;
case BINOP_GEQ:
strcpy (ptr, ">=");
break;
case BINOP_LEQ:
strcpy (ptr, "<=");
break;
case BINOP_MOD: /* invalid */
default:
error ("Invalid binary operation specified.");
}
1999-07-07 20:19:36 +00:00
argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
if (argvec[0])
{
if (static_memfuncp)
{
argvec[1] = argvec[0];
argvec++;
}
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type;
return_type
= TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
return value_zero (return_type, VALUE_LVAL (arg1));
}
return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
}
error ("member function %s not found", tstr);
#ifdef lint
return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
#endif
}
/* We know that arg1 is a structure, so try to find a unary user
defined operator that matches the operator in question.
Create an argument vector that calls arg1.operator @ (arg1)
and return that value (where '@' is (almost) any unary operator which
is legal for GNU C++). */
2002-01-04 05:20:09 +00:00
struct value *
value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
{
2002-01-04 05:20:09 +00:00
struct value **argvec;
char *ptr, *mangle_ptr;
char tstr[13], mangle_tstr[13];
int static_memfuncp, nargs;
COERCE_REF (arg1);
COERCE_ENUM (arg1);
/* now we know that what we have to do is construct our
arg vector and find the right function to call it with. */
if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
1999-07-07 20:19:36 +00:00
error ("Can't do that unary op on that type"); /* FIXME be explicit */
argvec = (struct value **) alloca (sizeof (struct value *) * 4);
argvec[1] = value_addr (arg1);
argvec[2] = 0;
nargs = 1;
1999-07-07 20:19:36 +00:00
/* make the right function name up */
strcpy (tstr, "operator__");
ptr = tstr + 8;
strcpy (mangle_tstr, "__");
mangle_ptr = mangle_tstr + 2;
switch (op)
{
1999-07-07 20:19:36 +00:00
case UNOP_PREINCREMENT:
strcpy (ptr, "++");
break;
case UNOP_PREDECREMENT:
strcpy (ptr, "--");
1999-07-07 20:19:36 +00:00
break;
case UNOP_POSTINCREMENT:
strcpy (ptr, "++");
argvec[2] = value_from_longest (builtin_type_int, 0);
argvec[3] = 0;
nargs ++;
1999-07-07 20:19:36 +00:00
break;
case UNOP_POSTDECREMENT:
strcpy (ptr, "--");
argvec[2] = value_from_longest (builtin_type_int, 0);
argvec[3] = 0;
nargs ++;
1999-07-07 20:19:36 +00:00
break;
case UNOP_LOGICAL_NOT:
strcpy (ptr, "!");
break;
case UNOP_COMPLEMENT:
strcpy (ptr, "~");
break;
case UNOP_NEG:
strcpy (ptr, "-");
break;
case UNOP_IND:
strcpy (ptr, "*");
break;
default:
error ("Invalid unary operation specified.");
}
1999-07-07 20:19:36 +00:00
argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
if (argvec[0])
{
if (static_memfuncp)
{
argvec[1] = argvec[0];
nargs --;
argvec++;
}
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type;
return_type
= TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
return value_zero (return_type, VALUE_LVAL (arg1));
}
return call_function_by_hand (argvec[0], nargs, argvec + 1);
}
error ("member function %s not found", tstr);
1999-07-07 20:19:36 +00:00
return 0; /* For lint -- never reached */
}
1999-07-07 20:19:36 +00:00
/* Concatenate two values with the following conditions:
1999-07-07 20:19:36 +00:00
(1) Both values must be either bitstring values or character string
values and the resulting value consists of the concatenation of
ARG1 followed by ARG2.
1999-07-07 20:19:36 +00:00
or
1999-07-07 20:19:36 +00:00
One value must be an integer value and the other value must be
either a bitstring value or character string value, which is
to be repeated by the number of times specified by the integer
value.
1999-07-07 20:19:36 +00:00
(2) Boolean values are also allowed and are treated as bit string
values of length 1.
1999-07-07 20:19:36 +00:00
(3) Character values are also allowed and are treated as character
string values of length 1.
*/
2002-01-04 05:20:09 +00:00
struct value *
value_concat (struct value *arg1, struct value *arg2)
{
2002-01-04 05:20:09 +00:00
struct value *inval1;
struct value *inval2;
struct value *outval = NULL;
int inval1len, inval2len;
int count, idx;
char *ptr;
char inchar;
struct type *type1 = check_typedef (VALUE_TYPE (arg1));
struct type *type2 = check_typedef (VALUE_TYPE (arg2));
COERCE_VARYING_ARRAY (arg1, type1);
COERCE_VARYING_ARRAY (arg2, type2);
/* First figure out if we are dealing with two values to be concatenated
or a repeat count and a value to be repeated. INVAL1 is set to the
first of two concatenated values, or the repeat count. INVAL2 is set
to the second of the two concatenated values or the value to be
repeated. */
if (TYPE_CODE (type2) == TYPE_CODE_INT)
{
struct type *tmp = type1;
type1 = tmp;
tmp = type2;
inval1 = arg2;
inval2 = arg1;
}
else
{
inval1 = arg1;
inval2 = arg2;
}
/* Now process the input values. */
if (TYPE_CODE (type1) == TYPE_CODE_INT)
{
/* We have a repeat count. Validate the second value and then
1999-07-07 20:19:36 +00:00
construct a value repeated that many times. */
if (TYPE_CODE (type2) == TYPE_CODE_STRING
|| TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
count = longest_to_int (value_as_long (inval1));
inval2len = TYPE_LENGTH (type2);
ptr = (char *) alloca (count * inval2len);
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
inchar = (char) unpack_long (type2,
VALUE_CONTENTS (inval2));
for (idx = 0; idx < count; idx++)
{
*(ptr + idx) = inchar;
}
}
else
{
for (idx = 0; idx < count; idx++)
{
memcpy (ptr + (idx * inval2len), VALUE_CONTENTS (inval2),
inval2len);
}
}
outval = value_string (ptr, count * inval2len);
}
else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
|| TYPE_CODE (type2) == TYPE_CODE_BOOL)
{
error ("unimplemented support for bitstring/boolean repeats");
}
else
{
error ("can't repeat values of that type");
}
}
else if (TYPE_CODE (type1) == TYPE_CODE_STRING
1999-07-07 20:19:36 +00:00
|| TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
/* We have two character strings to concatenate. */
if (TYPE_CODE (type2) != TYPE_CODE_STRING
&& TYPE_CODE (type2) != TYPE_CODE_CHAR)
{
error ("Strings can only be concatenated with other strings.");
}
inval1len = TYPE_LENGTH (type1);
inval2len = TYPE_LENGTH (type2);
ptr = (char *) alloca (inval1len + inval2len);
if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
*ptr = (char) unpack_long (type1, VALUE_CONTENTS (inval1));
}
else
{
memcpy (ptr, VALUE_CONTENTS (inval1), inval1len);
}
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
1999-07-07 20:19:36 +00:00
*(ptr + inval1len) =
(char) unpack_long (type2, VALUE_CONTENTS (inval2));
}
else
{
memcpy (ptr + inval1len, VALUE_CONTENTS (inval2), inval2len);
}
outval = value_string (ptr, inval1len + inval2len);
}
else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
|| TYPE_CODE (type1) == TYPE_CODE_BOOL)
{
/* We have two bitstrings to concatenate. */
if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
&& TYPE_CODE (type2) != TYPE_CODE_BOOL)
{
error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
}
error ("unimplemented support for bitstring/boolean concatenation.");
1999-07-07 20:19:36 +00:00
}
else
{
/* We don't know how to concatenate these operands. */
error ("illegal operands for concatenation.");
}
return (outval);
}
1999-07-07 20:19:36 +00:00
/* Perform a binary operation on two operands which have reasonable
representations as integers or floats. This includes booleans,
characters, integers, or floats.
Does not support addition and subtraction on pointers;
use value_add or value_sub if you want to handle those possibilities. */
2002-01-04 05:20:09 +00:00
struct value *
value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
{
2002-01-04 05:20:09 +00:00
struct value *val;
struct type *type1, *type2;
COERCE_REF (arg1);
COERCE_REF (arg2);
COERCE_ENUM (arg1);
COERCE_ENUM (arg2);
type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2));
if ((TYPE_CODE (type1) != TYPE_CODE_FLT
&& TYPE_CODE (type1) != TYPE_CODE_CHAR
&& TYPE_CODE (type1) != TYPE_CODE_INT
&& TYPE_CODE (type1) != TYPE_CODE_BOOL
&& TYPE_CODE (type1) != TYPE_CODE_RANGE)
||
(TYPE_CODE (type2) != TYPE_CODE_FLT
&& TYPE_CODE (type2) != TYPE_CODE_CHAR
&& TYPE_CODE (type2) != TYPE_CODE_INT
&& TYPE_CODE (type2) != TYPE_CODE_BOOL
&& TYPE_CODE (type2) != TYPE_CODE_RANGE))
error ("Argument to arithmetic operation not a number or boolean.");
if (TYPE_CODE (type1) == TYPE_CODE_FLT
||
TYPE_CODE (type2) == TYPE_CODE_FLT)
{
/* FIXME-if-picky-about-floating-accuracy: Should be doing this
1999-07-07 20:19:36 +00:00
in target format. real.c in GCC probably has the necessary
code. */
1999-12-14 01:06:04 +00:00
DOUBLEST v1, v2, v = 0;
v1 = value_as_double (arg1);
v2 = value_as_double (arg2);
switch (op)
{
case BINOP_ADD:
v = v1 + v2;
break;
case BINOP_SUB:
v = v1 - v2;
break;
case BINOP_MUL:
v = v1 * v2;
break;
case BINOP_DIV:
v = v1 / v2;
break;
1999-12-14 01:06:04 +00:00
case BINOP_EXP:
v = pow (v1, v2);
if (errno)
2002-03-27 21:35:35 +00:00
error ("Cannot perform exponentiation: %s", safe_strerror (errno));
1999-12-14 01:06:04 +00:00
break;
default:
error ("Integer-only operation on floating point number.");
}
/* If either arg was long double, make sure that value is also long
1999-07-07 20:19:36 +00:00
double. */
1999-07-07 20:19:36 +00:00
if (TYPE_LENGTH (type1) * 8 > TARGET_DOUBLE_BIT
|| TYPE_LENGTH (type2) * 8 > TARGET_DOUBLE_BIT)
val = allocate_value (builtin_type_long_double);
else
val = allocate_value (builtin_type_double);
store_typed_floating (VALUE_CONTENTS_RAW (val), VALUE_TYPE (val), v);
}
else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
&&
TYPE_CODE (type2) == TYPE_CODE_BOOL)
1999-07-07 20:19:36 +00:00
{
1999-12-14 01:06:04 +00:00
LONGEST v1, v2, v = 0;
1999-07-07 20:19:36 +00:00
v1 = value_as_long (arg1);
v2 = value_as_long (arg2);
switch (op)
{
case BINOP_BITWISE_AND:
v = v1 & v2;
break;
case BINOP_BITWISE_IOR:
v = v1 | v2;
break;
case BINOP_BITWISE_XOR:
v = v1 ^ v2;
1999-12-14 01:06:04 +00:00
break;
case BINOP_EQUAL:
v = v1 == v2;
break;
case BINOP_NOTEQUAL:
v = v1 != v2;
1999-07-07 20:19:36 +00:00
break;
default:
error ("Invalid operation on booleans.");
}
val = allocate_value (type1);
store_signed_integer (VALUE_CONTENTS_RAW (val),
TYPE_LENGTH (type1),
v);
}
else
/* Integral operations here. */
/* FIXME: Also mixed integral/booleans, with result an integer. */
/* FIXME: This implements ANSI C rules (also correct for C++).
2003-01-02 Andrew Cagney <ac131313@redhat.com> * valarith.c (value_binop): Delete obsolete code and comments. * configure.host: Ditto. * buildsym.h (make_blockvector): Ditto. * buildsym.c (make_blockvector): Ditto. * defs.h (enum language): Ditto. (chill_demangle): Ditto. * elfread.c (elf_symtab_read): Ditto. * dwarfread.c (CHILL_PRODUCER): Ditto. (set_cu_language): Ditto. (handle_producer): Ditto. * expprint.c (print_subexp): Ditto. * gdbtypes.c (chill_varying_type): Ditto. * gdbtypes.h (builtin_type_chill_bool): Ditto. (builtin_type_chill_char, builtin_type_chill_long): Ditto. (builtin_type_chill_ulong, builtin_type_chill_real): Ditto. (chill_varying_type): Ditto. * language.h (_LANG_chill): Ditto. * language.c (binop_result_type, integral_type): Ditto. (character_type, string_type, structured_type): Ditto. (lang_bool_type, binop_type_check): Ditto. * stabsread.h (os9k_stabs): Ditto. * stabsread.c (os9k_type_vector, dbx_lookup_type): Ditto. (define_symbol, read_type, read_struct_fields): Ditto. (read_array_type, read_enum_type, read_huge_number): Ditto. (read_range_type, start_stabs): Ditto. * symfile.c (init_filename_language_table): Ditto. (add_psymbol_with_dem_name_to_list): Ditto. * symtab.c (symbol_init_language_specific): Ditto. (symbol_init_demangled_name, symbol_demangled_name): Ditto. * symtab.h (struct general_symbol_info): Ditto. (SYMBOL_CHILL_DEMANGLED_NAME): Ditto. * typeprint.c (typedef_print): Ditto. * utils.c (fprintf_symbol_filtered): Ditto. * valops.c (value_cast, search_struct_field, value_slice): Delete obsolete code. (varying_to_slice): Delete function. * value.h (COERCE_VARYING_ARRAY): Delete obsolete macro contents. (varying_to_slice): Delete declaration. * MAINTAINERS: Update.
2003-01-02 14:27:27 +00:00
What about FORTRAN and (the deleted) chill ? */
{
unsigned int promoted_len1 = TYPE_LENGTH (type1);
unsigned int promoted_len2 = TYPE_LENGTH (type2);
int is_unsigned1 = TYPE_UNSIGNED (type1);
int is_unsigned2 = TYPE_UNSIGNED (type2);
unsigned int result_len;
int unsigned_operation;
/* Determine type length and signedness after promotion for
1999-07-07 20:19:36 +00:00
both operands. */
if (promoted_len1 < TYPE_LENGTH (builtin_type_int))
{
is_unsigned1 = 0;
promoted_len1 = TYPE_LENGTH (builtin_type_int);
}
if (promoted_len2 < TYPE_LENGTH (builtin_type_int))
{
is_unsigned2 = 0;
promoted_len2 = TYPE_LENGTH (builtin_type_int);
}
/* Determine type length of the result, and if the operation should
1999-07-07 20:19:36 +00:00
be done unsigned.
Use the signedness of the operand with the greater length.
If both operands are of equal length, use unsigned operation
if one of the operands is unsigned. */
if (promoted_len1 > promoted_len2)
{
unsigned_operation = is_unsigned1;
result_len = promoted_len1;
}
else if (promoted_len2 > promoted_len1)
{
unsigned_operation = is_unsigned2;
result_len = promoted_len2;
}
else
{
unsigned_operation = is_unsigned1 || is_unsigned2;
result_len = promoted_len1;
}
if (unsigned_operation)
{
1999-12-14 01:06:04 +00:00
ULONGEST v1, v2, v = 0;
v1 = (ULONGEST) value_as_long (arg1);
v2 = (ULONGEST) value_as_long (arg2);
/* Truncate values to the type length of the result. */
if (result_len < sizeof (ULONGEST))
{
v1 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
v2 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
}
1999-07-07 20:19:36 +00:00
switch (op)
{
case BINOP_ADD:
v = v1 + v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_SUB:
v = v1 - v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_MUL:
v = v1 * v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_DIV:
v = v1 / v2;
break;
1999-07-07 20:19:36 +00:00
1999-12-14 01:06:04 +00:00
case BINOP_EXP:
v = pow (v1, v2);
if (errno)
2002-03-27 21:35:35 +00:00
error ("Cannot perform exponentiation: %s", safe_strerror (errno));
1999-12-14 01:06:04 +00:00
break;
case BINOP_REM:
v = v1 % v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_MOD:
/* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
v1 mod 0 has a defined value, v1. */
if (v2 == 0)
{
v = v1;
}
else
{
1999-07-07 20:19:36 +00:00
v = v1 / v2;
/* Note floor(v1/v2) == v1/v2 for unsigned. */
v = v1 - (v2 * v);
}
break;
1999-07-07 20:19:36 +00:00
case BINOP_LSH:
v = v1 << v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_RSH:
v = v1 >> v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_BITWISE_AND:
v = v1 & v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_BITWISE_IOR:
v = v1 | v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_BITWISE_XOR:
v = v1 ^ v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_LOGICAL_AND:
v = v1 && v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_LOGICAL_OR:
v = v1 || v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_MIN:
v = v1 < v2 ? v1 : v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_MAX:
v = v1 > v2 ? v1 : v2;
break;
case BINOP_EQUAL:
v = v1 == v2;
break;
1999-12-14 01:06:04 +00:00
case BINOP_NOTEQUAL:
v = v1 != v2;
break;
case BINOP_LESS:
v = v1 < v2;
break;
1999-07-07 20:19:36 +00:00
default:
error ("Invalid binary operation on numbers.");
}
/* This is a kludge to get around the fact that we don't
know how to determine the result type from the types of
the operands. (I'm not really sure how much we feel the
need to duplicate the exact rules of the current
language. They can get really hairy. But not to do so
makes it hard to document just what we *do* do). */
/* Can't just call init_type because we wouldn't know what
name to give the type. */
val = allocate_value
(result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
? builtin_type_unsigned_long_long
: builtin_type_unsigned_long);
store_unsigned_integer (VALUE_CONTENTS_RAW (val),
TYPE_LENGTH (VALUE_TYPE (val)),
v);
}
else
{
1999-12-14 01:06:04 +00:00
LONGEST v1, v2, v = 0;
v1 = value_as_long (arg1);
v2 = value_as_long (arg2);
1999-07-07 20:19:36 +00:00
switch (op)
{
case BINOP_ADD:
v = v1 + v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_SUB:
v = v1 - v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_MUL:
v = v1 * v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_DIV:
v = v1 / v2;
1999-12-14 01:06:04 +00:00
break;
case BINOP_EXP:
v = pow (v1, v2);
if (errno)
2002-03-27 21:35:35 +00:00
error ("Cannot perform exponentiation: %s", safe_strerror (errno));
break;
1999-07-07 20:19:36 +00:00
case BINOP_REM:
v = v1 % v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_MOD:
/* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
X mod 0 has a defined value, X. */
if (v2 == 0)
{
v = v1;
}
else
{
1999-07-07 20:19:36 +00:00
v = v1 / v2;
/* Compute floor. */
if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
{
v--;
}
v = v1 - (v2 * v);
}
break;
1999-07-07 20:19:36 +00:00
case BINOP_LSH:
v = v1 << v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_RSH:
v = v1 >> v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_BITWISE_AND:
v = v1 & v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_BITWISE_IOR:
v = v1 | v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_BITWISE_XOR:
v = v1 ^ v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_LOGICAL_AND:
v = v1 && v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_LOGICAL_OR:
v = v1 || v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_MIN:
v = v1 < v2 ? v1 : v2;
break;
1999-07-07 20:19:36 +00:00
case BINOP_MAX:
v = v1 > v2 ? v1 : v2;
break;
case BINOP_EQUAL:
v = v1 == v2;
break;
case BINOP_LESS:
v = v1 < v2;
break;
1999-07-07 20:19:36 +00:00
default:
error ("Invalid binary operation on numbers.");
}
/* This is a kludge to get around the fact that we don't
know how to determine the result type from the types of
the operands. (I'm not really sure how much we feel the
need to duplicate the exact rules of the current
language. They can get really hairy. But not to do so
makes it hard to document just what we *do* do). */
/* Can't just call init_type because we wouldn't know what
name to give the type. */
val = allocate_value
(result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
? builtin_type_long_long
: builtin_type_long);
store_signed_integer (VALUE_CONTENTS_RAW (val),
TYPE_LENGTH (VALUE_TYPE (val)),
v);
}
}
return val;
}
/* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
int
2002-01-04 05:20:09 +00:00
value_logical_not (struct value *arg1)
{
int len;
char *p;
struct type *type1;
COERCE_NUMBER (arg1);
type1 = check_typedef (VALUE_TYPE (arg1));
if (TYPE_CODE (type1) == TYPE_CODE_FLT)
return 0 == value_as_double (arg1);
len = TYPE_LENGTH (type1);
p = VALUE_CONTENTS (arg1);
while (--len >= 0)
{
if (*p++)
break;
}
return len < 0;
}
1999-12-14 01:06:04 +00:00
/* Perform a comparison on two string values (whose content are not
necessarily null terminated) based on their length */
static int
2002-01-04 05:20:09 +00:00
value_strcmp (struct value *arg1, struct value *arg2)
1999-12-14 01:06:04 +00:00
{
int len1 = TYPE_LENGTH (VALUE_TYPE (arg1));
int len2 = TYPE_LENGTH (VALUE_TYPE (arg2));
char *s1 = VALUE_CONTENTS (arg1);
char *s2 = VALUE_CONTENTS (arg2);
int i, len = len1 < len2 ? len1 : len2;
for (i = 0; i < len; i++)
{
if (s1[i] < s2[i])
return -1;
else if (s1[i] > s2[i])
return 1;
else
continue;
}
if (len1 < len2)
return -1;
else if (len1 > len2)
return 1;
else
return 0;
}
/* Simulate the C operator == by returning a 1
iff ARG1 and ARG2 have equal contents. */
int
2002-01-04 05:20:09 +00:00
value_equal (struct value *arg1, struct value *arg2)
{
int len;
char *p1, *p2;
struct type *type1, *type2;
enum type_code code1;
enum type_code code2;
COERCE_NUMBER (arg1);
COERCE_NUMBER (arg2);
type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2));
code1 = TYPE_CODE (type1);
code2 = TYPE_CODE (type2);
if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
(code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
return longest_to_int (value_as_long (value_binop (arg1, arg2,
BINOP_EQUAL)));
else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
&& (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
return value_as_double (arg1) == value_as_double (arg2);
/* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
is bigger. */
else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
else if (code1 == code2
&& ((len = (int) TYPE_LENGTH (type1))
== (int) TYPE_LENGTH (type2)))
{
p1 = VALUE_CONTENTS (arg1);
p2 = VALUE_CONTENTS (arg2);
while (--len >= 0)
{
if (*p1++ != *p2++)
break;
}
return len < 0;
}
1999-12-14 01:06:04 +00:00
else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
{
return value_strcmp (arg1, arg2) == 0;
}
else
{
error ("Invalid type combination in equality test.");
1999-07-07 20:19:36 +00:00
return 0; /* For lint -- never reached */
}
}
/* Simulate the C operator < by returning 1
iff ARG1's contents are less than ARG2's. */
int
2002-01-04 05:20:09 +00:00
value_less (struct value *arg1, struct value *arg2)
{
enum type_code code1;
enum type_code code2;
struct type *type1, *type2;
COERCE_NUMBER (arg1);
COERCE_NUMBER (arg2);
type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2));
code1 = TYPE_CODE (type1);
code2 = TYPE_CODE (type2);
if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
(code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
return longest_to_int (value_as_long (value_binop (arg1, arg2,
BINOP_LESS)));
else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
&& (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
return value_as_double (arg1) < value_as_double (arg2);
else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
return value_as_address (arg1) < value_as_address (arg2);
/* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
is bigger. */
else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1999-12-14 01:06:04 +00:00
else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
return value_strcmp (arg1, arg2) < 0;
else
{
error ("Invalid type combination in ordering comparison.");
return 0;
}
}
/* The unary operators - and ~. Both free the argument ARG1. */
2002-01-04 05:20:09 +00:00
struct value *
value_neg (struct value *arg1)
{
struct type *type;
struct type *result_type = VALUE_TYPE (arg1);
COERCE_REF (arg1);
COERCE_ENUM (arg1);
type = check_typedef (VALUE_TYPE (arg1));
if (TYPE_CODE (type) == TYPE_CODE_FLT)
1999-07-07 20:19:36 +00:00
return value_from_double (result_type, -value_as_double (arg1));
else if (TYPE_CODE (type) == TYPE_CODE_INT || TYPE_CODE (type) == TYPE_CODE_BOOL)
{
2002-08-01 Andrew Cagney <cagney@redhat.com> * NEWS: Menion that CHILL has been made obsolete. * gdbtypes.c (chill_varying_type): Make chill references obsolete. * gdbserver/Makefile.in: Ditto. * stabsread.c (read_range_type): Ditto. * gdbtypes.h: Ditto. * language.c (binop_type_check): Ditto. (binop_result_type): Ditto. (integral_type): Ditto. (character_type): Ditto. (string_type): Ditto. (boolean_type): Ditto. (structured_type): Ditto. (lang_bool_type): Ditto. (binop_type_check): Ditto. * language.h (_LANG_chill): Ditto. * dwarfread.c (set_cu_language): Ditto. * dwarfread.c (CHILL_PRODUCER): Ditto. * dwarfread.c (handle_producer): Ditto. * expression.h (enum exp_opcode): Ditto. * eval.c: Ditto for comments. * typeprint.c (typedef_print) [_LANG_chill]: Ditto. * expprint.c (print_subexp): Ditto. (print_subexp): Ditto. * valops.c (value_cast): Ditto. (search_struct_field): Ditto. * value.h (COERCE_VARYING_ARRAY): Ditto. * symfile.c (init_filename_language_table): Ditto. (add_psymbol_with_dem_name_to_list): Ditto. * valarith.c (value_binop): Ditto. (value_neg): Ditto. * valops.c (value_slice): Ditto. * symtab.h (union language_specific): Ditto. (SYMBOL_INIT_LANGUAGE_SPECIFIC): Ditto. (SYMBOL_DEMANGLED_NAME): Ditto. (SYMBOL_CHILL_DEMANGLED_NAME): Ditto. * defs.h (enum language): Ditto. * symtab.c (got_symtab): Ditto. * utils.c (fprintf_symbol_filtered): Ditto. * ch-typeprint.c: Make file obsolete. * ch-valprint.c: Make file obsolete. * ch-lang.h: Make file obsolete. * ch-exp.c: Make file obsolete. * ch-lang.c: Make file obsolete. * Makefile.in (FLAGS_TO_PASS): Do not pass CHILL or CHILLFLAGS or CHILL_LIB. (TARGET_FLAGS_TO_PASS): Ditto. (CHILLFLAGS): Obsolete. (CHILL): Obsolete. (CHILL_FOR_TARGET): Obsolete. (CHILL_LIB): Obsolete. (SFILES): Remove ch-exp.c, ch-lang.c, ch-typeprint.c and ch-valprint.c. (HFILES_NO_SRCDIR): Remove ch-lang.h. (COMMON_OBS): Remove ch-valprint.o, ch-typeprint.o, ch-exp.o and ch-lang.o. (ch-exp.o, ch-lang.o, ch-typeprint.o, ch-valprint.o): Delete targets. 2002-08-01 Andrew Cagney <cagney@redhat.com> * stabs.texinfo, gdb.texinfo, gdbint.texinfo: Obsolete references to CHILL. 2002-08-01 Andrew Cagney <cagney@redhat.com> * Makefile.in (TARGET_FLAGS_TO_PASS): Remove CHILLFLAGS, CHILL, CHILL_FOR_TARGET and CHILL_LIB. * configure.in (configdirs): Remove gdb.chill. * configure: Regenerate. * lib/gdb.exp: Obsolete references to chill. * gdb.fortran/types.exp: Ditto. * gdb.fortran/exprs.exp: Ditto.
2002-08-01 17:18:35 +00:00
/* Perform integral promotion for ANSI C/C++. FIXME: What about
2003-01-02 Andrew Cagney <ac131313@redhat.com> * valarith.c (value_binop): Delete obsolete code and comments. * configure.host: Ditto. * buildsym.h (make_blockvector): Ditto. * buildsym.c (make_blockvector): Ditto. * defs.h (enum language): Ditto. (chill_demangle): Ditto. * elfread.c (elf_symtab_read): Ditto. * dwarfread.c (CHILL_PRODUCER): Ditto. (set_cu_language): Ditto. (handle_producer): Ditto. * expprint.c (print_subexp): Ditto. * gdbtypes.c (chill_varying_type): Ditto. * gdbtypes.h (builtin_type_chill_bool): Ditto. (builtin_type_chill_char, builtin_type_chill_long): Ditto. (builtin_type_chill_ulong, builtin_type_chill_real): Ditto. (chill_varying_type): Ditto. * language.h (_LANG_chill): Ditto. * language.c (binop_result_type, integral_type): Ditto. (character_type, string_type, structured_type): Ditto. (lang_bool_type, binop_type_check): Ditto. * stabsread.h (os9k_stabs): Ditto. * stabsread.c (os9k_type_vector, dbx_lookup_type): Ditto. (define_symbol, read_type, read_struct_fields): Ditto. (read_array_type, read_enum_type, read_huge_number): Ditto. (read_range_type, start_stabs): Ditto. * symfile.c (init_filename_language_table): Ditto. (add_psymbol_with_dem_name_to_list): Ditto. * symtab.c (symbol_init_language_specific): Ditto. (symbol_init_demangled_name, symbol_demangled_name): Ditto. * symtab.h (struct general_symbol_info): Ditto. (SYMBOL_CHILL_DEMANGLED_NAME): Ditto. * typeprint.c (typedef_print): Ditto. * utils.c (fprintf_symbol_filtered): Ditto. * valops.c (value_cast, search_struct_field, value_slice): Delete obsolete code. (varying_to_slice): Delete function. * value.h (COERCE_VARYING_ARRAY): Delete obsolete macro contents. (varying_to_slice): Delete declaration. * MAINTAINERS: Update.
2003-01-02 14:27:27 +00:00
FORTRAN and (the deleted) chill ? */
if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
result_type = builtin_type_int;
1999-07-07 20:19:36 +00:00
return value_from_longest (result_type, -value_as_long (arg1));
}
else
{
error ("Argument to negate operation not a number.");
return 0; /* For lint -- never reached */
}
}
2002-01-04 05:20:09 +00:00
struct value *
value_complement (struct value *arg1)
{
struct type *type;
struct type *result_type = VALUE_TYPE (arg1);
1999-07-07 20:19:36 +00:00
int typecode;
COERCE_REF (arg1);
COERCE_ENUM (arg1);
type = check_typedef (VALUE_TYPE (arg1));
typecode = TYPE_CODE (type);
if ((typecode != TYPE_CODE_INT) && (typecode != TYPE_CODE_BOOL))
error ("Argument to complement operation not an integer or boolean.");
/* Perform integral promotion for ANSI C/C++.
FIXME: What about FORTRAN ? */
if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
result_type = builtin_type_int;
1999-07-07 20:19:36 +00:00
return value_from_longest (result_type, ~value_as_long (arg1));
}
/* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
and whose VALUE_CONTENTS is valaddr.
Return -1 if out of range, -2 other error. */
int
2000-07-30 01:48:28 +00:00
value_bit_index (struct type *type, char *valaddr, int index)
{
LONGEST low_bound, high_bound;
LONGEST word;
unsigned rel_index;
struct type *range = TYPE_FIELD_TYPE (type, 0);
if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
return -2;
if (index < low_bound || index > high_bound)
return -1;
rel_index = index - low_bound;
word = unpack_long (builtin_type_unsigned_char,
valaddr + (rel_index / TARGET_CHAR_BIT));
rel_index %= TARGET_CHAR_BIT;
if (BITS_BIG_ENDIAN)
rel_index = TARGET_CHAR_BIT - 1 - rel_index;
return (word >> rel_index) & 1;
}
2002-01-04 05:20:09 +00:00
struct value *
value_in (struct value *element, struct value *set)
{
int member;
struct type *settype = check_typedef (VALUE_TYPE (set));
struct type *eltype = check_typedef (VALUE_TYPE (element));
if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
eltype = TYPE_TARGET_TYPE (eltype);
if (TYPE_CODE (settype) != TYPE_CODE_SET)
error ("Second argument of 'IN' has wrong type");
if (TYPE_CODE (eltype) != TYPE_CODE_INT
&& TYPE_CODE (eltype) != TYPE_CODE_CHAR
&& TYPE_CODE (eltype) != TYPE_CODE_ENUM
&& TYPE_CODE (eltype) != TYPE_CODE_BOOL)
error ("First argument of 'IN' has wrong type");
member = value_bit_index (settype, VALUE_CONTENTS (set),
value_as_long (element));
if (member < 0)
error ("First argument of 'IN' not in range");
return value_from_longest (LA_BOOL_TYPE, member);
}
void
2000-07-30 01:48:28 +00:00
_initialize_valarith (void)
{
}