← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to target-ppc/op.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-07 06:20:34 UTC
  • mfrom: (1.1.9 upstream)
  • mto: This revision was merged to the branch mainline in revision 7.
  • Revision ID: james.westby@ubuntu.com-20090307062034-i3pead4mw653v2el
Tags: 0.10.0-1
http://bugs.debian.org/514462
http://bugs.debian.org/470231
http://bugs.debian.org/415996
http://bugs.debian.org/513210
http://bugs.debian.org/297572
[ Aurelien Jarno ]
* New upstream release:
  - Fix fr-be keyboard mapping (closes: bug#514462).
  - Fix stat64 structure on ppc-linux-user (closes: bug#470231).
  - Add a chroot option (closes: bug#415996).
  - Add evdev support (closes: bug#513210).
  - Fix loop on symlinks in user mode (closes: bug#297572).
  - Bump depends on openbios-sparc.
  - Depends on openbios-ppc.
  - Update 12_signal_powerpc_support.patch.
  - Update 21_net_soopts.patch.
  - Drop 44_socklen_t_check.patch (merged upstream).
  - Drop 49_null_check.patch (merged upstream).
  - Update 64_ppc_asm_constraints.patch.
  - Drop security/CVE-2008-0928-fedora.patch (merged upstream).
  - Drop security/CVE-2007-5730.patch (merged upstream).
* patches/80_stable-branch.patch: add patches from stable branch:
  - Fix race condition between signal handler/execution loop (closes:
    bug#474386, bug#501731).
* debian/copyright: update.
* Compile and install .dtb files:
  - debian/control: build-depends on device-tree-compiler.
  - debian/patches/81_compile_dtb.patch: new patch from upstream.
  - debian/rules: compile and install bamboo.dtb and mpc8544.dtb.

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-ppc/op.c
1
 
/*
2
 
 *  PowerPC emulation micro-operations for qemu.
3
 
 *
4
 
 *  Copyright (c) 2003-2007 Jocelyn Mayer
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"
25
 
#include "host-utils.h"
26
 
#include "helper_regs.h"
27
 
#include "op_helper.h"
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
 
 
125
 
void OPPROTO op_print_mem_EA (void)
126
 
{
127
 
    do_print_mem_EA(T0);
128
 
    RETURN();
129
 
}
130
 
 
131
 
/* PowerPC state maintenance operations */
132
 
/* set_Rc0 */
133
 
void OPPROTO op_set_Rc0 (void)
134
 
{
135
 
    env->crf[0] = T0 | xer_so;
136
 
    RETURN();
137
 
}
138
 
 
139
 
/* Constants load */
140
 
void OPPROTO op_reset_T0 (void)
141
 
{
142
 
    T0 = 0;
143
 
    RETURN();
144
 
}
145
 
 
146
 
void OPPROTO op_set_T0 (void)
147
 
{
148
 
    T0 = (uint32_t)PARAM1;
149
 
    RETURN();
150
 
}
151
 
 
152
 
#if defined(TARGET_PPC64)
153
 
void OPPROTO op_set_T0_64 (void)
154
 
{
155
 
    T0 = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
156
 
    RETURN();
157
 
}
158
 
#endif
159
 
 
160
 
void OPPROTO op_set_T1 (void)
161
 
{
162
 
    T1 = (uint32_t)PARAM1;
163
 
    RETURN();
164
 
}
165
 
 
166
 
#if defined(TARGET_PPC64)
167
 
void OPPROTO op_set_T1_64 (void)
168
 
{
169
 
    T1 = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
170
 
    RETURN();
171
 
}
172
 
#endif
173
 
 
174
 
#if 0 // unused
175
 
void OPPROTO op_set_T2 (void)
176
 
{
177
 
    T2 = (uint32_t)PARAM1;
178
 
    RETURN();
179
 
}
180
 
#endif
181
 
 
182
 
void OPPROTO op_move_T1_T0 (void)
183
 
{
184
 
    T1 = T0;
185
 
    RETURN();
186
 
}
187
 
 
188
 
void OPPROTO op_move_T2_T0 (void)
189
 
{
190
 
    T2 = T0;
191
 
    RETURN();
192
 
}
193
 
 
194
 
void OPPROTO op_moven_T2_T0 (void)
195
 
{
196
 
    T2 = ~T0;
197
 
    RETURN();
198
 
}
199
 
 
200
 
/* Generate exceptions */
201
 
void OPPROTO op_raise_exception_err (void)
202
 
{
203
 
    do_raise_exception_err(PARAM1, PARAM2);
204
 
}
205
 
 
206
 
void OPPROTO op_update_nip (void)
207
 
{
208
 
    env->nip = (uint32_t)PARAM1;
209
 
    RETURN();
210
 
}
211
 
 
212
 
#if defined(TARGET_PPC64)
213
 
void OPPROTO op_update_nip_64 (void)
214
 
{
215
 
    env->nip = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
216
 
    RETURN();
217
 
}
218
 
#endif
219
 
 
220
 
void OPPROTO op_debug (void)
221
 
{
222
 
    do_raise_exception(EXCP_DEBUG);
223
 
}
224
 
 
225
 
void OPPROTO op_exit_tb (void)
226
 
{
227
 
    EXIT_TB();
228
 
}
229
 
 
230
 
/* Load/store special registers */
231
 
void OPPROTO op_load_cr (void)
232
 
{
233
 
    do_load_cr();
234
 
    RETURN();
235
 
}
236
 
 
237
 
void OPPROTO op_store_cr (void)
238
 
{
239
 
    do_store_cr(PARAM1);
240
 
    RETURN();
241
 
}
242
 
 
243
 
void OPPROTO op_load_cro (void)
244
 
{
245
 
    T0 = env->crf[PARAM1];
246
 
    RETURN();
247
 
}
248
 
 
249
 
void OPPROTO op_store_cro (void)
250
 
{
251
 
    env->crf[PARAM1] = T0;
252
 
    RETURN();
253
 
}
254
 
 
255
 
void OPPROTO op_load_xer_cr (void)
256
 
{
257
 
    T0 = (xer_so << 3) | (xer_ov << 2) | (xer_ca << 1);
258
 
    RETURN();
259
 
}
260
 
 
261
 
void OPPROTO op_clear_xer_ov (void)
262
 
{
263
 
    xer_so = 0;
264
 
    xer_ov = 0;
265
 
    RETURN();
266
 
}
267
 
 
268
 
void OPPROTO op_clear_xer_ca (void)
269
 
{
270
 
    xer_ca = 0;
271
 
    RETURN();
272
 
}
273
 
 
274
 
void OPPROTO op_load_xer_bc (void)
275
 
{
276
 
    T1 = xer_bc;
277
 
    RETURN();
278
 
}
279
 
 
280
 
void OPPROTO op_store_xer_bc (void)
281
 
{
282
 
    xer_bc = T0;
283
 
    RETURN();
284
 
}
285
 
 
286
 
void OPPROTO op_load_xer (void)
287
 
{
288
 
    T0 = hreg_load_xer(env);
289
 
    RETURN();
290
 
}
291
 
 
292
 
void OPPROTO op_store_xer (void)
293
 
{
294
 
    hreg_store_xer(env, T0);
295
 
    RETURN();
296
 
}
297
 
 
298
 
#if defined(TARGET_PPC64)
299
 
void OPPROTO op_store_pri (void)
300
 
{
301
 
    do_store_pri(PARAM1);
302
 
    RETURN();
303
 
}
304
 
#endif
305
 
 
306
 
#if !defined(CONFIG_USER_ONLY)
307
 
/* Segment registers load and store */
308
 
void OPPROTO op_load_sr (void)
309
 
{
310
 
    T0 = env->sr[T1];
311
 
    RETURN();
312
 
}
313
 
 
314
 
void OPPROTO op_store_sr (void)
315
 
{
316
 
    do_store_sr(env, T1, T0);
317
 
    RETURN();
318
 
}
319
 
 
320
 
#if defined(TARGET_PPC64)
321
 
void OPPROTO op_load_slb (void)
322
 
{
323
 
    T0 = ppc_load_slb(env, T1);
324
 
    RETURN();
325
 
}
326
 
 
327
 
void OPPROTO op_store_slb (void)
328
 
{
329
 
    ppc_store_slb(env, T1, T0);
330
 
    RETURN();
331
 
}
332
 
#endif /* defined(TARGET_PPC64) */
333
 
 
334
 
void OPPROTO op_load_sdr1 (void)
335
 
{
336
 
    T0 = env->sdr1;
337
 
    RETURN();
338
 
}
339
 
 
340
 
void OPPROTO op_store_sdr1 (void)
341
 
{
342
 
    do_store_sdr1(env, T0);
343
 
    RETURN();
344
 
}
345
 
 
346
 
#if defined (TARGET_PPC64)
347
 
void OPPROTO op_load_asr (void)
348
 
{
349
 
    T0 = env->asr;
350
 
    RETURN();
351
 
}
352
 
 
353
 
void OPPROTO op_store_asr (void)
354
 
{
355
 
    ppc_store_asr(env, T0);
356
 
    RETURN();
357
 
}
358
 
#endif
359
 
 
360
 
void OPPROTO op_load_msr (void)
361
 
{
362
 
    T0 = env->msr;
363
 
    RETURN();
364
 
}
365
 
 
366
 
void OPPROTO op_store_msr (void)
367
 
{
368
 
    do_store_msr();
369
 
    RETURN();
370
 
}
371
 
 
372
 
#if defined (TARGET_PPC64)
373
 
void OPPROTO op_store_msr_32 (void)
374
 
{
375
 
    T0 = (env->msr & ~0xFFFFFFFFULL) | (T0 & 0xFFFFFFFF);
376
 
    do_store_msr();
377
 
    RETURN();
378
 
}
379
 
#endif
380
 
 
381
 
void OPPROTO op_update_riee (void)
382
 
{
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;
389
 
    RETURN();
390
 
}
391
 
#endif
392
 
 
393
 
/* SPR */
394
 
void OPPROTO op_load_spr (void)
395
 
{
396
 
    T0 = env->spr[PARAM1];
397
 
    RETURN();
398
 
}
399
 
 
400
 
void OPPROTO op_store_spr (void)
401
 
{
402
 
    env->spr[PARAM1] = T0;
403
 
    RETURN();
404
 
}
405
 
 
406
 
void OPPROTO op_load_dump_spr (void)
407
 
{
408
 
    T0 = ppc_load_dump_spr(PARAM1);
409
 
    RETURN();
410
 
}
411
 
 
412
 
void OPPROTO op_store_dump_spr (void)
413
 
{
414
 
    ppc_store_dump_spr(PARAM1, T0);
415
 
    RETURN();
416
 
}
417
 
 
418
 
void OPPROTO op_mask_spr (void)
419
 
{
420
 
    env->spr[PARAM1] &= ~T0;
421
 
    RETURN();
422
 
}
423
 
 
424
 
void OPPROTO op_load_lr (void)
425
 
{
426
 
    T0 = env->lr;
427
 
    RETURN();
428
 
}
429
 
 
430
 
void OPPROTO op_store_lr (void)
431
 
{
432
 
    env->lr = T0;
433
 
    RETURN();
434
 
}
435
 
 
436
 
void OPPROTO op_load_ctr (void)
437
 
{
438
 
    T0 = env->ctr;
439
 
    RETURN();
440
 
}
441
 
 
442
 
void OPPROTO op_store_ctr (void)
443
 
{
444
 
    env->ctr = T0;
445
 
    RETURN();
446
 
}
447
 
 
448
 
void OPPROTO op_load_tbl (void)
449
 
{
450
 
    T0 = cpu_ppc_load_tbl(env);
451
 
    RETURN();
452
 
}
453
 
 
454
 
void OPPROTO op_load_tbu (void)
455
 
{
456
 
    T0 = cpu_ppc_load_tbu(env);
457
 
    RETURN();
458
 
}
459
 
 
460
 
void OPPROTO op_load_atbl (void)
461
 
{
462
 
    T0 = cpu_ppc_load_atbl(env);
463
 
    RETURN();
464
 
}
465
 
 
466
 
void OPPROTO op_load_atbu (void)
467
 
{
468
 
    T0 = cpu_ppc_load_atbu(env);
469
 
    RETURN();
470
 
}
471
 
 
472
 
#if !defined(CONFIG_USER_ONLY)
473
 
void OPPROTO op_store_tbl (void)
474
 
{
475
 
    cpu_ppc_store_tbl(env, T0);
476
 
    RETURN();
477
 
}
478
 
 
479
 
void OPPROTO op_store_tbu (void)
480
 
{
481
 
    cpu_ppc_store_tbu(env, T0);
482
 
    RETURN();
483
 
}
484
 
 
485
 
void OPPROTO op_store_atbl (void)
486
 
{
487
 
    cpu_ppc_store_atbl(env, T0);
488
 
    RETURN();
489
 
}
490
 
 
491
 
void OPPROTO op_store_atbu (void)
492
 
{
493
 
    cpu_ppc_store_atbu(env, T0);
494
 
    RETURN();
495
 
}
496
 
 
497
 
void OPPROTO op_load_decr (void)
498
 
{
499
 
    T0 = cpu_ppc_load_decr(env);
500
 
    RETURN();
501
 
}
502
 
 
503
 
void OPPROTO op_store_decr (void)
504
 
{
505
 
    cpu_ppc_store_decr(env, T0);
506
 
    RETURN();
507
 
}
508
 
 
509
 
void OPPROTO op_load_ibat (void)
510
 
{
511
 
    T0 = env->IBAT[PARAM1][PARAM2];
512
 
    RETURN();
513
 
}
514
 
 
515
 
void OPPROTO op_store_ibatu (void)
516
 
{
517
 
    do_store_ibatu(env, PARAM1, T0);
518
 
    RETURN();
519
 
}
520
 
 
521
 
void OPPROTO op_store_ibatl (void)
522
 
{
523
 
#if 1
524
 
    env->IBAT[1][PARAM1] = T0;
525
 
#else
526
 
    do_store_ibatl(env, PARAM1, T0);
527
 
#endif
528
 
    RETURN();
529
 
}
530
 
 
531
 
void OPPROTO op_load_dbat (void)
532
 
{
533
 
    T0 = env->DBAT[PARAM1][PARAM2];
534
 
    RETURN();
535
 
}
536
 
 
537
 
void OPPROTO op_store_dbatu (void)
538
 
{
539
 
    do_store_dbatu(env, PARAM1, T0);
540
 
    RETURN();
541
 
}
542
 
 
543
 
void OPPROTO op_store_dbatl (void)
544
 
{
545
 
#if 1
546
 
    env->DBAT[1][PARAM1] = T0;
547
 
#else
548
 
    do_store_dbatl(env, PARAM1, T0);
549
 
#endif
550
 
    RETURN();
551
 
}
552
 
#endif /* !defined(CONFIG_USER_ONLY) */
553
 
 
554
 
/* FPSCR */
555
 
#ifdef CONFIG_SOFTFLOAT
556
 
void OPPROTO op_reset_fpstatus (void)
557
 
{
558
 
    env->fp_status.float_exception_flags = 0;
559
 
    RETURN();
560
 
}
561
 
#endif
562
 
 
563
 
void OPPROTO op_compute_fprf (void)
564
 
{
565
 
    do_compute_fprf(PARAM1);
566
 
    RETURN();
567
 
}
568
 
 
569
 
#ifdef CONFIG_SOFTFLOAT
570
 
void OPPROTO op_float_check_status (void)
571
 
{
572
 
    do_float_check_status();
573
 
    RETURN();
574
 
}
575
 
#else
576
 
void OPPROTO op_float_check_status (void)
577
 
{
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
 
    }
584
 
    RETURN();
585
 
}
586
 
#endif
587
 
 
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)
596
 
{
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;
610
 
    RETURN();
611
 
}
612
 
 
613
 
void OPPROTO op_set_FT0 (void)
614
 
{
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;
625
 
    RETURN();
626
 
}
627
 
#undef WORD0
628
 
#undef WORD1
629
 
 
630
 
void OPPROTO op_load_fpscr_T0 (void)
631
 
{
632
 
    T0 = (env->fpscr >> PARAM1) & 0xF;
633
 
    RETURN();
634
 
}
635
 
 
636
 
void OPPROTO op_load_fpcc (void)
637
 
{
638
 
    T0 = fpscr_fpcc;
639
 
    RETURN();
640
 
}
641
 
 
642
 
void OPPROTO op_fpscr_resetbit (void)
643
 
{
644
 
    env->fpscr &= PARAM1;
645
 
    RETURN();
646
 
}
647
 
 
648
 
void OPPROTO op_fpscr_setbit (void)
649
 
{
650
 
    do_fpscr_setbit(PARAM1);
651
 
    RETURN();
652
 
}
653
 
 
654
 
void OPPROTO op_store_fpscr (void)
655
 
{
656
 
    do_store_fpscr(PARAM1);
657
 
    RETURN();
658
 
}
659
 
 
660
 
/* Branch */
661
 
#define EIP env->nip
662
 
 
663
 
void OPPROTO op_setlr (void)
664
 
{
665
 
    env->lr = (uint32_t)PARAM1;
666
 
    RETURN();
667
 
}
668
 
 
669
 
#if defined (TARGET_PPC64)
670
 
void OPPROTO op_setlr_64 (void)
671
 
{
672
 
    env->lr = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
673
 
    RETURN();
674
 
}
675
 
#endif
676
 
 
677
 
void OPPROTO op_goto_tb0 (void)
678
 
{
679
 
    GOTO_TB(op_goto_tb0, PARAM1, 0);
680
 
}
681
 
 
682
 
void OPPROTO op_goto_tb1 (void)
683
 
{
684
 
    GOTO_TB(op_goto_tb1, PARAM1, 1);
685
 
}
686
 
 
687
 
void OPPROTO op_b_T1 (void)
688
 
{
689
 
    env->nip = (uint32_t)(T1 & ~3);
690
 
    RETURN();
691
 
}
692
 
 
693
 
#if defined (TARGET_PPC64)
694
 
void OPPROTO op_b_T1_64 (void)
695
 
{
696
 
    env->nip = (uint64_t)(T1 & ~3);
697
 
    RETURN();
698
 
}
699
 
#endif
700
 
 
701
 
void OPPROTO op_jz_T0 (void)
702
 
{
703
 
    if (!T0)
704
 
        GOTO_LABEL_PARAM(1);
705
 
    RETURN();
706
 
}
707
 
 
708
 
void OPPROTO op_btest_T1 (void)
709
 
{
710
 
    if (T0) {
711
 
        env->nip = (uint32_t)(T1 & ~3);
712
 
    } else {
713
 
        env->nip = (uint32_t)PARAM1;
714
 
    }
715
 
    RETURN();
716
 
}
717
 
 
718
 
#if defined (TARGET_PPC64)
719
 
void OPPROTO op_btest_T1_64 (void)
720
 
{
721
 
    if (T0) {
722
 
        env->nip = (uint64_t)(T1 & ~3);
723
 
    } else {
724
 
        env->nip = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
725
 
    }
726
 
    RETURN();
727
 
}
728
 
#endif
729
 
 
730
 
void OPPROTO op_movl_T1_ctr (void)
731
 
{
732
 
    T1 = env->ctr;
733
 
    RETURN();
734
 
}
735
 
 
736
 
void OPPROTO op_movl_T1_lr (void)
737
 
{
738
 
    T1 = env->lr;
739
 
    RETURN();
740
 
}
741
 
 
742
 
/* tests with result in T0 */
743
 
void OPPROTO op_test_ctr (void)
744
 
{
745
 
    T0 = (uint32_t)env->ctr;
746
 
    RETURN();
747
 
}
748
 
 
749
 
#if defined(TARGET_PPC64)
750
 
void OPPROTO op_test_ctr_64 (void)
751
 
{
752
 
    T0 = (uint64_t)env->ctr;
753
 
    RETURN();
754
 
}
755
 
#endif
756
 
 
757
 
void OPPROTO op_test_ctr_true (void)
758
 
{
759
 
    T0 = ((uint32_t)env->ctr != 0 && (T0 & PARAM1) != 0);
760
 
    RETURN();
761
 
}
762
 
 
763
 
#if defined(TARGET_PPC64)
764
 
void OPPROTO op_test_ctr_true_64 (void)
765
 
{
766
 
    T0 = ((uint64_t)env->ctr != 0 && (T0 & PARAM1) != 0);
767
 
    RETURN();
768
 
}
769
 
#endif
770
 
 
771
 
void OPPROTO op_test_ctr_false (void)
772
 
{
773
 
    T0 = ((uint32_t)env->ctr != 0 && (T0 & PARAM1) == 0);
774
 
    RETURN();
775
 
}
776
 
 
777
 
#if defined(TARGET_PPC64)
778
 
void OPPROTO op_test_ctr_false_64 (void)
779
 
{
780
 
    T0 = ((uint64_t)env->ctr != 0 && (T0 & PARAM1) == 0);
781
 
    RETURN();
782
 
}
783
 
#endif
784
 
 
785
 
void OPPROTO op_test_ctrz (void)
786
 
{
787
 
    T0 = ((uint32_t)env->ctr == 0);
788
 
    RETURN();
789
 
}
790
 
 
791
 
#if defined(TARGET_PPC64)
792
 
void OPPROTO op_test_ctrz_64 (void)
793
 
{
794
 
    T0 = ((uint64_t)env->ctr == 0);
795
 
    RETURN();
796
 
}
797
 
#endif
798
 
 
799
 
void OPPROTO op_test_ctrz_true (void)
800
 
{
801
 
    T0 = ((uint32_t)env->ctr == 0 && (T0 & PARAM1) != 0);
802
 
    RETURN();
803
 
}
804
 
 
805
 
#if defined(TARGET_PPC64)
806
 
void OPPROTO op_test_ctrz_true_64 (void)
807
 
{
808
 
    T0 = ((uint64_t)env->ctr == 0 && (T0 & PARAM1) != 0);
809
 
    RETURN();
810
 
}
811
 
#endif
812
 
 
813
 
void OPPROTO op_test_ctrz_false (void)
814
 
{
815
 
    T0 = ((uint32_t)env->ctr == 0 && (T0 & PARAM1) == 0);
816
 
    RETURN();
817
 
}
818
 
 
819
 
#if defined(TARGET_PPC64)
820
 
void OPPROTO op_test_ctrz_false_64 (void)
821
 
{
822
 
    T0 = ((uint64_t)env->ctr == 0 && (T0 & PARAM1) == 0);
823
 
    RETURN();
824
 
}
825
 
#endif
826
 
 
827
 
void OPPROTO op_test_true (void)
828
 
{
829
 
    T0 = (T0 & PARAM1);
830
 
    RETURN();
831
 
}
832
 
 
833
 
void OPPROTO op_test_false (void)
834
 
{
835
 
    T0 = ((T0 & PARAM1) == 0);
836
 
    RETURN();
837
 
}
838
 
 
839
 
/* CTR maintenance */
840
 
void OPPROTO op_dec_ctr (void)
841
 
{
842
 
    env->ctr--;
843
 
    RETURN();
844
 
}
845
 
 
846
 
/***                           Integer arithmetic                          ***/
847
 
/* add */
848
 
void OPPROTO op_add (void)
849
 
{
850
 
    T0 += T1;
851
 
    RETURN();
852
 
}
853
 
 
854
 
void OPPROTO op_check_addo (void)
855
 
{
856
 
    xer_ov = (((uint32_t)T2 ^ (uint32_t)T1 ^ UINT32_MAX) &
857
 
              ((uint32_t)T2 ^ (uint32_t)T0)) >> 31;
858
 
    xer_so |= xer_ov;
859
 
    RETURN();
860
 
}
861
 
 
862
 
#if defined(TARGET_PPC64)
863
 
void OPPROTO op_check_addo_64 (void)
864
 
{
865
 
    xer_ov = (((uint64_t)T2 ^ (uint64_t)T1 ^ UINT64_MAX) &
866
 
              ((uint64_t)T2 ^ (uint64_t)T0)) >> 63;
867
 
    xer_so |= xer_ov;
868
 
    RETURN();
869
 
}
870
 
#endif
871
 
 
872
 
/* add carrying */
873
 
void OPPROTO op_check_addc (void)
874
 
{
875
 
    if (likely((uint32_t)T0 >= (uint32_t)T2)) {
876
 
        xer_ca = 0;
877
 
    } else {
878
 
        xer_ca = 1;
879
 
    }
880
 
    RETURN();
881
 
}
882
 
 
883
 
#if defined(TARGET_PPC64)
884
 
void OPPROTO op_check_addc_64 (void)
885
 
{
886
 
    if (likely((uint64_t)T0 >= (uint64_t)T2)) {
887
 
        xer_ca = 0;
888
 
    } else {
889
 
        xer_ca = 1;
890
 
    }
891
 
    RETURN();
892
 
}
893
 
#endif
894
 
 
895
 
/* add extended */
896
 
void OPPROTO op_adde (void)
897
 
{
898
 
    do_adde();
899
 
    RETURN();
900
 
}
901
 
 
902
 
#if defined(TARGET_PPC64)
903
 
void OPPROTO op_adde_64 (void)
904
 
{
905
 
    do_adde_64();
906
 
    RETURN();
907
 
}
908
 
#endif
909
 
 
910
 
/* add immediate */
911
 
void OPPROTO op_addi (void)
912
 
{
913
 
    T0 += (int32_t)PARAM1;
914
 
    RETURN();
915
 
}
916
 
 
917
 
/* add to minus one extended */
918
 
void OPPROTO op_add_me (void)
919
 
{
920
 
    T0 += xer_ca + (-1);
921
 
    if (likely((uint32_t)T1 != 0))
922
 
        xer_ca = 1;
923
 
    else
924
 
        xer_ca = 0;
925
 
    RETURN();
926
 
}
927
 
 
928
 
#if defined(TARGET_PPC64)
929
 
void OPPROTO op_add_me_64 (void)
930
 
{
931
 
    T0 += xer_ca + (-1);
932
 
    if (likely((uint64_t)T1 != 0))
933
 
        xer_ca = 1;
934
 
    else
935
 
        xer_ca = 0;
936
 
    RETURN();
937
 
}
938
 
#endif
939
 
 
940
 
void OPPROTO op_addmeo (void)
941
 
{
942
 
    do_addmeo();
943
 
    RETURN();
944
 
}
945
 
 
946
 
void OPPROTO op_addmeo_64 (void)
947
 
{
948
 
    do_addmeo();
949
 
    RETURN();
950
 
}
951
 
 
952
 
/* add to zero extended */
953
 
void OPPROTO op_add_ze (void)
954
 
{
955
 
    T0 += xer_ca;
956
 
    RETURN();
957
 
}
958
 
 
959
 
/* divide word */
960
 
void OPPROTO op_divw (void)
961
 
{
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
 
    }
968
 
    RETURN();
969
 
}
970
 
 
971
 
#if defined(TARGET_PPC64)
972
 
void OPPROTO op_divd (void)
973
 
{
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
 
    }
980
 
    RETURN();
981
 
}
982
 
#endif
983
 
 
984
 
void OPPROTO op_divwo (void)
985
 
{
986
 
    do_divwo();
987
 
    RETURN();
988
 
}
989
 
 
990
 
#if defined(TARGET_PPC64)
991
 
void OPPROTO op_divdo (void)
992
 
{
993
 
    do_divdo();
994
 
    RETURN();
995
 
}
996
 
#endif
997
 
 
998
 
/* divide word unsigned */
999
 
void OPPROTO op_divwu (void)
1000
 
{
1001
 
    if (unlikely(T1 == 0)) {
1002
 
        T0 = 0;
1003
 
    } else {
1004
 
        T0 = (uint32_t)T0 / (uint32_t)T1;
1005
 
    }
1006
 
    RETURN();
1007
 
}
1008
 
 
1009
 
#if defined(TARGET_PPC64)
1010
 
void OPPROTO op_divdu (void)
1011
 
{
1012
 
    if (unlikely(T1 == 0)) {
1013
 
        T0 = 0;
1014
 
    } else {
1015
 
        T0 /= T1;
1016
 
    }
1017
 
    RETURN();
1018
 
}
1019
 
#endif
1020
 
 
1021
 
void OPPROTO op_divwuo (void)
1022
 
{
1023
 
    do_divwuo();
1024
 
    RETURN();
1025
 
}
1026
 
 
1027
 
#if defined(TARGET_PPC64)
1028
 
void OPPROTO op_divduo (void)
1029
 
{
1030
 
    do_divduo();
1031
 
    RETURN();
1032
 
}
1033
 
#endif
1034
 
 
1035
 
/* multiply high word */
1036
 
void OPPROTO op_mulhw (void)
1037
 
{
1038
 
    T0 = ((int64_t)((int32_t)T0) * (int64_t)((int32_t)T1)) >> 32;
1039
 
    RETURN();
1040
 
}
1041
 
 
1042
 
#if defined(TARGET_PPC64)
1043
 
void OPPROTO op_mulhd (void)
1044
 
{
1045
 
    uint64_t tl, th;
1046
 
 
1047
 
    muls64(&tl, &th, T0, T1);
1048
 
    T0 = th;
1049
 
    RETURN();
1050
 
}
1051
 
#endif
1052
 
 
1053
 
/* multiply high word unsigned */
1054
 
void OPPROTO op_mulhwu (void)
1055
 
{
1056
 
    T0 = ((uint64_t)(uint32_t)T0 * (uint64_t)(uint32_t)T1) >> 32;
1057
 
    RETURN();
1058
 
}
1059
 
 
1060
 
#if defined(TARGET_PPC64)
1061
 
void OPPROTO op_mulhdu (void)
1062
 
{
1063
 
    uint64_t tl, th;
1064
 
 
1065
 
    mulu64(&tl, &th, T0, T1);
1066
 
    T0 = th;
1067
 
    RETURN();
1068
 
}
1069
 
#endif
1070
 
 
1071
 
/* multiply low immediate */
1072
 
void OPPROTO op_mulli (void)
1073
 
{
1074
 
    T0 = ((int32_t)T0 * (int32_t)PARAM1);
1075
 
    RETURN();
1076
 
}
1077
 
 
1078
 
/* multiply low word */
1079
 
void OPPROTO op_mullw (void)
1080
 
{
1081
 
    T0 = (int32_t)(T0 * T1);
1082
 
    RETURN();
1083
 
}
1084
 
 
1085
 
#if defined(TARGET_PPC64)
1086
 
void OPPROTO op_mulld (void)
1087
 
{
1088
 
    T0 *= T1;
1089
 
    RETURN();
1090
 
}
1091
 
#endif
1092
 
 
1093
 
void OPPROTO op_mullwo (void)
1094
 
{
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;
1112
 
    }
1113
 
    RETURN();
1114
 
}
1115
 
 
1116
 
#if defined(TARGET_PPC64)
1117
 
void OPPROTO op_neg_64 (void)
1118
 
{
1119
 
    if (likely(T0 != INT64_MIN)) {
1120
 
        T0 = -(int64_t)T0;
1121
 
    }
1122
 
    RETURN();
1123
 
}
1124
 
#endif
1125
 
 
1126
 
void OPPROTO op_nego (void)
1127
 
{
1128
 
    do_nego();
1129
 
    RETURN();
1130
 
}
1131
 
 
1132
 
#if defined(TARGET_PPC64)
1133
 
void OPPROTO op_nego_64 (void)
1134
 
{
1135
 
    do_nego_64();
1136
 
    RETURN();
1137
 
}
1138
 
#endif
1139
 
 
1140
 
/* subtract from */
1141
 
void OPPROTO op_subf (void)
1142
 
{
1143
 
    T0 = T1 - T0;
1144
 
    RETURN();
1145
 
}
1146
 
 
1147
 
/* subtract from carrying */
1148
 
void OPPROTO op_check_subfc (void)
1149
 
{
1150
 
    if (likely((uint32_t)T0 > (uint32_t)T1)) {
1151
 
        xer_ca = 0;
1152
 
    } else {
1153
 
        xer_ca = 1;
1154
 
    }
1155
 
    RETURN();
1156
 
}
1157
 
 
1158
 
#if defined(TARGET_PPC64)
1159
 
void OPPROTO op_check_subfc_64 (void)
1160
 
{
1161
 
    if (likely((uint64_t)T0 > (uint64_t)T1)) {
1162
 
        xer_ca = 0;
1163
 
    } else {
1164
 
        xer_ca = 1;
1165
 
    }
1166
 
    RETURN();
1167
 
}
1168
 
#endif
1169
 
 
1170
 
/* subtract from extended */
1171
 
void OPPROTO op_subfe (void)
1172
 
{
1173
 
    do_subfe();
1174
 
    RETURN();
1175
 
}
1176
 
 
1177
 
#if defined(TARGET_PPC64)
1178
 
void OPPROTO op_subfe_64 (void)
1179
 
{
1180
 
    do_subfe_64();
1181
 
    RETURN();
1182
 
}
1183
 
#endif
1184
 
 
1185
 
/* subtract from immediate carrying */
1186
 
void OPPROTO op_subfic (void)
1187
 
{
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
 
    }
1194
 
    RETURN();
1195
 
}
1196
 
 
1197
 
#if defined(TARGET_PPC64)
1198
 
void OPPROTO op_subfic_64 (void)
1199
 
{
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
 
    }
1206
 
    RETURN();
1207
 
}
1208
 
#endif
1209
 
 
1210
 
/* subtract from minus one extended */
1211
 
void OPPROTO op_subfme (void)
1212
 
{
1213
 
    T0 = ~T0 + xer_ca - 1;
1214
 
    if (likely((uint32_t)T0 != UINT32_MAX))
1215
 
        xer_ca = 1;
1216
 
    else
1217
 
        xer_ca = 0;
1218
 
    RETURN();
1219
 
}
1220
 
 
1221
 
#if defined(TARGET_PPC64)
1222
 
void OPPROTO op_subfme_64 (void)
1223
 
{
1224
 
    T0 = ~T0 + xer_ca - 1;
1225
 
    if (likely((uint64_t)T0 != UINT64_MAX))
1226
 
        xer_ca = 1;
1227
 
    else
1228
 
        xer_ca = 0;
1229
 
    RETURN();
1230
 
}
1231
 
#endif
1232
 
 
1233
 
void OPPROTO op_subfmeo (void)
1234
 
{
1235
 
    do_subfmeo();
1236
 
    RETURN();
1237
 
}
1238
 
 
1239
 
#if defined(TARGET_PPC64)
1240
 
void OPPROTO op_subfmeo_64 (void)
1241
 
{
1242
 
    do_subfmeo_64();
1243
 
    RETURN();
1244
 
}
1245
 
#endif
1246
 
 
1247
 
/* subtract from zero extended */
1248
 
void OPPROTO op_subfze (void)
1249
 
{
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
 
    }
1257
 
    RETURN();
1258
 
}
1259
 
 
1260
 
#if defined(TARGET_PPC64)
1261
 
void OPPROTO op_subfze_64 (void)
1262
 
{
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
 
    }
1270
 
    RETURN();
1271
 
}
1272
 
#endif
1273
 
 
1274
 
void OPPROTO op_subfzeo (void)
1275
 
{
1276
 
    do_subfzeo();
1277
 
    RETURN();
1278
 
}
1279
 
 
1280
 
#if defined(TARGET_PPC64)
1281
 
void OPPROTO op_subfzeo_64 (void)
1282
 
{
1283
 
    do_subfzeo_64();
1284
 
    RETURN();
1285
 
}
1286
 
#endif
1287
 
 
1288
 
/***                           Integer comparison                          ***/
1289
 
/* compare */
1290
 
void OPPROTO op_cmp (void)
1291
 
{
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;
1300
 
    RETURN();
1301
 
}
1302
 
 
1303
 
#if defined(TARGET_PPC64)
1304
 
void OPPROTO op_cmp_64 (void)
1305
 
{
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;
1314
 
    RETURN();
1315
 
}
1316
 
#endif
1317
 
 
1318
 
/* compare immediate */
1319
 
void OPPROTO op_cmpi (void)
1320
 
{
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;
1329
 
    RETURN();
1330
 
}
1331
 
 
1332
 
#if defined(TARGET_PPC64)
1333
 
void OPPROTO op_cmpi_64 (void)
1334
 
{
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;
1343
 
    RETURN();
1344
 
}
1345
 
#endif
1346
 
 
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
 
}
1360
 
 
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
 
}
1374
 
#endif
1375
 
 
1376
 
/* compare logical immediate */
1377
 
void OPPROTO op_cmpli (void)
1378
 
{
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;
1387
 
    RETURN();
1388
 
}
1389
 
 
1390
 
#if defined(TARGET_PPC64)
1391
 
void OPPROTO op_cmpli_64 (void)
1392
 
{
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;
1411
 
    RETURN();
1412
 
}
1413
 
 
1414
 
void OPPROTO op_popcntb (void)
1415
 
{
1416
 
    do_popcntb();
1417
 
    RETURN();
1418
 
}
1419
 
 
1420
 
#if defined(TARGET_PPC64)
1421
 
void OPPROTO op_popcntb_64 (void)
1422
 
{
1423
 
    do_popcntb_64();
1424
 
    RETURN();
1425
 
}
1426
 
#endif
1427
 
 
1428
 
/***                            Integer logical                            ***/
1429
 
/* and */
1430
 
void OPPROTO op_and (void)
1431
 
{
1432
 
    T0 &= T1;
1433
 
    RETURN();
1434
 
}
1435
 
 
1436
 
/* andc */
1437
 
void OPPROTO op_andc (void)
1438
 
{
1439
 
    T0 &= ~T1;
1440
 
    RETURN();
1441
 
}
1442
 
 
1443
 
/* andi. */
1444
 
void OPPROTO op_andi_T0 (void)
1445
 
{
1446
 
    T0 &= (uint32_t)PARAM1;
1447
 
    RETURN();
1448
 
}
1449
 
 
1450
 
void OPPROTO op_andi_T1 (void)
1451
 
{
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);
3435
 
    RETURN();
3436
 
}