+ error (_("Don't know how to convert from %s to %s."), type1->name (),
+ 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. */
+
+static struct type *
+promotion_type (struct type *type1, struct type *type2)
+{
+ struct type *result_type;
+
+ if (is_floating_type (type1) || is_floating_type (type2))
+ {
+ /* If only one type is floating-point, use its type.
+ Otherwise use the bigger type. */
+ if (!is_floating_type (type1))
+ result_type = type2;
+ else if (!is_floating_type (type2))
+ result_type = type1;
+ else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+ result_type = type2;
+ else
+ result_type = type1;
+ }
+ else
+ {
+ /* Integer types. */
+ if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
+ result_type = type1;
+ else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+ result_type = type2;
+ else if (type1->is_unsigned ())
+ result_type = type1;
+ else if (type2->is_unsigned ())
+ result_type = type2;
+ else
+ result_type = type1;
+ }
+
+ return result_type;
+}
+
+static struct value *scalar_binop (struct value *arg1, struct value *arg2,
+ enum exp_opcode op);
+
+/* Perform a binary operation on complex operands. */
+
+static struct value *
+complex_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
+{
+ struct type *arg1_type = check_typedef (value_type (arg1));
+ struct type *arg2_type = check_typedef (value_type (arg2));
+
+ struct value *arg1_real, *arg1_imag, *arg2_real, *arg2_imag;
+ if (arg1_type->code () == TYPE_CODE_COMPLEX)
+ {
+ arg1_real = value_real_part (arg1);
+ arg1_imag = value_imaginary_part (arg1);
+ }
+ else
+ {
+ arg1_real = arg1;
+ arg1_imag = value_zero (arg1_type, not_lval);
+ }
+ if (arg2_type->code () == TYPE_CODE_COMPLEX)
+ {
+ arg2_real = value_real_part (arg2);
+ arg2_imag = value_imaginary_part (arg2);
+ }
+ else
+ {
+ arg2_real = arg2;
+ arg2_imag = value_zero (arg2_type, not_lval);
+ }
+
+ 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);
+ arg2_imag = value_cast (comp_type, arg2_imag);
+
+ struct type *result_type = init_complex_type (nullptr, comp_type);
+
+ struct value *result_real, *result_imag;
+ switch (op)
+ {
+ case BINOP_ADD:
+ case BINOP_SUB:
+ result_real = scalar_binop (arg1_real, arg2_real, op);
+ result_imag = scalar_binop (arg1_imag, arg2_imag, op);
+ break;
+
+ case BINOP_MUL:
+ {
+ struct value *x1 = scalar_binop (arg1_real, arg2_real, op);
+ struct value *x2 = scalar_binop (arg1_imag, arg2_imag, op);
+ result_real = scalar_binop (x1, x2, BINOP_SUB);
+
+ x1 = scalar_binop (arg1_real, arg2_imag, op);
+ x2 = scalar_binop (arg1_imag, arg2_real, op);
+ result_imag = scalar_binop (x1, x2, BINOP_ADD);
+ }
+ break;
+
+ case BINOP_DIV:
+ {
+ if (arg2_type->code () == TYPE_CODE_COMPLEX)
+ {
+ struct value *conjugate = value_complement (arg2);
+ /* We have to reconstruct ARG1, in case the type was
+ promoted. */
+ arg1 = value_literal_complex (arg1_real, arg1_imag, result_type);
+
+ struct value *numerator = scalar_binop (arg1, conjugate,
+ BINOP_MUL);
+ arg1_real = value_real_part (numerator);
+ arg1_imag = value_imaginary_part (numerator);
+
+ struct value *x1 = scalar_binop (arg2_real, arg2_real, BINOP_MUL);
+ struct value *x2 = scalar_binop (arg2_imag, arg2_imag, BINOP_MUL);
+ arg2_real = scalar_binop (x1, x2, BINOP_ADD);
+ }
+
+ result_real = scalar_binop (arg1_real, arg2_real, op);
+ result_imag = scalar_binop (arg1_imag, arg2_real, op);
+ }
+ break;
+
+ case BINOP_EQUAL:
+ case BINOP_NOTEQUAL:
+ {
+ struct value *x1 = scalar_binop (arg1_real, arg2_real, op);
+ struct value *x2 = scalar_binop (arg1_imag, arg2_imag, op);
+
+ LONGEST v1 = value_as_long (x1);
+ LONGEST v2 = value_as_long (x2);
+
+ if (op == BINOP_EQUAL)
+ v1 = v1 && v2;
+ else
+ v1 = v1 || v2;
+
+ return value_from_longest (value_type (x1), v1);
+ }
+ break;
+
+ default:
+ error (_("Invalid binary operation on numbers."));
+ }
+
+ return value_literal_complex (result_real, result_imag, result_type);