+2008-01-30 Thiago Jung Bauermann <bauerman@br.ibm.com>
+
+ * dfp-test.c (DELTA, DELTA_B): New definitions.
+ (double_val1, double_val2, double_val3, double_val4, double_val5,
+ double_val6, double_val7, double_val8, double_val9, double_val10,
+ double_val11, double_val12, double_val13, double_val14, dec32_val1,
+ dec32_val2, dec32_val3, dec32_val4, dec32_val5, dec32_val6, dec32_val7,
+ dec32_val8, dec32_val9, dec32_val10, dec32_val11, dec32_val12,
+ dec32_val13, dec32_val14, dec32_val15, dec32_val16, dec64_val1,
+ dec64_val2, dec64_val3, dec64_val4, dec64_val5, dec64_val6, dec64_val7,
+ dec64_val8, dec64_val9, dec64_val10, dec64_val11, dec64_val12,
+ dec64_val13, dec64_val14, dec64_val15, dec64_val16, dec128_val1,
+ dec128_val2, dec128_val3, dec128_val4, dec128_val5, dec128_val6,
+ dec128_val7, dec128_val8, dec128_val9, dec128_val10, dec128_val11,
+ dec128_val12, dec128_val13, dec128_val14, dec128_val15,
+ dec128_val16): New global variables.
+ (decimal_dec128_align): New function.
+ (decimal_mixed): Likewise.
+ (decimal_many_args_dec32): Likewise.
+ (decimal_many_args_dec64): Likewise.
+ (decimal_many_args_dec128): Likewise.
+ (decimal_many_args_mixed): Likewise.
+ * dfp-test.exp: Add tests calling new inferior functions.
+
2008-01-29 Daniel Jacobowitz <dan@codesourcery.com>
* gdb.server/ext-attach.c, gdb.server/ext-attach.exp,
#include <stdio.h>
#include <stdlib.h>
+#define DELTA (0.0001df)
+#define DELTA_B (0.001)
+
+double double_val1 = 45.125;
+double double_val2 = -67.75;
+double double_val3 = 0.25;
+double double_val4 = 1.25;
+double double_val5 = 2.25;
+double double_val6 = 3.25;
+double double_val7 = 4.25;
+double double_val8 = 5.25;
+double double_val9 = 6.25;
+double double_val10 = 7.25;
+double double_val11 = 8.25;
+double double_val12 = 9.25;
+double double_val13 = 10.25;
+double double_val14 = 11.25;
+
+_Decimal32 dec32_val1 = 3.14159df;
+_Decimal32 dec32_val2 = -2.3765df;
+_Decimal32 dec32_val3 = 0.2df;
+_Decimal32 dec32_val4 = 1.2df;
+_Decimal32 dec32_val5 = 2.2df;
+_Decimal32 dec32_val6 = 3.2df;
+_Decimal32 dec32_val7 = 4.2df;
+_Decimal32 dec32_val8 = 5.2df;
+_Decimal32 dec32_val9 = 6.2df;
+_Decimal32 dec32_val10 = 7.2df;
+_Decimal32 dec32_val11 = 8.2df;
+_Decimal32 dec32_val12 = 9.2df;
+_Decimal32 dec32_val13 = 10.2df;
+_Decimal32 dec32_val14 = 11.2df;
+_Decimal32 dec32_val15 = 12.2df;
+_Decimal32 dec32_val16 = 13.2df;
+
+_Decimal64 dec64_val1 = 3.14159dd;
+_Decimal64 dec64_val2 = -2.3765dd;
+_Decimal64 dec64_val3 = 0.2dd;
+_Decimal64 dec64_val4 = 1.2dd;
+_Decimal64 dec64_val5 = 2.2dd;
+_Decimal64 dec64_val6 = 3.2dd;
+_Decimal64 dec64_val7 = 4.2dd;
+_Decimal64 dec64_val8 = 5.2dd;
+_Decimal64 dec64_val9 = 6.2dd;
+_Decimal64 dec64_val10 = 7.2dd;
+_Decimal64 dec64_val11 = 8.2dd;
+_Decimal64 dec64_val12 = 9.2dd;
+_Decimal64 dec64_val13 = 10.2dd;
+_Decimal64 dec64_val14 = 11.2dd;
+_Decimal64 dec64_val15 = 12.2dd;
+_Decimal64 dec64_val16 = 13.2dd;
+
+_Decimal128 dec128_val1 = 3.14159dl;
+_Decimal128 dec128_val2 = -2.3765dl;
+_Decimal128 dec128_val3 = 0.2dl;
+_Decimal128 dec128_val4 = 1.2dl;
+_Decimal128 dec128_val5 = 2.2dl;
+_Decimal128 dec128_val6 = 3.2dl;
+_Decimal128 dec128_val7 = 4.2dl;
+_Decimal128 dec128_val8 = 5.2dl;
+_Decimal128 dec128_val9 = 6.2dl;
+_Decimal128 dec128_val10 = 7.2dl;
+_Decimal128 dec128_val11 = 8.2dl;
+_Decimal128 dec128_val12 = 9.2dl;
+_Decimal128 dec128_val13 = 10.2dl;
+_Decimal128 dec128_val14 = 11.2dl;
+_Decimal128 dec128_val15 = 12.2dl;
+_Decimal128 dec128_val16 = 13.2dl;
+
volatile _Decimal32 d32;
volatile _Decimal64 d64;
volatile _Decimal128 d128;
return arg0;
}
+/* Function to test if _Decimal128 argument interferes with stack slots
+ because of alignment. */
+int
+decimal_dec128_align (double arg0, _Decimal128 arg1, double arg2, double arg3,
+ double arg4, double arg5, double arg6, double arg7,
+ double arg8, double arg9, double arg10, double arg11,
+ double arg12, double arg13)
+{
+ return ((arg0 - double_val1) < DELTA_B
+ && (arg0 - double_val1) > -DELTA_B
+ && (arg1 - dec128_val2) < DELTA
+ && (arg1 - dec128_val2) > -DELTA
+ && (arg2 - double_val3) < DELTA_B
+ && (arg2 - double_val3) > -DELTA_B
+ && (arg3 - double_val4) < DELTA_B
+ && (arg3 - double_val4) > -DELTA_B
+ && (arg4 - double_val5) < DELTA_B
+ && (arg4 - double_val5) > -DELTA_B
+ && (arg5 - double_val6) < DELTA_B
+ && (arg5 - double_val6) > -DELTA_B
+ && (arg6 - double_val7) < DELTA_B
+ && (arg6 - double_val7) > -DELTA_B
+ && (arg7 - double_val8) < DELTA_B
+ && (arg7 - double_val8) > -DELTA_B
+ && (arg8 - double_val9) < DELTA_B
+ && (arg8 - double_val9) > -DELTA_B
+ && (arg9 - double_val10) < DELTA_B
+ && (arg9 - double_val10) > -DELTA_B
+ && (arg10 - double_val11) < DELTA_B
+ && (arg10 - double_val11) > -DELTA_B
+ && (arg11 - double_val12) < DELTA_B
+ && (arg11 - double_val12) > -DELTA_B
+ && (arg12 - double_val13) < DELTA_B
+ && (arg12 - double_val13) > -DELTA_B
+ && (arg13 - double_val14) < DELTA_B
+ && (arg13 - double_val14) > -DELTA_B);
+}
+
+int
+decimal_mixed (_Decimal32 arg0, _Decimal64 arg1, _Decimal128 arg2)
+{
+ return ((arg0 - dec32_val1) < DELTA
+ && (arg0 - dec32_val1) > -DELTA
+ && (arg1 - dec64_val1) < DELTA
+ && (arg1 - dec64_val1) > -DELTA
+ && (arg2 - dec128_val1) < DELTA
+ && (arg2 - dec128_val1) > -DELTA);
+}
+
+/* These functions have many arguments to force some of them to be passed via
+ the stack instead of registers, to test that GDB can construct correctly
+ the parameter save area. Note that Linux/ppc32 has 8 float registers to use
+ for float parameter passing and Linux/ppc64 has 13, so the number of
+ arguments has to be at least 14 to contemplate these platforms. */
+
+int
+decimal_many_args_dec32 (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
+ _Decimal32 f4, _Decimal32 f5, _Decimal32 f6,
+ _Decimal32 f7, _Decimal32 f8, _Decimal32 f9,
+ _Decimal32 f10, _Decimal32 f11, _Decimal32 f12,
+ _Decimal32 f13, _Decimal32 f14, _Decimal32 f15,
+ _Decimal32 f16)
+{
+ _Decimal32 sum_args;
+ _Decimal32 sum_values;
+
+ sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
+ + f13 + f14 + f15 + f16;
+ sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec32_val4 + dec32_val5
+ + dec32_val6 + dec32_val7 + dec32_val8 + dec32_val9
+ + dec32_val10 + dec32_val11 + dec32_val12 + dec32_val13
+ + dec32_val14 + dec32_val15 + dec32_val16;
+
+ return ((sum_args - sum_values) < DELTA
+ && (sum_args - sum_values) > -DELTA);
+}
+
+int
+decimal_many_args_dec64 (_Decimal64 f1, _Decimal64 f2, _Decimal64 f3,
+ _Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
+ _Decimal64 f7, _Decimal64 f8, _Decimal64 f9,
+ _Decimal64 f10, _Decimal64 f11, _Decimal64 f12,
+ _Decimal64 f13, _Decimal64 f14, _Decimal64 f15,
+ _Decimal64 f16)
+{
+ _Decimal64 sum_args;
+ _Decimal64 sum_values;
+
+ sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
+ + f13 + f14 + f15 + f16;
+ sum_values = dec64_val1 + dec64_val2 + dec64_val3 + dec64_val4 + dec64_val5
+ + dec64_val6 + dec64_val7 + dec64_val8 + dec64_val9
+ + dec64_val10 + dec64_val11 + dec64_val12 + dec64_val13
+ + dec64_val14 + dec64_val15 + dec64_val16;
+
+ return ((sum_args - sum_values) < DELTA
+ && (sum_args - sum_values) > -DELTA);
+}
+
+int
+decimal_many_args_dec128 (_Decimal128 f1, _Decimal128 f2, _Decimal128 f3,
+ _Decimal128 f4, _Decimal128 f5, _Decimal128 f6,
+ _Decimal128 f7, _Decimal128 f8, _Decimal128 f9,
+ _Decimal128 f10, _Decimal128 f11, _Decimal128 f12,
+ _Decimal128 f13, _Decimal128 f14, _Decimal128 f15,
+ _Decimal128 f16)
+{
+ _Decimal128 sum_args;
+ _Decimal128 sum_values;
+
+ sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
+ + f13 + f14 + f15 + f16;
+ sum_values = dec128_val1 + dec128_val2 + dec128_val3 + dec128_val4 + dec128_val5
+ + dec128_val6 + dec128_val7 + dec128_val8 + dec128_val9
+ + dec128_val10 + dec128_val11 + dec128_val12 + dec128_val13
+ + dec128_val14 + dec128_val15 + dec128_val16;
+
+ return ((sum_args - sum_values) < DELTA
+ && (sum_args - sum_values) > -DELTA);
+}
+
+int
+decimal_many_args_mixed (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
+ _Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
+ _Decimal64 f7, _Decimal128 f8, _Decimal128 f9,
+ _Decimal128 f10, _Decimal32 f11, _Decimal64 f12,
+ _Decimal32 f13, _Decimal64 f14, _Decimal128 f15)
+{
+ _Decimal128 sum_args;
+ _Decimal128 sum_values;
+
+ sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
+ + f13 + f14 + f15;
+ sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec64_val4 + dec64_val5
+ + dec64_val6 + dec64_val7 + dec128_val8 + dec128_val9
+ + dec128_val10 + dec32_val11 + dec64_val12 + dec32_val13
+ + dec64_val14 + dec128_val15;
+
+ return ((sum_args - sum_values) < DELTA
+ && (sum_args - sum_values) > -DELTA);
+}
+
int main()
{
/* An finite 32-bits decimal floating point. */
gdb_continue_to_breakpoint "entry to arg0_128"
gdb_test "backtrace" ".*arg0_128 \\(arg0=0.1, arg1=1.0, arg2=2.0, arg3=3.0, arg4=4.0, arg5=5.0\\).*" "backtrace at arg0_128"
+# Test calling inferior function with DFP arguments or return value.
+
+send_gdb "call arg0_32 (1.2df, 2.2df, 3.2df, 4.2df, 5.2df, 6.2df)\n"
+gdb_test "backtrace 1" "\n#\[0-9\]+ arg0_32 \\(arg0=1.2, arg1=2.2, arg2=3.2, arg3=4.2, arg4=5.2, arg5=6.2\\).*" "Call function with correct _Decimal32 arguments."
+gdb_test "finish" " = 1.2" "Correct _Decimal32 return value from called function."
+
+send_gdb "call arg0_64 (1.2dd, 2.2dd, 3.2dd, 4.2dd, 5.2dd, 6.2dd)\n"
+gdb_test "backtrace 1" "\n#\[0-9\]+ arg0_64 \\(arg0=1.2, arg1=2.2, arg2=3.2, arg3=4.2, arg4=5.2, arg5=6.2\\).*" "Call function with correct _Decimal64 arguments."
+gdb_test "finish" " = 1.2" "Correct _Decimal64 return value from called function."
+
+send_gdb "call arg0_128 (1.2dl, 2.2dl, 3.2dl, 4.2dl, 5.2dl, 6.2dl)\n"
+gdb_test "backtrace 1" "\n#\[0-9\]+ arg0_128 \\(arg0=1.2, arg1=2.2, arg2=3.2, arg3=4.2, arg4=5.2, arg5=6.2\\).*" "Call function with correct _Decimal128 arguments."
+gdb_test "finish" " = 1.2" "Correct _Decimal128 return value from called function."
+
+gdb_test "call decimal_dec128_align (double_val1, dec128_val2, double_val3, double_val4, double_val5, double_val6, double_val7, double_val8, double_val9, double_val10, double_val11, double_val12, double_val13, double_val14)" " = 1" \
+ "Call function with mixed decimal float arguments TEST."
+
+gdb_test "call decimal_mixed (dec32_val1, dec64_val1, dec128_val1)" " = 1" \
+ "Call function with mixed decimal float arguments."
+
+gdb_test "call decimal_many_args_dec32 (dec32_val1, dec32_val2, dec32_val3, dec32_val4, dec32_val5, dec32_val6, dec32_val7, dec32_val8, dec32_val9, dec32_val10, dec32_val11, dec32_val12, dec32_val13, dec32_val14, dec32_val15, dec32_val16)" " = 1" \
+ "Call function with many _Decimal32 arguments."
+
+gdb_test "call decimal_many_args_dec64 (dec64_val1, dec64_val2, dec64_val3, dec64_val4, dec64_val5, dec64_val6, dec64_val7, dec64_val8, dec64_val9, dec64_val10, dec64_val11, dec64_val12, dec64_val13, dec64_val14, dec64_val15, dec64_val16)" " = 1" \
+ "Call function with many _Decimal64 arguments."
+
+gdb_test "call decimal_many_args_dec128 (dec128_val1, dec128_val2, dec128_val3, dec128_val4, dec128_val5, dec128_val6, dec128_val7, dec128_val8, dec128_val9, dec128_val10, dec128_val11, dec128_val12, dec128_val13, dec128_val14, dec128_val15, dec128_val16)" " = 1" \
+ "Call function with many _Decimal128 arguments."
+
+gdb_test "call decimal_many_args_mixed (dec32_val1, dec32_val2, dec32_val3, dec64_val4, dec64_val5, dec64_val6, dec64_val7, dec128_val8, dec128_val9, dec128_val10, dec32_val11, dec64_val12, dec32_val13, dec64_val14, dec128_val15)" " = 1" \
+ "Call function with many mixed decimal float arguments."
+
# The following tests are intended to verify that gdb can handle DFP types
# correctly in struct.
projects / binutils-gdb.git / commitdiff