X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fvalarith.c;h=140ef448137ec58fedb7297d59a144b90434e2f6;hb=7c80aab93666727965c2d5d6e17b1338d88293e0;hp=a5779a3aff978be2653d0667739d343454f0de5b;hpb=3d967001ecd3b325fc39d7f53ebf7054d1ecd503;p=binutils-gdb.git diff --git a/gdb/valarith.c b/gdb/valarith.c index a5779a3aff9..140ef448137 100644 --- a/gdb/valarith.c +++ b/gdb/valarith.c @@ -1,6 +1,6 @@ /* Perform arithmetic and other operations on values, for GDB. - Copyright (C) 1986-2020 Free Software Foundation, Inc. + Copyright (C) 1986-2021 Free Software Foundation, Inc. This file is part of GDB. @@ -120,7 +120,7 @@ value_ptrdiff (struct value *arg1, struct value *arg2) if (sz == 0) { warning (_("Type size unknown, assuming 1. " - "Try casting to a known type, or void *.")); + "Try casting to a known type, or void *.")); sz = 1; } @@ -140,7 +140,7 @@ value_ptrdiff (struct value *arg1, struct value *arg2) struct value * value_subscript (struct value *array, LONGEST index) { - int c_style = current_language->c_style_arrays; + bool c_style = current_language->c_style_arrays_p (); struct type *tarray; array = coerce_ref (array); @@ -150,25 +150,33 @@ value_subscript (struct value *array, LONGEST index) || tarray->code () == TYPE_CODE_STRING) { struct type *range_type = tarray->index_type (); - LONGEST lowerbound, upperbound; + gdb::optional lowerbound = get_discrete_low_bound (range_type); + if (!lowerbound.has_value ()) + lowerbound = 0; - get_discrete_bounds (range_type, &lowerbound, &upperbound); if (VALUE_LVAL (array) != lval_memory) - return value_subscripted_rvalue (array, index, lowerbound); + return value_subscripted_rvalue (array, index, *lowerbound); - if (c_style == 0) + if (!c_style) { - if (index >= lowerbound && index <= upperbound) - return value_subscripted_rvalue (array, index, lowerbound); + gdb::optional upperbound + = get_discrete_high_bound (range_type); + + if (!upperbound.has_value ()) + upperbound = 0; + + if (index >= *lowerbound && index <= *upperbound) + 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) + if (*upperbound > -1) warning (_("array or string index out of range")); /* fall doing C stuff */ - c_style = 1; + c_style = true; } - index -= lowerbound; + index -= *lowerbound; array = value_coerce_array (array); } @@ -191,28 +199,29 @@ value_subscripted_rvalue (struct value *array, LONGEST index, LONGEST lowerbound /* Fetch the bit stride and convert it to a byte stride, assuming 8 bits in a byte. */ - LONGEST stride = TYPE_ARRAY_BIT_STRIDE (array_type); + LONGEST stride = array_type->bit_stride (); if (stride != 0) { - struct gdbarch *arch = get_type_arch (elt_type); + struct gdbarch *arch = elt_type->arch (); int unit_size = gdbarch_addressable_memory_unit_size (arch); elt_size = stride / (unit_size * 8); } LONGEST elt_offs = elt_size * (index - lowerbound); + bool array_upper_bound_undefined + = array_type->bounds ()->high.kind () == PROP_UNDEFINED; if (index < lowerbound - || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type) - && elt_offs >= type_length_units (array_type)) - || (VALUE_LVAL (array) != lval_memory - && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type))) + || (!array_upper_bound_undefined + && elt_offs >= type_length_units (array_type)) + || (VALUE_LVAL (array) != lval_memory && array_upper_bound_undefined)) { if (type_not_associated (array_type)) - error (_("no such vector element (vector not associated)")); + error (_("no such vector element (vector not associated)")); else if (type_not_allocated (array_type)) - error (_("no such vector element (vector not allocated)")); + error (_("no such vector element (vector not allocated)")); else - error (_("no such vector element")); + error (_("no such vector element")); } if (is_dynamic_type (elt_type)) @@ -294,16 +303,16 @@ unop_user_defined_p (enum exp_opcode op, struct value *arg1) static struct value * value_user_defined_cpp_op (gdb::array_view args, char *oper, - int *static_memfuncp, enum noside noside) + int *static_memfuncp, enum noside noside) { struct symbol *symp = NULL; struct value *valp = NULL; find_overload_match (args, oper, BOTH /* could be method */, - &args[0] /* objp */, - NULL /* pass NULL symbol since symbol is unknown */, - &valp, &symp, static_memfuncp, 0, noside); + &args[0] /* objp */, + NULL /* pass NULL symbol since symbol is unknown */, + &valp, &symp, static_memfuncp, 0, noside); if (valp) return valp; @@ -311,8 +320,8 @@ value_user_defined_cpp_op (gdb::array_view args, char *oper, if (symp) { /* This is a non member function and does not - expect a reference as its first argument - rather the explicit structure. */ + expect a reference as its first argument + rather the explicit structure. */ args[0] = value_ind (args[0]); return value_of_variable (symp, 0); } @@ -335,7 +344,7 @@ value_user_defined_op (struct value **argp, gdb::array_view args, noside); } else - result = value_struct_elt (argp, args.data (), name, static_memfuncp, + result = value_struct_elt (argp, args, name, static_memfuncp, "structure"); return result; @@ -518,7 +527,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op, argvec.slice (1, 2 - static_memfuncp)); } throw_error (NOT_FOUND_ERROR, - _("member function %s not found"), tstr); + _("member function %s not found"), tstr); } /* We know that arg1 is a structure, so try to find a unary user @@ -530,7 +539,7 @@ 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 gdbarch *gdbarch = value_type (arg1)->arch (); char *ptr; char tstr[13], mangle_tstr[13]; int static_memfuncp, nargs; @@ -632,7 +641,7 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside) argvec.slice (1, nargs)); } throw_error (NOT_FOUND_ERROR, - _("member function %s not found"), tstr); + _("member function %s not found"), tstr); } @@ -695,7 +704,7 @@ value_concat (struct value *arg1, struct value *arg2) if (type1->code () == 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 (type2->code () == TYPE_CODE_STRING || type2->code () == TYPE_CODE_CHAR) { @@ -707,7 +716,7 @@ value_concat (struct value *arg1, struct value *arg2) char_type = type2; inchar = (char) unpack_long (type2, - value_contents (inval2)); + value_contents (inval2).data ()); for (idx = 0; idx < count; idx++) { ptr[idx] = inchar; @@ -718,10 +727,8 @@ value_concat (struct value *arg1, struct value *arg2) char_type = TYPE_TARGET_TYPE (type2); for (idx = 0; idx < count; idx++) - { - memcpy (&ptr[idx * inval2len], value_contents (inval2), - inval2len); - } + memcpy (&ptr[idx * inval2len], value_contents (inval2).data (), + inval2len); } outval = value_string (ptr.data (), count * inval2len, char_type); } @@ -750,22 +757,22 @@ value_concat (struct value *arg1, struct value *arg2) { char_type = type1; - ptr[0] = (char) unpack_long (type1, value_contents (inval1)); + ptr[0] = (char) unpack_long (type1, value_contents (inval1).data ()); } else { char_type = TYPE_TARGET_TYPE (type1); - memcpy (ptr.data (), value_contents (inval1), inval1len); + memcpy (ptr.data (), value_contents (inval1).data (), inval1len); } if (type2->code () == TYPE_CODE_CHAR) { ptr[inval1len] = - (char) unpack_long (type2, value_contents (inval2)); + (char) unpack_long (type2, value_contents (inval2).data ()); } else { - memcpy (&ptr[inval1len], value_contents (inval2), inval2len); + memcpy (&ptr[inval1len], value_contents (inval2).data (), inval2len); } outval = value_string (ptr.data (), inval1len + inval2len, char_type); } @@ -818,37 +825,6 @@ integer_pow (LONGEST v1, LONGEST v2) } } -/* 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 argument values for binary operation, converting from other types if one of them is not floating point. */ static void @@ -877,12 +853,12 @@ value_args_as_target_float (struct value *arg1, struct value *arg2, if (is_floating_type (type1)) { *eff_type_x = type1; - memcpy (x, value_contents (arg1), TYPE_LENGTH (type1)); + memcpy (x, value_contents (arg1).data (), TYPE_LENGTH (type1)); } else if (is_integral_type (type1)) { *eff_type_x = type2; - if (TYPE_UNSIGNED (type1)) + if (type1->is_unsigned ()) target_float_from_ulongest (x, *eff_type_x, value_as_long (arg1)); else target_float_from_longest (x, *eff_type_x, value_as_long (arg1)); @@ -896,12 +872,12 @@ value_args_as_target_float (struct value *arg1, struct value *arg2, if (is_floating_type (type2)) { *eff_type_y = type2; - memcpy (y, value_contents (arg2), TYPE_LENGTH (type2)); + memcpy (y, value_contents (arg2).data (), TYPE_LENGTH (type2)); } else if (is_integral_type (type2)) { *eff_type_y = type1; - if (TYPE_UNSIGNED (type2)) + if (type2->is_unsigned ()) target_float_from_ulongest (y, *eff_type_y, value_as_long (arg2)); else target_float_from_longest (y, *eff_type_y, value_as_long (arg2)); @@ -911,6 +887,119 @@ value_args_as_target_float (struct value *arg1, struct value *arg2, type2->name ()); } +/* Assuming at last one of ARG1 or ARG2 is a fixed point value, + perform the binary operation OP on these two operands, and return + the resulting value (also as a fixed point). */ + +static struct value * +fixed_point_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) +{ + struct type *type1 = check_typedef (value_type (arg1)); + struct type *type2 = check_typedef (value_type (arg2)); + const struct language_defn *language = current_language; + + struct gdbarch *gdbarch = type1->arch (); + struct value *val; + + gdb_mpq v1, v2, res; + + gdb_assert (is_fixed_point_type (type1) || is_fixed_point_type (type2)); + if (op == BINOP_MUL || op == BINOP_DIV) + { + v1 = value_to_gdb_mpq (arg1); + v2 = value_to_gdb_mpq (arg2); + + /* The code below uses TYPE1 for the result type, so make sure + it is set properly. */ + if (!is_fixed_point_type (type1)) + type1 = type2; + } + else + { + if (!is_fixed_point_type (type1)) + { + arg1 = value_cast (type2, arg1); + type1 = type2; + } + if (!is_fixed_point_type (type2)) + { + arg2 = value_cast (type1, arg2); + type2 = type1; + } + + v1.read_fixed_point (gdb::make_array_view (value_contents (arg1).data (), + TYPE_LENGTH (type1)), + type_byte_order (type1), type1->is_unsigned (), + type1->fixed_point_scaling_factor ()); + v2.read_fixed_point (gdb::make_array_view (value_contents (arg2).data (), + TYPE_LENGTH (type2)), + type_byte_order (type2), type2->is_unsigned (), + type2->fixed_point_scaling_factor ()); + } + + auto fixed_point_to_value = [type1] (const gdb_mpq &fp) + { + value *fp_val = allocate_value (type1); + + fp.write_fixed_point + (gdb::make_array_view (value_contents_raw (fp_val).data (), + TYPE_LENGTH (type1)), + type_byte_order (type1), + type1->is_unsigned (), + type1->fixed_point_scaling_factor ()); + + return fp_val; + }; + + switch (op) + { + case BINOP_ADD: + mpq_add (res.val, v1.val, v2.val); + val = fixed_point_to_value (res); + break; + + case BINOP_SUB: + mpq_sub (res.val, v1.val, v2.val); + val = fixed_point_to_value (res); + break; + + case BINOP_MIN: + val = fixed_point_to_value (mpq_cmp (v1.val, v2.val) < 0 ? v1 : v2); + break; + + case BINOP_MAX: + val = fixed_point_to_value (mpq_cmp (v1.val, v2.val) > 0 ? v1 : v2); + break; + + case BINOP_MUL: + mpq_mul (res.val, v1.val, v2.val); + val = fixed_point_to_value (res); + break; + + case BINOP_DIV: + if (mpq_sgn (v2.val) == 0) + error (_("Division by zero")); + mpq_div (res.val, v1.val, v2.val); + val = fixed_point_to_value (res); + break; + + case BINOP_EQUAL: + val = value_from_ulongest (language_bool_type (language, gdbarch), + mpq_cmp (v1.val, v2.val) == 0 ? 1 : 0); + break; + + case BINOP_LESS: + val = value_from_ulongest (language_bool_type (language, gdbarch), + mpq_cmp (v1.val, v2.val) < 0 ? 1 : 0); + break; + + default: + error (_("Integer-only operation on fixed point number.")); + } + + return val; +} + /* A helper function that finds the type to use for a binary operation involving TYPE1 and TYPE2. */ @@ -939,9 +1028,9 @@ promotion_type (struct type *type1, struct type *type2) result_type = type1; else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1)) result_type = type2; - else if (TYPE_UNSIGNED (type1)) + else if (type1->is_unsigned ()) result_type = type1; - else if (TYPE_UNSIGNED (type2)) + else if (type2->is_unsigned ()) result_type = type2; else result_type = type1; @@ -985,6 +1074,9 @@ complex_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) struct type *comp_type = promotion_type (value_type (arg1_real), value_type (arg2_real)); + if (!can_create_complex_type (comp_type)) + error (_("Argument to complex arithmetic operation not supported.")); + arg1_real = value_cast (comp_type, arg1_real); arg1_imag = value_cast (comp_type, arg1_imag); arg2_real = value_cast (comp_type, arg2_real); @@ -1084,10 +1176,17 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) || type2->code () == TYPE_CODE_COMPLEX) return complex_binop (arg1, arg2, op); - if ((!is_floating_value (arg1) && !is_integral_type (type1)) - || (!is_floating_value (arg2) && !is_integral_type (type2))) + if ((!is_floating_value (arg1) + && !is_integral_type (type1) + && !is_fixed_point_type (type1)) + || (!is_floating_value (arg2) + && !is_integral_type (type2) + && !is_fixed_point_type (type2))) error (_("Argument to arithmetic operation not a number or boolean.")); + if (is_fixed_point_type (type1) || is_fixed_point_type (type2)) + return fixed_point_binop (arg1, arg2, op); + if (is_floating_type (type1) || is_floating_type (type2)) { result_type = promotion_type (type1, type2); @@ -1103,7 +1202,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) v2.data (), &eff_type_v2); target_float_binop (op, v1.data (), eff_type_v1, v2.data (), eff_type_v2, - value_contents_raw (val), result_type); + value_contents_raw (val).data (), result_type); } else if (type1->code () == TYPE_CODE_BOOL || type2->code () == TYPE_CODE_BOOL) @@ -1125,14 +1224,14 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) case BINOP_BITWISE_XOR: v = v1 ^ v2; - break; - - case BINOP_EQUAL: - v = v1 == v2; - break; - - case BINOP_NOTEQUAL: - v = v1 != v2; + break; + + case BINOP_EQUAL: + v = v1 == v2; + break; + + case BINOP_NOTEQUAL: + v = v1 != v2; break; default: @@ -1142,7 +1241,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) result_type = type1; val = allocate_value (result_type); - store_signed_integer (value_contents_raw (val), + store_signed_integer (value_contents_raw (val).data (), TYPE_LENGTH (result_type), type_byte_order (result_type), v); @@ -1161,7 +1260,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) else result_type = promotion_type (type1, type2); - if (TYPE_UNSIGNED (result_type)) + if (result_type->is_unsigned ()) { LONGEST v2_signed = value_as_long (arg2); ULONGEST v1, v2, v = 0; @@ -1192,7 +1291,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) break; case BINOP_EXP: - v = uinteger_pow (v1, v2_signed); + v = uinteger_pow (v1, v2_signed); break; case BINOP_REM: @@ -1204,7 +1303,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) 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; @@ -1257,9 +1356,9 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) v = v1 == v2; break; - case BINOP_NOTEQUAL: - v = v1 != v2; - break; + case BINOP_NOTEQUAL: + v = v1 != v2; + break; case BINOP_LESS: v = v1 < v2; @@ -1282,7 +1381,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) } val = allocate_value (result_type); - store_unsigned_integer (value_contents_raw (val), + store_unsigned_integer (value_contents_raw (val).data (), TYPE_LENGTH (value_type (val)), type_byte_order (result_type), v); @@ -1314,10 +1413,10 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) v = v1 / v2; else error (_("Division by zero")); - break; + break; case BINOP_EXP: - v = integer_pow (v1, v2); + v = integer_pow (v1, v2); break; case BINOP_REM: @@ -1329,7 +1428,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) 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; @@ -1386,9 +1485,9 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) v = v1 == v2; break; - case BINOP_NOTEQUAL: - v = v1 != v2; - break; + case BINOP_NOTEQUAL: + v = v1 != v2; + break; case BINOP_LESS: v = v1 < v2; @@ -1411,7 +1510,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) } val = allocate_value (result_type); - store_signed_integer (value_contents_raw (val), + store_signed_integer (value_contents_raw (val).data (), TYPE_LENGTH (value_type (val)), type_byte_order (result_type), v); @@ -1439,7 +1538,7 @@ value_vector_widen (struct value *scalar_value, struct type *vector_type) vector_type = check_typedef (vector_type); gdb_assert (vector_type->code () == TYPE_CODE_ARRAY - && TYPE_VECTOR (vector_type)); + && vector_type->is_vector ()); if (!get_array_bounds (vector_type, &low_bound, &high_bound)) error (_("Could not determine the vector bounds")); @@ -1458,8 +1557,8 @@ value_vector_widen (struct value *scalar_value, struct type *vector_type) 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)); + memcpy (value_contents_writeable (val).data () + (i * TYPE_LENGTH (eltype)), + value_contents_all (elval).data (), TYPE_LENGTH (eltype)); return val; } @@ -1479,9 +1578,9 @@ vector_binop (struct value *val1, struct value *val2, enum exp_opcode op) type2 = check_typedef (value_type (val2)); t1_is_vec = (type1->code () == TYPE_CODE_ARRAY - && TYPE_VECTOR (type1)) ? 1 : 0; + && type1->is_vector ()) ? 1 : 0; t2_is_vec = (type2->code () == TYPE_CODE_ARRAY - && TYPE_VECTOR (type2)) ? 1 : 0; + && type2->is_vector ()) ? 1 : 0; if (!t1_is_vec || !t2_is_vec) error (_("Vector operations are only supported among vectors")); @@ -1496,7 +1595,7 @@ vector_binop (struct value *val1, struct value *val2, enum exp_opcode op) if (eltype1->code () != eltype2->code () || elsize != TYPE_LENGTH (eltype2) - || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2) + || eltype1->is_unsigned () != eltype2->is_unsigned () || low_bound1 != low_bound2 || high_bound1 != high_bound2) error (_("Cannot perform operation on vectors with different types")); @@ -1506,8 +1605,8 @@ vector_binop (struct value *val1, struct value *val2, enum exp_opcode op) { tmp = value_binop (value_subscript (val1, i), value_subscript (val2, i), op); - memcpy (value_contents_writeable (val) + i * elsize, - value_contents_all (tmp), + memcpy (value_contents_writeable (val).data () + i * elsize, + value_contents_all (tmp).data (), elsize); } value_free_to_mark (mark); @@ -1524,9 +1623,9 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) struct type *type1 = check_typedef (value_type (arg1)); struct type *type2 = check_typedef (value_type (arg2)); int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY - && TYPE_VECTOR (type1)); + && type1->is_vector ()); int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY - && TYPE_VECTOR (type2)); + && type2->is_vector ()); if (!t1_is_vec && !t2_is_vec) val = scalar_binop (arg1, arg2, op); @@ -1552,9 +1651,9 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) return val; } -/* Simulate the C operator ! -- return 1 if ARG1 contains zero. */ +/* See value.h. */ -int +bool value_logical_not (struct value *arg1) { int len; @@ -1565,10 +1664,10 @@ value_logical_not (struct value *arg1) type1 = check_typedef (value_type (arg1)); if (is_floating_value (arg1)) - return target_float_is_zero (value_contents (arg1), type1); + return target_float_is_zero (value_contents (arg1).data (), type1); len = TYPE_LENGTH (type1); - p = value_contents (arg1); + p = value_contents (arg1).data (); while (--len >= 0) { @@ -1587,18 +1686,18 @@ value_strcmp (struct value *arg1, struct value *arg2) { int len1 = TYPE_LENGTH (value_type (arg1)); int len2 = TYPE_LENGTH (value_type (arg2)); - const gdb_byte *s1 = value_contents (arg1); - const gdb_byte *s2 = value_contents (arg2); + const gdb_byte *s1 = value_contents (arg1).data (); + const gdb_byte *s2 = value_contents (arg2).data (); int i, len = len1 < len2 ? len1 : len2; for (i = 0; i < len; i++) { if (s1[i] < s2[i]) - return -1; + return -1; else if (s1[i] > s2[i]) - return 1; + return 1; else - continue; + continue; } if (len1 < len2) @@ -1663,8 +1762,8 @@ value_equal (struct value *arg1, struct value *arg2) && ((len = (int) TYPE_LENGTH (type1)) == (int) TYPE_LENGTH (type2))) { - p1 = value_contents (arg1); - p2 = value_contents (arg2); + p1 = value_contents (arg1).data (); + p2 = value_contents (arg2).data (); while (--len >= 0) { if (*p1++ != *p2++) @@ -1694,7 +1793,8 @@ value_equal_contents (struct value *arg1, struct value *arg2) return (type1->code () == type2->code () && TYPE_LENGTH (type1) == TYPE_LENGTH (type2) - && memcmp (value_contents (arg1), value_contents (arg2), + && memcmp (value_contents (arg1).data (), + value_contents (arg2).data (), TYPE_LENGTH (type1)) == 0); } @@ -1719,7 +1819,8 @@ value_less (struct value *arg1, struct value *arg2) is_int1 = is_integral_type (type1); is_int2 = is_integral_type (type2); - if (is_int1 && is_int2) + if ((is_int1 && is_int2) + || (is_fixed_point_type (type1) && is_fixed_point_type (type2))) return longest_to_int (value_as_long (value_binop (arg1, arg2, BINOP_LESS))); else if ((is_floating_value (arg1) || is_int1) @@ -1766,9 +1867,9 @@ value_pos (struct value *arg1) type = check_typedef (value_type (arg1)); if (is_integral_type (type) || is_floating_value (arg1) - || (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)) + || (type->code () == TYPE_CODE_ARRAY && type->is_vector ()) || type->code () == TYPE_CODE_COMPLEX) - return value_from_contents (type, value_contents (arg1)); + return value_from_contents (type, value_contents (arg1).data ()); else error (_("Argument to positive operation not a number.")); } @@ -1783,7 +1884,9 @@ value_neg (struct value *arg1) if (is_integral_type (type) || is_floating_type (type)) return value_binop (value_from_longest (type, 0), arg1, BINOP_SUB); - else if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)) + else if (is_fixed_point_type (type)) + return value_binop (value_zero (type, not_lval), arg1, BINOP_SUB); + else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ()) { struct value *tmp, *val = allocate_value (type); struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type)); @@ -1796,8 +1899,9 @@ value_neg (struct value *arg1) 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)); + memcpy ((value_contents_writeable (val).data () + + i * TYPE_LENGTH (eltype)), + value_contents_all (tmp).data (), TYPE_LENGTH (eltype)); } return val; } @@ -1825,7 +1929,7 @@ value_complement (struct value *arg1) if (is_integral_type (type)) val = value_from_longest (type, ~value_as_long (arg1)); - else if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)) + else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ()) { struct value *tmp; struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type)); @@ -1837,11 +1941,12 @@ value_complement (struct value *arg1) 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)); - } + { + tmp = value_complement (value_subscript (arg1, i)); + memcpy ((value_contents_writeable (val).data () + + i * TYPE_LENGTH (eltype)), + value_contents_all (tmp).data (), TYPE_LENGTH (eltype)); + } } else if (type->code () == TYPE_CODE_COMPLEX) { @@ -1866,13 +1971,13 @@ 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); + struct gdbarch *gdbarch = type->arch (); LONGEST low_bound, high_bound; LONGEST word; unsigned rel_index; struct type *range = type->index_type (); - if (get_discrete_bounds (range, &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (range, &low_bound, &high_bound)) return -2; if (index < low_bound || index > high_bound) return -1; @@ -1901,7 +2006,7 @@ value_in (struct value *element, struct value *set) && eltype->code () != TYPE_CODE_ENUM && eltype->code () != TYPE_CODE_BOOL) error (_("First argument of 'IN' has wrong type")); - member = value_bit_index (settype, value_contents (set), + member = value_bit_index (settype, value_contents (set).data (), value_as_long (element)); if (member < 0) error (_("First argument of 'IN' not in range"));