FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix fixed-point binary operation type handling

Browse source 
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  <tromey@adacore.com>

	* ada-lang.c (ada_evaluate_subexp) <BINOP_ADD, BINOP_SUB>:
	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  <tromey@adacore.com>

	* 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.
This commit is contained in:
Tom Tromey 2021-01-06 13:47:48 -07:00
parent 3c55062cc1
commit b49180acf2
9 changed files with 156 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

63
gdb/valops.c
View file

@ -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. */