/* Perform arithmetic and other operations on values, for GDB.
- 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.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
This file is part of GDB.
#include "expression.h"
#include "target.h"
#include "language.h"
-#include "gdb_string.h"
#include "doublest.h"
#include "dfp.h"
#include <math.h>
#include "infcall.h"
-#include "exceptions.h"
/* Define whether or not the C operator '/' truncates towards zero for
- differently signed operands (truncation direction is undefined in C). */
+ differently signed operands (truncation direction is undefined in C). */
#ifndef TRUNCATION_TOWARDS_ZERO
#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
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_ptradd.
-*/
+ helper for value_ptradd. */
static LONGEST
find_size_for_pointer_math (struct type *ptr_type)
gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
- sz = TYPE_LENGTH (ptr_target);
+ sz = type_length_units (ptr_target);
if (sz == 0)
{
if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
sz = 1;
else
{
- char *name;
+ const char *name;
name = TYPE_NAME (ptr_target);
if (name == NULL)
{
struct type *valptrtype;
LONGEST sz;
+ struct value *result;
arg1 = coerce_array (arg1);
valptrtype = check_typedef (value_type (arg1));
sz = find_size_for_pointer_math (valptrtype);
- return value_from_pointer (valptrtype,
- value_as_address (arg1) + sz * arg2);
+ result = value_from_pointer (valptrtype,
+ value_as_address (arg1) + sz * arg2);
+ if (VALUE_LVAL (result) != lval_internalvar)
+ set_value_component_location (result, arg1);
+ return result;
}
/* Given two compatible pointer values ARG1 and ARG2, return the
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."));
+ error (_("First argument of `-' is a pointer and "
+ "second argument is neither\n"
+ "an integer nor a pointer of the same type."));
- sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
+ sz = type_length_units (check_typedef (TYPE_TARGET_TYPE (type1)));
if (sz == 0)
{
warning (_("Type size unknown, assuming 1. "
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). */
+ verbosity is set, warn about invalid indices (but still use them). */
struct value *
value_subscript (struct value *array, LONGEST index)
{
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);
- unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
- struct value *v;
+ ULONGEST elt_size = type_length_units (elt_type);
+ ULONGEST elt_offs = elt_size * (index - lowerbound);
if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
- && elt_offs >= TYPE_LENGTH (array_type)))
- error (_("no such vector element"));
-
- v = allocate_value (elt_type);
- 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);
-
- 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);
+ && elt_offs >= type_length_units (array_type)))
+ {
+ if (type_not_associated (array_type))
+ error (_("no such vector element (vector not associated)"));
+ else if (type_not_allocated (array_type))
+ error (_("no such vector element (vector not allocated)"));
+ else
+ error (_("no such vector element"));
+ }
- 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);
+ if (is_dynamic_type (elt_type))
+ {
+ CORE_ADDR address;
- set_value_offset (v, offset + value_offset (bitstring));
+ address = value_address (array) + elt_offs;
+ elt_type = resolve_dynamic_type (elt_type, NULL, address);
+ }
- return v;
+ return value_from_component (array, elt_type, elt_offs);
}
\f
if (TYPE_CODE (type1) == TYPE_CODE_REF)
type1 = check_typedef (TYPE_TARGET_TYPE (type1));
- type2 = check_typedef (type1);
+ type2 = check_typedef (type2);
if (TYPE_CODE (type2) == TYPE_CODE_REF)
type2 = check_typedef (TYPE_TARGET_TYPE (type2));
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;
- }
+ if (TYPE_CODE (type1) == TYPE_CODE_REF)
+ type1 = check_typedef (TYPE_TARGET_TYPE (type1));
+ return TYPE_CODE (type1) == TYPE_CODE_STRUCT;
}
/* Try to find an operator named OPERATOR which takes NARGS arguments
situations or combinations thereof. */
static struct value *
-value_user_defined_cpp_op (struct value **args, int nargs, char *operator,
- int *static_memfuncp)
+value_user_defined_cpp_op (struct value **args, int nargs, char *oper,
+ int *static_memfuncp, enum noside noside)
{
struct symbol *symp = NULL;
struct value *valp = NULL;
- struct type **arg_types;
- int i;
-
- arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
- /* Prepare list of argument types for overload resolution */
- for (i = 0; i < nargs; i++)
- arg_types[i] = value_type (args[i]);
- find_overload_match (arg_types, nargs, operator, BOTH /* could be method */,
- 0 /* strict match */, &args[0], /* objp */
+ find_overload_match (args, nargs, oper, BOTH /* could be method */,
+ &args[0] /* objp */,
NULL /* pass NULL symbol since symbol is unknown */,
- &valp, &symp, static_memfuncp, 0);
+ &valp, &symp, static_memfuncp, 0, noside);
if (valp)
return valp;
return value_of_variable (symp, 0);
}
- error (_("Could not find %s."), operator);
+ error (_("Could not find %s."), oper);
}
/* Lookup user defined operator NAME. Return a value representing the
static struct value *
value_user_defined_op (struct value **argp, struct value **args, char *name,
- int *static_memfuncp, int nargs)
+ int *static_memfuncp, int nargs, enum noside noside)
{
struct value *result = NULL;
if (current_language->la_language == language_cplus)
- result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp);
+ {
+ result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp,
+ noside);
+ }
else
result = value_struct_elt (argp, args, name, static_memfuncp,
"structure");
argvec[2] = arg2;
argvec[3] = 0;
- /* make the right function name up */
+ /* Make the right function name up. */
strcpy (tstr, "operator__");
ptr = tstr + 8;
switch (op)
}
argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
- &static_memfuncp, 2);
+ &static_memfuncp, 2, noside);
if (argvec[0])
{
argvec[1] = argvec[0];
argvec++;
}
+ if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
+ {
+ /* Static xmethods are not supported yet. */
+ gdb_assert (static_memfuncp == 0);
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ struct type *return_type
+ = result_type_of_xmethod (argvec[0], 2, argvec + 1);
+
+ if (return_type == NULL)
+ error (_("Xmethod is missing return type."));
+ return value_zero (return_type, VALUE_LVAL (arg1));
+ }
+ return call_xmethod (argvec[0], 2, argvec + 1);
+ }
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct 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);
+ return call_function_by_hand (argvec[0], 2 - static_memfuncp,
+ argvec + 1);
}
- error (_("member function %s not found"), tstr);
+ throw_error (NOT_FOUND_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.
+ 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++). */
{
struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
struct value **argvec;
- char *ptr, *mangle_ptr;
+ char *ptr;
char tstr[13], mangle_tstr[13];
int static_memfuncp, nargs;
nargs = 1;
- /* make the right function name up */
+ /* Make the right function name up. */
strcpy (tstr, "operator__");
ptr = tstr + 8;
strcpy (mangle_tstr, "__");
- mangle_ptr = mangle_tstr + 2;
switch (op)
{
case UNOP_PREINCREMENT:
case UNOP_IND:
strcpy (ptr, "*");
break;
+ case STRUCTOP_PTR:
+ strcpy (ptr, "->");
+ break;
default:
error (_("Invalid unary operation specified."));
}
argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
- &static_memfuncp, nargs);
+ &static_memfuncp, nargs, noside);
if (argvec[0])
{
nargs --;
argvec++;
}
+ if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
+ {
+ /* Static xmethods are not supported yet. */
+ gdb_assert (static_memfuncp == 0);
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ struct type *return_type
+ = result_type_of_xmethod (argvec[0], 1, argvec + 1);
+
+ if (return_type == NULL)
+ error (_("Xmethod is missing return type."));
+ return value_zero (return_type, VALUE_LVAL (arg1));
+ }
+ return call_xmethod (argvec[0], 1, argvec + 1);
+ }
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type;
}
return call_function_by_hand (argvec[0], nargs, argvec + 1);
}
- error (_("member function %s not found"), tstr);
+ throw_error (NOT_FOUND_ERROR,
+ _("member function %s not found"), tstr);
+
return 0; /* For lint -- never reached */
}
\f
values of length 1.
(3) Character values are also allowed and are treated as character
- string values of length 1.
- */
+ string values of length 1. */
struct value *
value_concat (struct value *arg1, struct value *arg2)
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. */
+ repeated. */
if (TYPE_CODE (type2) == TYPE_CODE_INT)
{
inval2 = arg2;
}
- /* Now process the input values. */
+ /* Now process the input values. */
if (TYPE_CODE (type1) == TYPE_CODE_INT)
{
/* We have a repeat count. Validate the second value and then
- construct a value repeated that many times. */
+ construct a value repeated that many times. */
if (TYPE_CODE (type2) == TYPE_CODE_STRING
|| TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
+ struct cleanup *back_to;
+
count = longest_to_int (value_as_long (inval1));
inval2len = TYPE_LENGTH (type2);
- ptr = (char *) alloca (count * inval2len);
+ ptr = (char *) xmalloc (count * inval2len);
+ back_to = make_cleanup (xfree, ptr);
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
char_type = type2;
}
}
outval = value_string (ptr, count * inval2len, char_type);
+ do_cleanups (back_to);
}
- else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
- || TYPE_CODE (type2) == TYPE_CODE_BOOL)
+ else if (TYPE_CODE (type2) == TYPE_CODE_BOOL)
{
- error (_("unimplemented support for bitstring/boolean repeats"));
+ error (_("unimplemented support for boolean repeats"));
}
else
{
else if (TYPE_CODE (type1) == TYPE_CODE_STRING
|| TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
- /* We have two character strings to concatenate. */
+ struct cleanup *back_to;
+
+ /* We have two character strings to concatenate. */
if (TYPE_CODE (type2) != TYPE_CODE_STRING
&& TYPE_CODE (type2) != TYPE_CODE_CHAR)
{
}
inval1len = TYPE_LENGTH (type1);
inval2len = TYPE_LENGTH (type2);
- ptr = (char *) alloca (inval1len + inval2len);
+ ptr = (char *) xmalloc (inval1len + inval2len);
+ back_to = make_cleanup (xfree, ptr);
if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
char_type = type1;
memcpy (ptr + inval1len, value_contents (inval2), inval2len);
}
outval = value_string (ptr, inval1len + inval2len, char_type);
+ do_cleanups (back_to);
}
- else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
- || TYPE_CODE (type1) == TYPE_CODE_BOOL)
+ else if (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)
+ /* We have two bitstrings to concatenate. */
+ if (TYPE_CODE (type2) != TYPE_CODE_BOOL)
{
- error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans."));
+ error (_("Booleans can only be concatenated "
+ "with other bitstrings or booleans."));
}
- error (_("unimplemented support for bitstring/boolean concatenation."));
+ error (_("unimplemented support for boolean concatenation."));
}
else
{
- /* We don't know how to concatenate these operands. */
+ /* We don't know how to concatenate these operands. */
error (_("illegal operands for concatenation."));
}
return (outval);
\f
/* 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)
{
}
else
{
- /* The Russian Peasant's Algorithm */
+ /* The Russian Peasant's Algorithm. */
LONGEST v;
v = 1;
/* 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)
{
}
else
{
- /* The Russian Peasant's Algorithm */
+ /* The Russian Peasant's Algorithm. */
ULONGEST v;
v = 1;
/* 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."));
+ error (_("Mixing decimal floating types with "
+ "other floating types is not allowed."));
/* Obtain decimal value of arg1, converting from other types
if necessary. */
Does not support addition and subtraction on pointers;
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)
+static struct value *
+scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
{
struct value *val;
struct type *type1, *type2, *result_type;
errno = 0;
v = pow (v1, v2);
if (errno)
- error (_("Cannot perform exponentiation: %s"), safe_strerror (errno));
+ error (_("Cannot perform exponentiation: %s"),
+ safe_strerror (errno));
break;
case BINOP_MIN:
case BINOP_MOD:
/* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
- v1 mod 0 has a defined value, v1. */
+ v1 mod 0 has a defined value, v1. */
if (v2 == 0)
{
v = v1;
else
{
v = v1 / v2;
- /* Note floor(v1/v2) == v1/v2 for unsigned. */
+ /* Note floor(v1/v2) == v1/v2 for unsigned. */
v = v1 - (v2 * v);
}
break;
case BINOP_MOD:
/* Knuth 1.2.4, integer only. Note that unlike the C '%' op,
- X mod 0 has a defined value, X. */
+ X mod 0 has a defined value, X. */
if (v2 == 0)
{
v = v1;
else
{
v = v1 / v2;
- /* Compute floor. */
+ /* Compute floor. */
if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
{
v--;
return val;
}
+
+/* Widen a scalar value SCALAR_VALUE to vector type VECTOR_TYPE by
+ replicating SCALAR_VALUE for each element of the vector. Only scalar
+ types that can be cast to the type of one element of the vector are
+ acceptable. The newly created vector value is returned upon success,
+ otherwise an error is thrown. */
+
+struct value *
+value_vector_widen (struct value *scalar_value, struct type *vector_type)
+{
+ /* Widen the scalar to a vector. */
+ struct type *eltype, *scalar_type;
+ struct value *val, *elval;
+ LONGEST low_bound, high_bound;
+ int i;
+
+ vector_type = check_typedef (vector_type);
+
+ gdb_assert (TYPE_CODE (vector_type) == TYPE_CODE_ARRAY
+ && TYPE_VECTOR (vector_type));
+
+ if (!get_array_bounds (vector_type, &low_bound, &high_bound))
+ error (_("Could not determine the vector bounds"));
+
+ eltype = check_typedef (TYPE_TARGET_TYPE (vector_type));
+ elval = value_cast (eltype, scalar_value);
+
+ scalar_type = check_typedef (value_type (scalar_value));
+
+ /* If we reduced the length of the scalar then check we didn't loose any
+ important bits. */
+ if (TYPE_LENGTH (eltype) < TYPE_LENGTH (scalar_type)
+ && !value_equal (elval, scalar_value))
+ error (_("conversion of scalar to vector involves truncation"));
+
+ val = allocate_value (vector_type);
+ for (i = 0; i < high_bound - low_bound + 1; i++)
+ /* Duplicate the contents of elval into the destination vector. */
+ memcpy (value_contents_writeable (val) + (i * TYPE_LENGTH (eltype)),
+ value_contents_all (elval), TYPE_LENGTH (eltype));
+
+ return val;
+}
+
+/* Performs a binary operation on two vector operands by calling scalar_binop
+ for each pair of vector components. */
+
+static struct value *
+vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
+{
+ struct value *val, *tmp, *mark;
+ struct type *type1, *type2, *eltype1, *eltype2;
+ int t1_is_vec, t2_is_vec, elsize, i;
+ LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
+
+ type1 = check_typedef (value_type (val1));
+ type2 = check_typedef (value_type (val2));
+
+ t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
+ && TYPE_VECTOR (type1)) ? 1 : 0;
+ t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
+ && TYPE_VECTOR (type2)) ? 1 : 0;
+
+ if (!t1_is_vec || !t2_is_vec)
+ error (_("Vector operations are only supported among vectors"));
+
+ if (!get_array_bounds (type1, &low_bound1, &high_bound1)
+ || !get_array_bounds (type2, &low_bound2, &high_bound2))
+ error (_("Could not determine the vector bounds"));
+
+ eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
+ eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
+ elsize = TYPE_LENGTH (eltype1);
+
+ if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
+ || elsize != TYPE_LENGTH (eltype2)
+ || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
+ || low_bound1 != low_bound2 || high_bound1 != high_bound2)
+ error (_("Cannot perform operation on vectors with different types"));
+
+ val = allocate_value (type1);
+ mark = value_mark ();
+ for (i = 0; i < high_bound1 - low_bound1 + 1; i++)
+ {
+ tmp = value_binop (value_subscript (val1, i),
+ value_subscript (val2, i), op);
+ memcpy (value_contents_writeable (val) + i * elsize,
+ value_contents_all (tmp),
+ elsize);
+ }
+ value_free_to_mark (mark);
+
+ return val;
+}
+
+/* Perform a binary operation on two operands. */
+
+struct value *
+value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
+{
+ struct value *val;
+ struct type *type1 = check_typedef (value_type (arg1));
+ struct type *type2 = check_typedef (value_type (arg2));
+ int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
+ && TYPE_VECTOR (type1));
+ int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
+ && TYPE_VECTOR (type2));
+
+ if (!t1_is_vec && !t2_is_vec)
+ val = scalar_binop (arg1, arg2, op);
+ else if (t1_is_vec && t2_is_vec)
+ val = vector_binop (arg1, arg2, op);
+ else
+ {
+ /* Widen the scalar operand to a vector. */
+ struct value **v = t1_is_vec ? &arg2 : &arg1;
+ struct type *t = t1_is_vec ? type2 : type1;
+
+ if (TYPE_CODE (t) != TYPE_CODE_FLT
+ && TYPE_CODE (t) != TYPE_CODE_DECFLOAT
+ && !is_integral_type (t))
+ error (_("Argument to operation not a number or boolean."));
+
+ /* Replicate the scalar value to make a vector value. */
+ *v = value_vector_widen (*v, t1_is_vec ? type1 : type2);
+
+ val = vector_binop (arg1, arg2, op);
+ }
+
+ return val;
+}
\f
/* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
}
/* Perform a comparison on two string values (whose content are not
- necessarily null terminated) based on their length */
+ necessarily null terminated) based on their length. */
static int
value_strcmp (struct value *arg1, struct value *arg2)
else
{
error (_("Invalid type combination in equality test."));
- return 0; /* For lint -- never reached */
+ return 0; /* For lint -- never reached. */
}
}
{
return value_from_longest (type, value_as_long (arg1));
}
+ else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+ {
+ struct value *val = allocate_value (type);
+
+ memcpy (value_contents_raw (val), value_contents (arg1),
+ TYPE_LENGTH (type));
+ return val;
+ }
else
{
- error ("Argument to positive operation not a number.");
- return 0; /* For lint -- never reached */
+ error (_("Argument to positive operation not a number."));
+ return 0; /* For lint -- never reached. */
}
}
{
struct value *val = allocate_value (type);
int len = TYPE_LENGTH (type);
- gdb_byte decbytes[16]; /* a decfloat is at most 128 bits long */
+ gdb_byte decbytes[16]; /* a decfloat is at most 128 bits long. */
memcpy (decbytes, value_contents (arg1), len);
{
return value_from_longest (type, -value_as_long (arg1));
}
+ else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+ {
+ struct value *tmp, *val = allocate_value (type);
+ struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+ int i;
+ LONGEST low_bound, high_bound;
+
+ if (!get_array_bounds (type, &low_bound, &high_bound))
+ error (_("Could not determine the vector bounds"));
+
+ for (i = 0; i < high_bound - low_bound + 1; i++)
+ {
+ tmp = value_neg (value_subscript (arg1, i));
+ memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
+ value_contents_all (tmp), TYPE_LENGTH (eltype));
+ }
+ return val;
+ }
else
{
error (_("Argument to negate operation not a number."));
- return 0; /* For lint -- never reached */
+ return 0; /* For lint -- never reached. */
}
}
value_complement (struct value *arg1)
{
struct type *type;
+ struct value *val;
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."));
+ if (is_integral_type (type))
+ val = value_from_longest (type, ~value_as_long (arg1));
+ else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+ {
+ struct value *tmp;
+ struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+ int i;
+ LONGEST low_bound, high_bound;
+
+ if (!get_array_bounds (type, &low_bound, &high_bound))
+ error (_("Could not determine the vector bounds"));
+
+ val = allocate_value (type);
+ for (i = 0; i < high_bound - low_bound + 1; i++)
+ {
+ tmp = value_complement (value_subscript (arg1, i));
+ memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
+ value_contents_all (tmp), TYPE_LENGTH (eltype));
+ }
+ }
+ else
+ error (_("Argument to complement operation not an integer, boolean."));
- return value_from_longest (type, ~value_as_long (arg1));
+ return val;
}
\f
/* 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. */
+ Return -1 if out of range, -2 other error. */
int
value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
projects / deliverable / binutils-gdb.git / blobdiff