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