target-i386/int_helper.c

   1 /*
   2  *  x86 integer helpers
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "cpu.h"
  21 #include "dyngen-exec.h"
  22 #include "host-utils.h"
  23 #include "helper.h"
  24
  25 //#define DEBUG_MULDIV
  26
  27 /* modulo 9 table */
  28 static const uint8_t rclb_table[32] = {
  29     0, 1, 2, 3, 4, 5, 6, 7,
  30     8, 0, 1, 2, 3, 4, 5, 6,
  31     7, 8, 0, 1, 2, 3, 4, 5,
  32     6, 7, 8, 0, 1, 2, 3, 4,
  33 };
  34
  35 /* modulo 17 table */
  36 static const uint8_t rclw_table[32] = {
  37     0, 1, 2, 3, 4, 5, 6, 7,
  38     8, 9, 10, 11, 12, 13, 14, 15,
  39     16, 0, 1, 2, 3, 4, 5, 6,
  40     7, 8, 9, 10, 11, 12, 13, 14,
  41 };
  42
  43 /* division, flags are undefined */
  44
  45 void helper_divb_AL(target_ulong t0)
  46 {
  47     unsigned int num, den, q, r;
  48
  49     num = (EAX & 0xffff);
  50     den = (t0 & 0xff);
  51     if (den == 0) {
  52         raise_exception(env, EXCP00_DIVZ);
  53     }
  54     q = (num / den);
  55     if (q > 0xff) {
  56         raise_exception(env, EXCP00_DIVZ);
  57     }
  58     q &= 0xff;
  59     r = (num % den) & 0xff;
  60     EAX = (EAX & ~0xffff) | (r << 8) | q;
  61 }
  62
  63 void helper_idivb_AL(target_ulong t0)
  64 {
  65     int num, den, q, r;
  66
  67     num = (int16_t)EAX;
  68     den = (int8_t)t0;
  69     if (den == 0) {
  70         raise_exception(env, EXCP00_DIVZ);
  71     }
  72     q = (num / den);
  73     if (q != (int8_t)q) {
  74         raise_exception(env, EXCP00_DIVZ);
  75     }
  76     q &= 0xff;
  77     r = (num % den) & 0xff;
  78     EAX = (EAX & ~0xffff) | (r << 8) | q;
  79 }
  80
  81 void helper_divw_AX(target_ulong t0)
  82 {
  83     unsigned int num, den, q, r;
  84
  85     num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
  86     den = (t0 & 0xffff);
  87     if (den == 0) {
  88         raise_exception(env, EXCP00_DIVZ);
  89     }
  90     q = (num / den);
  91     if (q > 0xffff) {
  92         raise_exception(env, EXCP00_DIVZ);
  93     }
  94     q &= 0xffff;
  95     r = (num % den) & 0xffff;
  96     EAX = (EAX & ~0xffff) | q;
  97     EDX = (EDX & ~0xffff) | r;
  98 }
  99
 100 void helper_idivw_AX(target_ulong t0)
 101 {
 102     int num, den, q, r;
 103
 104     num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
 105     den = (int16_t)t0;
 106     if (den == 0) {
 107         raise_exception(env, EXCP00_DIVZ);
 108     }
 109     q = (num / den);
 110     if (q != (int16_t)q) {
 111         raise_exception(env, EXCP00_DIVZ);
 112     }
 113     q &= 0xffff;
 114     r = (num % den) & 0xffff;
 115     EAX = (EAX & ~0xffff) | q;
 116     EDX = (EDX & ~0xffff) | r;
 117 }
 118
 119 void helper_divl_EAX(target_ulong t0)
 120 {
 121     unsigned int den, r;
 122     uint64_t num, q;
 123
 124     num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
 125     den = t0;
 126     if (den == 0) {
 127         raise_exception(env, EXCP00_DIVZ);
 128     }
 129     q = (num / den);
 130     r = (num % den);
 131     if (q > 0xffffffff) {
 132         raise_exception(env, EXCP00_DIVZ);
 133     }
 134     EAX = (uint32_t)q;
 135     EDX = (uint32_t)r;
 136 }
 137
 138 void helper_idivl_EAX(target_ulong t0)
 139 {
 140     int den, r;
 141     int64_t num, q;
 142
 143     num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
 144     den = t0;
 145     if (den == 0) {
 146         raise_exception(env, EXCP00_DIVZ);
 147     }
 148     q = (num / den);
 149     r = (num % den);
 150     if (q != (int32_t)q) {
 151         raise_exception(env, EXCP00_DIVZ);
 152     }
 153     EAX = (uint32_t)q;
 154     EDX = (uint32_t)r;
 155 }
 156
 157 /* bcd */
 158
 159 /* XXX: exception */
 160 void helper_aam(int base)
 161 {
 162     int al, ah;
 163
 164     al = EAX & 0xff;
 165     ah = al / base;
 166     al = al % base;
 167     EAX = (EAX & ~0xffff) | al | (ah << 8);
 168     CC_DST = al;
 169 }
 170
 171 void helper_aad(int base)
 172 {
 173     int al, ah;
 174
 175     al = EAX & 0xff;
 176     ah = (EAX >> 8) & 0xff;
 177     al = ((ah * base) + al) & 0xff;
 178     EAX = (EAX & ~0xffff) | al;
 179     CC_DST = al;
 180 }
 181
 182 void helper_aaa(void)
 183 {
 184     int icarry;
 185     int al, ah, af;
 186     int eflags;
 187
 188     eflags = helper_cc_compute_all(CC_OP);
 189     af = eflags & CC_A;
 190     al = EAX & 0xff;
 191     ah = (EAX >> 8) & 0xff;
 192
 193     icarry = (al > 0xf9);
 194     if (((al & 0x0f) > 9) || af) {
 195         al = (al + 6) & 0x0f;
 196         ah = (ah + 1 + icarry) & 0xff;
 197         eflags |= CC_C | CC_A;
 198     } else {
 199         eflags &= ~(CC_C | CC_A);
 200         al &= 0x0f;
 201     }
 202     EAX = (EAX & ~0xffff) | al | (ah << 8);
 203     CC_SRC = eflags;
 204 }
 205
 206 void helper_aas(void)
 207 {
 208     int icarry;
 209     int al, ah, af;
 210     int eflags;
 211
 212     eflags = helper_cc_compute_all(CC_OP);
 213     af = eflags & CC_A;
 214     al = EAX & 0xff;
 215     ah = (EAX >> 8) & 0xff;
 216
 217     icarry = (al < 6);
 218     if (((al & 0x0f) > 9) || af) {
 219         al = (al - 6) & 0x0f;
 220         ah = (ah - 1 - icarry) & 0xff;
 221         eflags |= CC_C | CC_A;
 222     } else {
 223         eflags &= ~(CC_C | CC_A);
 224         al &= 0x0f;
 225     }
 226     EAX = (EAX & ~0xffff) | al | (ah << 8);
 227     CC_SRC = eflags;
 228 }
 229
 230 void helper_daa(void)
 231 {
 232     int old_al, al, af, cf;
 233     int eflags;
 234
 235     eflags = helper_cc_compute_all(CC_OP);
 236     cf = eflags & CC_C;
 237     af = eflags & CC_A;
 238     old_al = al = EAX & 0xff;
 239
 240     eflags = 0;
 241     if (((al & 0x0f) > 9) || af) {
 242         al = (al + 6) & 0xff;
 243         eflags |= CC_A;
 244     }
 245     if ((old_al > 0x99) || cf) {
 246         al = (al + 0x60) & 0xff;
 247         eflags |= CC_C;
 248     }
 249     EAX = (EAX & ~0xff) | al;
 250     /* well, speed is not an issue here, so we compute the flags by hand */
 251     eflags |= (al == 0) << 6; /* zf */
 252     eflags |= parity_table[al]; /* pf */
 253     eflags |= (al & 0x80); /* sf */
 254     CC_SRC = eflags;
 255 }
 256
 257 void helper_das(void)
 258 {
 259     int al, al1, af, cf;
 260     int eflags;
 261
 262     eflags = helper_cc_compute_all(CC_OP);
 263     cf = eflags & CC_C;
 264     af = eflags & CC_A;
 265     al = EAX & 0xff;
 266
 267     eflags = 0;
 268     al1 = al;
 269     if (((al & 0x0f) > 9) || af) {
 270         eflags |= CC_A;
 271         if (al < 6 || cf) {
 272             eflags |= CC_C;
 273         }
 274         al = (al - 6) & 0xff;
 275     }
 276     if ((al1 > 0x99) || cf) {
 277         al = (al - 0x60) & 0xff;
 278         eflags |= CC_C;
 279     }
 280     EAX = (EAX & ~0xff) | al;
 281     /* well, speed is not an issue here, so we compute the flags by hand */
 282     eflags |= (al == 0) << 6; /* zf */
 283     eflags |= parity_table[al]; /* pf */
 284     eflags |= (al & 0x80); /* sf */
 285     CC_SRC = eflags;
 286 }
 287
 288 #ifdef TARGET_X86_64
 289 static void add128(uint64_t *plow, uint64_t *phigh, uint64_t a, uint64_t b)
 290 {
 291     *plow += a;
 292     /* carry test */
 293     if (*plow < a) {
 294         (*phigh)++;
 295     }
 296     *phigh += b;
 297 }
 298
 299 static void neg128(uint64_t *plow, uint64_t *phigh)
 300 {
 301     *plow = ~*plow;
 302     *phigh = ~*phigh;
 303     add128(plow, phigh, 1, 0);
 304 }
 305
 306 /* return TRUE if overflow */
 307 static int div64(uint64_t *plow, uint64_t *phigh, uint64_t b)
 308 {
 309     uint64_t q, r, a1, a0;
 310     int i, qb, ab;
 311
 312     a0 = *plow;
 313     a1 = *phigh;
 314     if (a1 == 0) {
 315         q = a0 / b;
 316         r = a0 % b;
 317         *plow = q;
 318         *phigh = r;
 319     } else {
 320         if (a1 >= b) {
 321             return 1;
 322         }
 323         /* XXX: use a better algorithm */
 324         for (i = 0; i < 64; i++) {
 325             ab = a1 >> 63;
 326             a1 = (a1 << 1) | (a0 >> 63);
 327             if (ab || a1 >= b) {
 328                 a1 -= b;
 329                 qb = 1;
 330             } else {
 331                 qb = 0;
 332             }
 333             a0 = (a0 << 1) | qb;
 334         }
 335 #if defined(DEBUG_MULDIV)
 336         printf("div: 0x%016" PRIx64 "%016" PRIx64 " / 0x%016" PRIx64
 337                ": q=0x%016" PRIx64 " r=0x%016" PRIx64 "\n",
 338                *phigh, *plow, b, a0, a1);
 339 #endif
 340         *plow = a0;
 341         *phigh = a1;
 342     }
 343     return 0;
 344 }
 345
 346 /* return TRUE if overflow */
 347 static int idiv64(uint64_t *plow, uint64_t *phigh, int64_t b)
 348 {
 349     int sa, sb;
 350
 351     sa = ((int64_t)*phigh < 0);
 352     if (sa) {
 353         neg128(plow, phigh);
 354     }
 355     sb = (b < 0);
 356     if (sb) {
 357         b = -b;
 358     }
 359     if (div64(plow, phigh, b) != 0) {
 360         return 1;
 361     }
 362     if (sa ^ sb) {
 363         if (*plow > (1ULL << 63)) {
 364             return 1;
 365         }
 366         *plow = -*plow;
 367     } else {
 368         if (*plow >= (1ULL << 63)) {
 369             return 1;
 370         }
 371     }
 372     if (sa) {
 373         *phigh = -*phigh;
 374     }
 375     return 0;
 376 }
 377
 378 void helper_mulq_EAX_T0(target_ulong t0)
 379 {
 380     uint64_t r0, r1;
 381
 382     mulu64(&r0, &r1, EAX, t0);
 383     EAX = r0;
 384     EDX = r1;
 385     CC_DST = r0;
 386     CC_SRC = r1;
 387 }
 388
 389 void helper_imulq_EAX_T0(target_ulong t0)
 390 {
 391     uint64_t r0, r1;
 392
 393     muls64(&r0, &r1, EAX, t0);
 394     EAX = r0;
 395     EDX = r1;
 396     CC_DST = r0;
 397     CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
 398 }
 399
 400 target_ulong helper_imulq_T0_T1(target_ulong t0, target_ulong t1)
 401 {
 402     uint64_t r0, r1;
 403
 404     muls64(&r0, &r1, t0, t1);
 405     CC_DST = r0;
 406     CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
 407     return r0;
 408 }
 409
 410 void helper_divq_EAX(target_ulong t0)
 411 {
 412     uint64_t r0, r1;
 413
 414     if (t0 == 0) {
 415         raise_exception(env, EXCP00_DIVZ);
 416     }
 417     r0 = EAX;
 418     r1 = EDX;
 419     if (div64(&r0, &r1, t0)) {
 420         raise_exception(env, EXCP00_DIVZ);
 421     }
 422     EAX = r0;
 423     EDX = r1;
 424 }
 425
 426 void helper_idivq_EAX(target_ulong t0)
 427 {
 428     uint64_t r0, r1;
 429
 430     if (t0 == 0) {
 431         raise_exception(env, EXCP00_DIVZ);
 432     }
 433     r0 = EAX;
 434     r1 = EDX;
 435     if (idiv64(&r0, &r1, t0)) {
 436         raise_exception(env, EXCP00_DIVZ);
 437     }
 438     EAX = r0;
 439     EDX = r1;
 440 }
 441 #endif
 442
 443 /* bit operations */
 444 target_ulong helper_bsf(target_ulong t0)
 445 {
 446     int count;
 447     target_ulong res;
 448
 449     res = t0;
 450     count = 0;
 451     while ((res & 1) == 0) {
 452         count++;
 453         res >>= 1;
 454     }
 455     return count;
 456 }
 457
 458 target_ulong helper_lzcnt(target_ulong t0, int wordsize)
 459 {
 460     int count;
 461     target_ulong res, mask;
 462
 463     if (wordsize > 0 && t0 == 0) {
 464         return wordsize;
 465     }
 466     res = t0;
 467     count = TARGET_LONG_BITS - 1;
 468     mask = (target_ulong)1 << (TARGET_LONG_BITS - 1);
 469     while ((res & mask) == 0) {
 470         count--;
 471         res <<= 1;
 472     }
 473     if (wordsize > 0) {
 474         return wordsize - 1 - count;
 475     }
 476     return count;
 477 }
 478
 479 target_ulong helper_bsr(target_ulong t0)
 480 {
 481     return helper_lzcnt(t0, 0);
 482 }
 483
 484 #define SHIFT 0
 485 #include "shift_helper_template.h"
 486 #undef SHIFT
 487
 488 #define SHIFT 1
 489 #include "shift_helper_template.h"
 490 #undef SHIFT
 491
 492 #define SHIFT 2
 493 #include "shift_helper_template.h"
 494 #undef SHIFT
 495
 496 #ifdef TARGET_X86_64
 497 #define SHIFT 3
 498 #include "shift_helper_template.h"
 499 #undef SHIFT
 500 #endif