![[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-ppc|
Return to op.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-ppc |
1.1 root 1: /*
2: * PowerPC emulation micro-operations for qemu.
1.1.1.4 ! root 3: *
! 4: * Copyright (c) 2003-2007 Jocelyn Mayer
1.1 root 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, write to the Free Software
18: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19: */
20:
21: //#define DEBUG_OP
22:
23: #include "config.h"
24: #include "exec.h"
1.1.1.4 ! root 25: #include "host-utils.h"
! 26: #include "helper_regs.h"
! 27: #include "op_helper.h"
1.1 root 28:
29: #define REG 0
30: #include "op_template.h"
31:
32: #define REG 1
33: #include "op_template.h"
34:
35: #define REG 2
36: #include "op_template.h"
37:
38: #define REG 3
39: #include "op_template.h"
40:
41: #define REG 4
42: #include "op_template.h"
43:
44: #define REG 5
45: #include "op_template.h"
46:
47: #define REG 6
48: #include "op_template.h"
49:
50: #define REG 7
51: #include "op_template.h"
52:
53: #define REG 8
54: #include "op_template.h"
55:
56: #define REG 9
57: #include "op_template.h"
58:
59: #define REG 10
60: #include "op_template.h"
61:
62: #define REG 11
63: #include "op_template.h"
64:
65: #define REG 12
66: #include "op_template.h"
67:
68: #define REG 13
69: #include "op_template.h"
70:
71: #define REG 14
72: #include "op_template.h"
73:
74: #define REG 15
75: #include "op_template.h"
76:
77: #define REG 16
78: #include "op_template.h"
79:
80: #define REG 17
81: #include "op_template.h"
82:
83: #define REG 18
84: #include "op_template.h"
85:
86: #define REG 19
87: #include "op_template.h"
88:
89: #define REG 20
90: #include "op_template.h"
91:
92: #define REG 21
93: #include "op_template.h"
94:
95: #define REG 22
96: #include "op_template.h"
97:
98: #define REG 23
99: #include "op_template.h"
100:
101: #define REG 24
102: #include "op_template.h"
103:
104: #define REG 25
105: #include "op_template.h"
106:
107: #define REG 26
108: #include "op_template.h"
109:
110: #define REG 27
111: #include "op_template.h"
112:
113: #define REG 28
114: #include "op_template.h"
115:
116: #define REG 29
117: #include "op_template.h"
118:
119: #define REG 30
120: #include "op_template.h"
121:
122: #define REG 31
123: #include "op_template.h"
124:
1.1.1.4 ! root 125: void OPPROTO op_print_mem_EA (void)
! 126: {
! 127: do_print_mem_EA(T0);
! 128: RETURN();
! 129: }
! 130:
1.1 root 131: /* PowerPC state maintenance operations */
132: /* set_Rc0 */
1.1.1.4 ! root 133: void OPPROTO op_set_Rc0 (void)
1.1 root 134: {
1.1.1.4 ! root 135: env->crf[0] = T0 | xer_so;
1.1 root 136: RETURN();
137: }
138:
1.1.1.4 ! root 139: /* Constants load */
! 140: void OPPROTO op_reset_T0 (void)
1.1 root 141: {
1.1.1.4 ! root 142: T0 = 0;
1.1 root 143: RETURN();
144: }
145:
1.1.1.4 ! root 146: void OPPROTO op_set_T0 (void)
1.1 root 147: {
1.1.1.4 ! root 148: T0 = (uint32_t)PARAM1;
1.1 root 149: RETURN();
150: }
151:
1.1.1.4 ! root 152: #if defined(TARGET_PPC64)
! 153: void OPPROTO op_set_T0_64 (void)
1.1 root 154: {
1.1.1.4 ! root 155: T0 = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
1.1 root 156: RETURN();
157: }
1.1.1.4 ! root 158: #endif
1.1 root 159:
1.1.1.4 ! root 160: void OPPROTO op_set_T1 (void)
1.1 root 161: {
1.1.1.4 ! root 162: T1 = (uint32_t)PARAM1;
1.1 root 163: RETURN();
164: }
165:
1.1.1.4 ! root 166: #if defined(TARGET_PPC64)
! 167: void OPPROTO op_set_T1_64 (void)
1.1 root 168: {
1.1.1.4 ! root 169: T1 = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
1.1 root 170: RETURN();
171: }
1.1.1.4 ! root 172: #endif
1.1 root 173:
1.1.1.4 ! root 174: #if 0 // unused
! 175: void OPPROTO op_set_T2 (void)
1.1 root 176: {
1.1.1.4 ! root 177: T2 = (uint32_t)PARAM1;
1.1 root 178: RETURN();
179: }
1.1.1.4 ! root 180: #endif
1.1 root 181:
1.1.1.4 ! root 182: void OPPROTO op_move_T1_T0 (void)
1.1 root 183: {
1.1.1.4 ! root 184: T1 = T0;
! 185: RETURN();
1.1 root 186: }
187:
1.1.1.4 ! root 188: void OPPROTO op_move_T2_T0 (void)
1.1 root 189: {
1.1.1.4 ! root 190: T2 = T0;
! 191: RETURN();
1.1 root 192: }
193:
1.1.1.4 ! root 194: void OPPROTO op_moven_T2_T0 (void)
1.1 root 195: {
1.1.1.4 ! root 196: T2 = ~T0;
! 197: RETURN();
1.1 root 198: }
199:
1.1.1.4 ! root 200: /* Generate exceptions */
! 201: void OPPROTO op_raise_exception_err (void)
1.1.1.3 root 202: {
1.1.1.4 ! root 203: do_raise_exception_err(PARAM1, PARAM2);
1.1.1.3 root 204: }
205:
1.1.1.4 ! root 206: void OPPROTO op_update_nip (void)
1.1 root 207: {
1.1.1.4 ! root 208: env->nip = (uint32_t)PARAM1;
1.1 root 209: RETURN();
210: }
211:
1.1.1.4 ! root 212: #if defined(TARGET_PPC64)
! 213: void OPPROTO op_update_nip_64 (void)
1.1 root 214: {
1.1.1.4 ! root 215: env->nip = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
1.1 root 216: RETURN();
217: }
1.1.1.4 ! root 218: #endif
1.1 root 219:
1.1.1.4 ! root 220: void OPPROTO op_debug (void)
1.1 root 221: {
1.1.1.4 ! root 222: do_raise_exception(EXCP_DEBUG);
1.1 root 223: }
224:
1.1.1.4 ! root 225: void OPPROTO op_exit_tb (void)
1.1 root 226: {
1.1.1.4 ! root 227: EXIT_TB();
! 228: }
! 229:
! 230: /* Load/store special registers */
! 231: void OPPROTO op_load_cr (void)
! 232: {
! 233: do_load_cr();
1.1 root 234: RETURN();
235: }
236:
1.1.1.4 ! root 237: void OPPROTO op_store_cr (void)
1.1 root 238: {
1.1.1.4 ! root 239: do_store_cr(PARAM1);
! 240: RETURN();
1.1 root 241: }
242:
1.1.1.4 ! root 243: void OPPROTO op_load_cro (void)
1.1 root 244: {
1.1.1.4 ! root 245: T0 = env->crf[PARAM1];
1.1 root 246: RETURN();
247: }
248:
1.1.1.4 ! root 249: void OPPROTO op_store_cro (void)
1.1 root 250: {
1.1.1.4 ! root 251: env->crf[PARAM1] = T0;
1.1 root 252: RETURN();
253: }
254:
1.1.1.4 ! root 255: void OPPROTO op_load_xer_cr (void)
1.1 root 256: {
257: T0 = (xer_so << 3) | (xer_ov << 2) | (xer_ca << 1);
258: RETURN();
259: }
260:
1.1.1.4 ! root 261: void OPPROTO op_clear_xer_ov (void)
1.1 root 262: {
263: xer_so = 0;
264: xer_ov = 0;
1.1.1.4 ! root 265: RETURN();
! 266: }
! 267:
! 268: void OPPROTO op_clear_xer_ca (void)
! 269: {
1.1 root 270: xer_ca = 0;
271: RETURN();
272: }
273:
1.1.1.4 ! root 274: void OPPROTO op_load_xer_bc (void)
1.1 root 275: {
276: T1 = xer_bc;
277: RETURN();
278: }
279:
1.1.1.4 ! root 280: void OPPROTO op_store_xer_bc (void)
1.1 root 281: {
1.1.1.4 ! root 282: xer_bc = T0;
1.1 root 283: RETURN();
284: }
285:
1.1.1.4 ! root 286: void OPPROTO op_load_xer (void)
1.1 root 287: {
1.1.1.4 ! root 288: T0 = hreg_load_xer(env);
1.1 root 289: RETURN();
290: }
291:
1.1.1.4 ! root 292: void OPPROTO op_store_xer (void)
1.1 root 293: {
1.1.1.4 ! root 294: hreg_store_xer(env, T0);
1.1 root 295: RETURN();
296: }
297:
1.1.1.4 ! root 298: #if defined(TARGET_PPC64)
! 299: void OPPROTO op_store_pri (void)
1.1 root 300: {
1.1.1.4 ! root 301: do_store_pri(PARAM1);
1.1 root 302: RETURN();
303: }
1.1.1.4 ! root 304: #endif
1.1 root 305:
1.1.1.4 ! root 306: #if !defined(CONFIG_USER_ONLY)
! 307: /* Segment registers load and store */
! 308: void OPPROTO op_load_sr (void)
1.1 root 309: {
1.1.1.4 ! root 310: T0 = env->sr[T1];
1.1 root 311: RETURN();
312: }
313:
1.1.1.4 ! root 314: void OPPROTO op_store_sr (void)
1.1 root 315: {
1.1.1.4 ! root 316: do_store_sr(env, T1, T0);
1.1 root 317: RETURN();
318: }
319:
1.1.1.4 ! root 320: #if defined(TARGET_PPC64)
! 321: void OPPROTO op_load_slb (void)
1.1 root 322: {
1.1.1.4 ! root 323: T0 = ppc_load_slb(env, T1);
1.1 root 324: RETURN();
325: }
326:
1.1.1.4 ! root 327: void OPPROTO op_store_slb (void)
1.1 root 328: {
1.1.1.4 ! root 329: ppc_store_slb(env, T1, T0);
1.1 root 330: RETURN();
331: }
1.1.1.4 ! root 332: #endif /* defined(TARGET_PPC64) */
1.1 root 333:
1.1.1.4 ! root 334: void OPPROTO op_load_sdr1 (void)
1.1 root 335: {
1.1.1.4 ! root 336: T0 = env->sdr1;
1.1 root 337: RETURN();
338: }
339:
1.1.1.4 ! root 340: void OPPROTO op_store_sdr1 (void)
1.1 root 341: {
1.1.1.4 ! root 342: do_store_sdr1(env, T0);
1.1 root 343: RETURN();
344: }
345:
1.1.1.4 ! root 346: #if defined (TARGET_PPC64)
! 347: void OPPROTO op_load_asr (void)
1.1 root 348: {
1.1.1.4 ! root 349: T0 = env->asr;
1.1 root 350: RETURN();
351: }
352:
1.1.1.4 ! root 353: void OPPROTO op_store_asr (void)
1.1 root 354: {
1.1.1.4 ! root 355: ppc_store_asr(env, T0);
1.1 root 356: RETURN();
357: }
1.1.1.4 ! root 358: #endif
1.1 root 359:
1.1.1.4 ! root 360: void OPPROTO op_load_msr (void)
1.1 root 361: {
1.1.1.4 ! root 362: T0 = env->msr;
1.1 root 363: RETURN();
364: }
365:
1.1.1.4 ! root 366: void OPPROTO op_store_msr (void)
1.1 root 367: {
1.1.1.4 ! root 368: do_store_msr();
1.1 root 369: RETURN();
370: }
371:
1.1.1.4 ! root 372: #if defined (TARGET_PPC64)
! 373: void OPPROTO op_store_msr_32 (void)
1.1 root 374: {
1.1.1.4 ! root 375: T0 = (env->msr & ~0xFFFFFFFFULL) | (T0 & 0xFFFFFFFF);
! 376: do_store_msr();
! 377: RETURN();
! 378: }
! 379: #endif
1.1 root 380:
1.1.1.4 ! root 381: void OPPROTO op_update_riee (void)
1.1 root 382: {
1.1.1.4 ! root 383: /* We don't call do_store_msr here as we won't trigger
! 384: * any special case nor change hflags
! 385: */
! 386: T0 &= (1 << MSR_RI) | (1 << MSR_EE);
! 387: env->msr &= ~(1 << MSR_RI) | (1 << MSR_EE);
! 388: env->msr |= T0;
1.1 root 389: RETURN();
390: }
1.1.1.4 ! root 391: #endif
1.1 root 392:
1.1.1.4 ! root 393: /* SPR */
! 394: void OPPROTO op_load_spr (void)
1.1 root 395: {
1.1.1.4 ! root 396: T0 = env->spr[PARAM1];
! 397: RETURN();
1.1 root 398: }
399:
1.1.1.4 ! root 400: void OPPROTO op_store_spr (void)
1.1 root 401: {
1.1.1.4 ! root 402: env->spr[PARAM1] = T0;
1.1 root 403: RETURN();
404: }
405:
1.1.1.4 ! root 406: void OPPROTO op_load_dump_spr (void)
1.1 root 407: {
1.1.1.4 ! root 408: T0 = ppc_load_dump_spr(PARAM1);
1.1 root 409: RETURN();
410: }
411:
1.1.1.4 ! root 412: void OPPROTO op_store_dump_spr (void)
1.1 root 413: {
1.1.1.4 ! root 414: ppc_store_dump_spr(PARAM1, T0);
! 415: RETURN();
1.1 root 416: }
417:
1.1.1.4 ! root 418: void OPPROTO op_mask_spr (void)
1.1 root 419: {
1.1.1.4 ! root 420: env->spr[PARAM1] &= ~T0;
1.1 root 421: RETURN();
422: }
423:
1.1.1.4 ! root 424: void OPPROTO op_load_lr (void)
1.1 root 425: {
1.1.1.4 ! root 426: T0 = env->lr;
1.1 root 427: RETURN();
428: }
429:
1.1.1.4 ! root 430: void OPPROTO op_store_lr (void)
1.1 root 431: {
1.1.1.4 ! root 432: env->lr = T0;
1.1 root 433: RETURN();
434: }
435:
1.1.1.4 ! root 436: void OPPROTO op_load_ctr (void)
1.1 root 437: {
1.1.1.4 ! root 438: T0 = env->ctr;
1.1 root 439: RETURN();
440: }
441:
1.1.1.4 ! root 442: void OPPROTO op_store_ctr (void)
1.1 root 443: {
1.1.1.4 ! root 444: env->ctr = T0;
1.1 root 445: RETURN();
446: }
447:
1.1.1.4 ! root 448: void OPPROTO op_load_tbl (void)
1.1 root 449: {
1.1.1.4 ! root 450: T0 = cpu_ppc_load_tbl(env);
1.1 root 451: RETURN();
452: }
453:
1.1.1.4 ! root 454: void OPPROTO op_load_tbu (void)
1.1 root 455: {
1.1.1.4 ! root 456: T0 = cpu_ppc_load_tbu(env);
1.1 root 457: RETURN();
458: }
459:
1.1.1.4 ! root 460: void OPPROTO op_load_atbl (void)
1.1 root 461: {
1.1.1.4 ! root 462: T0 = cpu_ppc_load_atbl(env);
1.1 root 463: RETURN();
464: }
465:
1.1.1.4 ! root 466: void OPPROTO op_load_atbu (void)
1.1 root 467: {
1.1.1.4 ! root 468: T0 = cpu_ppc_load_atbu(env);
! 469: RETURN();
1.1 root 470: }
471:
1.1.1.4 ! root 472: #if !defined(CONFIG_USER_ONLY)
! 473: void OPPROTO op_store_tbl (void)
1.1 root 474: {
1.1.1.4 ! root 475: cpu_ppc_store_tbl(env, T0);
! 476: RETURN();
1.1.1.2 root 477: }
478:
1.1.1.4 ! root 479: void OPPROTO op_store_tbu (void)
1.1.1.2 root 480: {
1.1.1.4 ! root 481: cpu_ppc_store_tbu(env, T0);
! 482: RETURN();
1.1 root 483: }
484:
1.1.1.4 ! root 485: void OPPROTO op_store_atbl (void)
1.1 root 486: {
1.1.1.4 ! root 487: cpu_ppc_store_atbl(env, T0);
! 488: RETURN();
1.1 root 489: }
490:
1.1.1.4 ! root 491: void OPPROTO op_store_atbu (void)
1.1 root 492: {
1.1.1.4 ! root 493: cpu_ppc_store_atbu(env, T0);
1.1 root 494: RETURN();
495: }
496:
1.1.1.4 ! root 497: void OPPROTO op_load_decr (void)
1.1 root 498: {
1.1.1.4 ! root 499: T0 = cpu_ppc_load_decr(env);
1.1 root 500: RETURN();
501: }
502:
1.1.1.4 ! root 503: void OPPROTO op_store_decr (void)
1.1 root 504: {
1.1.1.4 ! root 505: cpu_ppc_store_decr(env, T0);
! 506: RETURN();
1.1 root 507: }
508:
1.1.1.4 ! root 509: void OPPROTO op_load_ibat (void)
1.1 root 510: {
1.1.1.4 ! root 511: T0 = env->IBAT[PARAM1][PARAM2];
! 512: RETURN();
1.1 root 513: }
514:
1.1.1.4 ! root 515: void OPPROTO op_store_ibatu (void)
1.1 root 516: {
1.1.1.4 ! root 517: do_store_ibatu(env, PARAM1, T0);
! 518: RETURN();
1.1 root 519: }
520:
1.1.1.4 ! root 521: void OPPROTO op_store_ibatl (void)
1.1 root 522: {
1.1.1.4 ! root 523: #if 1
! 524: env->IBAT[1][PARAM1] = T0;
! 525: #else
! 526: do_store_ibatl(env, PARAM1, T0);
! 527: #endif
! 528: RETURN();
1.1 root 529: }
530:
1.1.1.4 ! root 531: void OPPROTO op_load_dbat (void)
1.1 root 532: {
1.1.1.4 ! root 533: T0 = env->DBAT[PARAM1][PARAM2];
! 534: RETURN();
1.1 root 535: }
536:
1.1.1.4 ! root 537: void OPPROTO op_store_dbatu (void)
1.1 root 538: {
1.1.1.4 ! root 539: do_store_dbatu(env, PARAM1, T0);
! 540: RETURN();
1.1 root 541: }
542:
1.1.1.4 ! root 543: void OPPROTO op_store_dbatl (void)
1.1 root 544: {
1.1.1.4 ! root 545: #if 1
! 546: env->DBAT[1][PARAM1] = T0;
! 547: #else
! 548: do_store_dbatl(env, PARAM1, T0);
! 549: #endif
! 550: RETURN();
1.1 root 551: }
1.1.1.4 ! root 552: #endif /* !defined(CONFIG_USER_ONLY) */
1.1 root 553:
1.1.1.4 ! root 554: /* FPSCR */
! 555: #ifdef CONFIG_SOFTFLOAT
! 556: void OPPROTO op_reset_fpstatus (void)
1.1 root 557: {
1.1.1.4 ! root 558: env->fp_status.float_exception_flags = 0;
! 559: RETURN();
1.1 root 560: }
1.1.1.4 ! root 561: #endif
1.1 root 562:
1.1.1.4 ! root 563: void OPPROTO op_compute_fprf (void)
1.1 root 564: {
1.1.1.4 ! root 565: do_compute_fprf(PARAM1);
! 566: RETURN();
1.1 root 567: }
568:
1.1.1.4 ! root 569: #ifdef CONFIG_SOFTFLOAT
! 570: void OPPROTO op_float_check_status (void)
1.1 root 571: {
1.1.1.4 ! root 572: do_float_check_status();
! 573: RETURN();
1.1 root 574: }
1.1.1.4 ! root 575: #else
! 576: void OPPROTO op_float_check_status (void)
1.1 root 577: {
1.1.1.4 ! root 578: if (env->exception_index == POWERPC_EXCP_PROGRAM &&
! 579: (env->error_code & POWERPC_EXCP_FP)) {
! 580: /* Differred floating-point exception after target FPR update */
! 581: if (msr_fe0 != 0 || msr_fe1 != 0)
! 582: do_raise_exception_err(env->exception_index, env->error_code);
! 583: }
1.1 root 584: RETURN();
585: }
1.1.1.4 ! root 586: #endif
1.1 root 587:
1.1.1.4 ! root 588: #if defined(WORDS_BIGENDIAN)
! 589: #define WORD0 0
! 590: #define WORD1 1
! 591: #else
! 592: #define WORD0 1
! 593: #define WORD1 0
! 594: #endif
! 595: void OPPROTO op_load_fpscr_FT0 (void)
1.1 root 596: {
1.1.1.4 ! root 597: /* The 32 MSB of the target fpr are undefined.
! 598: * They'll be zero...
! 599: */
! 600: union {
! 601: float64 d;
! 602: struct {
! 603: uint32_t u[2];
! 604: } s;
! 605: } u;
! 606:
! 607: u.s.u[WORD0] = 0;
! 608: u.s.u[WORD1] = env->fpscr;
! 609: FT0 = u.d;
1.1 root 610: RETURN();
611: }
612:
1.1.1.4 ! root 613: void OPPROTO op_set_FT0 (void)
1.1 root 614: {
1.1.1.4 ! root 615: union {
! 616: float64 d;
! 617: struct {
! 618: uint32_t u[2];
! 619: } s;
! 620: } u;
! 621:
! 622: u.s.u[WORD0] = 0;
! 623: u.s.u[WORD1] = PARAM1;
! 624: FT0 = u.d;
1.1 root 625: RETURN();
626: }
1.1.1.4 ! root 627: #undef WORD0
! 628: #undef WORD1
1.1 root 629:
1.1.1.4 ! root 630: void OPPROTO op_load_fpscr_T0 (void)
1.1 root 631: {
1.1.1.4 ! root 632: T0 = (env->fpscr >> PARAM1) & 0xF;
1.1 root 633: RETURN();
634: }
635:
1.1.1.4 ! root 636: void OPPROTO op_load_fpcc (void)
1.1 root 637: {
1.1.1.4 ! root 638: T0 = fpscr_fpcc;
1.1 root 639: RETURN();
640: }
641:
1.1.1.4 ! root 642: void OPPROTO op_fpscr_resetbit (void)
1.1 root 643: {
1.1.1.4 ! root 644: env->fpscr &= PARAM1;
! 645: RETURN();
1.1 root 646: }
647:
1.1.1.4 ! root 648: void OPPROTO op_fpscr_setbit (void)
1.1 root 649: {
1.1.1.4 ! root 650: do_fpscr_setbit(PARAM1);
1.1 root 651: RETURN();
652: }
653:
1.1.1.4 ! root 654: void OPPROTO op_store_fpscr (void)
1.1 root 655: {
1.1.1.4 ! root 656: do_store_fpscr(PARAM1);
1.1 root 657: RETURN();
658: }
659:
1.1.1.4 ! root 660: /* Branch */
! 661: #define EIP env->nip
! 662:
! 663: void OPPROTO op_setlr (void)
1.1 root 664: {
1.1.1.4 ! root 665: env->lr = (uint32_t)PARAM1;
1.1 root 666: RETURN();
667: }
668:
1.1.1.4 ! root 669: #if defined (TARGET_PPC64)
! 670: void OPPROTO op_setlr_64 (void)
1.1 root 671: {
1.1.1.4 ! root 672: env->lr = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
1.1 root 673: RETURN();
674: }
1.1.1.4 ! root 675: #endif
1.1 root 676:
1.1.1.4 ! root 677: void OPPROTO op_goto_tb0 (void)
1.1 root 678: {
1.1.1.4 ! root 679: GOTO_TB(op_goto_tb0, PARAM1, 0);
1.1 root 680: }
681:
1.1.1.4 ! root 682: void OPPROTO op_goto_tb1 (void)
1.1 root 683: {
1.1.1.4 ! root 684: GOTO_TB(op_goto_tb1, PARAM1, 1);
1.1 root 685: }
686:
1.1.1.4 ! root 687: void OPPROTO op_b_T1 (void)
1.1 root 688: {
1.1.1.4 ! root 689: env->nip = (uint32_t)(T1 & ~3);
1.1 root 690: RETURN();
691: }
692:
1.1.1.4 ! root 693: #if defined (TARGET_PPC64)
! 694: void OPPROTO op_b_T1_64 (void)
1.1 root 695: {
1.1.1.4 ! root 696: env->nip = (uint64_t)(T1 & ~3);
1.1 root 697: RETURN();
698: }
1.1.1.4 ! root 699: #endif
1.1 root 700:
1.1.1.4 ! root 701: void OPPROTO op_jz_T0 (void)
1.1 root 702: {
1.1.1.4 ! root 703: if (!T0)
! 704: GOTO_LABEL_PARAM(1);
1.1 root 705: RETURN();
706: }
707:
1.1.1.4 ! root 708: void OPPROTO op_btest_T1 (void)
1.1 root 709: {
1.1.1.4 ! root 710: if (T0) {
! 711: env->nip = (uint32_t)(T1 & ~3);
1.1 root 712: } else {
1.1.1.4 ! root 713: env->nip = (uint32_t)PARAM1;
1.1 root 714: }
715: RETURN();
716: }
717:
1.1.1.4 ! root 718: #if defined (TARGET_PPC64)
! 719: void OPPROTO op_btest_T1_64 (void)
1.1 root 720: {
1.1.1.4 ! root 721: if (T0) {
! 722: env->nip = (uint64_t)(T1 & ~3);
! 723: } else {
! 724: env->nip = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
! 725: }
1.1 root 726: RETURN();
727: }
1.1.1.4 ! root 728: #endif
1.1 root 729:
1.1.1.4 ! root 730: void OPPROTO op_movl_T1_ctr (void)
1.1 root 731: {
1.1.1.4 ! root 732: T1 = env->ctr;
1.1 root 733: RETURN();
734: }
735:
1.1.1.4 ! root 736: void OPPROTO op_movl_T1_lr (void)
1.1 root 737: {
1.1.1.4 ! root 738: T1 = env->lr;
1.1 root 739: RETURN();
740: }
741:
1.1.1.4 ! root 742: /* tests with result in T0 */
! 743: void OPPROTO op_test_ctr (void)
1.1 root 744: {
1.1.1.4 ! root 745: T0 = (uint32_t)env->ctr;
1.1 root 746: RETURN();
747: }
748:
1.1.1.4 ! root 749: #if defined(TARGET_PPC64)
! 750: void OPPROTO op_test_ctr_64 (void)
1.1 root 751: {
1.1.1.4 ! root 752: T0 = (uint64_t)env->ctr;
1.1 root 753: RETURN();
754: }
1.1.1.4 ! root 755: #endif
1.1 root 756:
1.1.1.4 ! root 757: void OPPROTO op_test_ctr_true (void)
1.1 root 758: {
1.1.1.4 ! root 759: T0 = ((uint32_t)env->ctr != 0 && (T0 & PARAM1) != 0);
1.1 root 760: RETURN();
761: }
762:
1.1.1.4 ! root 763: #if defined(TARGET_PPC64)
! 764: void OPPROTO op_test_ctr_true_64 (void)
1.1 root 765: {
1.1.1.4 ! root 766: T0 = ((uint64_t)env->ctr != 0 && (T0 & PARAM1) != 0);
1.1 root 767: RETURN();
768: }
1.1.1.4 ! root 769: #endif
1.1 root 770:
1.1.1.4 ! root 771: void OPPROTO op_test_ctr_false (void)
1.1 root 772: {
1.1.1.4 ! root 773: T0 = ((uint32_t)env->ctr != 0 && (T0 & PARAM1) == 0);
1.1 root 774: RETURN();
775: }
776:
1.1.1.4 ! root 777: #if defined(TARGET_PPC64)
! 778: void OPPROTO op_test_ctr_false_64 (void)
1.1 root 779: {
1.1.1.4 ! root 780: T0 = ((uint64_t)env->ctr != 0 && (T0 & PARAM1) == 0);
1.1 root 781: RETURN();
782: }
1.1.1.4 ! root 783: #endif
1.1 root 784:
1.1.1.4 ! root 785: void OPPROTO op_test_ctrz (void)
1.1 root 786: {
1.1.1.4 ! root 787: T0 = ((uint32_t)env->ctr == 0);
1.1 root 788: RETURN();
789: }
790:
1.1.1.4 ! root 791: #if defined(TARGET_PPC64)
! 792: void OPPROTO op_test_ctrz_64 (void)
1.1 root 793: {
1.1.1.4 ! root 794: T0 = ((uint64_t)env->ctr == 0);
1.1 root 795: RETURN();
796: }
1.1.1.4 ! root 797: #endif
1.1 root 798:
1.1.1.4 ! root 799: void OPPROTO op_test_ctrz_true (void)
1.1 root 800: {
1.1.1.4 ! root 801: T0 = ((uint32_t)env->ctr == 0 && (T0 & PARAM1) != 0);
1.1 root 802: RETURN();
803: }
804:
1.1.1.4 ! root 805: #if defined(TARGET_PPC64)
! 806: void OPPROTO op_test_ctrz_true_64 (void)
1.1 root 807: {
1.1.1.4 ! root 808: T0 = ((uint64_t)env->ctr == 0 && (T0 & PARAM1) != 0);
1.1 root 809: RETURN();
810: }
1.1.1.4 ! root 811: #endif
1.1 root 812:
1.1.1.4 ! root 813: void OPPROTO op_test_ctrz_false (void)
1.1 root 814: {
1.1.1.4 ! root 815: T0 = ((uint32_t)env->ctr == 0 && (T0 & PARAM1) == 0);
1.1 root 816: RETURN();
817: }
818:
1.1.1.4 ! root 819: #if defined(TARGET_PPC64)
! 820: void OPPROTO op_test_ctrz_false_64 (void)
1.1 root 821: {
1.1.1.4 ! root 822: T0 = ((uint64_t)env->ctr == 0 && (T0 & PARAM1) == 0);
1.1 root 823: RETURN();
824: }
1.1.1.4 ! root 825: #endif
1.1 root 826:
1.1.1.4 ! root 827: void OPPROTO op_test_true (void)
1.1 root 828: {
1.1.1.4 ! root 829: T0 = (T0 & PARAM1);
1.1 root 830: RETURN();
831: }
832:
1.1.1.4 ! root 833: void OPPROTO op_test_false (void)
1.1 root 834: {
1.1.1.4 ! root 835: T0 = ((T0 & PARAM1) == 0);
1.1 root 836: RETURN();
837: }
838:
1.1.1.4 ! root 839: /* CTR maintenance */
! 840: void OPPROTO op_dec_ctr (void)
1.1 root 841: {
1.1.1.4 ! root 842: env->ctr--;
1.1 root 843: RETURN();
844: }
845:
1.1.1.4 ! root 846: /*** Integer arithmetic ***/
! 847: /* add */
! 848: void OPPROTO op_add (void)
1.1 root 849: {
1.1.1.4 ! root 850: T0 += T1;
1.1 root 851: RETURN();
852: }
853:
1.1.1.4 ! root 854: void OPPROTO op_check_addo (void)
1.1 root 855: {
1.1.1.4 ! root 856: xer_ov = (((uint32_t)T2 ^ (uint32_t)T1 ^ UINT32_MAX) &
! 857: ((uint32_t)T2 ^ (uint32_t)T0)) >> 31;
! 858: xer_so |= xer_ov;
1.1 root 859: RETURN();
860: }
861:
1.1.1.4 ! root 862: #if defined(TARGET_PPC64)
! 863: void OPPROTO op_check_addo_64 (void)
1.1 root 864: {
1.1.1.4 ! root 865: xer_ov = (((uint64_t)T2 ^ (uint64_t)T1 ^ UINT64_MAX) &
! 866: ((uint64_t)T2 ^ (uint64_t)T0)) >> 63;
! 867: xer_so |= xer_ov;
1.1 root 868: RETURN();
869: }
1.1.1.4 ! root 870: #endif
1.1 root 871:
1.1.1.4 ! root 872: /* add carrying */
! 873: void OPPROTO op_check_addc (void)
1.1 root 874: {
1.1.1.4 ! root 875: if (likely((uint32_t)T0 >= (uint32_t)T2)) {
! 876: xer_ca = 0;
1.1 root 877: } else {
1.1.1.4 ! root 878: xer_ca = 1;
1.1 root 879: }
880: RETURN();
881: }
882:
1.1.1.4 ! root 883: #if defined(TARGET_PPC64)
! 884: void OPPROTO op_check_addc_64 (void)
1.1 root 885: {
1.1.1.4 ! root 886: if (likely((uint64_t)T0 >= (uint64_t)T2)) {
! 887: xer_ca = 0;
1.1 root 888: } else {
1.1.1.4 ! root 889: xer_ca = 1;
1.1 root 890: }
891: RETURN();
892: }
1.1.1.4 ! root 893: #endif
1.1 root 894:
1.1.1.4 ! root 895: /* add extended */
! 896: void OPPROTO op_adde (void)
1.1 root 897: {
1.1.1.4 ! root 898: do_adde();
1.1 root 899: RETURN();
900: }
901:
1.1.1.4 ! root 902: #if defined(TARGET_PPC64)
! 903: void OPPROTO op_adde_64 (void)
1.1 root 904: {
1.1.1.4 ! root 905: do_adde_64();
1.1 root 906: RETURN();
907: }
1.1.1.4 ! root 908: #endif
1.1 root 909:
1.1.1.4 ! root 910: /* add immediate */
! 911: void OPPROTO op_addi (void)
1.1 root 912: {
1.1.1.4 ! root 913: T0 += (int32_t)PARAM1;
1.1 root 914: RETURN();
915: }
916:
1.1.1.4 ! root 917: /* add to minus one extended */
! 918: void OPPROTO op_add_me (void)
1.1 root 919: {
1.1.1.4 ! root 920: T0 += xer_ca + (-1);
! 921: if (likely((uint32_t)T1 != 0))
! 922: xer_ca = 1;
! 923: else
! 924: xer_ca = 0;
1.1 root 925: RETURN();
926: }
927:
1.1.1.4 ! root 928: #if defined(TARGET_PPC64)
! 929: void OPPROTO op_add_me_64 (void)
1.1 root 930: {
1.1.1.4 ! root 931: T0 += xer_ca + (-1);
! 932: if (likely((uint64_t)T1 != 0))
! 933: xer_ca = 1;
! 934: else
! 935: xer_ca = 0;
1.1 root 936: RETURN();
937: }
1.1.1.4 ! root 938: #endif
1.1 root 939:
1.1.1.4 ! root 940: void OPPROTO op_addmeo (void)
1.1 root 941: {
1.1.1.4 ! root 942: do_addmeo();
1.1 root 943: RETURN();
944: }
945:
1.1.1.4 ! root 946: void OPPROTO op_addmeo_64 (void)
1.1 root 947: {
1.1.1.4 ! root 948: do_addmeo();
1.1 root 949: RETURN();
950: }
951:
1.1.1.4 ! root 952: /* add to zero extended */
! 953: void OPPROTO op_add_ze (void)
1.1 root 954: {
1.1.1.4 ! root 955: T0 += xer_ca;
1.1 root 956: RETURN();
957: }
958:
1.1.1.4 ! root 959: /* divide word */
! 960: void OPPROTO op_divw (void)
1.1 root 961: {
1.1.1.4 ! root 962: if (unlikely(((int32_t)T0 == INT32_MIN && (int32_t)T1 == (int32_t)-1) ||
! 963: (int32_t)T1 == 0)) {
! 964: T0 = (int32_t)(UINT32_MAX * ((uint32_t)T0 >> 31));
! 965: } else {
! 966: T0 = (int32_t)T0 / (int32_t)T1;
! 967: }
1.1 root 968: RETURN();
969: }
970:
1.1.1.4 ! root 971: #if defined(TARGET_PPC64)
! 972: void OPPROTO op_divd (void)
1.1 root 973: {
1.1.1.4 ! root 974: if (unlikely(((int64_t)T0 == INT64_MIN && (int64_t)T1 == (int64_t)-1LL) ||
! 975: (int64_t)T1 == 0)) {
! 976: T0 = (int64_t)(UINT64_MAX * ((uint64_t)T0 >> 63));
! 977: } else {
! 978: T0 = (int64_t)T0 / (int64_t)T1;
! 979: }
1.1 root 980: RETURN();
981: }
1.1.1.4 ! root 982: #endif
1.1 root 983:
1.1.1.4 ! root 984: void OPPROTO op_divwo (void)
1.1 root 985: {
1.1.1.4 ! root 986: do_divwo();
1.1 root 987: RETURN();
988: }
989:
1.1.1.4 ! root 990: #if defined(TARGET_PPC64)
! 991: void OPPROTO op_divdo (void)
1.1 root 992: {
1.1.1.4 ! root 993: do_divdo();
1.1 root 994: RETURN();
995: }
1.1.1.4 ! root 996: #endif
1.1 root 997:
1.1.1.4 ! root 998: /* divide word unsigned */
! 999: void OPPROTO op_divwu (void)
1.1 root 1000: {
1.1.1.4 ! root 1001: if (unlikely(T1 == 0)) {
! 1002: T0 = 0;
! 1003: } else {
! 1004: T0 = (uint32_t)T0 / (uint32_t)T1;
! 1005: }
1.1 root 1006: RETURN();
1007: }
1008:
1.1.1.4 ! root 1009: #if defined(TARGET_PPC64)
! 1010: void OPPROTO op_divdu (void)
1.1 root 1011: {
1.1.1.4 ! root 1012: if (unlikely(T1 == 0)) {
! 1013: T0 = 0;
! 1014: } else {
! 1015: T0 /= T1;
! 1016: }
1.1 root 1017: RETURN();
1018: }
1.1.1.4 ! root 1019: #endif
1.1 root 1020:
1.1.1.4 ! root 1021: void OPPROTO op_divwuo (void)
1.1 root 1022: {
1.1.1.4 ! root 1023: do_divwuo();
1.1 root 1024: RETURN();
1025: }
1026:
1.1.1.4 ! root 1027: #if defined(TARGET_PPC64)
! 1028: void OPPROTO op_divduo (void)
1.1 root 1029: {
1.1.1.4 ! root 1030: do_divduo();
1.1 root 1031: RETURN();
1032: }
1.1.1.4 ! root 1033: #endif
1.1 root 1034:
1.1.1.4 ! root 1035: /* multiply high word */
! 1036: void OPPROTO op_mulhw (void)
1.1 root 1037: {
1.1.1.4 ! root 1038: T0 = ((int64_t)((int32_t)T0) * (int64_t)((int32_t)T1)) >> 32;
1.1 root 1039: RETURN();
1040: }
1041:
1.1.1.4 ! root 1042: #if defined(TARGET_PPC64)
! 1043: void OPPROTO op_mulhd (void)
1.1 root 1044: {
1.1.1.4 ! root 1045: uint64_t tl, th;
! 1046:
! 1047: muls64(&tl, &th, T0, T1);
! 1048: T0 = th;
1.1 root 1049: RETURN();
1050: }
1.1.1.4 ! root 1051: #endif
1.1 root 1052:
1.1.1.4 ! root 1053: /* multiply high word unsigned */
! 1054: void OPPROTO op_mulhwu (void)
1.1 root 1055: {
1.1.1.4 ! root 1056: T0 = ((uint64_t)(uint32_t)T0 * (uint64_t)(uint32_t)T1) >> 32;
1.1 root 1057: RETURN();
1058: }
1059:
1.1.1.4 ! root 1060: #if defined(TARGET_PPC64)
! 1061: void OPPROTO op_mulhdu (void)
1.1 root 1062: {
1.1.1.4 ! root 1063: uint64_t tl, th;
! 1064:
! 1065: mulu64(&tl, &th, T0, T1);
! 1066: T0 = th;
1.1 root 1067: RETURN();
1068: }
1.1.1.4 ! root 1069: #endif
1.1 root 1070:
1.1.1.4 ! root 1071: /* multiply low immediate */
! 1072: void OPPROTO op_mulli (void)
1.1 root 1073: {
1.1.1.4 ! root 1074: T0 = ((int32_t)T0 * (int32_t)PARAM1);
1.1 root 1075: RETURN();
1076: }
1077:
1.1.1.4 ! root 1078: /* multiply low word */
! 1079: void OPPROTO op_mullw (void)
1.1 root 1080: {
1.1.1.4 ! root 1081: T0 = (int32_t)(T0 * T1);
1.1 root 1082: RETURN();
1083: }
1084:
1.1.1.4 ! root 1085: #if defined(TARGET_PPC64)
! 1086: void OPPROTO op_mulld (void)
1.1 root 1087: {
1.1.1.4 ! root 1088: T0 *= T1;
1.1 root 1089: RETURN();
1090: }
1.1.1.4 ! root 1091: #endif
1.1 root 1092:
1.1.1.4 ! root 1093: void OPPROTO op_mullwo (void)
1.1 root 1094: {
1.1.1.4 ! root 1095: do_mullwo();
! 1096: RETURN();
! 1097: }
! 1098:
! 1099: #if defined(TARGET_PPC64)
! 1100: void OPPROTO op_mulldo (void)
! 1101: {
! 1102: do_mulldo();
! 1103: RETURN();
! 1104: }
! 1105: #endif
! 1106:
! 1107: /* negate */
! 1108: void OPPROTO op_neg (void)
! 1109: {
! 1110: if (likely(T0 != INT32_MIN)) {
! 1111: T0 = -(int32_t)T0;
1.1 root 1112: }
1113: RETURN();
1114: }
1115:
1.1.1.4 ! root 1116: #if defined(TARGET_PPC64)
! 1117: void OPPROTO op_neg_64 (void)
1.1 root 1118: {
1.1.1.4 ! root 1119: if (likely(T0 != INT64_MIN)) {
! 1120: T0 = -(int64_t)T0;
1.1 root 1121: }
1122: RETURN();
1123: }
1.1.1.4 ! root 1124: #endif
1.1 root 1125:
1.1.1.4 ! root 1126: void OPPROTO op_nego (void)
1.1 root 1127: {
1.1.1.4 ! root 1128: do_nego();
1.1 root 1129: RETURN();
1130: }
1131:
1.1.1.4 ! root 1132: #if defined(TARGET_PPC64)
! 1133: void OPPROTO op_nego_64 (void)
1.1 root 1134: {
1.1.1.4 ! root 1135: do_nego_64();
1.1 root 1136: RETURN();
1137: }
1.1.1.4 ! root 1138: #endif
1.1 root 1139:
1.1.1.4 ! root 1140: /* subtract from */
! 1141: void OPPROTO op_subf (void)
1.1 root 1142: {
1.1.1.4 ! root 1143: T0 = T1 - T0;
1.1 root 1144: RETURN();
1145: }
1146:
1.1.1.4 ! root 1147: /* subtract from carrying */
! 1148: void OPPROTO op_check_subfc (void)
1.1 root 1149: {
1.1.1.4 ! root 1150: if (likely((uint32_t)T0 > (uint32_t)T1)) {
! 1151: xer_ca = 0;
! 1152: } else {
! 1153: xer_ca = 1;
! 1154: }
1.1 root 1155: RETURN();
1156: }
1157:
1.1.1.4 ! root 1158: #if defined(TARGET_PPC64)
! 1159: void OPPROTO op_check_subfc_64 (void)
1.1 root 1160: {
1.1.1.4 ! root 1161: if (likely((uint64_t)T0 > (uint64_t)T1)) {
! 1162: xer_ca = 0;
! 1163: } else {
! 1164: xer_ca = 1;
! 1165: }
1.1 root 1166: RETURN();
1167: }
1.1.1.4 ! root 1168: #endif
1.1 root 1169:
1.1.1.4 ! root 1170: /* subtract from extended */
! 1171: void OPPROTO op_subfe (void)
1.1 root 1172: {
1.1.1.4 ! root 1173: do_subfe();
1.1 root 1174: RETURN();
1175: }
1176:
1.1.1.4 ! root 1177: #if defined(TARGET_PPC64)
! 1178: void OPPROTO op_subfe_64 (void)
1.1 root 1179: {
1.1.1.4 ! root 1180: do_subfe_64();
1.1 root 1181: RETURN();
1182: }
1.1.1.4 ! root 1183: #endif
1.1 root 1184:
1.1.1.4 ! root 1185: /* subtract from immediate carrying */
! 1186: void OPPROTO op_subfic (void)
1.1 root 1187: {
1.1.1.4 ! root 1188: T0 = (int32_t)PARAM1 + ~T0 + 1;
! 1189: if ((uint32_t)T0 <= (uint32_t)PARAM1) {
! 1190: xer_ca = 1;
! 1191: } else {
! 1192: xer_ca = 0;
! 1193: }
1.1 root 1194: RETURN();
1195: }
1196:
1.1.1.4 ! root 1197: #if defined(TARGET_PPC64)
! 1198: void OPPROTO op_subfic_64 (void)
1.1 root 1199: {
1.1.1.4 ! root 1200: T0 = (int64_t)PARAM1 + ~T0 + 1;
! 1201: if ((uint64_t)T0 <= (uint64_t)PARAM1) {
! 1202: xer_ca = 1;
! 1203: } else {
! 1204: xer_ca = 0;
! 1205: }
1.1 root 1206: RETURN();
1207: }
1.1.1.4 ! root 1208: #endif
1.1 root 1209:
1.1.1.4 ! root 1210: /* subtract from minus one extended */
! 1211: void OPPROTO op_subfme (void)
1.1 root 1212: {
1.1.1.4 ! root 1213: T0 = ~T0 + xer_ca - 1;
! 1214: if (likely((uint32_t)T0 != UINT32_MAX))
! 1215: xer_ca = 1;
! 1216: else
! 1217: xer_ca = 0;
1.1 root 1218: RETURN();
1219: }
1220:
1.1.1.4 ! root 1221: #if defined(TARGET_PPC64)
! 1222: void OPPROTO op_subfme_64 (void)
1.1 root 1223: {
1.1.1.4 ! root 1224: T0 = ~T0 + xer_ca - 1;
! 1225: if (likely((uint64_t)T0 != UINT64_MAX))
! 1226: xer_ca = 1;
! 1227: else
! 1228: xer_ca = 0;
1.1 root 1229: RETURN();
1230: }
1.1.1.4 ! root 1231: #endif
1.1 root 1232:
1.1.1.4 ! root 1233: void OPPROTO op_subfmeo (void)
1.1 root 1234: {
1.1.1.4 ! root 1235: do_subfmeo();
1.1 root 1236: RETURN();
1237: }
1238:
1.1.1.4 ! root 1239: #if defined(TARGET_PPC64)
! 1240: void OPPROTO op_subfmeo_64 (void)
1.1 root 1241: {
1.1.1.4 ! root 1242: do_subfmeo_64();
1.1 root 1243: RETURN();
1244: }
1.1.1.4 ! root 1245: #endif
1.1 root 1246:
1.1.1.4 ! root 1247: /* subtract from zero extended */
! 1248: void OPPROTO op_subfze (void)
1.1 root 1249: {
1.1.1.4 ! root 1250: T1 = ~T0;
! 1251: T0 = T1 + xer_ca;
! 1252: if ((uint32_t)T0 < (uint32_t)T1) {
! 1253: xer_ca = 1;
! 1254: } else {
! 1255: xer_ca = 0;
! 1256: }
1.1 root 1257: RETURN();
1258: }
1259:
1.1.1.4 ! root 1260: #if defined(TARGET_PPC64)
! 1261: void OPPROTO op_subfze_64 (void)
1.1 root 1262: {
1.1.1.4 ! root 1263: T1 = ~T0;
! 1264: T0 = T1 + xer_ca;
! 1265: if ((uint64_t)T0 < (uint64_t)T1) {
! 1266: xer_ca = 1;
! 1267: } else {
! 1268: xer_ca = 0;
! 1269: }
1.1 root 1270: RETURN();
1271: }
1.1.1.4 ! root 1272: #endif
1.1 root 1273:
1.1.1.4 ! root 1274: void OPPROTO op_subfzeo (void)
! 1275: {
! 1276: do_subfzeo();
! 1277: RETURN();
! 1278: }
1.1 root 1279:
1.1.1.4 ! root 1280: #if defined(TARGET_PPC64)
! 1281: void OPPROTO op_subfzeo_64 (void)
1.1 root 1282: {
1.1.1.4 ! root 1283: do_subfzeo_64();
1.1 root 1284: RETURN();
1285: }
1.1.1.4 ! root 1286: #endif
1.1 root 1287:
1.1.1.4 ! root 1288: /*** Integer comparison ***/
! 1289: /* compare */
! 1290: void OPPROTO op_cmp (void)
1.1 root 1291: {
1.1.1.4 ! root 1292: if ((int32_t)T0 < (int32_t)T1) {
! 1293: T0 = 0x08;
! 1294: } else if ((int32_t)T0 > (int32_t)T1) {
! 1295: T0 = 0x04;
! 1296: } else {
! 1297: T0 = 0x02;
! 1298: }
! 1299: T0 |= xer_so;
1.1 root 1300: RETURN();
1301: }
1302:
1.1.1.4 ! root 1303: #if defined(TARGET_PPC64)
! 1304: void OPPROTO op_cmp_64 (void)
1.1 root 1305: {
1.1.1.4 ! root 1306: if ((int64_t)T0 < (int64_t)T1) {
! 1307: T0 = 0x08;
! 1308: } else if ((int64_t)T0 > (int64_t)T1) {
! 1309: T0 = 0x04;
! 1310: } else {
! 1311: T0 = 0x02;
! 1312: }
! 1313: T0 |= xer_so;
1.1 root 1314: RETURN();
1315: }
1.1.1.4 ! root 1316: #endif
1.1 root 1317:
1.1.1.4 ! root 1318: /* compare immediate */
! 1319: void OPPROTO op_cmpi (void)
1.1 root 1320: {
1.1.1.4 ! root 1321: if ((int32_t)T0 < (int32_t)PARAM1) {
! 1322: T0 = 0x08;
! 1323: } else if ((int32_t)T0 > (int32_t)PARAM1) {
! 1324: T0 = 0x04;
! 1325: } else {
! 1326: T0 = 0x02;
! 1327: }
! 1328: T0 |= xer_so;
1.1 root 1329: RETURN();
1330: }
1331:
1.1.1.4 ! root 1332: #if defined(TARGET_PPC64)
! 1333: void OPPROTO op_cmpi_64 (void)
1.1 root 1334: {
1.1.1.4 ! root 1335: if ((int64_t)T0 < (int64_t)((int32_t)PARAM1)) {
! 1336: T0 = 0x08;
! 1337: } else if ((int64_t)T0 > (int64_t)((int32_t)PARAM1)) {
! 1338: T0 = 0x04;
! 1339: } else {
! 1340: T0 = 0x02;
! 1341: }
! 1342: T0 |= xer_so;
1.1 root 1343: RETURN();
1344: }
1.1.1.4 ! root 1345: #endif
1.1 root 1346:
1.1.1.4 ! root 1347: /* compare logical */
! 1348: void OPPROTO op_cmpl (void)
! 1349: {
! 1350: if ((uint32_t)T0 < (uint32_t)T1) {
! 1351: T0 = 0x08;
! 1352: } else if ((uint32_t)T0 > (uint32_t)T1) {
! 1353: T0 = 0x04;
! 1354: } else {
! 1355: T0 = 0x02;
! 1356: }
! 1357: T0 |= xer_so;
! 1358: RETURN();
! 1359: }
1.1 root 1360:
1.1.1.4 ! root 1361: #if defined(TARGET_PPC64)
! 1362: void OPPROTO op_cmpl_64 (void)
! 1363: {
! 1364: if ((uint64_t)T0 < (uint64_t)T1) {
! 1365: T0 = 0x08;
! 1366: } else if ((uint64_t)T0 > (uint64_t)T1) {
! 1367: T0 = 0x04;
! 1368: } else {
! 1369: T0 = 0x02;
! 1370: }
! 1371: T0 |= xer_so;
! 1372: RETURN();
! 1373: }
1.1 root 1374: #endif
1375:
1.1.1.4 ! root 1376: /* compare logical immediate */
! 1377: void OPPROTO op_cmpli (void)
1.1 root 1378: {
1.1.1.4 ! root 1379: if ((uint32_t)T0 < (uint32_t)PARAM1) {
! 1380: T0 = 0x08;
! 1381: } else if ((uint32_t)T0 > (uint32_t)PARAM1) {
! 1382: T0 = 0x04;
! 1383: } else {
! 1384: T0 = 0x02;
! 1385: }
! 1386: T0 |= xer_so;
1.1 root 1387: RETURN();
1388: }
1389:
1.1.1.4 ! root 1390: #if defined(TARGET_PPC64)
! 1391: void OPPROTO op_cmpli_64 (void)
1.1 root 1392: {
1.1.1.4 ! root 1393: if ((uint64_t)T0 < (uint64_t)PARAM1) {
! 1394: T0 = 0x08;
! 1395: } else if ((uint64_t)T0 > (uint64_t)PARAM1) {
! 1396: T0 = 0x04;
! 1397: } else {
! 1398: T0 = 0x02;
! 1399: }
! 1400: T0 |= xer_so;
! 1401: RETURN();
! 1402: }
! 1403: #endif
! 1404:
! 1405: void OPPROTO op_isel (void)
! 1406: {
! 1407: if (T0)
! 1408: T0 = T1;
! 1409: else
! 1410: T0 = T2;
1.1 root 1411: RETURN();
1412: }
1413:
1.1.1.4 ! root 1414: void OPPROTO op_popcntb (void)
1.1 root 1415: {
1.1.1.4 ! root 1416: do_popcntb();
1.1 root 1417: RETURN();
1418: }
1419:
1.1.1.4 ! root 1420: #if defined(TARGET_PPC64)
! 1421: void OPPROTO op_popcntb_64 (void)
1.1 root 1422: {
1.1.1.4 ! root 1423: do_popcntb_64();
1.1 root 1424: RETURN();
1425: }
1.1.1.4 ! root 1426: #endif
1.1 root 1427:
1.1.1.4 ! root 1428: /*** Integer logical ***/
! 1429: /* and */
! 1430: void OPPROTO op_and (void)
1.1 root 1431: {
1.1.1.4 ! root 1432: T0 &= T1;
1.1 root 1433: RETURN();
1434: }
1435:
1.1.1.4 ! root 1436: /* andc */
! 1437: void OPPROTO op_andc (void)
1.1 root 1438: {
1.1.1.4 ! root 1439: T0 &= ~T1;
1.1 root 1440: RETURN();
1441: }
1442:
1.1.1.4 ! root 1443: /* andi. */
! 1444: void OPPROTO op_andi_T0 (void)
1.1 root 1445: {
1.1.1.4 ! root 1446: T0 &= (uint32_t)PARAM1;
1.1 root 1447: RETURN();
1448: }
1449:
1.1.1.4 ! root 1450: void OPPROTO op_andi_T1 (void)
1.1 root 1451: {
1.1.1.4 ! root 1452: T1 &= (uint32_t)PARAM1;
! 1453: RETURN();
! 1454: }
! 1455:
! 1456: #if defined(TARGET_PPC64)
! 1457: void OPPROTO op_andi_T0_64 (void)
! 1458: {
! 1459: T0 &= ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
! 1460: RETURN();
! 1461: }
! 1462:
! 1463: void OPPROTO op_andi_T1_64 (void)
! 1464: {
! 1465: T1 &= ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
! 1466: RETURN();
! 1467: }
! 1468: #endif
! 1469:
! 1470: /* count leading zero */
! 1471: void OPPROTO op_cntlzw (void)
! 1472: {
! 1473: do_cntlzw();
! 1474: RETURN();
! 1475: }
! 1476:
! 1477: #if defined(TARGET_PPC64)
! 1478: void OPPROTO op_cntlzd (void)
! 1479: {
! 1480: do_cntlzd();
! 1481: RETURN();
! 1482: }
! 1483: #endif
! 1484:
! 1485: /* eqv */
! 1486: void OPPROTO op_eqv (void)
! 1487: {
! 1488: T0 = ~(T0 ^ T1);
! 1489: RETURN();
! 1490: }
! 1491:
! 1492: /* extend sign byte */
! 1493: void OPPROTO op_extsb (void)
! 1494: {
! 1495: #if defined (TARGET_PPC64)
! 1496: T0 = (int64_t)((int8_t)T0);
! 1497: #else
! 1498: T0 = (int32_t)((int8_t)T0);
! 1499: #endif
! 1500: RETURN();
! 1501: }
! 1502:
! 1503: /* extend sign half word */
! 1504: void OPPROTO op_extsh (void)
! 1505: {
! 1506: #if defined (TARGET_PPC64)
! 1507: T0 = (int64_t)((int16_t)T0);
! 1508: #else
! 1509: T0 = (int32_t)((int16_t)T0);
! 1510: #endif
! 1511: RETURN();
! 1512: }
! 1513:
! 1514: #if defined (TARGET_PPC64)
! 1515: void OPPROTO op_extsw (void)
! 1516: {
! 1517: T0 = (int64_t)((int32_t)T0);
! 1518: RETURN();
! 1519: }
! 1520: #endif
! 1521:
! 1522: /* nand */
! 1523: void OPPROTO op_nand (void)
! 1524: {
! 1525: T0 = ~(T0 & T1);
! 1526: RETURN();
! 1527: }
! 1528:
! 1529: /* nor */
! 1530: void OPPROTO op_nor (void)
! 1531: {
! 1532: T0 = ~(T0 | T1);
! 1533: RETURN();
! 1534: }
! 1535:
! 1536: /* or */
! 1537: void OPPROTO op_or (void)
! 1538: {
! 1539: T0 |= T1;
! 1540: RETURN();
! 1541: }
! 1542:
! 1543: /* orc */
! 1544: void OPPROTO op_orc (void)
! 1545: {
! 1546: T0 |= ~T1;
! 1547: RETURN();
! 1548: }
! 1549:
! 1550: /* ori */
! 1551: void OPPROTO op_ori (void)
! 1552: {
! 1553: T0 |= (uint32_t)PARAM1;
! 1554: RETURN();
! 1555: }
! 1556:
! 1557: /* xor */
! 1558: void OPPROTO op_xor (void)
! 1559: {
! 1560: T0 ^= T1;
! 1561: RETURN();
! 1562: }
! 1563:
! 1564: /* xori */
! 1565: void OPPROTO op_xori (void)
! 1566: {
! 1567: T0 ^= (uint32_t)PARAM1;
! 1568: RETURN();
! 1569: }
! 1570:
! 1571: /*** Integer rotate ***/
! 1572: void OPPROTO op_rotl32_T0_T1 (void)
! 1573: {
! 1574: T0 = rotl32(T0, T1 & 0x1F);
! 1575: RETURN();
! 1576: }
! 1577:
! 1578: void OPPROTO op_rotli32_T0 (void)
! 1579: {
! 1580: T0 = rotl32(T0, PARAM1);
! 1581: RETURN();
! 1582: }
! 1583:
! 1584: #if defined(TARGET_PPC64)
! 1585: void OPPROTO op_rotl64_T0_T1 (void)
! 1586: {
! 1587: T0 = rotl64(T0, T1 & 0x3F);
! 1588: RETURN();
! 1589: }
! 1590:
! 1591: void OPPROTO op_rotli64_T0 (void)
! 1592: {
! 1593: T0 = rotl64(T0, PARAM1);
! 1594: RETURN();
! 1595: }
! 1596: #endif
! 1597:
! 1598: /*** Integer shift ***/
! 1599: /* shift left word */
! 1600: void OPPROTO op_slw (void)
! 1601: {
! 1602: if (T1 & 0x20) {
! 1603: T0 = 0;
! 1604: } else {
! 1605: T0 = (uint32_t)(T0 << T1);
! 1606: }
! 1607: RETURN();
! 1608: }
! 1609:
! 1610: #if defined(TARGET_PPC64)
! 1611: void OPPROTO op_sld (void)
! 1612: {
! 1613: if (T1 & 0x40) {
! 1614: T0 = 0;
! 1615: } else {
! 1616: T0 = T0 << T1;
! 1617: }
! 1618: RETURN();
! 1619: }
! 1620: #endif
! 1621:
! 1622: /* shift right algebraic word */
! 1623: void OPPROTO op_sraw (void)
! 1624: {
! 1625: do_sraw();
! 1626: RETURN();
! 1627: }
! 1628:
! 1629: #if defined(TARGET_PPC64)
! 1630: void OPPROTO op_srad (void)
! 1631: {
! 1632: do_srad();
! 1633: RETURN();
! 1634: }
! 1635: #endif
! 1636:
! 1637: /* shift right algebraic word immediate */
! 1638: void OPPROTO op_srawi (void)
! 1639: {
! 1640: uint32_t mask = (uint32_t)PARAM2;
! 1641:
! 1642: T0 = (int32_t)T0 >> PARAM1;
! 1643: if ((int32_t)T1 < 0 && (T1 & mask) != 0) {
! 1644: xer_ca = 1;
! 1645: } else {
! 1646: xer_ca = 0;
! 1647: }
! 1648: RETURN();
! 1649: }
! 1650:
! 1651: #if defined(TARGET_PPC64)
! 1652: void OPPROTO op_sradi (void)
! 1653: {
! 1654: uint64_t mask = ((uint64_t)PARAM2 << 32) | (uint64_t)PARAM3;
! 1655:
! 1656: T0 = (int64_t)T0 >> PARAM1;
! 1657: if ((int64_t)T1 < 0 && ((uint64_t)T1 & mask) != 0) {
! 1658: xer_ca = 1;
! 1659: } else {
! 1660: xer_ca = 0;
! 1661: }
! 1662: RETURN();
! 1663: }
! 1664: #endif
! 1665:
! 1666: /* shift right word */
! 1667: void OPPROTO op_srw (void)
! 1668: {
! 1669: if (T1 & 0x20) {
! 1670: T0 = 0;
! 1671: } else {
! 1672: T0 = (uint32_t)T0 >> T1;
! 1673: }
! 1674: RETURN();
! 1675: }
! 1676:
! 1677: #if defined(TARGET_PPC64)
! 1678: void OPPROTO op_srd (void)
! 1679: {
! 1680: if (T1 & 0x40) {
! 1681: T0 = 0;
! 1682: } else {
! 1683: T0 = (uint64_t)T0 >> T1;
! 1684: }
! 1685: RETURN();
! 1686: }
! 1687: #endif
! 1688:
! 1689: void OPPROTO op_sl_T0_T1 (void)
! 1690: {
! 1691: T0 = T0 << T1;
! 1692: RETURN();
! 1693: }
! 1694:
! 1695: void OPPROTO op_sli_T0 (void)
! 1696: {
! 1697: T0 = T0 << PARAM1;
! 1698: RETURN();
! 1699: }
! 1700:
! 1701: void OPPROTO op_sli_T1 (void)
! 1702: {
! 1703: T1 = T1 << PARAM1;
! 1704: RETURN();
! 1705: }
! 1706:
! 1707: void OPPROTO op_srl_T0_T1 (void)
! 1708: {
! 1709: T0 = (uint32_t)T0 >> T1;
! 1710: RETURN();
! 1711: }
! 1712:
! 1713: #if defined(TARGET_PPC64)
! 1714: void OPPROTO op_srl_T0_T1_64 (void)
! 1715: {
! 1716: T0 = (uint32_t)T0 >> T1;
! 1717: RETURN();
! 1718: }
! 1719: #endif
! 1720:
! 1721: void OPPROTO op_srli_T0 (void)
! 1722: {
! 1723: T0 = (uint32_t)T0 >> PARAM1;
! 1724: RETURN();
! 1725: }
! 1726:
! 1727: #if defined(TARGET_PPC64)
! 1728: void OPPROTO op_srli_T0_64 (void)
! 1729: {
! 1730: T0 = (uint64_t)T0 >> PARAM1;
! 1731: RETURN();
! 1732: }
! 1733: #endif
! 1734:
! 1735: void OPPROTO op_srli_T1 (void)
! 1736: {
! 1737: T1 = (uint32_t)T1 >> PARAM1;
! 1738: RETURN();
! 1739: }
! 1740:
! 1741: #if defined(TARGET_PPC64)
! 1742: void OPPROTO op_srli_T1_64 (void)
! 1743: {
! 1744: T1 = (uint64_t)T1 >> PARAM1;
! 1745: RETURN();
! 1746: }
! 1747: #endif
! 1748:
! 1749: /*** Floating-Point arithmetic ***/
! 1750: /* fadd - fadd. */
! 1751: void OPPROTO op_fadd (void)
! 1752: {
! 1753: #if USE_PRECISE_EMULATION
! 1754: do_fadd();
! 1755: #else
! 1756: FT0 = float64_add(FT0, FT1, &env->fp_status);
! 1757: #endif
! 1758: RETURN();
! 1759: }
! 1760:
! 1761: /* fsub - fsub. */
! 1762: void OPPROTO op_fsub (void)
! 1763: {
! 1764: #if USE_PRECISE_EMULATION
! 1765: do_fsub();
! 1766: #else
! 1767: FT0 = float64_sub(FT0, FT1, &env->fp_status);
! 1768: #endif
! 1769: RETURN();
! 1770: }
! 1771:
! 1772: /* fmul - fmul. */
! 1773: void OPPROTO op_fmul (void)
! 1774: {
! 1775: #if USE_PRECISE_EMULATION
! 1776: do_fmul();
! 1777: #else
! 1778: FT0 = float64_mul(FT0, FT1, &env->fp_status);
! 1779: #endif
! 1780: RETURN();
! 1781: }
! 1782:
! 1783: /* fdiv - fdiv. */
! 1784: void OPPROTO op_fdiv (void)
! 1785: {
! 1786: #if USE_PRECISE_EMULATION
! 1787: do_fdiv();
! 1788: #else
! 1789: FT0 = float64_div(FT0, FT1, &env->fp_status);
! 1790: #endif
! 1791: RETURN();
! 1792: }
! 1793:
! 1794: /* fsqrt - fsqrt. */
! 1795: void OPPROTO op_fsqrt (void)
! 1796: {
! 1797: do_fsqrt();
! 1798: RETURN();
! 1799: }
! 1800:
! 1801: /* fre - fre. */
! 1802: void OPPROTO op_fre (void)
! 1803: {
! 1804: do_fre();
! 1805: RETURN();
! 1806: }
! 1807:
! 1808: /* fres - fres. */
! 1809: void OPPROTO op_fres (void)
! 1810: {
! 1811: do_fres();
! 1812: RETURN();
! 1813: }
! 1814:
! 1815: /* frsqrte - frsqrte. */
! 1816: void OPPROTO op_frsqrte (void)
! 1817: {
! 1818: do_frsqrte();
! 1819: RETURN();
! 1820: }
! 1821:
! 1822: /* fsel - fsel. */
! 1823: void OPPROTO op_fsel (void)
! 1824: {
! 1825: do_fsel();
! 1826: RETURN();
! 1827: }
! 1828:
! 1829: /*** Floating-Point multiply-and-add ***/
! 1830: /* fmadd - fmadd. */
! 1831: void OPPROTO op_fmadd (void)
! 1832: {
! 1833: #if USE_PRECISE_EMULATION
! 1834: do_fmadd();
! 1835: #else
! 1836: FT0 = float64_mul(FT0, FT1, &env->fp_status);
! 1837: FT0 = float64_add(FT0, FT2, &env->fp_status);
! 1838: #endif
! 1839: RETURN();
! 1840: }
! 1841:
! 1842: /* fmsub - fmsub. */
! 1843: void OPPROTO op_fmsub (void)
! 1844: {
! 1845: #if USE_PRECISE_EMULATION
! 1846: do_fmsub();
! 1847: #else
! 1848: FT0 = float64_mul(FT0, FT1, &env->fp_status);
! 1849: FT0 = float64_sub(FT0, FT2, &env->fp_status);
! 1850: #endif
! 1851: RETURN();
! 1852: }
! 1853:
! 1854: /* fnmadd - fnmadd. - fnmadds - fnmadds. */
! 1855: void OPPROTO op_fnmadd (void)
! 1856: {
! 1857: do_fnmadd();
! 1858: RETURN();
! 1859: }
! 1860:
! 1861: /* fnmsub - fnmsub. */
! 1862: void OPPROTO op_fnmsub (void)
! 1863: {
! 1864: do_fnmsub();
! 1865: RETURN();
! 1866: }
! 1867:
! 1868: /*** Floating-Point round & convert ***/
! 1869: /* frsp - frsp. */
! 1870: void OPPROTO op_frsp (void)
! 1871: {
! 1872: #if USE_PRECISE_EMULATION
! 1873: do_frsp();
! 1874: #else
! 1875: FT0 = float64_to_float32(FT0, &env->fp_status);
! 1876: #endif
! 1877: RETURN();
! 1878: }
! 1879:
! 1880: /* fctiw - fctiw. */
! 1881: void OPPROTO op_fctiw (void)
! 1882: {
! 1883: do_fctiw();
! 1884: RETURN();
! 1885: }
! 1886:
! 1887: /* fctiwz - fctiwz. */
! 1888: void OPPROTO op_fctiwz (void)
! 1889: {
! 1890: do_fctiwz();
! 1891: RETURN();
! 1892: }
! 1893:
! 1894: #if defined(TARGET_PPC64)
! 1895: /* fcfid - fcfid. */
! 1896: void OPPROTO op_fcfid (void)
! 1897: {
! 1898: do_fcfid();
! 1899: RETURN();
! 1900: }
! 1901:
! 1902: /* fctid - fctid. */
! 1903: void OPPROTO op_fctid (void)
! 1904: {
! 1905: do_fctid();
! 1906: RETURN();
! 1907: }
! 1908:
! 1909: /* fctidz - fctidz. */
! 1910: void OPPROTO op_fctidz (void)
! 1911: {
! 1912: do_fctidz();
! 1913: RETURN();
! 1914: }
! 1915: #endif
! 1916:
! 1917: void OPPROTO op_frin (void)
! 1918: {
! 1919: do_frin();
! 1920: RETURN();
! 1921: }
! 1922:
! 1923: void OPPROTO op_friz (void)
! 1924: {
! 1925: do_friz();
! 1926: RETURN();
! 1927: }
! 1928:
! 1929: void OPPROTO op_frip (void)
! 1930: {
! 1931: do_frip();
! 1932: RETURN();
! 1933: }
! 1934:
! 1935: void OPPROTO op_frim (void)
! 1936: {
! 1937: do_frim();
! 1938: RETURN();
! 1939: }
! 1940:
! 1941: /*** Floating-Point compare ***/
! 1942: /* fcmpu */
! 1943: void OPPROTO op_fcmpu (void)
! 1944: {
! 1945: do_fcmpu();
! 1946: RETURN();
! 1947: }
! 1948:
! 1949: /* fcmpo */
! 1950: void OPPROTO op_fcmpo (void)
! 1951: {
! 1952: do_fcmpo();
! 1953: RETURN();
! 1954: }
! 1955:
! 1956: /*** Floating-point move ***/
! 1957: /* fabs */
! 1958: void OPPROTO op_fabs (void)
! 1959: {
! 1960: FT0 = float64_abs(FT0);
! 1961: RETURN();
! 1962: }
! 1963:
! 1964: /* fnabs */
! 1965: void OPPROTO op_fnabs (void)
! 1966: {
! 1967: FT0 = float64_abs(FT0);
! 1968: FT0 = float64_chs(FT0);
! 1969: RETURN();
! 1970: }
! 1971:
! 1972: /* fneg */
! 1973: void OPPROTO op_fneg (void)
! 1974: {
! 1975: FT0 = float64_chs(FT0);
! 1976: RETURN();
! 1977: }
! 1978:
! 1979: /* Load and store */
! 1980: #define MEMSUFFIX _raw
! 1981: #include "op_helper.h"
! 1982: #include "op_mem.h"
! 1983: #if !defined(CONFIG_USER_ONLY)
! 1984: #define MEMSUFFIX _user
! 1985: #include "op_helper.h"
! 1986: #include "op_mem.h"
! 1987: #define MEMSUFFIX _kernel
! 1988: #include "op_helper.h"
! 1989: #include "op_mem.h"
! 1990: #define MEMSUFFIX _hypv
! 1991: #include "op_helper.h"
! 1992: #include "op_mem.h"
! 1993: #endif
! 1994:
! 1995: /* Special op to check and maybe clear reservation */
! 1996: void OPPROTO op_check_reservation (void)
! 1997: {
! 1998: if ((uint32_t)env->reserve == (uint32_t)(T0 & ~0x00000003))
! 1999: env->reserve = (target_ulong)-1ULL;
! 2000: RETURN();
! 2001: }
! 2002:
! 2003: #if defined(TARGET_PPC64)
! 2004: void OPPROTO op_check_reservation_64 (void)
! 2005: {
! 2006: if ((uint64_t)env->reserve == (uint64_t)(T0 & ~0x00000003))
! 2007: env->reserve = (target_ulong)-1ULL;
! 2008: RETURN();
! 2009: }
! 2010: #endif
! 2011:
! 2012: void OPPROTO op_wait (void)
! 2013: {
! 2014: env->halted = 1;
! 2015: RETURN();
! 2016: }
! 2017:
! 2018: /* Return from interrupt */
! 2019: #if !defined(CONFIG_USER_ONLY)
! 2020: void OPPROTO op_rfi (void)
! 2021: {
! 2022: do_rfi();
! 2023: RETURN();
! 2024: }
! 2025:
! 2026: #if defined(TARGET_PPC64)
! 2027: void OPPROTO op_rfid (void)
! 2028: {
! 2029: do_rfid();
! 2030: RETURN();
! 2031: }
! 2032:
! 2033: void OPPROTO op_hrfid (void)
! 2034: {
! 2035: do_hrfid();
! 2036: RETURN();
! 2037: }
! 2038: #endif
! 2039:
! 2040: /* Exception vectors */
! 2041: void OPPROTO op_store_excp_prefix (void)
! 2042: {
! 2043: T0 &= env->ivpr_mask;
! 2044: env->excp_prefix = T0;
! 2045: RETURN();
! 2046: }
! 2047:
! 2048: void OPPROTO op_store_excp_vector (void)
! 2049: {
! 2050: T0 &= env->ivor_mask;
! 2051: env->excp_vectors[PARAM1] = T0;
! 2052: RETURN();
! 2053: }
! 2054: #endif
! 2055:
! 2056: /* Trap word */
! 2057: void OPPROTO op_tw (void)
! 2058: {
! 2059: do_tw(PARAM1);
! 2060: RETURN();
! 2061: }
! 2062:
! 2063: #if defined(TARGET_PPC64)
! 2064: void OPPROTO op_td (void)
! 2065: {
! 2066: do_td(PARAM1);
! 2067: RETURN();
! 2068: }
! 2069: #endif
! 2070:
! 2071: #if !defined(CONFIG_USER_ONLY)
! 2072: /* tlbia */
! 2073: void OPPROTO op_tlbia (void)
! 2074: {
! 2075: ppc_tlb_invalidate_all(env);
! 2076: RETURN();
! 2077: }
! 2078:
! 2079: /* tlbie */
! 2080: void OPPROTO op_tlbie (void)
! 2081: {
! 2082: ppc_tlb_invalidate_one(env, (uint32_t)T0);
! 2083: RETURN();
! 2084: }
! 2085:
! 2086: #if defined(TARGET_PPC64)
! 2087: void OPPROTO op_tlbie_64 (void)
! 2088: {
! 2089: ppc_tlb_invalidate_one(env, T0);
! 2090: RETURN();
! 2091: }
! 2092: #endif
! 2093:
! 2094: #if defined(TARGET_PPC64)
! 2095: void OPPROTO op_slbia (void)
! 2096: {
! 2097: ppc_slb_invalidate_all(env);
! 2098: RETURN();
! 2099: }
! 2100:
! 2101: void OPPROTO op_slbie (void)
! 2102: {
! 2103: ppc_slb_invalidate_one(env, (uint32_t)T0);
! 2104: RETURN();
! 2105: }
! 2106:
! 2107: void OPPROTO op_slbie_64 (void)
! 2108: {
! 2109: ppc_slb_invalidate_one(env, T0);
! 2110: RETURN();
! 2111: }
! 2112: #endif
! 2113: #endif
! 2114:
! 2115: #if !defined(CONFIG_USER_ONLY)
! 2116: /* PowerPC 602/603/755 software TLB load instructions */
! 2117: void OPPROTO op_6xx_tlbld (void)
! 2118: {
! 2119: do_load_6xx_tlb(0);
! 2120: RETURN();
! 2121: }
! 2122:
! 2123: void OPPROTO op_6xx_tlbli (void)
! 2124: {
! 2125: do_load_6xx_tlb(1);
! 2126: RETURN();
! 2127: }
! 2128:
! 2129: /* PowerPC 74xx software TLB load instructions */
! 2130: void OPPROTO op_74xx_tlbld (void)
! 2131: {
! 2132: do_load_74xx_tlb(0);
! 2133: RETURN();
! 2134: }
! 2135:
! 2136: void OPPROTO op_74xx_tlbli (void)
! 2137: {
! 2138: do_load_74xx_tlb(1);
! 2139: RETURN();
! 2140: }
! 2141: #endif
! 2142:
! 2143: /* 601 specific */
! 2144: void OPPROTO op_load_601_rtcl (void)
! 2145: {
! 2146: T0 = cpu_ppc601_load_rtcl(env);
! 2147: RETURN();
! 2148: }
! 2149:
! 2150: void OPPROTO op_load_601_rtcu (void)
! 2151: {
! 2152: T0 = cpu_ppc601_load_rtcu(env);
! 2153: RETURN();
! 2154: }
! 2155:
! 2156: #if !defined(CONFIG_USER_ONLY)
! 2157: void OPPROTO op_store_601_rtcl (void)
! 2158: {
! 2159: cpu_ppc601_store_rtcl(env, T0);
! 2160: RETURN();
! 2161: }
! 2162:
! 2163: void OPPROTO op_store_601_rtcu (void)
! 2164: {
! 2165: cpu_ppc601_store_rtcu(env, T0);
! 2166: RETURN();
! 2167: }
! 2168:
! 2169: void OPPROTO op_store_hid0_601 (void)
! 2170: {
! 2171: do_store_hid0_601();
! 2172: RETURN();
! 2173: }
! 2174:
! 2175: void OPPROTO op_load_601_bat (void)
! 2176: {
! 2177: T0 = env->IBAT[PARAM1][PARAM2];
! 2178: RETURN();
! 2179: }
! 2180:
! 2181: void OPPROTO op_store_601_batl (void)
! 2182: {
! 2183: do_store_ibatl_601(env, PARAM1, T0);
! 2184: RETURN();
! 2185: }
! 2186:
! 2187: void OPPROTO op_store_601_batu (void)
! 2188: {
! 2189: do_store_ibatu_601(env, PARAM1, T0);
! 2190: RETURN();
! 2191: }
! 2192: #endif /* !defined(CONFIG_USER_ONLY) */
! 2193:
! 2194: /* PowerPC 601 specific instructions (POWER bridge) */
! 2195: /* XXX: those micro-ops need tests ! */
! 2196: void OPPROTO op_POWER_abs (void)
! 2197: {
! 2198: if ((int32_t)T0 == INT32_MIN)
! 2199: T0 = INT32_MAX;
! 2200: else if ((int32_t)T0 < 0)
! 2201: T0 = -T0;
! 2202: RETURN();
! 2203: }
! 2204:
! 2205: void OPPROTO op_POWER_abso (void)
! 2206: {
! 2207: do_POWER_abso();
! 2208: RETURN();
! 2209: }
! 2210:
! 2211: void OPPROTO op_POWER_clcs (void)
! 2212: {
! 2213: do_POWER_clcs();
! 2214: RETURN();
! 2215: }
! 2216:
! 2217: void OPPROTO op_POWER_div (void)
! 2218: {
! 2219: do_POWER_div();
! 2220: RETURN();
! 2221: }
! 2222:
! 2223: void OPPROTO op_POWER_divo (void)
! 2224: {
! 2225: do_POWER_divo();
! 2226: RETURN();
! 2227: }
! 2228:
! 2229: void OPPROTO op_POWER_divs (void)
! 2230: {
! 2231: do_POWER_divs();
! 2232: RETURN();
! 2233: }
! 2234:
! 2235: void OPPROTO op_POWER_divso (void)
! 2236: {
! 2237: do_POWER_divso();
! 2238: RETURN();
! 2239: }
! 2240:
! 2241: void OPPROTO op_POWER_doz (void)
! 2242: {
! 2243: if ((int32_t)T1 > (int32_t)T0)
! 2244: T0 = T1 - T0;
! 2245: else
! 2246: T0 = 0;
! 2247: RETURN();
! 2248: }
! 2249:
! 2250: void OPPROTO op_POWER_dozo (void)
! 2251: {
! 2252: do_POWER_dozo();
! 2253: RETURN();
! 2254: }
! 2255:
! 2256: void OPPROTO op_load_xer_cmp (void)
! 2257: {
! 2258: T2 = xer_cmp;
! 2259: RETURN();
! 2260: }
! 2261:
! 2262: void OPPROTO op_POWER_maskg (void)
! 2263: {
! 2264: do_POWER_maskg();
! 2265: RETURN();
! 2266: }
! 2267:
! 2268: void OPPROTO op_POWER_maskir (void)
! 2269: {
! 2270: T0 = (T0 & ~T2) | (T1 & T2);
! 2271: RETURN();
! 2272: }
! 2273:
! 2274: void OPPROTO op_POWER_mul (void)
! 2275: {
! 2276: uint64_t tmp;
! 2277:
! 2278: tmp = (uint64_t)T0 * (uint64_t)T1;
! 2279: env->spr[SPR_MQ] = tmp >> 32;
! 2280: T0 = tmp;
! 2281: RETURN();
! 2282: }
! 2283:
! 2284: void OPPROTO op_POWER_mulo (void)
! 2285: {
! 2286: do_POWER_mulo();
! 2287: RETURN();
! 2288: }
! 2289:
! 2290: void OPPROTO op_POWER_nabs (void)
! 2291: {
! 2292: if (T0 > 0)
! 2293: T0 = -T0;
! 2294: RETURN();
! 2295: }
! 2296:
! 2297: void OPPROTO op_POWER_nabso (void)
! 2298: {
! 2299: /* nabs never overflows */
! 2300: if (T0 > 0)
! 2301: T0 = -T0;
! 2302: xer_ov = 0;
! 2303: RETURN();
! 2304: }
! 2305:
! 2306: /* XXX: factorise POWER rotates... */
! 2307: void OPPROTO op_POWER_rlmi (void)
! 2308: {
! 2309: T0 = rotl32(T0, T2) & PARAM1;
! 2310: T0 |= T1 & (uint32_t)PARAM2;
! 2311: RETURN();
! 2312: }
! 2313:
! 2314: void OPPROTO op_POWER_rrib (void)
! 2315: {
! 2316: T2 &= 0x1FUL;
! 2317: T0 = rotl32(T0 & INT32_MIN, T2);
! 2318: T0 |= T1 & ~rotl32(INT32_MIN, T2);
! 2319: RETURN();
! 2320: }
! 2321:
! 2322: void OPPROTO op_POWER_sle (void)
! 2323: {
! 2324: T1 &= 0x1FUL;
! 2325: env->spr[SPR_MQ] = rotl32(T0, T1);
! 2326: T0 = T0 << T1;
! 2327: RETURN();
! 2328: }
! 2329:
! 2330: void OPPROTO op_POWER_sleq (void)
! 2331: {
! 2332: uint32_t tmp = env->spr[SPR_MQ];
! 2333:
! 2334: T1 &= 0x1FUL;
! 2335: env->spr[SPR_MQ] = rotl32(T0, T1);
! 2336: T0 = T0 << T1;
! 2337: T0 |= tmp >> (32 - T1);
! 2338: RETURN();
! 2339: }
! 2340:
! 2341: void OPPROTO op_POWER_sllq (void)
! 2342: {
! 2343: uint32_t msk = UINT32_MAX;
! 2344:
! 2345: msk = msk << (T1 & 0x1FUL);
! 2346: if (T1 & 0x20UL)
! 2347: msk = ~msk;
! 2348: T1 &= 0x1FUL;
! 2349: T0 = (T0 << T1) & msk;
! 2350: T0 |= env->spr[SPR_MQ] & ~msk;
! 2351: RETURN();
! 2352: }
! 2353:
! 2354: void OPPROTO op_POWER_slq (void)
! 2355: {
! 2356: uint32_t msk = UINT32_MAX, tmp;
! 2357:
! 2358: msk = msk << (T1 & 0x1FUL);
! 2359: if (T1 & 0x20UL)
! 2360: msk = ~msk;
! 2361: T1 &= 0x1FUL;
! 2362: tmp = rotl32(T0, T1);
! 2363: T0 = tmp & msk;
! 2364: env->spr[SPR_MQ] = tmp;
! 2365: RETURN();
! 2366: }
! 2367:
! 2368: void OPPROTO op_POWER_sraq (void)
! 2369: {
! 2370: env->spr[SPR_MQ] = rotl32(T0, 32 - (T1 & 0x1FUL));
! 2371: if (T1 & 0x20UL)
! 2372: T0 = UINT32_MAX;
! 2373: else
! 2374: T0 = (int32_t)T0 >> T1;
! 2375: RETURN();
! 2376: }
! 2377:
! 2378: void OPPROTO op_POWER_sre (void)
! 2379: {
! 2380: T1 &= 0x1FUL;
! 2381: env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
! 2382: T0 = (int32_t)T0 >> T1;
! 2383: RETURN();
! 2384: }
! 2385:
! 2386: void OPPROTO op_POWER_srea (void)
! 2387: {
! 2388: T1 &= 0x1FUL;
! 2389: env->spr[SPR_MQ] = T0 >> T1;
! 2390: T0 = (int32_t)T0 >> T1;
! 2391: RETURN();
! 2392: }
! 2393:
! 2394: void OPPROTO op_POWER_sreq (void)
! 2395: {
! 2396: uint32_t tmp;
! 2397: int32_t msk;
! 2398:
! 2399: T1 &= 0x1FUL;
! 2400: msk = INT32_MIN >> T1;
! 2401: tmp = env->spr[SPR_MQ];
! 2402: env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
! 2403: T0 = T0 >> T1;
! 2404: T0 |= tmp & msk;
! 2405: RETURN();
! 2406: }
! 2407:
! 2408: void OPPROTO op_POWER_srlq (void)
! 2409: {
! 2410: uint32_t tmp;
! 2411: int32_t msk;
! 2412:
! 2413: msk = INT32_MIN >> (T1 & 0x1FUL);
! 2414: if (T1 & 0x20UL)
! 2415: msk = ~msk;
! 2416: T1 &= 0x1FUL;
! 2417: tmp = env->spr[SPR_MQ];
! 2418: env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
! 2419: T0 = T0 >> T1;
! 2420: T0 &= msk;
! 2421: T0 |= tmp & ~msk;
! 2422: RETURN();
! 2423: }
! 2424:
! 2425: void OPPROTO op_POWER_srq (void)
! 2426: {
! 2427: T1 &= 0x1FUL;
! 2428: env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
! 2429: T0 = T0 >> T1;
! 2430: RETURN();
! 2431: }
! 2432:
! 2433: /* POWER instructions not implemented in PowerPC 601 */
! 2434: #if !defined(CONFIG_USER_ONLY)
! 2435: void OPPROTO op_POWER_mfsri (void)
! 2436: {
! 2437: T1 = T0 >> 28;
! 2438: T0 = env->sr[T1];
! 2439: RETURN();
! 2440: }
! 2441:
! 2442: void OPPROTO op_POWER_rac (void)
! 2443: {
! 2444: do_POWER_rac();
! 2445: RETURN();
! 2446: }
! 2447:
! 2448: void OPPROTO op_POWER_rfsvc (void)
! 2449: {
! 2450: do_POWER_rfsvc();
! 2451: RETURN();
! 2452: }
! 2453: #endif
! 2454:
! 2455: /* PowerPC 602 specific instruction */
! 2456: #if !defined(CONFIG_USER_ONLY)
! 2457: void OPPROTO op_602_mfrom (void)
! 2458: {
! 2459: do_op_602_mfrom();
! 2460: RETURN();
! 2461: }
! 2462: #endif
! 2463:
! 2464: /* PowerPC 4xx specific micro-ops */
! 2465: void OPPROTO op_405_add_T0_T2 (void)
! 2466: {
! 2467: T0 = (int32_t)T0 + (int32_t)T2;
! 2468: RETURN();
! 2469: }
! 2470:
! 2471: void OPPROTO op_405_mulchw (void)
! 2472: {
! 2473: T0 = ((int16_t)T0) * ((int16_t)(T1 >> 16));
! 2474: RETURN();
! 2475: }
! 2476:
! 2477: void OPPROTO op_405_mulchwu (void)
! 2478: {
! 2479: T0 = ((uint16_t)T0) * ((uint16_t)(T1 >> 16));
! 2480: RETURN();
! 2481: }
! 2482:
! 2483: void OPPROTO op_405_mulhhw (void)
! 2484: {
! 2485: T0 = ((int16_t)(T0 >> 16)) * ((int16_t)(T1 >> 16));
! 2486: RETURN();
! 2487: }
! 2488:
! 2489: void OPPROTO op_405_mulhhwu (void)
! 2490: {
! 2491: T0 = ((uint16_t)(T0 >> 16)) * ((uint16_t)(T1 >> 16));
! 2492: RETURN();
! 2493: }
! 2494:
! 2495: void OPPROTO op_405_mullhw (void)
! 2496: {
! 2497: T0 = ((int16_t)T0) * ((int16_t)T1);
! 2498: RETURN();
! 2499: }
! 2500:
! 2501: void OPPROTO op_405_mullhwu (void)
! 2502: {
! 2503: T0 = ((uint16_t)T0) * ((uint16_t)T1);
! 2504: RETURN();
! 2505: }
! 2506:
! 2507: void OPPROTO op_405_check_sat (void)
! 2508: {
! 2509: do_405_check_sat();
! 2510: RETURN();
! 2511: }
! 2512:
! 2513: void OPPROTO op_405_check_ovu (void)
! 2514: {
! 2515: if (likely(T0 >= T2)) {
! 2516: xer_ov = 0;
! 2517: } else {
! 2518: xer_ov = 1;
! 2519: xer_so = 1;
! 2520: }
! 2521: RETURN();
! 2522: }
! 2523:
! 2524: void OPPROTO op_405_check_satu (void)
! 2525: {
! 2526: if (unlikely(T0 < T2)) {
! 2527: /* Saturate result */
! 2528: T0 = UINT32_MAX;
! 2529: }
! 2530: RETURN();
! 2531: }
! 2532:
! 2533: void OPPROTO op_load_dcr (void)
! 2534: {
! 2535: do_load_dcr();
! 2536: RETURN();
! 2537: }
! 2538:
! 2539: void OPPROTO op_store_dcr (void)
! 2540: {
! 2541: do_store_dcr();
! 2542: RETURN();
! 2543: }
! 2544:
! 2545: #if !defined(CONFIG_USER_ONLY)
! 2546: /* Return from critical interrupt :
! 2547: * same as rfi, except nip & MSR are loaded from SRR2/3 instead of SRR0/1
! 2548: */
! 2549: void OPPROTO op_40x_rfci (void)
! 2550: {
! 2551: do_40x_rfci();
! 2552: RETURN();
! 2553: }
! 2554:
! 2555: void OPPROTO op_rfci (void)
! 2556: {
! 2557: do_rfci();
! 2558: RETURN();
! 2559: }
! 2560:
! 2561: void OPPROTO op_rfdi (void)
! 2562: {
! 2563: do_rfdi();
! 2564: RETURN();
! 2565: }
! 2566:
! 2567: void OPPROTO op_rfmci (void)
! 2568: {
! 2569: do_rfmci();
! 2570: RETURN();
! 2571: }
! 2572:
! 2573: void OPPROTO op_wrte (void)
! 2574: {
! 2575: /* We don't call do_store_msr here as we won't trigger
! 2576: * any special case nor change hflags
! 2577: */
! 2578: T0 &= 1 << MSR_EE;
! 2579: env->msr &= ~(1 << MSR_EE);
! 2580: env->msr |= T0;
! 2581: RETURN();
! 2582: }
! 2583:
! 2584: void OPPROTO op_440_tlbre (void)
! 2585: {
! 2586: do_440_tlbre(PARAM1);
! 2587: RETURN();
! 2588: }
! 2589:
! 2590: void OPPROTO op_440_tlbsx (void)
! 2591: {
! 2592: T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_440_MMUCR] & 0xFF);
! 2593: RETURN();
! 2594: }
! 2595:
! 2596: void OPPROTO op_4xx_tlbsx_check (void)
! 2597: {
! 2598: int tmp;
! 2599:
! 2600: tmp = xer_so;
! 2601: if ((int)T0 != -1)
! 2602: tmp |= 0x02;
! 2603: env->crf[0] = tmp;
! 2604: RETURN();
! 2605: }
! 2606:
! 2607: void OPPROTO op_440_tlbwe (void)
! 2608: {
! 2609: do_440_tlbwe(PARAM1);
! 2610: RETURN();
! 2611: }
! 2612:
! 2613: void OPPROTO op_4xx_tlbre_lo (void)
! 2614: {
! 2615: do_4xx_tlbre_lo();
! 2616: RETURN();
! 2617: }
! 2618:
! 2619: void OPPROTO op_4xx_tlbre_hi (void)
! 2620: {
! 2621: do_4xx_tlbre_hi();
! 2622: RETURN();
! 2623: }
! 2624:
! 2625: void OPPROTO op_4xx_tlbsx (void)
! 2626: {
! 2627: T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_40x_PID]);
! 2628: RETURN();
! 2629: }
! 2630:
! 2631: void OPPROTO op_4xx_tlbwe_lo (void)
! 2632: {
! 2633: do_4xx_tlbwe_lo();
! 2634: RETURN();
! 2635: }
! 2636:
! 2637: void OPPROTO op_4xx_tlbwe_hi (void)
! 2638: {
! 2639: do_4xx_tlbwe_hi();
! 2640: RETURN();
! 2641: }
! 2642: #endif
! 2643:
! 2644: /* SPR micro-ops */
! 2645: /* 440 specific */
! 2646: void OPPROTO op_440_dlmzb (void)
! 2647: {
! 2648: do_440_dlmzb();
! 2649: RETURN();
! 2650: }
! 2651:
! 2652: void OPPROTO op_440_dlmzb_update_Rc (void)
! 2653: {
! 2654: if (T0 == 8)
! 2655: T0 = 0x2;
! 2656: else if (T0 < 4)
! 2657: T0 = 0x4;
! 2658: else
! 2659: T0 = 0x8;
! 2660: RETURN();
! 2661: }
! 2662:
! 2663: #if !defined(CONFIG_USER_ONLY)
! 2664: void OPPROTO op_store_pir (void)
! 2665: {
! 2666: env->spr[SPR_PIR] = T0 & 0x0000000FUL;
! 2667: RETURN();
! 2668: }
! 2669:
! 2670: void OPPROTO op_load_403_pb (void)
! 2671: {
! 2672: do_load_403_pb(PARAM1);
! 2673: RETURN();
! 2674: }
! 2675:
! 2676: void OPPROTO op_store_403_pb (void)
! 2677: {
! 2678: do_store_403_pb(PARAM1);
! 2679: RETURN();
! 2680: }
! 2681:
! 2682: void OPPROTO op_load_40x_pit (void)
! 2683: {
! 2684: T0 = load_40x_pit(env);
! 2685: RETURN();
! 2686: }
! 2687:
! 2688: void OPPROTO op_store_40x_pit (void)
! 2689: {
! 2690: store_40x_pit(env, T0);
! 2691: RETURN();
! 2692: }
! 2693:
! 2694: void OPPROTO op_store_40x_dbcr0 (void)
! 2695: {
! 2696: store_40x_dbcr0(env, T0);
! 2697: RETURN();
! 2698: }
! 2699:
! 2700: void OPPROTO op_store_40x_sler (void)
! 2701: {
! 2702: store_40x_sler(env, T0);
! 2703: RETURN();
! 2704: }
! 2705:
! 2706: void OPPROTO op_store_booke_tcr (void)
! 2707: {
! 2708: store_booke_tcr(env, T0);
! 2709: RETURN();
! 2710: }
! 2711:
! 2712: void OPPROTO op_store_booke_tsr (void)
! 2713: {
! 2714: store_booke_tsr(env, T0);
! 2715: RETURN();
! 2716: }
! 2717: #endif /* !defined(CONFIG_USER_ONLY) */
! 2718:
! 2719: /* SPE extension */
! 2720: void OPPROTO op_splatw_T1_64 (void)
! 2721: {
! 2722: T1_64 = (T1_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
! 2723: RETURN();
! 2724: }
! 2725:
! 2726: void OPPROTO op_splatwi_T0_64 (void)
! 2727: {
! 2728: uint64_t tmp = PARAM1;
! 2729:
! 2730: T0_64 = (tmp << 32) | tmp;
! 2731: RETURN();
! 2732: }
! 2733:
! 2734: void OPPROTO op_splatwi_T1_64 (void)
! 2735: {
! 2736: uint64_t tmp = PARAM1;
! 2737:
! 2738: T1_64 = (tmp << 32) | tmp;
! 2739: RETURN();
! 2740: }
! 2741:
! 2742: void OPPROTO op_extsh_T1_64 (void)
! 2743: {
! 2744: T1_64 = (int32_t)((int16_t)T1_64);
! 2745: RETURN();
! 2746: }
! 2747:
! 2748: void OPPROTO op_sli16_T1_64 (void)
! 2749: {
! 2750: T1_64 = T1_64 << 16;
! 2751: RETURN();
! 2752: }
! 2753:
! 2754: void OPPROTO op_sli32_T1_64 (void)
! 2755: {
! 2756: T1_64 = T1_64 << 32;
! 2757: RETURN();
! 2758: }
! 2759:
! 2760: void OPPROTO op_srli32_T1_64 (void)
! 2761: {
! 2762: T1_64 = T1_64 >> 32;
! 2763: RETURN();
! 2764: }
! 2765:
! 2766: void OPPROTO op_evsel (void)
! 2767: {
! 2768: do_evsel();
! 2769: RETURN();
! 2770: }
! 2771:
! 2772: void OPPROTO op_evaddw (void)
! 2773: {
! 2774: do_evaddw();
! 2775: RETURN();
! 2776: }
! 2777:
! 2778: void OPPROTO op_evsubfw (void)
! 2779: {
! 2780: do_evsubfw();
! 2781: RETURN();
! 2782: }
! 2783:
! 2784: void OPPROTO op_evneg (void)
! 2785: {
! 2786: do_evneg();
! 2787: RETURN();
! 2788: }
! 2789:
! 2790: void OPPROTO op_evabs (void)
! 2791: {
! 2792: do_evabs();
! 2793: RETURN();
! 2794: }
! 2795:
! 2796: void OPPROTO op_evextsh (void)
! 2797: {
! 2798: T0_64 = ((uint64_t)((int32_t)(int16_t)(T0_64 >> 32)) << 32) |
! 2799: (uint64_t)((int32_t)(int16_t)T0_64);
! 2800: RETURN();
! 2801: }
! 2802:
! 2803: void OPPROTO op_evextsb (void)
! 2804: {
! 2805: T0_64 = ((uint64_t)((int32_t)(int8_t)(T0_64 >> 32)) << 32) |
! 2806: (uint64_t)((int32_t)(int8_t)T0_64);
! 2807: RETURN();
! 2808: }
! 2809:
! 2810: void OPPROTO op_evcntlzw (void)
! 2811: {
! 2812: do_evcntlzw();
! 2813: RETURN();
! 2814: }
! 2815:
! 2816: void OPPROTO op_evrndw (void)
! 2817: {
! 2818: do_evrndw();
! 2819: RETURN();
! 2820: }
! 2821:
! 2822: void OPPROTO op_brinc (void)
! 2823: {
! 2824: do_brinc();
! 2825: RETURN();
! 2826: }
! 2827:
! 2828: void OPPROTO op_evcntlsw (void)
! 2829: {
! 2830: do_evcntlsw();
! 2831: RETURN();
! 2832: }
! 2833:
! 2834: void OPPROTO op_evand (void)
! 2835: {
! 2836: T0_64 &= T1_64;
! 2837: RETURN();
! 2838: }
! 2839:
! 2840: void OPPROTO op_evandc (void)
! 2841: {
! 2842: T0_64 &= ~T1_64;
! 2843: RETURN();
! 2844: }
! 2845:
! 2846: void OPPROTO op_evor (void)
! 2847: {
! 2848: T0_64 |= T1_64;
! 2849: RETURN();
! 2850: }
! 2851:
! 2852: void OPPROTO op_evxor (void)
! 2853: {
! 2854: T0_64 ^= T1_64;
! 2855: RETURN();
! 2856: }
! 2857:
! 2858: void OPPROTO op_eveqv (void)
! 2859: {
! 2860: T0_64 = ~(T0_64 ^ T1_64);
! 2861: RETURN();
! 2862: }
! 2863:
! 2864: void OPPROTO op_evnor (void)
! 2865: {
! 2866: T0_64 = ~(T0_64 | T1_64);
! 2867: RETURN();
! 2868: }
! 2869:
! 2870: void OPPROTO op_evorc (void)
! 2871: {
! 2872: T0_64 |= ~T1_64;
! 2873: RETURN();
! 2874: }
! 2875:
! 2876: void OPPROTO op_evnand (void)
! 2877: {
! 2878: T0_64 = ~(T0_64 & T1_64);
! 2879: RETURN();
! 2880: }
! 2881:
! 2882: void OPPROTO op_evsrws (void)
! 2883: {
! 2884: do_evsrws();
! 2885: RETURN();
! 2886: }
! 2887:
! 2888: void OPPROTO op_evsrwu (void)
! 2889: {
! 2890: do_evsrwu();
! 2891: RETURN();
! 2892: }
! 2893:
! 2894: void OPPROTO op_evslw (void)
! 2895: {
! 2896: do_evslw();
! 2897: RETURN();
! 2898: }
! 2899:
! 2900: void OPPROTO op_evrlw (void)
! 2901: {
! 2902: do_evrlw();
! 2903: RETURN();
! 2904: }
! 2905:
! 2906: void OPPROTO op_evmergelo (void)
! 2907: {
! 2908: T0_64 = (T0_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
! 2909: RETURN();
! 2910: }
! 2911:
! 2912: void OPPROTO op_evmergehi (void)
! 2913: {
! 2914: T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 >> 32);
! 2915: RETURN();
! 2916: }
! 2917:
! 2918: void OPPROTO op_evmergelohi (void)
! 2919: {
! 2920: T0_64 = (T0_64 << 32) | (T1_64 >> 32);
! 2921: RETURN();
! 2922: }
! 2923:
! 2924: void OPPROTO op_evmergehilo (void)
! 2925: {
! 2926: T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 & 0x00000000FFFFFFFFULL);
! 2927: RETURN();
! 2928: }
! 2929:
! 2930: void OPPROTO op_evcmpgts (void)
! 2931: {
! 2932: do_evcmpgts();
! 2933: RETURN();
! 2934: }
! 2935:
! 2936: void OPPROTO op_evcmpgtu (void)
! 2937: {
! 2938: do_evcmpgtu();
! 2939: RETURN();
! 2940: }
! 2941:
! 2942: void OPPROTO op_evcmplts (void)
! 2943: {
! 2944: do_evcmplts();
! 2945: RETURN();
! 2946: }
! 2947:
! 2948: void OPPROTO op_evcmpltu (void)
! 2949: {
! 2950: do_evcmpltu();
! 2951: RETURN();
! 2952: }
! 2953:
! 2954: void OPPROTO op_evcmpeq (void)
! 2955: {
! 2956: do_evcmpeq();
! 2957: RETURN();
! 2958: }
! 2959:
! 2960: void OPPROTO op_evfssub (void)
! 2961: {
! 2962: do_evfssub();
! 2963: RETURN();
! 2964: }
! 2965:
! 2966: void OPPROTO op_evfsadd (void)
! 2967: {
! 2968: do_evfsadd();
! 2969: RETURN();
! 2970: }
! 2971:
! 2972: void OPPROTO op_evfsnabs (void)
! 2973: {
! 2974: do_evfsnabs();
! 2975: RETURN();
! 2976: }
! 2977:
! 2978: void OPPROTO op_evfsabs (void)
! 2979: {
! 2980: do_evfsabs();
! 2981: RETURN();
! 2982: }
! 2983:
! 2984: void OPPROTO op_evfsneg (void)
! 2985: {
! 2986: do_evfsneg();
! 2987: RETURN();
! 2988: }
! 2989:
! 2990: void OPPROTO op_evfsdiv (void)
! 2991: {
! 2992: do_evfsdiv();
! 2993: RETURN();
! 2994: }
! 2995:
! 2996: void OPPROTO op_evfsmul (void)
! 2997: {
! 2998: do_evfsmul();
! 2999: RETURN();
! 3000: }
! 3001:
! 3002: void OPPROTO op_evfscmplt (void)
! 3003: {
! 3004: do_evfscmplt();
! 3005: RETURN();
! 3006: }
! 3007:
! 3008: void OPPROTO op_evfscmpgt (void)
! 3009: {
! 3010: do_evfscmpgt();
! 3011: RETURN();
! 3012: }
! 3013:
! 3014: void OPPROTO op_evfscmpeq (void)
! 3015: {
! 3016: do_evfscmpeq();
! 3017: RETURN();
! 3018: }
! 3019:
! 3020: void OPPROTO op_evfscfsi (void)
! 3021: {
! 3022: do_evfscfsi();
! 3023: RETURN();
! 3024: }
! 3025:
! 3026: void OPPROTO op_evfscfui (void)
! 3027: {
! 3028: do_evfscfui();
! 3029: RETURN();
! 3030: }
! 3031:
! 3032: void OPPROTO op_evfscfsf (void)
! 3033: {
! 3034: do_evfscfsf();
! 3035: RETURN();
! 3036: }
! 3037:
! 3038: void OPPROTO op_evfscfuf (void)
! 3039: {
! 3040: do_evfscfuf();
! 3041: RETURN();
! 3042: }
! 3043:
! 3044: void OPPROTO op_evfsctsi (void)
! 3045: {
! 3046: do_evfsctsi();
! 3047: RETURN();
! 3048: }
! 3049:
! 3050: void OPPROTO op_evfsctui (void)
! 3051: {
! 3052: do_evfsctui();
! 3053: RETURN();
! 3054: }
! 3055:
! 3056: void OPPROTO op_evfsctsf (void)
! 3057: {
! 3058: do_evfsctsf();
! 3059: RETURN();
! 3060: }
! 3061:
! 3062: void OPPROTO op_evfsctuf (void)
! 3063: {
! 3064: do_evfsctuf();
! 3065: RETURN();
! 3066: }
! 3067:
! 3068: void OPPROTO op_evfsctuiz (void)
! 3069: {
! 3070: do_evfsctuiz();
! 3071: RETURN();
! 3072: }
! 3073:
! 3074: void OPPROTO op_evfsctsiz (void)
! 3075: {
! 3076: do_evfsctsiz();
! 3077: RETURN();
! 3078: }
! 3079:
! 3080: void OPPROTO op_evfststlt (void)
! 3081: {
! 3082: do_evfststlt();
! 3083: RETURN();
! 3084: }
! 3085:
! 3086: void OPPROTO op_evfststgt (void)
! 3087: {
! 3088: do_evfststgt();
! 3089: RETURN();
! 3090: }
! 3091:
! 3092: void OPPROTO op_evfststeq (void)
! 3093: {
! 3094: do_evfststeq();
! 3095: RETURN();
! 3096: }
! 3097:
! 3098: void OPPROTO op_efssub (void)
! 3099: {
! 3100: T0_64 = _do_efssub(T0_64, T1_64);
! 3101: RETURN();
! 3102: }
! 3103:
! 3104: void OPPROTO op_efsadd (void)
! 3105: {
! 3106: T0_64 = _do_efsadd(T0_64, T1_64);
! 3107: RETURN();
! 3108: }
! 3109:
! 3110: void OPPROTO op_efsnabs (void)
! 3111: {
! 3112: T0_64 = _do_efsnabs(T0_64);
! 3113: RETURN();
! 3114: }
! 3115:
! 3116: void OPPROTO op_efsabs (void)
! 3117: {
! 3118: T0_64 = _do_efsabs(T0_64);
! 3119: RETURN();
! 3120: }
! 3121:
! 3122: void OPPROTO op_efsneg (void)
! 3123: {
! 3124: T0_64 = _do_efsneg(T0_64);
! 3125: RETURN();
! 3126: }
! 3127:
! 3128: void OPPROTO op_efsdiv (void)
! 3129: {
! 3130: T0_64 = _do_efsdiv(T0_64, T1_64);
! 3131: RETURN();
! 3132: }
! 3133:
! 3134: void OPPROTO op_efsmul (void)
! 3135: {
! 3136: T0_64 = _do_efsmul(T0_64, T1_64);
! 3137: RETURN();
! 3138: }
! 3139:
! 3140: void OPPROTO op_efscmplt (void)
! 3141: {
! 3142: do_efscmplt();
! 3143: RETURN();
! 3144: }
! 3145:
! 3146: void OPPROTO op_efscmpgt (void)
! 3147: {
! 3148: do_efscmpgt();
! 3149: RETURN();
! 3150: }
! 3151:
! 3152: void OPPROTO op_efscfd (void)
! 3153: {
! 3154: do_efscfd();
! 3155: RETURN();
! 3156: }
! 3157:
! 3158: void OPPROTO op_efscmpeq (void)
! 3159: {
! 3160: do_efscmpeq();
! 3161: RETURN();
! 3162: }
! 3163:
! 3164: void OPPROTO op_efscfsi (void)
! 3165: {
! 3166: do_efscfsi();
! 3167: RETURN();
! 3168: }
! 3169:
! 3170: void OPPROTO op_efscfui (void)
! 3171: {
! 3172: do_efscfui();
! 3173: RETURN();
! 3174: }
! 3175:
! 3176: void OPPROTO op_efscfsf (void)
! 3177: {
! 3178: do_efscfsf();
! 3179: RETURN();
! 3180: }
! 3181:
! 3182: void OPPROTO op_efscfuf (void)
! 3183: {
! 3184: do_efscfuf();
! 3185: RETURN();
! 3186: }
! 3187:
! 3188: void OPPROTO op_efsctsi (void)
! 3189: {
! 3190: do_efsctsi();
! 3191: RETURN();
! 3192: }
! 3193:
! 3194: void OPPROTO op_efsctui (void)
! 3195: {
! 3196: do_efsctui();
! 3197: RETURN();
! 3198: }
! 3199:
! 3200: void OPPROTO op_efsctsf (void)
! 3201: {
! 3202: do_efsctsf();
! 3203: RETURN();
! 3204: }
! 3205:
! 3206: void OPPROTO op_efsctuf (void)
! 3207: {
! 3208: do_efsctuf();
! 3209: RETURN();
! 3210: }
! 3211:
! 3212: void OPPROTO op_efsctsiz (void)
! 3213: {
! 3214: do_efsctsiz();
! 3215: RETURN();
! 3216: }
! 3217:
! 3218: void OPPROTO op_efsctuiz (void)
! 3219: {
! 3220: do_efsctuiz();
! 3221: RETURN();
! 3222: }
! 3223:
! 3224: void OPPROTO op_efststlt (void)
! 3225: {
! 3226: T0 = _do_efststlt(T0_64, T1_64);
! 3227: RETURN();
! 3228: }
! 3229:
! 3230: void OPPROTO op_efststgt (void)
! 3231: {
! 3232: T0 = _do_efststgt(T0_64, T1_64);
! 3233: RETURN();
! 3234: }
! 3235:
! 3236: void OPPROTO op_efststeq (void)
! 3237: {
! 3238: T0 = _do_efststeq(T0_64, T1_64);
! 3239: RETURN();
! 3240: }
! 3241:
! 3242: void OPPROTO op_efdsub (void)
! 3243: {
! 3244: union {
! 3245: uint64_t u;
! 3246: float64 f;
! 3247: } u1, u2;
! 3248: u1.u = T0_64;
! 3249: u2.u = T1_64;
! 3250: u1.f = float64_sub(u1.f, u2.f, &env->spe_status);
! 3251: T0_64 = u1.u;
! 3252: RETURN();
! 3253: }
! 3254:
! 3255: void OPPROTO op_efdadd (void)
! 3256: {
! 3257: union {
! 3258: uint64_t u;
! 3259: float64 f;
! 3260: } u1, u2;
! 3261: u1.u = T0_64;
! 3262: u2.u = T1_64;
! 3263: u1.f = float64_add(u1.f, u2.f, &env->spe_status);
! 3264: T0_64 = u1.u;
! 3265: RETURN();
! 3266: }
! 3267:
! 3268: void OPPROTO op_efdcfsid (void)
! 3269: {
! 3270: do_efdcfsi();
! 3271: RETURN();
! 3272: }
! 3273:
! 3274: void OPPROTO op_efdcfuid (void)
! 3275: {
! 3276: do_efdcfui();
! 3277: RETURN();
! 3278: }
! 3279:
! 3280: void OPPROTO op_efdnabs (void)
! 3281: {
! 3282: T0_64 |= 0x8000000000000000ULL;
! 3283: RETURN();
! 3284: }
! 3285:
! 3286: void OPPROTO op_efdabs (void)
! 3287: {
! 3288: T0_64 &= ~0x8000000000000000ULL;
! 3289: RETURN();
! 3290: }
! 3291:
! 3292: void OPPROTO op_efdneg (void)
! 3293: {
! 3294: T0_64 ^= 0x8000000000000000ULL;
! 3295: RETURN();
! 3296: }
! 3297:
! 3298: void OPPROTO op_efddiv (void)
! 3299: {
! 3300: union {
! 3301: uint64_t u;
! 3302: float64 f;
! 3303: } u1, u2;
! 3304: u1.u = T0_64;
! 3305: u2.u = T1_64;
! 3306: u1.f = float64_div(u1.f, u2.f, &env->spe_status);
! 3307: T0_64 = u1.u;
! 3308: RETURN();
! 3309: }
! 3310:
! 3311: void OPPROTO op_efdmul (void)
! 3312: {
! 3313: union {
! 3314: uint64_t u;
! 3315: float64 f;
! 3316: } u1, u2;
! 3317: u1.u = T0_64;
! 3318: u2.u = T1_64;
! 3319: u1.f = float64_mul(u1.f, u2.f, &env->spe_status);
! 3320: T0_64 = u1.u;
! 3321: RETURN();
! 3322: }
! 3323:
! 3324: void OPPROTO op_efdctsidz (void)
! 3325: {
! 3326: do_efdctsiz();
! 3327: RETURN();
! 3328: }
! 3329:
! 3330: void OPPROTO op_efdctuidz (void)
! 3331: {
! 3332: do_efdctuiz();
! 3333: RETURN();
! 3334: }
! 3335:
! 3336: void OPPROTO op_efdcmplt (void)
! 3337: {
! 3338: do_efdcmplt();
! 3339: RETURN();
! 3340: }
! 3341:
! 3342: void OPPROTO op_efdcmpgt (void)
! 3343: {
! 3344: do_efdcmpgt();
! 3345: RETURN();
! 3346: }
! 3347:
! 3348: void OPPROTO op_efdcfs (void)
! 3349: {
! 3350: do_efdcfs();
! 3351: RETURN();
! 3352: }
! 3353:
! 3354: void OPPROTO op_efdcmpeq (void)
! 3355: {
! 3356: do_efdcmpeq();
! 3357: RETURN();
! 3358: }
! 3359:
! 3360: void OPPROTO op_efdcfsi (void)
! 3361: {
! 3362: do_efdcfsi();
! 3363: RETURN();
! 3364: }
! 3365:
! 3366: void OPPROTO op_efdcfui (void)
! 3367: {
! 3368: do_efdcfui();
! 3369: RETURN();
! 3370: }
! 3371:
! 3372: void OPPROTO op_efdcfsf (void)
! 3373: {
! 3374: do_efdcfsf();
! 3375: RETURN();
! 3376: }
! 3377:
! 3378: void OPPROTO op_efdcfuf (void)
! 3379: {
! 3380: do_efdcfuf();
! 3381: RETURN();
! 3382: }
! 3383:
! 3384: void OPPROTO op_efdctsi (void)
! 3385: {
! 3386: do_efdctsi();
! 3387: RETURN();
! 3388: }
! 3389:
! 3390: void OPPROTO op_efdctui (void)
! 3391: {
! 3392: do_efdctui();
! 3393: RETURN();
! 3394: }
! 3395:
! 3396: void OPPROTO op_efdctsf (void)
! 3397: {
! 3398: do_efdctsf();
! 3399: RETURN();
! 3400: }
! 3401:
! 3402: void OPPROTO op_efdctuf (void)
! 3403: {
! 3404: do_efdctuf();
! 3405: RETURN();
! 3406: }
! 3407:
! 3408: void OPPROTO op_efdctuiz (void)
! 3409: {
! 3410: do_efdctuiz();
! 3411: RETURN();
! 3412: }
! 3413:
! 3414: void OPPROTO op_efdctsiz (void)
! 3415: {
! 3416: do_efdctsiz();
! 3417: RETURN();
! 3418: }
! 3419:
! 3420: void OPPROTO op_efdtstlt (void)
! 3421: {
! 3422: T0 = _do_efdtstlt(T0_64, T1_64);
! 3423: RETURN();
! 3424: }
! 3425:
! 3426: void OPPROTO op_efdtstgt (void)
! 3427: {
! 3428: T0 = _do_efdtstgt(T0_64, T1_64);
! 3429: RETURN();
! 3430: }
! 3431:
! 3432: void OPPROTO op_efdtsteq (void)
! 3433: {
! 3434: T0 = _do_efdtsteq(T0_64, T1_64);
1.1 root 3435: RETURN();
3436: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.