| 1 | # Copyright (C) 2007-2013 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 | |
| 21 | standard_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. |
| 25 | if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {quiet debug}] != "" } { |
| 26 | verbose "Skipping DFP tests." |
| 27 | return -1 |
| 28 | } |
| 29 | |
| 30 | clean_restart ${binfile} |
| 31 | |
| 32 | if ![runto_main] then { |
| 33 | perror "couldn't run to breakpoint" |
| 34 | continue |
| 35 | } |
| 36 | |
| 37 | set sizeof_long [get_sizeof "long" 4] |
| 38 | |
| 39 | proc 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 | |
| 70 | proc 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 | |
| 100 | proc 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 | |
| 133 | if [gdb_test "next" \ |
| 134 | ".*Positive infd32.*" \ |
| 135 | "next after initializing d32"] then { gdb_suppress_tests } |
| 136 | gdb_test "print d32" "1.2345" "d32 is initialized to 1.2345" |
| 137 | |
| 138 | if [gdb_test "next" \ |
| 139 | ".*Negative infd32.*" \ |
| 140 | "next after assigning builtin infinity to d32"] then { gdb_suppress_tests } |
| 141 | gdb_test "print d32" "Infinity" "d32 is positive Infinity" |
| 142 | |
| 143 | if [gdb_test "next" \ |
| 144 | ".*__builtin_nand32.*" \ |
| 145 | "next after assigning negative builtin infinity to d32"] then { gdb_suppress_tests } |
| 146 | gdb_test "print d32" "-Infinity" "d32 is negative Infinity" |
| 147 | |
| 148 | if [gdb_test "next" \ |
| 149 | ".*d64 = 1.2345.*" \ |
| 150 | "next after assigning builtin NaN to d32"] then { gdb_suppress_tests } |
| 151 | gdb_test "print d32" "NaN" "d32 is NaN" |
| 152 | |
| 153 | d32_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 | |
| 160 | if [gdb_test "next" \ |
| 161 | ".*Positive infd64.*" \ |
| 162 | "next after initializing d64"] then { gdb_suppress_tests } |
| 163 | gdb_test "print d64" "1.2345" "d64 is initialized to 1.2345" |
| 164 | |
| 165 | if [gdb_test "next" \ |
| 166 | ".*Negative infd64.*" \ |
| 167 | "next after assigning builtin infinity to d64"] then { gdb_suppress_tests } |
| 168 | gdb_test "print d64" "Infinity" "d64 is positive Infinity" |
| 169 | |
| 170 | if [gdb_test "next" \ |
| 171 | ".*__builtin_nand64.*" \ |
| 172 | "next after assigning negative builtin infinity to d64"] then { gdb_suppress_tests } |
| 173 | gdb_test "print d64" "-Infinity" "d64 is negative Infinity" |
| 174 | |
| 175 | if [gdb_test "next" \ |
| 176 | ".*d128 = 1.2345.*" \ |
| 177 | "next after assigning builtin NaN to d64"] then { gdb_suppress_tests } |
| 178 | gdb_test "print d64" "NaN" "d64 is NaN" |
| 179 | |
| 180 | d64_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 | |
| 187 | if [gdb_test "next" \ |
| 188 | ".*Positive infd128.*" \ |
| 189 | "next after initializing d128"] then { gdb_suppress_tests } |
| 190 | gdb_test "print d128" "1.2345" "d128 is initialized to 1.2345" |
| 191 | |
| 192 | d128_set_tests |
| 193 | |
| 194 | if [gdb_test "next" \ |
| 195 | ".*Negative infd128.*" \ |
| 196 | "next after assigning builtin infinity to d128"] then { gdb_suppress_tests } |
| 197 | gdb_test "print d128" "Infinity" "d128 is positive Infinity" |
| 198 | |
| 199 | if [gdb_test "next" \ |
| 200 | ".*__builtin_nand128.*" \ |
| 201 | "next after assigning negative builtin infinity to d128"] then { gdb_suppress_tests } |
| 202 | gdb_test "print d128" "-Infinity" "d128 is negative Infinity" |
| 203 | |
| 204 | if [gdb_test "next" \ |
| 205 | ".*arg0_32.*" \ |
| 206 | "next after assigning builtin NaN to d128"] then { gdb_suppress_tests } |
| 207 | gdb_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 | |
| 212 | gdb_breakpoint arg0_32 |
| 213 | gdb_continue_to_breakpoint "entry to arg0_32" |
| 214 | gdb_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 | |
| 216 | gdb_breakpoint arg0_64 |
| 217 | gdb_continue_to_breakpoint "entry to arg0_64" |
| 218 | gdb_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 | |
| 220 | gdb_breakpoint arg0_128 |
| 221 | gdb_continue_to_breakpoint "entry to arg0_128" |
| 222 | 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" |
| 223 | |
| 224 | # Test calling inferior function with DFP arguments or return value. |
| 225 | |
| 226 | gdb_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." |
| 227 | 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\\).*" "Backtrace function with correct _Decimal32 arguments." |
| 228 | gdb_test "finish" " = 1.2" "Correct _Decimal32 return value from called function." |
| 229 | |
| 230 | gdb_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." |
| 231 | 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\\).*" "Backtrace function with correct _Decimal64 arguments." |
| 232 | gdb_test "finish" " = 1.2" "Correct _Decimal64 return value from called function." |
| 233 | |
| 234 | gdb_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." |
| 235 | 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\\).*" "Backtrace function with correct _Decimal128 arguments." |
| 236 | gdb_test "finish" " = 1.2" "Correct _Decimal128 return value from called function." |
| 237 | |
| 238 | 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" \ |
| 239 | "Call function with mixed decimal float arguments TEST." |
| 240 | |
| 241 | gdb_test "call decimal_mixed (dec32_val1, dec64_val1, dec128_val1)" " = 1" \ |
| 242 | "Call function with mixed decimal float arguments." |
| 243 | |
| 244 | 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" \ |
| 245 | "Call function with many _Decimal32 arguments." |
| 246 | |
| 247 | 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" \ |
| 248 | "Call function with many _Decimal64 arguments." |
| 249 | |
| 250 | 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" \ |
| 251 | "Call function with many _Decimal128 arguments." |
| 252 | |
| 253 | 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" \ |
| 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 | |
| 259 | gdb_breakpoint [gdb_get_line_number "Exit point"] |
| 260 | gdb_continue_to_breakpoint "Setting a decimal struct" |
| 261 | gdb_test "print ds.dec32" " = 1.2345" |
| 262 | gdb_test "print ds.dec64" " = 1.2345" |
| 263 | gdb_test "print ds.dec128" " = 1.2345" |
| 264 | |
| 265 | # Test expressions with DFP variables. |
| 266 | |
| 267 | gdb_test "print d32 + ds.dec32" " = 1.3345" |
| 268 | gdb_test "print d64 + ds.dec64" " = 1.3345" |
| 269 | gdb_test "print d128 + ds.dec128" " = 1.3345" |
| 270 | |
| 271 | # Test conversion between different _Decimal sizes. |
| 272 | |
| 273 | gdb_test "ptype d64 + ds.dec32" " = volatile _Decimal64" |
| 274 | gdb_test "ptype d128 + ds.dec32" " = volatile _Decimal128" |
| 275 | gdb_test "ptype d128 + ds.dec64" " = volatile _Decimal128" |
| 276 | |
| 277 | # Mixture of Decimal and integral operands |
| 278 | gdb_test "p d32 + 1" " = 1.1" |
| 279 | gdb_test "p 2 + d64" " = 2.1" |
| 280 | gdb_test "p ds.int4 + d128" " = 1.1" |
| 281 | gdb_test "ptype d32 + 1" " = volatile _Decimal32" |
| 282 | gdb_test "ptype ds.int4 + d128" " = volatile _Decimal128" |
| 283 | |
| 284 | # Test other operations with DFP operands |
| 285 | gdb_test "p !d32" " = 0" |
| 286 | gdb_test "p !d64" " = 0" |
| 287 | gdb_test "p !d128" " = 0" |
| 288 | gdb_test "p +d32" " = 0.1" |
| 289 | gdb_test "p +d64" " = 0.1" |
| 290 | gdb_test "p +d128" " = 0.1" |
| 291 | gdb_test "p d64 == d128" " = 1" |
| 292 | gdb_test "p d128 == ds.dec32" " = 0" |
| 293 | gdb_test "p d128 == d32" " = 1" |
| 294 | gdb_test "p ds.dec32 == ds.dec64" " = 1" |
| 295 | gdb_test "p d32 < ds.dec32" " = 1" |
| 296 | gdb_test "p d64 < ds.dec64" " = 1" |
| 297 | gdb_test "p d128 < ds.dec128" " = 1" |
| 298 | gdb_test "p ds.dec32 < d32" " = 0" |
| 299 | gdb_test "p d64 > ds.dec64" " = 0" |
| 300 | gdb_test "p ds.dec128 > d128 " " = 1" |
| 301 | gdb_test "p d32 < ds.int4" " = 1" |
| 302 | gdb_test "p ds.int4 > d32" " = 1" |
| 303 | gdb_test "p ds.dec32 < ds.int4" " = 0" |
| 304 | gdb_test "p ds.int4 > ds.dec64" " = 0" |
| 305 | gdb_test "p ds.dec128 > ds.int4" " = 1" |
| 306 | |
| 307 | # Reject operation with integral larger than 32-bits |
| 308 | if { ${sizeof_long} > 4 } { |
| 309 | gdb_test "p d32 + ds.long8" "Conversion of large integer to a decimal floating type is not supported." |
| 310 | } |
| 311 | |
| 312 | # Reject operation with DFP and Binary FP |
| 313 | gdb_test "p d64 + ds.float4" "Mixing decimal floating types with other floating types is not allowed." |
| 314 | gdb_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 | |
| 319 | gdb_test "print ds.dec32=d32" " = 0.1" |
| 320 | gdb_test "print ds.dec64=d64" " = 0.1" |
| 321 | gdb_test "print ds.dec128=d128" " = 0.1" |
| 322 | gdb_test "print ds.dec32 = -d32" " = -0.1" |
| 323 | gdb_test "print ds.dec64 = -d64" " = -0.1" |
| 324 | gdb_test "print ds.dec128 = -d128" " = -0.1" |
| 325 | |
| 326 | # Test cast to and from DFP values |
| 327 | |
| 328 | gdb_test "print ds.double8 = ds.dec64" " = -0.(0999.*|1000.*)" |
| 329 | gdb_test "print ds.dec64 = ds.float4" " = 3.(0999.*|1000.*)" |
| 330 | gdb_test "print ds.dec128 = -ds.double8" " = 0.(0999.*|1000.*)" |
| 331 | gdb_test "print ds.dec128 = ds.dec32" " = -0.1" |
| 332 | gdb_test "print ds.dec32 = ds.int4" " = 1" |
| 333 | gdb_test "print ds.int4 = 7.3dl" " = 7" |