gdb/testsuite/gdb.base/dfp-test.exp

   1 # Copyright (C) 2007, 2008 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 proc d32_set_tests {} {
  22
  23     gdb_test "p d32=123.45df" " = 123.45"
  24     gdb_test "p d32=12345.df" " = 12345"
  25     gdb_test "p d32=12345.67df" " = 12345.67"
  26     gdb_test "p d32=1234567.df" " = 1234567"
  27
  28     gdb_test "p d32=1.234567E0df" " = 1.234567"
  29     gdb_test "p d32=1.234567E10df" " = 1.234567E\\+10"
  30     gdb_test "p d32=1.234567E+96df" " = 1.234567E\\+96"
  31
  32     # Test that gdb could handle the max, normalized min and subnormalized min.
  33     gdb_test "p d32=9.999999E96df" " = 9.999999E\\+96"
  34     gdb_test "p d32=1.0E-95df" " = 1.0E\\-95"
  35     gdb_test "p d32=1.E-101df" " = 1E\\-101"
  36     gdb_test "p d32=0.000001E-95df" " = 1E\\-101"
  37
  38     # Test that gdb could detect coefficient/exponent out of range.
  39     # The coefficient out of range will be rounded to its nearest value.
  40     # And the exponent out of range will be handled as infinity.
  41     gdb_test "p d32=1.2345678df" " = 1.234568" "1.2345678 is rounded to 1.234568"
  42     gdb_test "p d32=1.0E-101df" " = 1E-101" "1.0E-101 is rounded to 1E-101"
  43     gdb_test "p d32=1.234567E+97df" " = Infinity" "1.234567E+97 is Infinity"
  44
  45     # Test that gdb could detect the errors in the string representation of _Decimal32
  46     gdb_test "p d32=12345.df" " = 12345" "12345. is an valid number"
  47     gdb_test "p d32=12345df" ".*Invalid number.*" "12345 is an invalid number"
  48     gdb_test "p d32=1.23Edf" " = NaN" "1.23E is NaN (not a number)"
  49     gdb_test "p d32=1.23E45Adf" " = NaN" "1.23E45A is NaN (not a number)"
  50 }
  51
  52 proc d64_set_tests {} {
  53
  54     gdb_test "p d64=123.45dd" " = 123.45"
  55     gdb_test "p d64=12345.dd" " = 12345"
  56     gdb_test "p d64=12345.67dd" " = 12345.67"
  57     gdb_test "p d64=1.234567890123456dd" " = 1.234567890123456"
  58
  59     gdb_test "p d64=1.234567890123456E10dd" " = 12345678901.23456"
  60     gdb_test "p d64=1.234567890123456E100dd" " = 1.234567890123456E\\+100"
  61     gdb_test "p d64=1.234567890123456E384dd" " = 1.234567890123456E\\+384"
  62
  63     # Test that gdb could handle the max, normalized min and subnormalized min.
  64     gdb_test "p d64=9.999999999999999E384dd" " = 9.999999999999999E\\+384"
  65     gdb_test "p d64=1.E-383dd" " = 1E\\-383"
  66     gdb_test "p d64=1.E-398dd" " = 1E\\-398"
  67     gdb_test "p d64=0.000000000000001E-383dd" " = 1E\\-398"
  68
  69     # Test that gdb could detect coefficient/exponent out of range.
  70     # The coefficient out of range will be rounded to its nearest value.
  71     # And the exponent out of range will be handled as infinity.
  72     gdb_test "p d64=1.2345678901234567dd" " = 1.234567890123457" "1.2345678901234567 is rounded to 1.234567890123457"
  73     gdb_test "p d64=9.9999999999999999E384dd" " = Infinity" "d64=9.9999999999999999E384 is Infinity"
  74     gdb_test "p d64=1.234567890123456E385dd" " = Infinity" "d64=1.234567890123456E385 is Infinity"
  75
  76     # Test that gdb could detect the errors in the string representation of _Decimal64
  77     gdb_test "p d64=12345dd" ".*Invalid number.*" "12345dd is an invalid number"
  78     gdb_test "p d64=1.23Edd" " = NaN" "1.23E is NaN (not a number)"
  79     gdb_test "p d64=1.23E45Add" "= NaN" "1.23E45A is NaN (not a number)"
  80 }
  81
  82 proc d128_set_tests {} {
  83
  84     gdb_test "p d128=123.45dl" " = 123.45"
  85     gdb_test "p d128=12345.dl" " = 12345"
  86     gdb_test "p d128=12345.67dl" " = 12345.67"
  87     gdb_test "p d128=1.234567890123456789012345678901234dl" " = 1.234567890123456789012345678901234"
  88
  89     gdb_test "p d128=1.234567890123456E10dl" " = 12345678901.23456"
  90     gdb_test "p d128=1.234567890123456E100dl" " = 1.234567890123456E\\+100"
  91     gdb_test "p d128=1.234567890123456E1000dl" " = 1.234567890123456E\\+1000"
  92
  93     # Test that gdb could handle the max, normalized min and subnormalized min.
  94     gdb_test "p d128=9.999999999999999999999999999999999E6144dl" " = 9.999999999999999999999999999999999E\\+6144"
  95     gdb_test "p d128=1.E-6143dl" " = 1E\\-6143"
  96     gdb_test "p d128=1.E-6176dl" " = 1E\\-6176"
  97     gdb_test "p d128=0.000000000000000000000000000000001E-6143dl" " = 1E\\-6176"
  98
  99     # Test that gdb could detect coefficient/exponent out of range.
 100     # The coefficient out of range will be rounded to its nearest value.
 101     # And the exponent out of range will be handled as infinity.
 102     gdb_test "p d128=1.2345678901234567890123456789012345dl" "1.234567890123456789012345678901234" "1.2345678901234567890123456789012345 is rounded to 1.234567890123456789012345678901234"
 103     gdb_test "p d128=1.234567890123456E6145dl" "Infinity" "d128=1.234567890123456E6145 is Infinity"
 104
 105     # Test that gdb could detect the errors in the string representation of _Decimal128
 106     gdb_test "p d128=12345dl" ".*Invalid number.*" "12345dl is an invalid number"
 107     gdb_test "p d128=1.23Edl" " = NaN" "1.23E is NaN (not a number)"
 108     gdb_test "p d128=1.23E45Adl" "= NaN" "1.23E45A is NaN (not a number)"
 109 }
 110
 111
 112 if $tracelevel {
 113     strace $tracelevel
 114 }
 115
 116 set testfile "dfp-test"
 117 set srcfile ${testfile}.c
 118 set binfile ${objdir}/${subdir}/${testfile}
 119 # Try to compile the test case.  If we can't, assume the
 120 # toolchain does not yet provide DFP support and bail out.
 121 if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {quiet debug}] != "" } {
 122     verbose "Skipping DFP tests."
 123     return -1
 124 }
 125
 126 gdb_exit
 127 gdb_start
 128 gdb_reinitialize_dir $srcdir/$subdir
 129 gdb_load ${binfile}
 130
 131 if ![runto_main] then {
 132     perror "couldn't run to breakpoint"
 133     continue
 134 }
 135
 136 # Different tests on 32-bits decimal floating point, including the printing
 137 # of finite numbers, infinite and NaN, and also the setting of different
 138 # decimal value.
 139
 140 if [gdb_test "next" \
 141     ".*Positive infd32.*" \
 142     "next after initializing d32"] then { gdb_suppress_tests }
 143 gdb_test "print d32" "1.2345" "d32 is initialized to 1.2345"
 144
 145 if [gdb_test "next" \
 146     ".*Negative infd32.*" \
 147     "next after assigning builtin infinity to d32"] then { gdb_suppress_tests }
 148 gdb_test "print d32" "Infinity" "d32 is positive Infinity"
 149
 150 if [gdb_test "next" \
 151     ".*__builtin_nand32.*" \
 152     "next after assigning negative builtin infinity to d32"] then { gdb_suppress_tests }
 153 gdb_test "print d32" "-Infinity" "d32 is negative Infinity"
 154
 155 if [gdb_test "next" \
 156     ".*d64 = 1.2345.*" \
 157     "next after assigning builtin NaN to d32"] then { gdb_suppress_tests }
 158 gdb_test "print d32" "NaN" "d32 is NaN"
 159
 160 d32_set_tests
 161
 162
 163 # Different tests on 64-bits decimal floating point, including the display
 164 # of finite number, infinite and NaN, and also the setting of different
 165 # decimal value.
 166
 167 if [gdb_test "next" \
 168     ".*Positive infd64.*" \
 169     "next after initializing d64"] then { gdb_suppress_tests }
 170 gdb_test "print d64" "1.2345" "d64 is initialized to 1.2345"
 171
 172 if [gdb_test "next" \
 173     ".*Negative infd64.*" \
 174     "next after assigning builtin infinity to d64"] then { gdb_suppress_tests }
 175 gdb_test "print d64" "Infinity" "d64 is positive Infinity"
 176
 177 if [gdb_test "next" \
 178     ".*__builtin_nand64.*" \
 179     "next after assigning negative builtin infinity to d64"] then { gdb_suppress_tests }
 180 gdb_test "print d64" "-Infinity" "d64 is negative Infinity"
 181
 182 if [gdb_test "next" \
 183     ".*d128 = 1.2345.*" \
 184     "next after assigning builtin NaN to d64"] then { gdb_suppress_tests }
 185 gdb_test "print d64" "NaN" "d64 is NaN"
 186
 187 d64_set_tests
 188
 189
 190 # Different tests on 128-bits decimal floating point, including the display
 191 # of finite number, infinite and NaN, and also the setting of different
 192 # decimal value.
 193
 194 if [gdb_test "next" \
 195     ".*Positive infd128.*" \
 196     "next after initializing d128"] then { gdb_suppress_tests }
 197 gdb_test "print d128" "1.2345" "d128 is initialized to 1.2345"
 198
 199 d128_set_tests
 200
 201 if [gdb_test "next" \
 202     ".*Negative infd128.*" \
 203     "next after assigning builtin infinity to d128"] then { gdb_suppress_tests }
 204 gdb_test "print d128" "Infinity" "d128 is positive Infinity"
 205
 206 if [gdb_test "next" \
 207     ".*__builtin_nand128.*" \
 208     "next after assigning negative builtin infinity to d128"] then { gdb_suppress_tests }
 209 gdb_test "print d128" "-Infinity" "d128 is negative Infinity"
 210
 211 if [gdb_test "next" \
 212     ".*arg0_32.*" \
 213     "next after assigning builtin NaN to d128"] then { gdb_suppress_tests }
 214 gdb_test "print d128" "NaN" "d128 is NaN"
 215
 216 # The following tests are intended to verify that gdb can correctly handle
 217 # DFP types in function arguments.
 218
 219 gdb_breakpoint arg0_32
 220 gdb_continue_to_breakpoint "entry to arg0_32"
 221 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"
 222
 223 gdb_breakpoint arg0_64
 224 gdb_continue_to_breakpoint "entry to arg0_64"
 225 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"
 226
 227 gdb_breakpoint arg0_128
 228 gdb_continue_to_breakpoint "entry to arg0_128"
 229 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"
 230
 231 # The following tests are intended to verify that gdb can handle DFP types
 232 # correctly in struct.
 233
 234 gdb_breakpoint [gdb_get_line_number "Exit point"]
 235 gdb_continue_to_breakpoint "Setting a decimal struct"
 236 gdb_test "print ds.dec32" " = 1.2345"
 237 gdb_test "print ds.dec64" " = 1.2345"
 238 gdb_test "print ds.dec128" " = 1.2345"
 239
 240 # The following tests are intended to verify that gdb can handle "d1=d2"
 241 # and "d1=-d2" correctly.
 242
 243 gdb_test "print ds.dec32=d32" " = 0.1"
 244 gdb_test "print ds.dec64=d64" " = 0.1"
 245 gdb_test "print ds.dec128=d128" " = 0.1"
 246 gdb_test "print ds.dec32 = -d32" " = -0.1"
 247 gdb_test "print ds.dec64 = -d64" " = -0.1"
 248 gdb_test "print ds.dec128 = -d128" " = -0.1"