From b49180acf205d8e52050cc05ca63f8f8630e7a9c Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Wed, 6 Jan 2021 13:47:48 -0700 Subject: Fix fixed-point binary operation type handling Testing showed that gdb was not correctly handling some fixed-point binary operations correctly. Addition and subtraction worked by casting the result to the type of left hand operand. So, "fixed+int" had a different type -- and different value -- from "int+fixed". Furthermore, for multiplication and division, it does not make sense to first cast both sides to the fixed-point type. For example, this can prevent "f * 1" from yielding "f", if 1 is not in the domain of "f". Instead, this patch changes gdb to use the value. (This is somewhat different from Ada semantics, as those can yield a "universal fixed point".) This includes a new test case. It is only run in "minimal" mode, as the old-style fixed point works differently, and is obsolete, so I have no plans to change it. gdb/ChangeLog 2021-01-06 Tom Tromey * ada-lang.c (ada_evaluate_subexp) : Do not cast result. * valarith.c (fixed_point_binop): Handle multiplication and division specially. * valops.c (value_to_gdb_mpq): New function. (value_cast_to_fixed_point): Use it. gdb/testsuite/ChangeLog 2021-01-06 Tom Tromey * gdb.ada/fixed_points/pck.ads (Delta4): New constant. (FP4_Type): New type. (FP4_Var): New variable. * gdb.ada/fixed_points/fixed_points.adb: Update. * gdb.ada/fixed_points.exp: Add tests for binary operators. --- gdb/valops.c | 63 ++++++++++++++++++++++++++++++++++++------------------------ 1 file changed, 38 insertions(+), 25 deletions(-) (limited to 'gdb/valops.c') diff --git a/gdb/valops.c b/gdb/valops.c index 455cf7d..6a9cbdc 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -331,6 +331,39 @@ value_cast_pointers (struct type *type, struct value *arg2, return arg2; } +/* See value.h. */ + +gdb_mpq +value_to_gdb_mpq (struct value *value) +{ + struct type *type = check_typedef (value_type (value)); + + gdb_mpq result; + if (is_floating_type (type)) + { + double d = target_float_to_host_double (value_contents (value), + type); + mpq_set_d (result.val, d); + } + else + { + gdb_assert (is_integral_type (type) + || is_fixed_point_type (type)); + + gdb_mpz vz; + vz.read (gdb::make_array_view (value_contents (value), + TYPE_LENGTH (type)), + type_byte_order (type), type->is_unsigned ()); + mpq_set_z (result.val, vz.val); + + if (is_fixed_point_type (type)) + mpq_mul (result.val, result.val, + type->fixed_point_scaling_factor ().val); + } + + return result; +} + /* Assuming that TO_TYPE is a fixed point type, return a value corresponding to the cast of FROM_VAL to that type. */ @@ -342,34 +375,14 @@ value_cast_to_fixed_point (struct type *to_type, struct value *from_val) if (from_type == to_type) return from_val; - gdb_mpq vq; - - /* Extract the value as a rational number. */ - - if (is_floating_type (from_type)) - { - double d = target_float_to_host_double (value_contents (from_val), - from_type); - mpq_set_d (vq.val, d); - } - - else if (is_integral_type (from_type) || is_fixed_point_type (from_type)) - { - gdb_mpz vz; - - vz.read (gdb::make_array_view (value_contents (from_val), - TYPE_LENGTH (from_type)), - type_byte_order (from_type), from_type->is_unsigned ()); - mpq_set_z (vq.val, vz.val); - - if (is_fixed_point_type (from_type)) - mpq_mul (vq.val, vq.val, from_type->fixed_point_scaling_factor ().val); - } - - else + if (!is_floating_type (from_type) + && !is_integral_type (from_type) + && !is_fixed_point_type (from_type)) error (_("Invalid conversion from type %s to fixed point type %s"), from_type->name (), to_type->name ()); + gdb_mpq vq = value_to_gdb_mpq (from_val); + /* Divide that value by the scaling factor to obtain the unscaled value, first in rational form, and then in integer form. */ -- cgit v1.1