![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to op.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / target-m68k|
Return to op.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-m68k |
1.1 ! root 1: /* ! 2: * m68k micro operations ! 3: * ! 4: * Copyright (c) 2006 CodeSourcery ! 5: * Written by Paul Brook ! 6: * ! 7: * This library is free software; you can redistribute it and/or ! 8: * modify it under the terms of the GNU Lesser General Public ! 9: * License as published by the Free Software Foundation; either ! 10: * version 2 of the License, or (at your option) any later version. ! 11: * ! 12: * This library is distributed in the hope that it will be useful, ! 13: * but WITHOUT ANY WARRANTY; without even the implied warranty of ! 14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ! 15: * General Public License for more details. ! 16: * ! 17: * You should have received a copy of the GNU Lesser General Public ! 18: * License along with this library; if not, write to the Free Software ! 19: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ! 20: */ ! 21: ! 22: #include "exec.h" ! 23: #include "m68k-qreg.h" ! 24: ! 25: #ifndef offsetof ! 26: #define offsetof(type, field) ((size_t) &((type *)0)->field) ! 27: #endif ! 28: ! 29: static long qreg_offsets[] = { ! 30: #define DEFO32(name, offset) offsetof(CPUState, offset), ! 31: #define DEFR(name, reg, mode) -1, ! 32: #define DEFF64(name, offset) offsetof(CPUState, offset), ! 33: 0, ! 34: #include "qregs.def" ! 35: }; ! 36: ! 37: #define CPU_FP_STATUS env->fp_status ! 38: ! 39: #define RAISE_EXCEPTION(n) do { \ ! 40: env->exception_index = n; \ ! 41: cpu_loop_exit(); \ ! 42: } while(0) ! 43: ! 44: #define get_op helper_get_op ! 45: #define set_op helper_set_op ! 46: #define get_opf64 helper_get_opf64 ! 47: #define set_opf64 helper_set_opf64 ! 48: uint32_t ! 49: get_op(int qreg) ! 50: { ! 51: if (qreg == QREG_T0) { ! 52: return T0; ! 53: } else if (qreg < TARGET_NUM_QREGS) { ! 54: return *(uint32_t *)(((long)env) + qreg_offsets[qreg]); ! 55: } else { ! 56: return env->qregs[qreg - TARGET_NUM_QREGS]; ! 57: } ! 58: } ! 59: ! 60: void set_op(int qreg, uint32_t val) ! 61: { ! 62: if (qreg == QREG_T0) { ! 63: T0 = val; ! 64: } else if (qreg < TARGET_NUM_QREGS) { ! 65: *(uint32_t *)(((long)env) + qreg_offsets[qreg]) = val; ! 66: } else { ! 67: env->qregs[qreg - TARGET_NUM_QREGS] = val; ! 68: } ! 69: } ! 70: ! 71: float64 get_opf64(int qreg) ! 72: { ! 73: if (qreg < TARGET_NUM_QREGS) { ! 74: return *(float64 *)(((long)env) + qreg_offsets[qreg]); ! 75: } else { ! 76: return *(float64 *)&env->qregs[qreg - TARGET_NUM_QREGS]; ! 77: } ! 78: } ! 79: ! 80: void set_opf64(int qreg, float64 val) ! 81: { ! 82: if (qreg < TARGET_NUM_QREGS) { ! 83: *(float64 *)(((long)env) + qreg_offsets[qreg]) = val; ! 84: } else { ! 85: *(float64 *)&env->qregs[qreg - TARGET_NUM_QREGS] = val; ! 86: } ! 87: } ! 88: ! 89: #define OP(name) void OPPROTO op_##name (void) ! 90: ! 91: OP(mov32) ! 92: { ! 93: set_op(PARAM1, get_op(PARAM2)); ! 94: FORCE_RET(); ! 95: } ! 96: ! 97: OP(mov32_im) ! 98: { ! 99: set_op(PARAM1, PARAM2); ! 100: FORCE_RET(); ! 101: } ! 102: ! 103: OP(movf64) ! 104: { ! 105: set_opf64(PARAM1, get_opf64(PARAM2)); ! 106: FORCE_RET(); ! 107: } ! 108: ! 109: OP(zerof64) ! 110: { ! 111: set_opf64(PARAM1, 0); ! 112: FORCE_RET(); ! 113: } ! 114: ! 115: OP(add32) ! 116: { ! 117: uint32_t op2 = get_op(PARAM2); ! 118: uint32_t op3 = get_op(PARAM3); ! 119: set_op(PARAM1, op2 + op3); ! 120: FORCE_RET(); ! 121: } ! 122: ! 123: OP(sub32) ! 124: { ! 125: uint32_t op2 = get_op(PARAM2); ! 126: uint32_t op3 = get_op(PARAM3); ! 127: set_op(PARAM1, op2 - op3); ! 128: FORCE_RET(); ! 129: } ! 130: ! 131: OP(mul32) ! 132: { ! 133: uint32_t op2 = get_op(PARAM2); ! 134: uint32_t op3 = get_op(PARAM3); ! 135: set_op(PARAM1, op2 * op3); ! 136: FORCE_RET(); ! 137: } ! 138: ! 139: OP(not32) ! 140: { ! 141: uint32_t arg = get_op(PARAM2); ! 142: set_op(PARAM1, ~arg); ! 143: FORCE_RET(); ! 144: } ! 145: ! 146: OP(neg32) ! 147: { ! 148: uint32_t arg = get_op(PARAM2); ! 149: set_op(PARAM1, -arg); ! 150: FORCE_RET(); ! 151: } ! 152: ! 153: OP(bswap32) ! 154: { ! 155: uint32_t arg = get_op(PARAM2); ! 156: arg = (arg >> 24) | (arg << 24) ! 157: | ((arg >> 16) & 0xff00) | ((arg << 16) & 0xff0000); ! 158: set_op(PARAM1, arg); ! 159: FORCE_RET(); ! 160: } ! 161: ! 162: OP(btest) ! 163: { ! 164: uint32_t op1 = get_op(PARAM1); ! 165: uint32_t op2 = get_op(PARAM2); ! 166: if (op1 & op2) ! 167: env->cc_dest &= ~CCF_Z; ! 168: else ! 169: env->cc_dest |= CCF_Z; ! 170: FORCE_RET(); ! 171: } ! 172: ! 173: OP(addx_cc) ! 174: { ! 175: uint32_t op1 = get_op(PARAM1); ! 176: uint32_t op2 = get_op(PARAM2); ! 177: uint32_t res; ! 178: if (env->cc_x) { ! 179: env->cc_x = (op1 <= op2); ! 180: env->cc_op = CC_OP_SUBX; ! 181: res = op1 - (op2 + 1); ! 182: } else { ! 183: env->cc_x = (op1 < op2); ! 184: env->cc_op = CC_OP_SUB; ! 185: res = op1 - op2; ! 186: } ! 187: set_op(PARAM1, res); ! 188: FORCE_RET(); ! 189: } ! 190: ! 191: OP(subx_cc) ! 192: { ! 193: uint32_t op1 = get_op(PARAM1); ! 194: uint32_t op2 = get_op(PARAM2); ! 195: uint32_t res; ! 196: if (env->cc_x) { ! 197: res = op1 + op2 + 1; ! 198: env->cc_x = (res <= op2); ! 199: env->cc_op = CC_OP_ADDX; ! 200: } else { ! 201: res = op1 + op2; ! 202: env->cc_x = (res < op2); ! 203: env->cc_op = CC_OP_ADD; ! 204: } ! 205: set_op(PARAM1, res); ! 206: FORCE_RET(); ! 207: } ! 208: ! 209: /* Logic ops. */ ! 210: ! 211: OP(and32) ! 212: { ! 213: uint32_t op2 = get_op(PARAM2); ! 214: uint32_t op3 = get_op(PARAM3); ! 215: set_op(PARAM1, op2 & op3); ! 216: FORCE_RET(); ! 217: } ! 218: ! 219: OP(or32) ! 220: { ! 221: uint32_t op2 = get_op(PARAM2); ! 222: uint32_t op3 = get_op(PARAM3); ! 223: set_op(PARAM1, op2 | op3); ! 224: FORCE_RET(); ! 225: } ! 226: ! 227: OP(xor32) ! 228: { ! 229: uint32_t op2 = get_op(PARAM2); ! 230: uint32_t op3 = get_op(PARAM3); ! 231: set_op(PARAM1, op2 ^ op3); ! 232: FORCE_RET(); ! 233: } ! 234: ! 235: /* Shifts. */ ! 236: OP(shl32) ! 237: { ! 238: uint32_t op2 = get_op(PARAM2); ! 239: uint32_t op3 = get_op(PARAM3); ! 240: uint32_t result; ! 241: result = op2 << op3; ! 242: set_op(PARAM1, result); ! 243: FORCE_RET(); ! 244: } ! 245: ! 246: OP(shl_cc) ! 247: { ! 248: uint32_t op1 = get_op(PARAM1); ! 249: uint32_t op2 = get_op(PARAM2); ! 250: uint32_t result; ! 251: result = op1 << op2; ! 252: set_op(PARAM1, result); ! 253: env->cc_x = (op1 << (op2 - 1)) & 1; ! 254: FORCE_RET(); ! 255: } ! 256: ! 257: OP(shr32) ! 258: { ! 259: uint32_t op2 = get_op(PARAM2); ! 260: uint32_t op3 = get_op(PARAM3); ! 261: uint32_t result; ! 262: result = op2 >> op3; ! 263: set_op(PARAM1, result); ! 264: FORCE_RET(); ! 265: } ! 266: ! 267: OP(shr_cc) ! 268: { ! 269: uint32_t op1 = get_op(PARAM1); ! 270: uint32_t op2 = get_op(PARAM2); ! 271: uint32_t result; ! 272: result = op1 >> op2; ! 273: set_op(PARAM1, result); ! 274: env->cc_x = (op1 >> (op2 - 1)) & 1; ! 275: FORCE_RET(); ! 276: } ! 277: ! 278: OP(sar_cc) ! 279: { ! 280: int32_t op1 = get_op(PARAM1); ! 281: uint32_t op2 = get_op(PARAM2); ! 282: uint32_t result; ! 283: result = op1 >> op2; ! 284: set_op(PARAM1, result); ! 285: env->cc_x = (op1 >> (op2 - 1)) & 1; ! 286: FORCE_RET(); ! 287: } ! 288: ! 289: /* Value extend. */ ! 290: ! 291: OP(ext8u32) ! 292: { ! 293: uint32_t op2 = get_op(PARAM2); ! 294: set_op(PARAM1, (uint8_t)op2); ! 295: FORCE_RET(); ! 296: } ! 297: ! 298: OP(ext8s32) ! 299: { ! 300: uint32_t op2 = get_op(PARAM2); ! 301: set_op(PARAM1, (int8_t)op2); ! 302: FORCE_RET(); ! 303: } ! 304: ! 305: OP(ext16u32) ! 306: { ! 307: uint32_t op2 = get_op(PARAM2); ! 308: set_op(PARAM1, (uint16_t)op2); ! 309: FORCE_RET(); ! 310: } ! 311: ! 312: OP(ext16s32) ! 313: { ! 314: uint32_t op2 = get_op(PARAM2); ! 315: set_op(PARAM1, (int16_t)op2); ! 316: FORCE_RET(); ! 317: } ! 318: ! 319: /* Load/store ops. */ ! 320: OP(ld8u32) ! 321: { ! 322: uint32_t addr = get_op(PARAM2); ! 323: set_op(PARAM1, ldub(addr)); ! 324: FORCE_RET(); ! 325: } ! 326: ! 327: OP(ld8s32) ! 328: { ! 329: uint32_t addr = get_op(PARAM2); ! 330: set_op(PARAM1, ldsb(addr)); ! 331: FORCE_RET(); ! 332: } ! 333: ! 334: OP(ld16u32) ! 335: { ! 336: uint32_t addr = get_op(PARAM2); ! 337: set_op(PARAM1, lduw(addr)); ! 338: FORCE_RET(); ! 339: } ! 340: ! 341: OP(ld16s32) ! 342: { ! 343: uint32_t addr = get_op(PARAM2); ! 344: set_op(PARAM1, ldsw(addr)); ! 345: FORCE_RET(); ! 346: } ! 347: ! 348: OP(ld32) ! 349: { ! 350: uint32_t addr = get_op(PARAM2); ! 351: set_op(PARAM1, ldl(addr)); ! 352: FORCE_RET(); ! 353: } ! 354: ! 355: OP(st8) ! 356: { ! 357: uint32_t addr = get_op(PARAM1); ! 358: stb(addr, get_op(PARAM2)); ! 359: FORCE_RET(); ! 360: } ! 361: ! 362: OP(st16) ! 363: { ! 364: uint32_t addr = get_op(PARAM1); ! 365: stw(addr, get_op(PARAM2)); ! 366: FORCE_RET(); ! 367: } ! 368: ! 369: OP(st32) ! 370: { ! 371: uint32_t addr = get_op(PARAM1); ! 372: stl(addr, get_op(PARAM2)); ! 373: FORCE_RET(); ! 374: } ! 375: ! 376: OP(ldf64) ! 377: { ! 378: uint32_t addr = get_op(PARAM2); ! 379: set_opf64(PARAM1, ldfq(addr)); ! 380: FORCE_RET(); ! 381: } ! 382: ! 383: OP(stf64) ! 384: { ! 385: uint32_t addr = get_op(PARAM1); ! 386: stfq(addr, get_opf64(PARAM2)); ! 387: FORCE_RET(); ! 388: } ! 389: ! 390: OP(flush_flags) ! 391: { ! 392: int cc_op = PARAM1; ! 393: if (cc_op == CC_OP_DYNAMIC) ! 394: cc_op = env->cc_op; ! 395: cpu_m68k_flush_flags(env, cc_op); ! 396: FORCE_RET(); ! 397: } ! 398: ! 399: OP(divu) ! 400: { ! 401: uint32_t num; ! 402: uint32_t den; ! 403: uint32_t quot; ! 404: uint32_t rem; ! 405: uint32_t flags; ! 406: ! 407: num = env->div1; ! 408: den = env->div2; ! 409: /* ??? This needs to make sure the throwing location is accurate. */ ! 410: if (den == 0) ! 411: RAISE_EXCEPTION(EXCP_DIV0); ! 412: quot = num / den; ! 413: rem = num % den; ! 414: flags = 0; ! 415: /* Avoid using a PARAM1 of zero. This breaks dyngen because it uses ! 416: the address of a symbol, and gcc knows symbols can't have address ! 417: zero. */ ! 418: if (PARAM1 == 2 && quot > 0xffff) ! 419: flags |= CCF_V; ! 420: if (quot == 0) ! 421: flags |= CCF_Z; ! 422: else if ((int32_t)quot < 0) ! 423: flags |= CCF_N; ! 424: env->div1 = quot; ! 425: env->div2 = rem; ! 426: env->cc_dest = flags; ! 427: FORCE_RET(); ! 428: } ! 429: ! 430: OP(divs) ! 431: { ! 432: int32_t num; ! 433: int32_t den; ! 434: int32_t quot; ! 435: int32_t rem; ! 436: int32_t flags; ! 437: ! 438: num = env->div1; ! 439: den = env->div2; ! 440: if (den == 0) ! 441: RAISE_EXCEPTION(EXCP_DIV0); ! 442: quot = num / den; ! 443: rem = num % den; ! 444: flags = 0; ! 445: if (PARAM1 == 2 && quot != (int16_t)quot) ! 446: flags |= CCF_V; ! 447: if (quot == 0) ! 448: flags |= CCF_Z; ! 449: else if (quot < 0) ! 450: flags |= CCF_N; ! 451: env->div1 = quot; ! 452: env->div2 = rem; ! 453: env->cc_dest = flags; ! 454: FORCE_RET(); ! 455: } ! 456: ! 457: OP(raise_exception) ! 458: { ! 459: RAISE_EXCEPTION(PARAM1); ! 460: FORCE_RET(); ! 461: } ! 462: ! 463: /* Floating point comparison sets flags differently to other instructions. */ ! 464: ! 465: OP(sub_cmpf64) ! 466: { ! 467: float64 src0; ! 468: float64 src1; ! 469: src0 = get_opf64(PARAM2); ! 470: src1 = get_opf64(PARAM3); ! 471: set_opf64(PARAM1, helper_sub_cmpf64(env, src0, src1)); ! 472: FORCE_RET(); ! 473: } ! 474: ! 475: OP(update_xflag_tst) ! 476: { ! 477: uint32_t op1 = get_op(PARAM1); ! 478: env->cc_x = op1; ! 479: FORCE_RET(); ! 480: } ! 481: ! 482: OP(update_xflag_lt) ! 483: { ! 484: uint32_t op1 = get_op(PARAM1); ! 485: uint32_t op2 = get_op(PARAM2); ! 486: env->cc_x = (op1 < op2); ! 487: FORCE_RET(); ! 488: } ! 489: ! 490: OP(get_xflag) ! 491: { ! 492: set_op(PARAM1, env->cc_x); ! 493: FORCE_RET(); ! 494: } ! 495: ! 496: OP(logic_cc) ! 497: { ! 498: uint32_t op1 = get_op(PARAM1); ! 499: env->cc_dest = op1; ! 500: FORCE_RET(); ! 501: } ! 502: ! 503: OP(update_cc_add) ! 504: { ! 505: uint32_t op1 = get_op(PARAM1); ! 506: uint32_t op2 = get_op(PARAM2); ! 507: env->cc_dest = op1; ! 508: env->cc_src = op2; ! 509: FORCE_RET(); ! 510: } ! 511: ! 512: OP(fp_result) ! 513: { ! 514: env->fp_result = get_opf64(PARAM1); ! 515: FORCE_RET(); ! 516: } ! 517: ! 518: OP(jmp) ! 519: { ! 520: GOTO_LABEL_PARAM(1); ! 521: } ! 522: ! 523: /* These ops involve a function call, which probably requires a stack frame ! 524: and breaks things on some hosts. */ ! 525: OP(jmp_z32) ! 526: { ! 527: uint32_t arg = get_op(PARAM1); ! 528: if (arg == 0) ! 529: GOTO_LABEL_PARAM(2); ! 530: FORCE_RET(); ! 531: } ! 532: ! 533: OP(jmp_nz32) ! 534: { ! 535: uint32_t arg = get_op(PARAM1); ! 536: if (arg != 0) ! 537: GOTO_LABEL_PARAM(2); ! 538: FORCE_RET(); ! 539: } ! 540: ! 541: OP(jmp_s32) ! 542: { ! 543: int32_t arg = get_op(PARAM1); ! 544: if (arg < 0) ! 545: GOTO_LABEL_PARAM(2); ! 546: FORCE_RET(); ! 547: } ! 548: ! 549: OP(jmp_ns32) ! 550: { ! 551: int32_t arg = get_op(PARAM1); ! 552: if (arg >= 0) ! 553: GOTO_LABEL_PARAM(2); ! 554: FORCE_RET(); ! 555: } ! 556: ! 557: void OPPROTO op_goto_tb0(void) ! 558: { ! 559: GOTO_TB(op_goto_tb0, PARAM1, 0); ! 560: } ! 561: ! 562: void OPPROTO op_goto_tb1(void) ! 563: { ! 564: GOTO_TB(op_goto_tb1, PARAM1, 1); ! 565: } ! 566: ! 567: OP(exit_tb) ! 568: { ! 569: EXIT_TB(); ! 570: } ! 571: ! 572: ! 573: /* Floating point. */ ! 574: OP(f64_to_i32) ! 575: { ! 576: set_op(PARAM1, float64_to_int32(get_opf64(PARAM2), &CPU_FP_STATUS)); ! 577: FORCE_RET(); ! 578: } ! 579: ! 580: OP(f64_to_f32) ! 581: { ! 582: union { ! 583: float32 f; ! 584: uint32_t i; ! 585: } u; ! 586: u.f = float64_to_float32(get_opf64(PARAM2), &CPU_FP_STATUS); ! 587: set_op(PARAM1, u.i); ! 588: FORCE_RET(); ! 589: } ! 590: ! 591: OP(i32_to_f64) ! 592: { ! 593: set_opf64(PARAM1, int32_to_float64(get_op(PARAM2), &CPU_FP_STATUS)); ! 594: FORCE_RET(); ! 595: } ! 596: ! 597: OP(f32_to_f64) ! 598: { ! 599: union { ! 600: float32 f; ! 601: uint32_t i; ! 602: } u; ! 603: u.i = get_op(PARAM2); ! 604: set_opf64(PARAM1, float32_to_float64(u.f, &CPU_FP_STATUS)); ! 605: FORCE_RET(); ! 606: } ! 607: ! 608: OP(absf64) ! 609: { ! 610: float64 op0 = get_opf64(PARAM2); ! 611: set_opf64(PARAM1, float64_abs(op0)); ! 612: FORCE_RET(); ! 613: } ! 614: ! 615: OP(chsf64) ! 616: { ! 617: float64 op0 = get_opf64(PARAM2); ! 618: set_opf64(PARAM1, float64_chs(op0)); ! 619: FORCE_RET(); ! 620: } ! 621: ! 622: OP(sqrtf64) ! 623: { ! 624: float64 op0 = get_opf64(PARAM2); ! 625: set_opf64(PARAM1, float64_sqrt(op0, &CPU_FP_STATUS)); ! 626: FORCE_RET(); ! 627: } ! 628: ! 629: OP(addf64) ! 630: { ! 631: float64 op0 = get_opf64(PARAM2); ! 632: float64 op1 = get_opf64(PARAM3); ! 633: set_opf64(PARAM1, float64_add(op0, op1, &CPU_FP_STATUS)); ! 634: FORCE_RET(); ! 635: } ! 636: ! 637: OP(subf64) ! 638: { ! 639: float64 op0 = get_opf64(PARAM2); ! 640: float64 op1 = get_opf64(PARAM3); ! 641: set_opf64(PARAM1, float64_sub(op0, op1, &CPU_FP_STATUS)); ! 642: FORCE_RET(); ! 643: } ! 644: ! 645: OP(mulf64) ! 646: { ! 647: float64 op0 = get_opf64(PARAM2); ! 648: float64 op1 = get_opf64(PARAM3); ! 649: set_opf64(PARAM1, float64_mul(op0, op1, &CPU_FP_STATUS)); ! 650: FORCE_RET(); ! 651: } ! 652: ! 653: OP(divf64) ! 654: { ! 655: float64 op0 = get_opf64(PARAM2); ! 656: float64 op1 = get_opf64(PARAM3); ! 657: set_opf64(PARAM1, float64_div(op0, op1, &CPU_FP_STATUS)); ! 658: FORCE_RET(); ! 659: } ! 660: ! 661: OP(iround_f64) ! 662: { ! 663: float64 op0 = get_opf64(PARAM2); ! 664: set_opf64(PARAM1, float64_round_to_int(op0, &CPU_FP_STATUS)); ! 665: FORCE_RET(); ! 666: } ! 667: ! 668: OP(itrunc_f64) ! 669: { ! 670: float64 op0 = get_opf64(PARAM2); ! 671: set_opf64(PARAM1, float64_trunc_to_int(op0, &CPU_FP_STATUS)); ! 672: FORCE_RET(); ! 673: } ! 674: ! 675: OP(compare_quietf64) ! 676: { ! 677: float64 op0 = get_opf64(PARAM2); ! 678: float64 op1 = get_opf64(PARAM3); ! 679: set_op(PARAM1, float64_compare_quiet(op0, op1, &CPU_FP_STATUS)); ! 680: FORCE_RET(); ! 681: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.