sid/component/cgen-cpu/cgen-fpu.cxx

   1 // cgen-fpu.cxx - CPU components.  -*- C++ -*-
   2 // CGEN fpu support for SID
   3 //
   4 // Copyright (C) 2005, 2010 Red Hat.
   5 // This file is part of SID and is licensed under the GPL.
   6 // See the file COPYING.SID for conditions for redistribution.
   7
   8 #include "cgen-fpu.h"
   9 #include "fp.h"
  10
  11 using namespace sidutil;
  12
  13 namespace cgen
  14 {
  15 /* basic SF ops */
  16 SF
  17 cgen_fp_ops::addsf (const cgen_fpu* fpu, SF x, SF y)
  18 {
  19   fp r = fp (x) + fp (y);
  20   check_result (fpu, r);
  21   SF tmp;
  22   r.pack (tmp);
  23   return tmp;
  24 }
  25
  26 SF cgen_fp_ops::subsf (const cgen_fpu* fpu, SF x, SF y)
  27 {
  28   fp r = fp (x) - fp (y);
  29   check_result (fpu, r);
  30   SF tmp;
  31   r.pack (tmp);
  32   return tmp;
  33 }
  34
  35 SF cgen_fp_ops::mulsf (const cgen_fpu* fpu, SF x, SF y)
  36 {
  37   fp r = fp (x) * fp (y);
  38   check_result (fpu, r);
  39   SF tmp;
  40   r.pack (tmp);
  41   return tmp;
  42 }
  43
  44 SF cgen_fp_ops::divsf (const cgen_fpu* fpu, SF x, SF y)
  45 {
  46   fp r = fp (x) / fp (y);
  47   check_result (fpu, r);
  48   SF tmp;
  49   r.pack (tmp);
  50   return tmp;
  51 }
  52
  53 SF cgen_fp_ops::negsf (const cgen_fpu* fpu, SF x)
  54 {
  55   fp r (x);
  56   r = fp::neg (r);
  57   check_result (fpu, r);
  58   SF tmp;
  59   r.pack (tmp);
  60   return tmp;
  61 }
  62
  63 SF cgen_fp_ops::abssf (const cgen_fpu* fpu, SF x)
  64 {
  65   fp r (x);
  66   r = fp::abs (r);
  67   check_result (fpu, r);
  68   SF tmp;
  69   r.pack (tmp);
  70   return tmp;
  71 }
  72
  73 SF cgen_fp_ops::sqrtsf (const cgen_fpu* fpu, SF x)
  74 {
  75   fp r (x);
  76   r = fp::sqrt (r);
  77   check_result (fpu, r);
  78   SF tmp;
  79   r.pack (tmp);
  80   return tmp;
  81 }
  82
  83
  84 #if 0 // not implemented yet
  85 SF cgen_fp_ops::invsf (const cgen_fpu*, SF);
  86 SF cgen_fp_ops::cossf (const cgen_fpu*, SF);
  87 SF cgen_fp_ops::sinsf (const cgen_fpu*, SF);
  88 SF cgen_fp_ops::minsf (const cgen_fpu*, SF, SF);
  89 SF cgen_fp_ops::maxsf (const cgen_fpu*, SF, SF);
  90 #endif
  91
  92 int cgen_fp_ops::eqsf (const cgen_fpu*, SF x, SF y)
  93 {
  94   return fp (x) == fp (y);
  95 }
  96 int cgen_fp_ops::nesf (const cgen_fpu*, SF x, SF y)
  97 {
  98   return fp (x) != fp (y);
  99 }
 100 int cgen_fp_ops::ltsf (const cgen_fpu*, SF x, SF y)
 101 {
 102   return fp (x) < fp (y);
 103 }
 104 int cgen_fp_ops::lesf (const cgen_fpu*, SF x, SF y)
 105 {
 106   return fp (x) <= fp (y);
 107 }
 108 int cgen_fp_ops::gtsf (const cgen_fpu*, SF x, SF y)
 109 {
 110   return fp (x) > fp (y);
 111 }
 112 int cgen_fp_ops::gesf (const cgen_fpu*, SF x, SF y)
 113 {
 114   return fp (x) >= fp (y);
 115 }
 116
 117 int cgen_fp_ops::unorderedsf (const cgen_fpu*, SF x, SF y)
 118 {
 119   fp f1(x);
 120   fp f2(y);
 121   return f1.is_nan () || f2.is_nan ();
 122 }
 123
 124 /* basic DF ops */
 125 DF cgen_fp_ops::adddf (const cgen_fpu *fpu, DF x, DF y)
 126 {
 127   fp r = fp (x) + fp (y);
 128   check_result (fpu, r);
 129   DF tmp;
 130   r.pack (tmp);
 131   return tmp;
 132 }
 133
 134 DF cgen_fp_ops::subdf (const cgen_fpu *fpu, DF x, DF y)
 135 {
 136   fp r = fp (x) - fp (y);
 137   check_result (fpu, r);
 138   DF tmp;
 139   r.pack (tmp);
 140   return tmp;
 141 }
 142
 143 DF cgen_fp_ops::muldf (const cgen_fpu *fpu, DF x, DF y)
 144 {
 145   fp r = fp (x) * fp (y);
 146   check_result (fpu, r);
 147   DF tmp;
 148   r.pack (tmp);
 149   return tmp;
 150 }
 151
 152 DF cgen_fp_ops::divdf (const cgen_fpu *fpu, DF x, DF y)
 153 {
 154   fp r = fp (x) / fp (y);
 155   check_result (fpu, r);
 156   DF tmp;
 157   r.pack (tmp);
 158   return tmp;
 159 }
 160
 161 DF cgen_fp_ops::negdf (const cgen_fpu *fpu, DF x)
 162 {
 163   fp r (x);
 164   r = fp::neg (r);
 165   check_result (fpu, r);
 166   DF tmp;
 167   r.pack (tmp);
 168   return tmp;
 169 }
 170
 171 DF cgen_fp_ops::absdf (const cgen_fpu *fpu, DF x)
 172 {
 173   fp r (x);
 174   r = fp::abs (r);
 175   check_result (fpu, r);
 176   DF tmp;
 177   r.pack (tmp);
 178   return tmp;
 179 }
 180
 181 DF cgen_fp_ops::sqrtdf (const cgen_fpu *fpu, DF x)
 182 {
 183   fp r (x);
 184   r = fp::sqrt (r);
 185   check_result (fpu, r);
 186   DF tmp;
 187   r.pack (tmp);
 188   return tmp;
 189 }
 190
 191 #if 0
 192 DF cgen_fp_ops::invdf (const cgen_fpu*, DF);
 193 DF cgen_fp_ops::cosdf (const cgen_fpu*, DF);
 194 DF cgen_fp_ops::sindf (const cgen_fpu*, DF);
 195 DF cgen_fp_ops::mindf (const cgen_fpu*, DF, DF);
 196 DF cgen_fp_ops::maxdf (const cgen_fpu*, DF, DF);
 197 #endif
 198
 199 int cgen_fp_ops::eqdf (const cgen_fpu *fpu, DF x, DF y)
 200 {
 201   return fp (x) == fp (y);
 202 }
 203
 204 int cgen_fp_ops::nedf (const cgen_fpu *fpu, DF x, DF y)
 205 {
 206   return fp (x) == fp (y);
 207 }
 208 int cgen_fp_ops::ltdf (const cgen_fpu *fpu, DF x, DF y)
 209 {
 210   return fp (x) < fp (y);
 211 }
 212 int cgen_fp_ops::ledf (const cgen_fpu *fpu, DF x, DF y)
 213 {
 214   return fp (x) <= fp (y);
 215 }
 216 int cgen_fp_ops::gtdf (const cgen_fpu *fpu, DF x, DF y)
 217 {
 218   return fp (x) > fp (y);
 219 }
 220 int cgen_fp_ops::gedf (const cgen_fpu *fpu, DF x, DF y)
 221 {
 222   return fp (x) >= fp (y);
 223 }
 224
 225 int cgen_fp_ops::unordereddf (const cgen_fpu *fpu, DF x, DF y)
 226 {
 227   fp f1(x);
 228   fp f2(y);
 229   return f1.is_nan () || f2.is_nan ();
 230 }
 231
 232 /* SF/DF conversion ops */
 233
 234 DF cgen_fp_ops::fextsfdf (const cgen_fpu *fpu, int how, SF x)
 235 {
 236   fp r (x);
 237   DF tmp;
 238   r.pack (tmp);
 239   return tmp;
 240 }
 241
 242 SF cgen_fp_ops::ftruncdfsf (const cgen_fpu *fpu, int how, DF x)
 243 {
 244   fp r (x);
 245   SF tmp;
 246   r.pack (tmp);
 247   return tmp;
 248 }
 249
 250 SF cgen_fp_ops::floatsisf (const cgen_fpu* fpu, int how, SI x)
 251 {
 252   fp r = fp::from_int (x);
 253   check_result (fpu, r);
 254   SF tmp;
 255   r.pack (tmp);
 256   return tmp;
 257 }
 258
 259 SF cgen_fp_ops::floatdisf (const cgen_fpu *fpu, int how, DI x)
 260 {
 261   fp r = fp::from_int (x);
 262   check_result (fpu, r);
 263   DF tmp;
 264   r.pack (tmp);
 265   return tmp;
 266 }
 267
 268 #if 0 // not implemented yet
 269 SF cgen_fp_ops::ufloatsisf (const cgen_fpu*, int how, USI);
 270 SF cgen_fp_ops::ufloatdisf (const cgen_fpu*, int how, UDI);
 271 #endif // not implemented yet
 272
 273 SI cgen_fp_ops::fixsfsi (const cgen_fpu *fpu, int how, SF x)
 274 {
 275   fp r (x);
 276   SI tmp;
 277   r.integer (tmp, fp::round_default);
 278   return tmp;
 279 }
 280
 281 DI cgen_fp_ops::fixsfdi (const cgen_fpu *fpu, int how, SF x)
 282 {
 283   fp r (x);
 284   DI tmp;
 285   r.integer (tmp, fp::round_default);
 286   return tmp;
 287 }
 288
 289 #if 0 // not implemented yet
 290 USI cgen_fp_ops::ufixsfsi (const cgen_fpu*, int how, SF);
 291 UDI cgen_fp_ops::ufixsfdi (const cgen_fpu*, int how, SF);
 292 #endif
 293
 294 DF cgen_fp_ops::floatsidf (const cgen_fpu *fpu, int how, SI x)
 295 {
 296   fp r = fp::from_int (x);
 297   check_result (fpu, r);
 298   DF tmp;
 299   r.pack (tmp);
 300   return tmp;
 301 }
 302
 303 DF cgen_fp_ops::floatdidf (const cgen_fpu *fpu, int how, DI x)
 304 {
 305   fp r = fp::from_int (x);
 306   check_result (fpu, r);
 307   DF tmp;
 308   r.pack (tmp);
 309   return tmp;
 310 }
 311
 312 #if 0
 313 DF cgen_fp_ops::ufloatsidf (const cgen_fpu*, int how, USI);
 314 DF cgen_fp_ops::ufloatdidf (const cgen_fpu*, int how, UDI);
 315 #endif
 316
 317 SI cgen_fp_ops::fixdfsi (const cgen_fpu *fpu, int how, DF x)
 318 {
 319   fp r (x);
 320   SI tmp;
 321   r.integer (tmp, fp::round_default);
 322   return tmp;
 323 }
 324
 325 DI cgen_fp_ops::fixdfdi (const cgen_fpu *fpu, int how, DF x)
 326 {
 327   fp r (x);
 328   DI tmp;
 329   r.integer (tmp, fp::round_default);
 330   return tmp;
 331 }
 332
 333 #if 0
 334 USI cgen_fp_ops::ufixdfsi (const cgen_fpu*, int how, DF);
 335 UDI cgen_fp_ops::ufixdfdi (const cgen_fpu*, int how, DF);
 336
 337 /* XF mode support (kept separate 'cus not always present) */
 338 XF cgen_fp_ops::addxf (const cgen_fpu*, XF, XF);
 339 XF cgen_fp_ops::subxf (const cgen_fpu*, XF, XF);
 340 XF cgen_fp_ops::mulxf (const cgen_fpu*, XF, XF);
 341 XF cgen_fp_ops::divxf (const cgen_fpu*, XF, XF);
 342 XF cgen_fp_ops::negxf (const cgen_fpu*, XF);
 343 XF cgen_fp_ops::absxf (const cgen_fpu*, XF);
 344 XF cgen_fp_ops::sqrtxf (const cgen_fpu*, XF);
 345 XF cgen_fp_ops::invxf (const cgen_fpu*, XF);
 346 XF cgen_fp_ops::cosxf (const cgen_fpu*, XF);
 347 XF cgen_fp_ops::sinxf (const cgen_fpu*, XF);
 348 XF cgen_fp_ops::minxf (const cgen_fpu*, XF, XF);
 349 XF cgen_fp_ops::maxxf (const cgen_fpu*, XF, XF);
 350
 351 int cgen_fp_ops::eqxf (const cgen_fpu*, XF, XF);
 352 int cgen_fp_ops::nexf (const cgen_fpu*, XF, XF);
 353 int cgen_fp_ops::ltxf (const cgen_fpu*, XF, XF);
 354 int cgen_fp_ops::lexf (const cgen_fpu*, XF, XF);
 355 int cgen_fp_ops::gtxf (const cgen_fpu*, XF, XF);
 356 int cgen_fp_ops::gexf (const cgen_fpu*, XF, XF);
 357
 358 XF cgen_fp_ops::extsfxf (const cgen_fpu*, int how, SF);
 359 XF cgen_fp_ops::extdfxf (const cgen_fpu*, int how, DF);
 360 SF cgen_fp_ops::truncxfsf (const cgen_fpu*, int how, XF);
 361 DF cgen_fp_ops::truncxfdf (const cgen_fpu*, int how, XF);
 362
 363 XF cgen_fp_ops::floatsixf (const cgen_fpu*, int how, SI);
 364 XF cgen_fp_ops::floatdixf (const cgen_fpu*, int how, DI);
 365 XF cgen_fp_ops::ufloatsixf (const cgen_fpu*, int how, USI);
 366 XF cgen_fp_ops::ufloatdixf (const cgen_fpu*, int how, UDI);
 367
 368 SI cgen_fp_ops::fixxfsi (const cgen_fpu*, int how, XF);
 369 DI cgen_fp_ops::fixxfdi (const cgen_fpu*, int how, XF);
 370 USI cgen_fp_ops::ufixxfsi (const cgen_fpu*, int how, XF);
 371 UDI cgen_fp_ops::ufixxfdi (const cgen_fpu*, int how, XF);
 372
 373 /* TF mode support (kept separate 'cus not always present) */
 374 TF cgen_fp_ops::addtf (const cgen_fpu*, TF, TF);
 375 TF cgen_fp_ops::subtf (const cgen_fpu*, TF, TF);
 376 TF cgen_fp_ops::multf (const cgen_fpu*, TF, TF);
 377 TF cgen_fp_ops::divtf (const cgen_fpu*, TF, TF);
 378 TF cgen_fp_ops::negtf (const cgen_fpu*, TF);
 379 TF cgen_fp_ops::abstf (const cgen_fpu*, TF);
 380 TF cgen_fp_ops::sqrttf (const cgen_fpu*, TF);
 381 TF cgen_fp_ops::invtf (const cgen_fpu*, TF);
 382 TF cgen_fp_ops::costf (const cgen_fpu*, TF);
 383 TF cgen_fp_ops::sintf (const cgen_fpu*, TF);
 384 TF cgen_fp_ops::mintf (const cgen_fpu*, TF, TF);
 385 TF cgen_fp_ops::maxtf (const cgen_fpu*, TF, TF);
 386
 387 int cgen_fp_ops::eqtf (const cgen_fpu*, TF, TF);
 388 int cgen_fp_ops::netf (const cgen_fpu*, TF, TF);
 389 int cgen_fp_ops::lttf (const cgen_fpu*, TF, TF);
 390 int cgen_fp_ops::letf (const cgen_fpu*, TF, TF);
 391 int cgen_fp_ops::gttf (const cgen_fpu*, TF, TF);
 392 int cgen_fp_ops::getf (const cgen_fpu*, TF, TF);
 393
 394 TF cgen_fp_ops::extsftf (const cgen_fpu*, int how, SF);
 395 TF cgen_fp_ops::extdftf (const cgen_fpu*, int how, DF);
 396 SF cgen_fp_ops::trunctfsf (const cgen_fpu*, int how, TF);
 397 DF cgen_fp_ops::trunctfdf (const cgen_fpu*, int how, TF);
 398
 399 TF cgen_fp_ops::floatsitf (const cgen_fpu*, int how, SI);
 400 TF cgen_fp_ops::floatditf (const cgen_fpu*, int how, DI);
 401 TF cgen_fp_ops::ufloatsitf (const cgen_fpu*, int how, USI);
 402 TF cgen_fp_ops::ufloatditf (const cgen_fpu*, int how, UDI);
 403
 404 SI cgen_fp_ops::fixtfsi (const cgen_fpu*, int how, TF);
 405 DI cgen_fp_ops::fixtfdi (const cgen_fpu*, int how, TF);
 406 USI cgen_fp_ops::ufixtfsi (const cgen_fpu*, int how, TF);
 407 UDI cgen_fp_ops::ufixtfdi (const cgen_fpu*, int how, TF);
 408 #endif // not implemented yet
 409
 410 }; // namespace cgen