1# Copyright (C) 2007-2020 Free Software Foundation, Inc.
2
3# This program is free software; you can redistribute it and/or modify
4# it under the terms of the GNU General Public License as published by
5# the Free Software Foundation; either version 3 of the License, or
6# (at your option) any later version.
7#
8# This program is distributed in the hope that it will be useful,
9# but WITHOUT ANY WARRANTY; without even the implied warranty of
10# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11# GNU General Public License for more details.
12#
13# You should have received a copy of the GNU General Public License
14# along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
16#  This file was written by Wu Zhou. (woodzltc@cn.ibm.com)
17
18# This file is part of the gdb testsuite.  It is intended to test that
19# gdb could correctly handle decimal floating point introduced in IEEE 754R.
20
21standard_testfile .c
22
23# Try to compile the test case.  If we can't, assume the
24# toolchain does not yet provide DFP support and bail out.
25if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {quiet debug}] != "" } {
26    verbose "Skipping DFP tests."
27    return -1
28}
29
30clean_restart ${binfile}
31
32if ![runto_main] then {
33    perror "couldn't run to breakpoint"
34    continue
35}
36
37set sizeof_long [get_sizeof "long" 4]
38
39proc d32_set_tests {} {
40
41    gdb_test "p d32=123.45df" " = 123.45"
42    gdb_test "p d32=12345.df" " = 12345"
43    gdb_test "p d32=12345.67df" " = 12345.67"
44    gdb_test "p d32=1234567.df" " = 1234567"
45
46    gdb_test "p d32=1.234567E0df" " = 1.234567"
47    gdb_test "p d32=1.234567E10df" " = 1.234567E\\+10"
48    gdb_test "p d32=1.234567E+96df" " = 1.234567E\\+96"
49
50    # Test that gdb could handle the max, normalized min and subnormalized min.
51    gdb_test "p d32=9.999999E96df" " = 9.999999E\\+96"
52    gdb_test "p d32=1.0E-95df" " = 1.0E\\-95"
53    gdb_test "p d32=1.E-101df" " = 1E\\-101"
54    gdb_test "p d32=0.000001E-95df" " = 1E\\-101"
55
56    # Test that gdb could detect coefficient/exponent out of range.
57    # The coefficient out of range will be rounded to its nearest value.
58    # And the exponent out of range will be handled as infinity.
59    gdb_test "p d32=1.2345678df" " = 1.234568" "1.2345678 is rounded to 1.234568"
60    gdb_test "p d32=1.0E-101df" " = 1E-101" "1.0E-101 is rounded to 1E-101"
61    gdb_test "p d32=1.234567E+97df" " = Infinity" "1.234567E+97 is Infinity"
62
63    # Test that gdb could detect the errors in the string representation of _Decimal32
64    gdb_test "p d32=12345.df" " = 12345" "12345. is a valid number"
65    gdb_test "p d32=12345df" ".*Invalid number.*" "12345 is an invalid number"
66    gdb_test "p d32=1.23Edf" ".*Conversion syntax.*" "1.23E is an invalid number"
67    gdb_test "p d32=1.23E45Adf" ".*Conversion syntax.*" "1.23E45A is an invalid number"
68}
69
70proc d64_set_tests {} {
71
72    gdb_test "p d64=123.45dd" " = 123.45"
73    gdb_test "p d64=12345.dd" " = 12345"
74    gdb_test "p d64=12345.67dd" " = 12345.67"
75    gdb_test "p d64=1.234567890123456dd" " = 1.234567890123456"
76
77    gdb_test "p d64=1.234567890123456E10dd" " = 12345678901.23456"
78    gdb_test "p d64=1.234567890123456E100dd" " = 1.234567890123456E\\+100"
79    gdb_test "p d64=1.234567890123456E384dd" " = 1.234567890123456E\\+384"
80
81    # Test that gdb could handle the max, normalized min and subnormalized min.
82    gdb_test "p d64=9.999999999999999E384dd" " = 9.999999999999999E\\+384"
83    gdb_test "p d64=1.E-383dd" " = 1E\\-383"
84    gdb_test "p d64=1.E-398dd" " = 1E\\-398"
85    gdb_test "p d64=0.000000000000001E-383dd" " = 1E\\-398"
86
87    # Test that gdb could detect coefficient/exponent out of range.
88    # The coefficient out of range will be rounded to its nearest value.
89    # And the exponent out of range will be handled as infinity.
90    gdb_test "p d64=1.2345678901234567dd" " = 1.234567890123457" "1.2345678901234567 is rounded to 1.234567890123457"
91    gdb_test "p d64=9.9999999999999999E384dd" " = Infinity" "d64=9.9999999999999999E384 is Infinity"
92    gdb_test "p d64=1.234567890123456E385dd" " = Infinity" "d64=1.234567890123456E385 is Infinity"
93
94    # Test that gdb could detect the errors in the string representation of _Decimal64
95    gdb_test "p d64=12345dd" ".*Invalid number.*" "12345dd is an invalid number"
96    gdb_test "p d64=1.23Edd" ".*Conversion syntax.*" "1.23E is an invalid number"
97    gdb_test "p d64=1.23E45Add" ".*Conversion syntax.*" "1.23E45A is an invalid number"
98}
99
100proc d128_set_tests {} {
101
102    gdb_test "p d128=123.45dl" " = 123.45"
103    gdb_test "p d128=12345.dl" " = 12345"
104    gdb_test "p d128=12345.67dl" " = 12345.67"
105    gdb_test "p d128=1.234567890123456789012345678901234dl" " = 1.234567890123456789012345678901234"
106
107    gdb_test "p d128=1.234567890123456E10dl" " = 12345678901.23456"
108    gdb_test "p d128=1.234567890123456E100dl" " = 1.234567890123456E\\+100"
109    gdb_test "p d128=1.234567890123456E1000dl" " = 1.234567890123456E\\+1000"
110
111    # Test that gdb could handle the max, normalized min and subnormalized min.
112    gdb_test "p d128=9.999999999999999999999999999999999E6144dl" " = 9.999999999999999999999999999999999E\\+6144"
113    gdb_test "p d128=1.E-6143dl" " = 1E\\-6143"
114    gdb_test "p d128=1.E-6176dl" " = 1E\\-6176"
115    gdb_test "p d128=0.000000000000000000000000000000001E-6143dl" " = 1E\\-6176"
116
117    # Test that gdb could detect coefficient/exponent out of range.
118    # The coefficient out of range will be rounded to its nearest value.
119    # And the exponent out of range will be handled as infinity.
120    gdb_test "p d128=1.2345678901234567890123456789012345dl" "1.234567890123456789012345678901234" "1.2345678901234567890123456789012345 is rounded to 1.234567890123456789012345678901234"
121    gdb_test "p d128=1.234567890123456E6145dl" "Infinity" "d128=1.234567890123456E6145 is Infinity"
122
123    # Test that gdb could detect the errors in the string representation of _Decimal128
124    gdb_test "p d128=12345dl" ".*Invalid number.*" "12345dl is an invalid number"
125    gdb_test "p d128=1.23Edl" ".*Conversion syntax.*" "1.23E is an invalid number"
126    gdb_test "p d128=1.23E45Adl" ".*Conversion syntax.*" "1.23E45A is an invalid number"
127}
128
129# Different tests on 32-bits decimal floating point, including the printing
130# of finite numbers, infinite and NaN, and also the setting of different
131# decimal value.
132
133if [gdb_test "next" \
134    ".*Positive infd32.*" \
135    "next after initializing d32"] then { gdb_suppress_tests }
136gdb_test "print d32" "1.2345" "d32 is initialized to 1.2345"
137
138if [gdb_test "next" \
139    ".*Negative infd32.*" \
140    "next after assigning builtin infinity to d32"] then { gdb_suppress_tests }
141gdb_test "print d32" "Infinity" "d32 is positive Infinity"
142
143if [gdb_test "next" \
144    ".*__builtin_nand32.*" \
145    "next after assigning negative builtin infinity to d32"] then { gdb_suppress_tests }
146gdb_test "print d32" "-Infinity" "d32 is negative Infinity"
147
148if [gdb_test "next" \
149    ".*d64 = 1.2345.*" \
150    "next after assigning builtin NaN to d32"] then { gdb_suppress_tests }
151gdb_test "print d32" "NaN" "d32 is NaN"
152
153d32_set_tests
154
155
156# Different tests on 64-bits decimal floating point, including the display
157# of finite number, infinite and NaN, and also the setting of different
158# decimal value.
159
160if [gdb_test "next" \
161    ".*Positive infd64.*" \
162    "next after initializing d64"] then { gdb_suppress_tests }
163gdb_test "print d64" "1.2345" "d64 is initialized to 1.2345"
164
165if [gdb_test "next" \
166    ".*Negative infd64.*" \
167    "next after assigning builtin infinity to d64"] then { gdb_suppress_tests }
168gdb_test "print d64" "Infinity" "d64 is positive Infinity"
169
170if [gdb_test "next" \
171    ".*__builtin_nand64.*" \
172    "next after assigning negative builtin infinity to d64"] then { gdb_suppress_tests }
173gdb_test "print d64" "-Infinity" "d64 is negative Infinity"
174
175if [gdb_test "next" \
176    ".*d128 = 1.2345.*" \
177    "next after assigning builtin NaN to d64"] then { gdb_suppress_tests }
178gdb_test "print d64" "NaN" "d64 is NaN"
179
180d64_set_tests
181
182
183# Different tests on 128-bits decimal floating point, including the display
184# of finite number, infinite and NaN, and also the setting of different
185# decimal value.
186
187if [gdb_test "next" \
188    ".*Positive infd128.*" \
189    "next after initializing d128"] then { gdb_suppress_tests }
190gdb_test "print d128" "1.2345" "d128 is initialized to 1.2345"
191
192d128_set_tests
193
194if [gdb_test "next" \
195    ".*Negative infd128.*" \
196    "next after assigning builtin infinity to d128"] then { gdb_suppress_tests }
197gdb_test "print d128" "Infinity" "d128 is positive Infinity"
198
199if [gdb_test "next" \
200    ".*__builtin_nand128.*" \
201    "next after assigning negative builtin infinity to d128"] then { gdb_suppress_tests }
202gdb_test "print d128" "-Infinity" "d128 is negative Infinity"
203
204if [gdb_test "next" \
205    ".*arg0_32.*" \
206    "next after assigning builtin NaN to d128"] then { gdb_suppress_tests }
207gdb_test "print d128" "NaN" "d128 is NaN"
208
209# The following tests are intended to verify that gdb can correctly handle
210# DFP types in function arguments.
211
212gdb_breakpoint arg0_32
213gdb_continue_to_breakpoint "entry to arg0_32"
214gdb_test "backtrace" ".*arg0_32 \\(arg0=0.1, arg1=1.0, arg2=2.0, arg3=3.0, arg4=4.0, arg5=5.0\\).*" "backtrace at arg0_32"
215
216gdb_breakpoint arg0_64
217gdb_continue_to_breakpoint "entry to arg0_64"
218gdb_test "backtrace" ".*arg0_64 \\(arg0=0.1, arg1=1.0, arg2=2.0, arg3=3.0, arg4=4.0, arg5=5.0\\).*" "backtrace at arg0_64"
219
220gdb_breakpoint arg0_128
221gdb_continue_to_breakpoint "entry to arg0_128"
222gdb_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"
223
224# Test calling inferior function with DFP arguments or return value.
225
226gdb_test "call arg0_32 (1.2df, 2.2df, 3.2df, 4.2df, 5.2df, 6.2df)" "Breakpoint.*arg0_32.*" "call function with correct _Decimal32 arguments."
227gdb_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\\).*" "backtrace function with correct _Decimal32 arguments."
228gdb_test "finish" " = 1.2" "correct _Decimal32 return value from called function."
229
230gdb_test "call arg0_64 (1.2dd, 2.2dd, 3.2dd, 4.2dd, 5.2dd, 6.2dd)" "Breakpoint.*arg0_64.*" "call function with correct _Decimal64 arguments."
231gdb_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\\).*" "backtrace function with correct _Decimal64 arguments."
232gdb_test "finish" " = 1.2" "correct _Decimal64 return value from called function."
233
234gdb_test "call arg0_128 (1.2dl, 2.2dl, 3.2dl, 4.2dl, 5.2dl, 6.2dl)" "Breakpoint.*arg0_128.*" "call function with correct _Decimal128 arguments."
235gdb_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\\).*" "backtrace function with correct _Decimal128 arguments."
236gdb_test "finish" " = 1.2" "correct _Decimal128 return value from called function."
237
238gdb_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" \
239  "Call function with mixed decimal float arguments TEST."
240
241gdb_test "call decimal_mixed (dec32_val1, dec64_val1, dec128_val1)" " = 1" \
242  "Call function with mixed decimal float arguments."
243
244gdb_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" \
245  "Call function with many _Decimal32 arguments."
246
247gdb_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" \
248  "Call function with many _Decimal64 arguments."
249
250gdb_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" \
251  "Call function with many _Decimal128 arguments."
252
253gdb_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" \
254  "Call function with many mixed decimal float arguments."
255
256# The following tests are intended to verify that gdb can handle DFP types
257# correctly in struct.
258
259gdb_breakpoint [gdb_get_line_number "Exit point"]
260gdb_continue_to_breakpoint "Setting a decimal struct"
261gdb_test "print ds.dec32" " = 1.2345"
262gdb_test "print ds.dec64" " = 1.2345"
263gdb_test "print ds.dec128" " = 1.2345"
264
265# Test expressions with DFP variables.
266
267gdb_test "print d32 + ds.dec32" " = 1.3345"
268gdb_test "print d64 + ds.dec64" " = 1.3345"
269gdb_test "print d128 + ds.dec128" " = 1.3345"
270
271# Test conversion between different _Decimal sizes.
272
273gdb_test "ptype d64 + ds.dec32" " = volatile _Decimal64"
274gdb_test "ptype d128 + ds.dec32" " = volatile _Decimal128"
275gdb_test "ptype d128 + ds.dec64" " = volatile _Decimal128"
276
277gdb_test "whatis d64 + ds.dec32" " = volatile _Decimal64"
278gdb_test "whatis d128 + ds.dec32" " = volatile _Decimal128"
279gdb_test "whatis d128 + ds.dec64" " = volatile _Decimal128"
280
281# Mixture of Decimal and integral operands
282gdb_test "p d32 + 1" " = 1.1"
283gdb_test "p 2 + d64" " = 2.1"
284gdb_test "p ds.int4 + d128" " = 1.1"
285gdb_test "p d32 + ds.long8" " = 2.1"
286gdb_test "ptype d32 + 1" " = volatile _Decimal32"
287gdb_test "ptype ds.int4 + d128" " = volatile _Decimal128"
288
289# Test other operations with DFP operands
290gdb_test "p !d32" " = 0"
291gdb_test "p !d64" " = 0"
292gdb_test "p !d128" " = 0"
293gdb_test "p +d32" " = 0.1"
294gdb_test "p +d64" " = 0.1"
295gdb_test "p +d128" " = 0.1"
296gdb_test "p d64 == d128" " = 1"
297gdb_test "p d128 == ds.dec32" " = 0"
298gdb_test "p d128 == d32" " = 1"
299gdb_test "p ds.dec32 == ds.dec64" " = 1"
300gdb_test "p d32 < ds.dec32" " = 1"
301gdb_test "p d64 < ds.dec64" " = 1"
302gdb_test "p d128 < ds.dec128" " = 1"
303gdb_test "p ds.dec32 < d32" " = 0"
304gdb_test "p d64 > ds.dec64" " = 0"
305gdb_test "p ds.dec128 > d128 " " = 1"
306gdb_test "p d32 < ds.int4" " = 1"
307gdb_test "p ds.int4 > d32" " = 1"
308gdb_test "p ds.dec32 < ds.int4" " = 0"
309gdb_test "p ds.int4 > ds.dec64" " = 0"
310gdb_test "p ds.dec128 > ds.int4" " = 1"
311
312# Reject operation with DFP and Binary FP
313gdb_test "p d64 + ds.float4" "Mixing decimal floating types with other floating types is not allowed."
314gdb_test "p ds.double8 + d128" "Mixing decimal floating types with other floating types is not allowed."
315
316# The following tests are intended to verify that gdb can handle "d1=d2"
317# and "d1=-d2" correctly.
318
319gdb_test "print ds.dec32=d32" " = 0.1"
320gdb_test "print ds.dec64=d64" " = 0.1"
321gdb_test "print ds.dec128=d128" " = 0.1"
322gdb_test "print ds.dec32 = -d32" " = -0.1"
323gdb_test "print ds.dec64 = -d64" " = -0.1"
324gdb_test "print ds.dec128 = -d128" " = -0.1"
325
326# Test cast to and from DFP values
327
328gdb_test "print ds.double8 = ds.dec64" " = -0.(0999.*|1000.*)"
329gdb_test "print ds.dec64 = ds.float4" " = 3.(0999.*|1000.*)"
330gdb_test "print ds.dec128 = -ds.double8" " = 0.(0999.*|1000.*)"
331gdb_test "print ds.dec128 = ds.dec32" " = -0.1"
332gdb_test "print ds.dec32 = ds.int4" " = 1"
333gdb_test "print ds.int4 = 7.3dl" " = 7"
334
335# Test "whatis"/"ptype" of expressions involving casts to/from dfp
336# typedefs.
337
338# This list is composed by sub-lists, and their elements are (in
339# order):
340#
341# - Type to cast to.  This is also what "whatis" should print.
342# - What "ptype" should print.
343
344# Columns in the sublists represent:
345     # to/whatis   # ptype
346foreach elem {
347    {"_Decimal32"  "_Decimal32"}
348    {"_Decimal64"  "_Decimal64"}
349    {"_Decimal128" "_Decimal128"}
350    {"d32_t"       "_Decimal32"}
351    {"d64_t"       "_Decimal64"}
352    {"d128_t"      "_Decimal128"}
353    {"d32_t2"      "_Decimal32"}
354    {"d64_t2"      "_Decimal64"}
355    {"d128_t2"     "_Decimal128"}
356} {
357    set type [lindex $elem 0]
358    set ptype [lindex $elem 1]
359    gdb_test "whatis ($type) 0" " = $type"
360    gdb_test "ptype ($type) 0" " = $ptype"
361}
362
363# Test:
364# - whatis/ptype of variables of typedef type.
365# - whatis/ptype of typedef type names.
366# - whatis/ptype of typedef-of-typedef type names.
367
368# Columns in the sublists represent:
369    # Type name    # whatis      # ptype
370foreach elem {
371    {"v_d32_t"     "d32_t"       "_Decimal32"}
372    {"v_d64_t"     "d64_t"       "_Decimal64"}
373    {"v_d128_t"    "d128_t"      "_Decimal128"}
374
375    {"d32_t"       "_Decimal32"  "_Decimal32"}
376    {"d64_t"       "_Decimal64"  "_Decimal64"}
377    {"d128_t"      "_Decimal128" "_Decimal128"}
378
379    {"d32_t2"      "d32_t"       "_Decimal32"}
380    {"d64_t2"      "d64_t"       "_Decimal64"}
381    {"d128_t2"     "d128_t"      "_Decimal128"}
382} {
383    set type [lindex $elem 0]
384    set whatis [lindex $elem 1]
385    set ptype [lindex $elem 2]
386    gdb_test "whatis $type" " = $whatis"
387    gdb_test "ptype $type" " = $ptype"
388}
389