X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fvalarith.c;h=ed76b0960ba73b8450083451e6b56e9805fa676a;hb=1180b2c86e7162bbe500802b3c16ea7ab26c6ab6;hp=ef03fb9839cfc0afd3d3041f67abb1930238715e;hpb=bd49c137fee8212c7e64ce62cc07d398b1278b14;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/valarith.c b/gdb/valarith.c
index ef03fb9839..ed76b0960b 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -1,14 +1,14 @@
/* Perform arithmetic and other operations on values, for GDB.
- Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free
- Software Foundation, Inc.
+ Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
+ 2010 Free Software Foundation, Inc.
This file is part of GDB.
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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -17,9 +17,7 @@
GNU General Public License for more details.
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. */
+ along with this program. If not, see . */
#include "defs.h"
#include "value.h"
@@ -30,6 +28,7 @@
#include "language.h"
#include "gdb_string.h"
#include "doublest.h"
+#include "dfp.h"
#include
#include "infcall.h"
@@ -40,8 +39,6 @@
#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
#endif
-static struct value *value_subscripted_rvalue (struct value *, struct value *, int);
-
void _initialize_valarith (void);
@@ -49,7 +46,7 @@ void _initialize_valarith (void);
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.
+ helper for value_ptradd.
*/
static LONGEST
@@ -58,6 +55,7 @@ find_size_for_pointer_math (struct type *ptr_type)
LONGEST sz = -1;
struct type *ptr_target;
+ gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
sz = TYPE_LENGTH (ptr_target);
@@ -83,100 +81,63 @@ find_size_for_pointer_math (struct type *ptr_type)
return sz;
}
+/* Given a pointer ARG1 and an integral value ARG2, return the
+ result of C-style pointer arithmetic ARG1 + ARG2. */
+
struct value *
-value_add (struct value *arg1, struct value *arg2)
+value_ptradd (struct value *arg1, LONGEST arg2)
{
- struct value *valint;
- struct value *valptr;
+ struct type *valptrtype;
LONGEST sz;
- struct type *type1, *type2, *valptrtype;
arg1 = coerce_array (arg1);
- arg2 = coerce_array (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)
- &&
- (is_integral_type (type1) || is_integral_type (type2)))
- /* Exactly one argument is a pointer, and one is an integer. */
- {
- 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);
+ valptrtype = check_typedef (value_type (arg1));
+ sz = find_size_for_pointer_math (valptrtype);
- retval = value_from_pointer (valptrtype,
- value_as_address (valptr)
- + (sz * value_as_long (valint)));
- return retval;
- }
-
- return value_binop (arg1, arg2, BINOP_ADD);
+ return value_from_pointer (valptrtype,
+ value_as_address (arg1) + sz * arg2);
}
-struct value *
-value_sub (struct value *arg1, struct value *arg2)
+/* Given two compatible pointer values ARG1 and ARG2, return the
+ result of C-style pointer arithmetic ARG1 - ARG2. */
+
+LONGEST
+value_ptrdiff (struct value *arg1, struct value *arg2)
{
struct type *type1, *type2;
+ LONGEST sz;
+
arg1 = coerce_array (arg1);
arg2 = coerce_array (arg2);
type1 = check_typedef (value_type (arg1));
type2 = check_typedef (value_type (arg2));
- if (TYPE_CODE (type1) == TYPE_CODE_PTR)
- {
- if (is_integral_type (type2))
- {
- /* pointer - integer. */
- LONGEST sz = find_size_for_pointer_math (type1);
+ gdb_assert (TYPE_CODE (type1) == TYPE_CODE_PTR);
+ gdb_assert (TYPE_CODE (type2) == TYPE_CODE_PTR);
- return value_from_pointer (type1,
- (value_as_address (arg1)
- - (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 - pointer to . */
- LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
- return value_from_longest
- (builtin_type_long, /* FIXME -- should be ptrdiff_t */
- (value_as_long (arg1) - value_as_long (arg2)) / sz);
- }
- else
- {
- error (_("\
+ if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
+ != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
+ 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);
+ sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
+ return (value_as_long (arg1) - value_as_long (arg2)) / sz;
}
/* Return the value of ARRAY[IDX].
+
+ ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
+ current language supports C-style arrays, it may also be TYPE_CODE_PTR.
+ To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
+
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). */
struct value *
-value_subscript (struct value *array, struct value *idx)
+value_subscript (struct value *array, LONGEST index)
{
struct value *bound;
int c_style = current_language->c_style_arrays;
@@ -193,13 +154,12 @@ value_subscript (struct value *array, struct value *idx)
get_discrete_bounds (range_type, &lowerbound, &upperbound);
if (VALUE_LVAL (array) != lval_memory)
- return value_subscripted_rvalue (array, idx, lowerbound);
+ return value_subscripted_rvalue (array, index, lowerbound);
if (c_style == 0)
{
- LONGEST index = value_as_long (idx);
if (index >= lowerbound && index <= upperbound)
- return value_subscripted_rvalue (array, idx, lowerbound);
+ return value_subscripted_rvalue (array, index, lowerbound);
/* Emit warning unless we have an array of unknown size.
An array of unknown size has lowerbound 0 and upperbound -1. */
if (upperbound > -1)
@@ -208,44 +168,12 @@ value_subscript (struct value *array, struct value *idx)
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);
- 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;
- 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);
- set_value_bitpos (v, bit_index);
- set_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_FRAME_ID (v) = VALUE_FRAME_ID (array);
- set_value_offset (v, offset + value_offset (array));
- return v;
+ array = value_coerce_array (array);
}
if (c_style)
- return value_ind (value_add (array, idx));
+ return value_ind (value_ptradd (array, index));
else
error (_("not an array or string"));
}
@@ -254,13 +182,12 @@ value_subscript (struct value *array, struct value *idx)
(eg, a vector register). This routine used to promote floats
to doubles, but no longer does. */
-static struct value *
-value_subscripted_rvalue (struct value *array, struct value *idx, int lowerbound)
+struct value *
+value_subscripted_rvalue (struct value *array, LONGEST index, 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);
struct value *v;
@@ -268,26 +195,63 @@ value_subscripted_rvalue (struct value *array, struct value *idx, int lowerbound
error (_("no such vector element"));
v = allocate_value (elt_type);
- if (value_lazy (array))
+ if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
set_value_lazy (v, 1);
else
memcpy (value_contents_writeable (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);
+ set_value_component_location (v, array);
VALUE_REGNUM (v) = VALUE_REGNUM (array);
VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
set_value_offset (v, value_offset (array) + elt_offs);
return v;
}
+
+/* Return the value of BITSTRING[IDX] as (boolean) type TYPE. */
+
+struct value *
+value_bitstring_subscript (struct type *type,
+ struct value *bitstring, LONGEST index)
+{
+
+ struct type *bitstring_type, *range_type;
+ struct value *v;
+ int offset, byte, bit_index;
+ LONGEST lowerbound, upperbound;
+
+ bitstring_type = check_typedef (value_type (bitstring));
+ gdb_assert (TYPE_CODE (bitstring_type) == TYPE_CODE_BITSTRING);
+
+ range_type = TYPE_INDEX_TYPE (bitstring_type);
+ 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;
+ byte = *((char *) value_contents (bitstring) + offset);
+
+ bit_index = index % TARGET_CHAR_BIT;
+ byte >>= (gdbarch_bits_big_endian (get_type_arch (bitstring_type)) ?
+ TARGET_CHAR_BIT - 1 - bit_index : bit_index);
+
+ v = value_from_longest (type, byte & 1);
+
+ set_value_bitpos (v, bit_index);
+ set_value_bitsize (v, 1);
+ set_value_component_location (v, bitstring);
+ VALUE_FRAME_ID (v) = VALUE_FRAME_ID (bitstring);
+
+ set_value_offset (v, offset + value_offset (bitstring));
+
+ 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.
+/* Check to see if either argument is a structure, or a reference to
+ one. 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. */
@@ -297,14 +261,17 @@ 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));
+ if (TYPE_CODE (type1) == TYPE_CODE_REF)
+ type1 = check_typedef (TYPE_TARGET_TYPE (type1));
+
type2 = check_typedef (value_type (arg2));
+ if (TYPE_CODE (type2) == TYPE_CODE_REF)
+ type2 = check_typedef (TYPE_TARGET_TYPE (type2));
+
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));
+ || TYPE_CODE (type2) == TYPE_CODE_STRUCT);
}
/* Check to see if argument is a structure. This is called so
@@ -351,8 +318,6 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
arg1 = coerce_ref (arg1);
arg2 = coerce_ref (arg2);
- arg1 = coerce_enum (arg1);
- arg2 = 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. */
@@ -506,13 +471,13 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
struct value *
value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
{
+ struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
struct value **argvec;
char *ptr, *mangle_ptr;
char tstr[13], mangle_tstr[13];
int static_memfuncp, nargs;
arg1 = coerce_ref (arg1);
- 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. */
@@ -541,13 +506,13 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
break;
case UNOP_POSTINCREMENT:
strcpy (ptr, "++");
- argvec[2] = value_from_longest (builtin_type_int, 0);
+ argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
argvec[3] = 0;
nargs ++;
break;
case UNOP_POSTDECREMENT:
strcpy (ptr, "--");
- argvec[2] = value_from_longest (builtin_type_int, 0);
+ argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
argvec[3] = 0;
nargs ++;
break;
@@ -627,6 +592,7 @@ value_concat (struct value *arg1, struct value *arg2)
char inchar;
struct type *type1 = check_typedef (value_type (arg1));
struct type *type2 = check_typedef (value_type (arg2));
+ struct type *char_type;
/* 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
@@ -662,6 +628,7 @@ value_concat (struct value *arg1, struct value *arg2)
ptr = (char *) alloca (count * inval2len);
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
+ char_type = type2;
inchar = (char) unpack_long (type2,
value_contents (inval2));
for (idx = 0; idx < count; idx++)
@@ -671,13 +638,14 @@ value_concat (struct value *arg1, struct value *arg2)
}
else
{
+ char_type = TYPE_TARGET_TYPE (type2);
for (idx = 0; idx < count; idx++)
{
memcpy (ptr + (idx * inval2len), value_contents (inval2),
inval2len);
}
}
- outval = value_string (ptr, count * inval2len);
+ outval = value_string (ptr, count * inval2len, char_type);
}
else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
|| TYPE_CODE (type2) == TYPE_CODE_BOOL)
@@ -703,10 +671,12 @@ value_concat (struct value *arg1, struct value *arg2)
ptr = (char *) alloca (inval1len + inval2len);
if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
+ char_type = type1;
*ptr = (char) unpack_long (type1, value_contents (inval1));
}
else
{
+ char_type = TYPE_TARGET_TYPE (type1);
memcpy (ptr, value_contents (inval1), inval1len);
}
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
@@ -718,7 +688,7 @@ value_concat (struct value *arg1, struct value *arg2)
{
memcpy (ptr + inval1len, value_contents (inval2), inval2len);
}
- outval = value_string (ptr, inval1len + inval2len);
+ outval = value_string (ptr, inval1len + inval2len, char_type);
}
else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
|| TYPE_CODE (type1) == TYPE_CODE_BOOL)
@@ -739,33 +709,200 @@ value_concat (struct value *arg1, struct value *arg2)
return (outval);
}
+/* Integer exponentiation: V1**V2, where both arguments are
+ integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
+static LONGEST
+integer_pow (LONGEST v1, LONGEST v2)
+{
+ if (v2 < 0)
+ {
+ if (v1 == 0)
+ error (_("Attempt to raise 0 to negative power."));
+ else
+ return 0;
+ }
+ else
+ {
+ /* The Russian Peasant's Algorithm */
+ LONGEST v;
+
+ v = 1;
+ for (;;)
+ {
+ if (v2 & 1L)
+ v *= v1;
+ v2 >>= 1;
+ if (v2 == 0)
+ return v;
+ v1 *= v1;
+ }
+ }
+}
+/* Integer exponentiation: V1**V2, where both arguments are
+ integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
+static ULONGEST
+uinteger_pow (ULONGEST v1, LONGEST v2)
+{
+ if (v2 < 0)
+ {
+ if (v1 == 0)
+ error (_("Attempt to raise 0 to negative power."));
+ else
+ return 0;
+ }
+ else
+ {
+ /* The Russian Peasant's Algorithm */
+ ULONGEST v;
+
+ v = 1;
+ for (;;)
+ {
+ if (v2 & 1L)
+ v *= v1;
+ v2 >>= 1;
+ if (v2 == 0)
+ return v;
+ v1 *= v1;
+ }
+ }
+}
+
+/* Obtain decimal value of arguments for binary operation, converting from
+ other types if one of them is not decimal floating point. */
+static void
+value_args_as_decimal (struct value *arg1, struct value *arg2,
+ gdb_byte *x, int *len_x, enum bfd_endian *byte_order_x,
+ gdb_byte *y, int *len_y, enum bfd_endian *byte_order_y)
+{
+ struct type *type1, *type2;
+
+ type1 = check_typedef (value_type (arg1));
+ type2 = check_typedef (value_type (arg2));
+
+ /* At least one of the arguments must be of decimal float type. */
+ gdb_assert (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
+ || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT);
+
+ if (TYPE_CODE (type1) == TYPE_CODE_FLT
+ || TYPE_CODE (type2) == TYPE_CODE_FLT)
+ /* The DFP extension to the C language does not allow mixing of
+ * decimal float types with other float types in expressions
+ * (see WDTR 24732, page 12). */
+ error (_("Mixing decimal floating types with other floating types is not allowed."));
+
+ /* Obtain decimal value of arg1, converting from other types
+ if necessary. */
+
+ if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
+ {
+ *byte_order_x = gdbarch_byte_order (get_type_arch (type1));
+ *len_x = TYPE_LENGTH (type1);
+ memcpy (x, value_contents (arg1), *len_x);
+ }
+ else if (is_integral_type (type1))
+ {
+ *byte_order_x = gdbarch_byte_order (get_type_arch (type2));
+ *len_x = TYPE_LENGTH (type2);
+ decimal_from_integral (arg1, x, *len_x, *byte_order_x);
+ }
+ else
+ error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
+ TYPE_NAME (type2));
+
+ /* Obtain decimal value of arg2, converting from other types
+ if necessary. */
+
+ if (TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
+ {
+ *byte_order_y = gdbarch_byte_order (get_type_arch (type2));
+ *len_y = TYPE_LENGTH (type2);
+ memcpy (y, value_contents (arg2), *len_y);
+ }
+ else if (is_integral_type (type2))
+ {
+ *byte_order_y = gdbarch_byte_order (get_type_arch (type1));
+ *len_y = TYPE_LENGTH (type1);
+ decimal_from_integral (arg2, y, *len_y, *byte_order_y);
+ }
+ else
+ error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
+ TYPE_NAME (type2));
+}
/* 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. */
+ use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
struct value *
value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
{
struct value *val;
- struct type *type1, *type2;
+ struct type *type1, *type2, *result_type;
arg1 = coerce_ref (arg1);
arg2 = coerce_ref (arg2);
+
type1 = check_typedef (value_type (arg1));
type2 = check_typedef (value_type (arg2));
- if ((TYPE_CODE (type1) != TYPE_CODE_FLT && !is_integral_type (type1))
- ||
- (TYPE_CODE (type2) != TYPE_CODE_FLT && !is_integral_type (type2)))
+ if ((TYPE_CODE (type1) != TYPE_CODE_FLT
+ && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
+ && !is_integral_type (type1))
+ || (TYPE_CODE (type2) != TYPE_CODE_FLT
+ && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
+ && !is_integral_type (type2)))
error (_("Argument to arithmetic operation not a number or boolean."));
- if (TYPE_CODE (type1) == TYPE_CODE_FLT
- ||
- TYPE_CODE (type2) == TYPE_CODE_FLT)
+ if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
+ || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
+ {
+ struct type *v_type;
+ int len_v1, len_v2, len_v;
+ enum bfd_endian byte_order_v1, byte_order_v2, byte_order_v;
+ gdb_byte v1[16], v2[16];
+ gdb_byte v[16];
+
+ /* If only one type is decimal float, use its type.
+ Otherwise use the bigger type. */
+ if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT)
+ result_type = type2;
+ else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT)
+ result_type = type1;
+ else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+ result_type = type2;
+ else
+ result_type = type1;
+
+ len_v = TYPE_LENGTH (result_type);
+ byte_order_v = gdbarch_byte_order (get_type_arch (result_type));
+
+ value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
+ v2, &len_v2, &byte_order_v2);
+
+ switch (op)
+ {
+ case BINOP_ADD:
+ case BINOP_SUB:
+ case BINOP_MUL:
+ case BINOP_DIV:
+ case BINOP_EXP:
+ decimal_binop (op, v1, len_v1, byte_order_v1,
+ v2, len_v2, byte_order_v2,
+ v, len_v, byte_order_v);
+ break;
+
+ default:
+ error (_("Operation not valid for decimal floating point number."));
+ }
+
+ val = value_from_decfloat (result_type, v);
+ }
+ else if (TYPE_CODE (type1) == TYPE_CODE_FLT
+ || TYPE_CODE (type2) == TYPE_CODE_FLT)
{
/* FIXME-if-picky-about-floating-accuracy: Should be doing this
in target format. real.c in GCC probably has the necessary
@@ -773,6 +910,7 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
DOUBLEST v1, v2, v = 0;
v1 = value_as_double (arg1);
v2 = value_as_double (arg2);
+
switch (op)
{
case BINOP_ADD:
@@ -798,24 +936,34 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
error (_("Cannot perform exponentiation: %s"), safe_strerror (errno));
break;
+ case BINOP_MIN:
+ v = v1 < v2 ? v1 : v2;
+ break;
+
+ case BINOP_MAX:
+ v = v1 > v2 ? v1 : v2;
+ break;
+
default:
error (_("Integer-only operation on floating point number."));
}
- /* If either arg was long double, make sure that value is also long
- double. */
-
- if (TYPE_LENGTH (type1) * 8 > TARGET_DOUBLE_BIT
- || TYPE_LENGTH (type2) * 8 > TARGET_DOUBLE_BIT)
- val = allocate_value (builtin_type_long_double);
+ /* If only one type is float, use its type.
+ Otherwise use the bigger type. */
+ if (TYPE_CODE (type1) != TYPE_CODE_FLT)
+ result_type = type2;
+ else if (TYPE_CODE (type2) != TYPE_CODE_FLT)
+ result_type = type1;
+ else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+ result_type = type2;
else
- val = allocate_value (builtin_type_double);
+ result_type = type1;
+ val = allocate_value (result_type);
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)
+ || TYPE_CODE (type2) == TYPE_CODE_BOOL)
{
LONGEST v1, v2, v = 0;
v1 = value_as_long (arg1);
@@ -847,70 +995,42 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
error (_("Invalid operation on booleans."));
}
- val = allocate_value (type1);
+ result_type = type1;
+
+ val = allocate_value (result_type);
store_signed_integer (value_contents_raw (val),
- TYPE_LENGTH (type1),
+ TYPE_LENGTH (result_type),
+ gdbarch_byte_order (get_type_arch (result_type)),
v);
}
else
/* Integral operations here. */
- /* FIXME: Also mixed integral/booleans, with result an integer. */
- /* FIXME: This implements ANSI C rules (also correct for C++).
- 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
- 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
- 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;
- }
+ be done unsigned. For exponentiation and shift operators,
+ use the length and type of the left operand. Otherwise,
+ 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 (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
+ result_type = type1;
+ else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
+ result_type = type1;
+ else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+ result_type = type2;
+ else if (TYPE_UNSIGNED (type1))
+ result_type = type1;
+ else if (TYPE_UNSIGNED (type2))
+ result_type = type2;
else
- {
- unsigned_operation = is_unsigned1 || is_unsigned2;
- result_len = promoted_len1;
- }
+ result_type = type1;
- if (unsigned_operation)
+ if (TYPE_UNSIGNED (result_type))
{
+ LONGEST v2_signed = value_as_long (arg2);
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;
- }
+ v2 = (ULONGEST) v2_signed;
switch (op)
{
@@ -927,18 +1047,22 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
break;
case BINOP_DIV:
- v = v1 / v2;
+ case BINOP_INTDIV:
+ if (v2 != 0)
+ v = v1 / v2;
+ else
+ error (_("Division by zero"));
break;
case BINOP_EXP:
- errno = 0;
- v = pow (v1, v2);
- if (errno)
- error (_("Cannot perform exponentiation: %s"), safe_strerror (errno));
+ v = uinteger_pow (v1, v2_signed);
break;
case BINOP_REM:
- v = v1 % v2;
+ if (v2 != 0)
+ v = v1 % v2;
+ else
+ error (_("Division by zero"));
break;
case BINOP_MOD:
@@ -1004,25 +1128,27 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
v = v1 < v2;
break;
+ case BINOP_GTR:
+ v = v1 > v2;
+ break;
+
+ case BINOP_LEQ:
+ v = v1 <= v2;
+ break;
+
+ case BINOP_GEQ:
+ v = v1 >= v2;
+ break;
+
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);
+ val = allocate_value (result_type);
store_unsigned_integer (value_contents_raw (val),
TYPE_LENGTH (value_type (val)),
+ gdbarch_byte_order
+ (get_type_arch (result_type)),
v);
}
else
@@ -1046,6 +1172,7 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
break;
case BINOP_DIV:
+ case BINOP_INTDIV:
if (v2 != 0)
v = v1 / v2;
else
@@ -1053,10 +1180,7 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
break;
case BINOP_EXP:
- errno = 0;
- v = pow (v1, v2);
- if (errno)
- error (_("Cannot perform exponentiation: %s"), safe_strerror (errno));
+ v = integer_pow (v1, v2);
break;
case BINOP_REM:
@@ -1125,29 +1249,35 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
v = v1 == v2;
break;
+ case BINOP_NOTEQUAL:
+ v = v1 != v2;
+ break;
+
case BINOP_LESS:
v = v1 < v2;
break;
+ case BINOP_GTR:
+ v = v1 > v2;
+ break;
+
+ case BINOP_LEQ:
+ v = v1 <= v2;
+ break;
+
+ case BINOP_GEQ:
+ v = v1 >= v2;
+ break;
+
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);
+ val = allocate_value (result_type);
store_signed_integer (value_contents_raw (val),
TYPE_LENGTH (value_type (val)),
+ gdbarch_byte_order
+ (get_type_arch (result_type)),
v);
}
}
@@ -1164,11 +1294,14 @@ value_logical_not (struct value *arg1)
const gdb_byte *p;
struct type *type1;
- arg1 = coerce_number (arg1);
+ arg1 = coerce_array (arg1);
type1 = check_typedef (value_type (arg1));
if (TYPE_CODE (type1) == TYPE_CODE_FLT)
return 0 == value_as_double (arg1);
+ else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
+ return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1),
+ gdbarch_byte_order (get_type_arch (type1)));
len = TYPE_LENGTH (type1);
p = value_contents (arg1);
@@ -1241,7 +1374,25 @@ value_equal (struct value *arg1, struct value *arg2)
BINOP_EQUAL)));
else if ((code1 == TYPE_CODE_FLT || is_int1)
&& (code2 == TYPE_CODE_FLT || is_int2))
- return value_as_double (arg1) == value_as_double (arg2);
+ {
+ /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
+ `long double' values are returned in static storage (m68k). */
+ DOUBLEST d = value_as_double (arg1);
+ return d == value_as_double (arg2);
+ }
+ else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
+ && (code2 == TYPE_CODE_DECFLOAT || is_int2))
+ {
+ gdb_byte v1[16], v2[16];
+ int len_v1, len_v2;
+ enum bfd_endian byte_order_v1, byte_order_v2;
+
+ value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
+ v2, &len_v2, &byte_order_v2);
+
+ return decimal_compare (v1, len_v1, byte_order_v1,
+ v2, len_v2, byte_order_v2) == 0;
+ }
/* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
is bigger. */
@@ -1274,6 +1425,24 @@ value_equal (struct value *arg1, struct value *arg2)
}
}
+/* Compare values based on their raw contents. Useful for arrays since
+ value_equal coerces them to pointers, thus comparing just the address
+ of the array instead of its contents. */
+
+int
+value_equal_contents (struct value *arg1, struct value *arg2)
+{
+ struct type *type1, *type2;
+
+ type1 = check_typedef (value_type (arg1));
+ type2 = check_typedef (value_type (arg2));
+
+ return (TYPE_CODE (type1) == TYPE_CODE (type2)
+ && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
+ && memcmp (value_contents (arg1), value_contents (arg2),
+ TYPE_LENGTH (type1)) == 0);
+}
+
/* Simulate the C operator < by returning 1
iff ARG1's contents are less than ARG2's. */
@@ -1300,7 +1469,25 @@ value_less (struct value *arg1, struct value *arg2)
BINOP_LESS)));
else if ((code1 == TYPE_CODE_FLT || is_int1)
&& (code2 == TYPE_CODE_FLT || is_int2))
- return value_as_double (arg1) < value_as_double (arg2);
+ {
+ /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
+ `long double' values are returned in static storage (m68k). */
+ DOUBLEST d = value_as_double (arg1);
+ return d < value_as_double (arg2);
+ }
+ else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
+ && (code2 == TYPE_CODE_DECFLOAT || is_int2))
+ {
+ gdb_byte v1[16], v2[16];
+ int len_v1, len_v2;
+ enum bfd_endian byte_order_v1, byte_order_v2;
+
+ value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
+ v2, &len_v2, &byte_order_v2);
+
+ return decimal_compare (v1, len_v1, byte_order_v1,
+ v2, len_v2, byte_order_v2) == -1;
+ }
else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
return value_as_address (arg1) < value_as_address (arg2);
@@ -1327,18 +1514,14 @@ value_pos (struct value *arg1)
struct type *type;
arg1 = coerce_ref (arg1);
-
type = check_typedef (value_type (arg1));
if (TYPE_CODE (type) == TYPE_CODE_FLT)
return value_from_double (type, value_as_double (arg1));
+ else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
+ return value_from_decfloat (type, value_contents (arg1));
else if (is_integral_type (type))
{
- /* Perform integral promotion for ANSI C/C++. FIXME: What about
- FORTRAN and (the deleted) chill ? */
- if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
- type = builtin_type_int;
-
return value_from_longest (type, value_as_long (arg1));
}
else
@@ -1352,22 +1535,31 @@ struct value *
value_neg (struct value *arg1)
{
struct type *type;
- struct type *result_type = value_type (arg1);
arg1 = coerce_ref (arg1);
-
type = check_typedef (value_type (arg1));
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- return value_from_double (result_type, -value_as_double (arg1));
- else if (is_integral_type (type))
+ if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
{
- /* Perform integral promotion for ANSI C/C++. FIXME: What about
- FORTRAN and (the deleted) chill ? */
- if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
- result_type = builtin_type_int;
+ struct value *val = allocate_value (type);
+ int len = TYPE_LENGTH (type);
+ gdb_byte decbytes[16]; /* a decfloat is at most 128 bits long */
+
+ memcpy (decbytes, value_contents (arg1), len);
- return value_from_longest (result_type, -value_as_long (arg1));
+ if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_LITTLE)
+ decbytes[len-1] = decbytes[len - 1] | 0x80;
+ else
+ decbytes[0] = decbytes[0] | 0x80;
+
+ memcpy (value_contents_raw (val), decbytes, len);
+ return val;
+ }
+ else if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ return value_from_double (type, -value_as_double (arg1));
+ else if (is_integral_type (type))
+ {
+ return value_from_longest (type, -value_as_long (arg1));
}
else
{
@@ -1380,21 +1572,14 @@ struct value *
value_complement (struct value *arg1)
{
struct type *type;
- struct type *result_type = value_type (arg1);
arg1 = coerce_ref (arg1);
-
type = check_typedef (value_type (arg1));
if (!is_integral_type (type))
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;
-
- return value_from_longest (result_type, ~value_as_long (arg1));
+ return value_from_longest (type, ~value_as_long (arg1));
}
/* The INDEX'th bit of SET value whose value_type is TYPE,
@@ -1404,24 +1589,25 @@ value_complement (struct value *arg1)
int
value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
{
+ struct gdbarch *gdbarch = get_type_arch (type);
LONGEST low_bound, high_bound;
LONGEST word;
unsigned rel_index;
- struct type *range = TYPE_FIELD_TYPE (type, 0);
+ struct type *range = TYPE_INDEX_TYPE (type);
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));
+ word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1,
+ gdbarch_byte_order (gdbarch));
rel_index %= TARGET_CHAR_BIT;
- if (BITS_BIG_ENDIAN)
+ if (gdbarch_bits_big_endian (gdbarch))
rel_index = TARGET_CHAR_BIT - 1 - rel_index;
return (word >> rel_index) & 1;
}
-struct value *
+int
value_in (struct value *element, struct value *set)
{
int member;
@@ -1440,7 +1626,7 @@ value_in (struct value *element, struct value *set)
value_as_long (element));
if (member < 0)
error (_("First argument of 'IN' not in range"));
- return value_from_longest (LA_BOOL_TYPE, member);
+ return member;
}
void