Statistics
| Branch: | Revision:

root / target-alpha / translate.c @ ffc500ea

History | View | Annotate | Download (75.2 kB)

1
/*
2
 *  Alpha emulation cpu translation for qemu.
3
 *
4
 *  Copyright (c) 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., 51 Franklin Street, Fifth Floor, Boston MA  02110-1301 USA
19
 */
20

    
21
#include <stdint.h>
22
#include <stdlib.h>
23
#include <stdio.h>
24

    
25
#include "cpu.h"
26
#include "exec-all.h"
27
#include "disas.h"
28
#include "host-utils.h"
29
#include "tcg-op.h"
30
#include "qemu-common.h"
31

    
32
#include "helper.h"
33
#define GEN_HELPER 1
34
#include "helper.h"
35

    
36
/* #define DO_SINGLE_STEP */
37
#define ALPHA_DEBUG_DISAS
38
/* #define DO_TB_FLUSH */
39

    
40

    
41
#ifdef ALPHA_DEBUG_DISAS
42
#  define LOG_DISAS(...) qemu_log(__VA_ARGS__)
43
#else
44
#  define LOG_DISAS(...) do { } while (0)
45
#endif
46

    
47
typedef struct DisasContext DisasContext;
48
struct DisasContext {
49
    uint64_t pc;
50
    int mem_idx;
51
#if !defined (CONFIG_USER_ONLY)
52
    int pal_mode;
53
#endif
54
    CPUAlphaState *env;
55
    uint32_t amask;
56
};
57

    
58
/* global register indexes */
59
static TCGv_ptr cpu_env;
60
static TCGv cpu_ir[31];
61
static TCGv cpu_fir[31];
62
static TCGv cpu_pc;
63
static TCGv cpu_lock;
64

    
65
/* register names */
66
static char cpu_reg_names[10*4+21*5 + 10*5+21*6];
67

    
68
#include "gen-icount.h"
69

    
70
static void alpha_translate_init(void)
71
{
72
    int i;
73
    char *p;
74
    static int done_init = 0;
75

    
76
    if (done_init)
77
        return;
78

    
79
    cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
80

    
81
    p = cpu_reg_names;
82
    for (i = 0; i < 31; i++) {
83
        sprintf(p, "ir%d", i);
84
        cpu_ir[i] = tcg_global_mem_new_i64(TCG_AREG0,
85
                                           offsetof(CPUState, ir[i]), p);
86
        p += (i < 10) ? 4 : 5;
87

    
88
        sprintf(p, "fir%d", i);
89
        cpu_fir[i] = tcg_global_mem_new_i64(TCG_AREG0,
90
                                            offsetof(CPUState, fir[i]), p);
91
        p += (i < 10) ? 5 : 6;
92
    }
93

    
94
    cpu_pc = tcg_global_mem_new_i64(TCG_AREG0,
95
                                    offsetof(CPUState, pc), "pc");
96

    
97
    cpu_lock = tcg_global_mem_new_i64(TCG_AREG0,
98
                                      offsetof(CPUState, lock), "lock");
99

    
100
    /* register helpers */
101
#define GEN_HELPER 2
102
#include "helper.h"
103

    
104
    done_init = 1;
105
}
106

    
107
static always_inline void gen_excp (DisasContext *ctx,
108
                                    int exception, int error_code)
109
{
110
    TCGv_i32 tmp1, tmp2;
111

    
112
    tcg_gen_movi_i64(cpu_pc, ctx->pc);
113
    tmp1 = tcg_const_i32(exception);
114
    tmp2 = tcg_const_i32(error_code);
115
    gen_helper_excp(tmp1, tmp2);
116
    tcg_temp_free_i32(tmp2);
117
    tcg_temp_free_i32(tmp1);
118
}
119

    
120
static always_inline void gen_invalid (DisasContext *ctx)
121
{
122
    gen_excp(ctx, EXCP_OPCDEC, 0);
123
}
124

    
125
static always_inline void gen_qemu_ldf (TCGv t0, TCGv t1, int flags)
126
{
127
    TCGv tmp = tcg_temp_new();
128
    TCGv_i32 tmp32 = tcg_temp_new_i32();
129
    tcg_gen_qemu_ld32u(tmp, t1, flags);
130
    tcg_gen_trunc_i64_i32(tmp32, tmp);
131
    gen_helper_memory_to_f(t0, tmp32);
132
    tcg_temp_free_i32(tmp32);
133
    tcg_temp_free(tmp);
134
}
135

    
136
static always_inline void gen_qemu_ldg (TCGv t0, TCGv t1, int flags)
137
{
138
    TCGv tmp = tcg_temp_new();
139
    tcg_gen_qemu_ld64(tmp, t1, flags);
140
    gen_helper_memory_to_g(t0, tmp);
141
    tcg_temp_free(tmp);
142
}
143

    
144
static always_inline void gen_qemu_lds (TCGv t0, TCGv t1, int flags)
145
{
146
    TCGv tmp = tcg_temp_new();
147
    TCGv_i32 tmp32 = tcg_temp_new_i32();
148
    tcg_gen_qemu_ld32u(tmp, t1, flags);
149
    tcg_gen_trunc_i64_i32(tmp32, tmp);
150
    gen_helper_memory_to_s(t0, tmp32);
151
    tcg_temp_free_i32(tmp32);
152
    tcg_temp_free(tmp);
153
}
154

    
155
static always_inline void gen_qemu_ldl_l (TCGv t0, TCGv t1, int flags)
156
{
157
    tcg_gen_mov_i64(cpu_lock, t1);
158
    tcg_gen_qemu_ld32s(t0, t1, flags);
159
}
160

    
161
static always_inline void gen_qemu_ldq_l (TCGv t0, TCGv t1, int flags)
162
{
163
    tcg_gen_mov_i64(cpu_lock, t1);
164
    tcg_gen_qemu_ld64(t0, t1, flags);
165
}
166

    
167
static always_inline void gen_load_mem (DisasContext *ctx,
168
                                        void (*tcg_gen_qemu_load)(TCGv t0, TCGv t1, int flags),
169
                                        int ra, int rb, int32_t disp16,
170
                                        int fp, int clear)
171
{
172
    TCGv addr;
173

    
174
    if (unlikely(ra == 31))
175
        return;
176

    
177
    addr = tcg_temp_new();
178
    if (rb != 31) {
179
        tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);
180
        if (clear)
181
            tcg_gen_andi_i64(addr, addr, ~0x7);
182
    } else {
183
        if (clear)
184
            disp16 &= ~0x7;
185
        tcg_gen_movi_i64(addr, disp16);
186
    }
187
    if (fp)
188
        tcg_gen_qemu_load(cpu_fir[ra], addr, ctx->mem_idx);
189
    else
190
        tcg_gen_qemu_load(cpu_ir[ra], addr, ctx->mem_idx);
191
    tcg_temp_free(addr);
192
}
193

    
194
static always_inline void gen_qemu_stf (TCGv t0, TCGv t1, int flags)
195
{
196
    TCGv_i32 tmp32 = tcg_temp_new_i32();
197
    TCGv tmp = tcg_temp_new();
198
    gen_helper_f_to_memory(tmp32, t0);
199
    tcg_gen_extu_i32_i64(tmp, tmp32);
200
    tcg_gen_qemu_st32(tmp, t1, flags);
201
    tcg_temp_free(tmp);
202
    tcg_temp_free_i32(tmp32);
203
}
204

    
205
static always_inline void gen_qemu_stg (TCGv t0, TCGv t1, int flags)
206
{
207
    TCGv tmp = tcg_temp_new();
208
    gen_helper_g_to_memory(tmp, t0);
209
    tcg_gen_qemu_st64(tmp, t1, flags);
210
    tcg_temp_free(tmp);
211
}
212

    
213
static always_inline void gen_qemu_sts (TCGv t0, TCGv t1, int flags)
214
{
215
    TCGv_i32 tmp32 = tcg_temp_new_i32();
216
    TCGv tmp = tcg_temp_new();
217
    gen_helper_s_to_memory(tmp32, t0);
218
    tcg_gen_extu_i32_i64(tmp, tmp32);
219
    tcg_gen_qemu_st32(tmp, t1, flags);
220
    tcg_temp_free(tmp);
221
    tcg_temp_free_i32(tmp32);
222
}
223

    
224
static always_inline void gen_qemu_stl_c (TCGv t0, TCGv t1, int flags)
225
{
226
    int l1, l2;
227

    
228
    l1 = gen_new_label();
229
    l2 = gen_new_label();
230
    tcg_gen_brcond_i64(TCG_COND_NE, cpu_lock, t1, l1);
231
    tcg_gen_qemu_st32(t0, t1, flags);
232
    tcg_gen_movi_i64(t0, 1);
233
    tcg_gen_br(l2);
234
    gen_set_label(l1);
235
    tcg_gen_movi_i64(t0, 0);
236
    gen_set_label(l2);
237
    tcg_gen_movi_i64(cpu_lock, -1);
238
}
239

    
240
static always_inline void gen_qemu_stq_c (TCGv t0, TCGv t1, int flags)
241
{
242
    int l1, l2;
243

    
244
    l1 = gen_new_label();
245
    l2 = gen_new_label();
246
    tcg_gen_brcond_i64(TCG_COND_NE, cpu_lock, t1, l1);
247
    tcg_gen_qemu_st64(t0, t1, flags);
248
    tcg_gen_movi_i64(t0, 1);
249
    tcg_gen_br(l2);
250
    gen_set_label(l1);
251
    tcg_gen_movi_i64(t0, 0);
252
    gen_set_label(l2);
253
    tcg_gen_movi_i64(cpu_lock, -1);
254
}
255

    
256
static always_inline void gen_store_mem (DisasContext *ctx,
257
                                         void (*tcg_gen_qemu_store)(TCGv t0, TCGv t1, int flags),
258
                                         int ra, int rb, int32_t disp16,
259
                                         int fp, int clear, int local)
260
{
261
    TCGv addr;
262
    if (local)
263
        addr = tcg_temp_local_new();
264
    else
265
        addr = tcg_temp_new();
266
    if (rb != 31) {
267
        tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);
268
        if (clear)
269
            tcg_gen_andi_i64(addr, addr, ~0x7);
270
    } else {
271
        if (clear)
272
            disp16 &= ~0x7;
273
        tcg_gen_movi_i64(addr, disp16);
274
    }
275
    if (ra != 31) {
276
        if (fp)
277
            tcg_gen_qemu_store(cpu_fir[ra], addr, ctx->mem_idx);
278
        else
279
            tcg_gen_qemu_store(cpu_ir[ra], addr, ctx->mem_idx);
280
    } else {
281
        TCGv zero;
282
        if (local)
283
            zero = tcg_const_local_i64(0);
284
        else
285
            zero = tcg_const_i64(0);
286
        tcg_gen_qemu_store(zero, addr, ctx->mem_idx);
287
        tcg_temp_free(zero);
288
    }
289
    tcg_temp_free(addr);
290
}
291

    
292
static always_inline void gen_bcond (DisasContext *ctx,
293
                                     TCGCond cond,
294
                                     int ra, int32_t disp, int mask)
295
{
296
    int l1, l2;
297

    
298
    l1 = gen_new_label();
299
    l2 = gen_new_label();
300
    if (likely(ra != 31)) {
301
        if (mask) {
302
            TCGv tmp = tcg_temp_new();
303
            tcg_gen_andi_i64(tmp, cpu_ir[ra], 1);
304
            tcg_gen_brcondi_i64(cond, tmp, 0, l1);
305
            tcg_temp_free(tmp);
306
        } else
307
            tcg_gen_brcondi_i64(cond, cpu_ir[ra], 0, l1);
308
    } else {
309
        /* Very uncommon case - Do not bother to optimize.  */
310
        TCGv tmp = tcg_const_i64(0);
311
        tcg_gen_brcondi_i64(cond, tmp, 0, l1);
312
        tcg_temp_free(tmp);
313
    }
314
    tcg_gen_movi_i64(cpu_pc, ctx->pc);
315
    tcg_gen_br(l2);
316
    gen_set_label(l1);
317
    tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp << 2));
318
    gen_set_label(l2);
319
}
320

    
321
static always_inline void gen_fbcond (DisasContext *ctx, int opc,
322
                                      int ra, int32_t disp16)
323
{
324
    int l1, l2;
325
    TCGv tmp;
326
    TCGv src;
327

    
328
    l1 = gen_new_label();
329
    l2 = gen_new_label();
330
    if (ra != 31) {
331
        tmp = tcg_temp_new();
332
        src = cpu_fir[ra];
333
    } else  {
334
        tmp = tcg_const_i64(0);
335
        src = tmp;
336
    }
337
    switch (opc) {
338
    case 0x31: /* FBEQ */
339
        gen_helper_cmpfeq(tmp, src);
340
        break;
341
    case 0x32: /* FBLT */
342
        gen_helper_cmpflt(tmp, src);
343
        break;
344
    case 0x33: /* FBLE */
345
        gen_helper_cmpfle(tmp, src);
346
        break;
347
    case 0x35: /* FBNE */
348
        gen_helper_cmpfne(tmp, src);
349
        break;
350
    case 0x36: /* FBGE */
351
        gen_helper_cmpfge(tmp, src);
352
        break;
353
    case 0x37: /* FBGT */
354
        gen_helper_cmpfgt(tmp, src);
355
        break;
356
    default:
357
        abort();
358
    }
359
    tcg_gen_brcondi_i64(TCG_COND_NE, tmp, 0, l1);
360
    tcg_gen_movi_i64(cpu_pc, ctx->pc);
361
    tcg_gen_br(l2);
362
    gen_set_label(l1);
363
    tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp16 << 2));
364
    gen_set_label(l2);
365
}
366

    
367
static always_inline void gen_cmov (TCGCond inv_cond,
368
                                    int ra, int rb, int rc,
369
                                    int islit, uint8_t lit, int mask)
370
{
371
    int l1;
372

    
373
    if (unlikely(rc == 31))
374
        return;
375

    
376
    l1 = gen_new_label();
377

    
378
    if (ra != 31) {
379
        if (mask) {
380
            TCGv tmp = tcg_temp_new();
381
            tcg_gen_andi_i64(tmp, cpu_ir[ra], 1);
382
            tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);
383
            tcg_temp_free(tmp);
384
        } else
385
            tcg_gen_brcondi_i64(inv_cond, cpu_ir[ra], 0, l1);
386
    } else {
387
        /* Very uncommon case - Do not bother to optimize.  */
388
        TCGv tmp = tcg_const_i64(0);
389
        tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);
390
        tcg_temp_free(tmp);
391
    }
392

    
393
    if (islit)
394
        tcg_gen_movi_i64(cpu_ir[rc], lit);
395
    else
396
        tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
397
    gen_set_label(l1);
398
}
399

    
400
#define FARITH2(name)                                       \
401
static always_inline void glue(gen_f, name)(int rb, int rc) \
402
{                                                           \
403
    if (unlikely(rc == 31))                                 \
404
      return;                                               \
405
                                                            \
406
    if (rb != 31)                                           \
407
        gen_helper_ ## name (cpu_fir[rc], cpu_fir[rb]);    \
408
    else {                                                  \
409
        TCGv tmp = tcg_const_i64(0);                        \
410
        gen_helper_ ## name (cpu_fir[rc], tmp);            \
411
        tcg_temp_free(tmp);                                 \
412
    }                                                       \
413
}
414
FARITH2(sqrts)
415
FARITH2(sqrtf)
416
FARITH2(sqrtg)
417
FARITH2(sqrtt)
418
FARITH2(cvtgf)
419
FARITH2(cvtgq)
420
FARITH2(cvtqf)
421
FARITH2(cvtqg)
422
FARITH2(cvtst)
423
FARITH2(cvtts)
424
FARITH2(cvttq)
425
FARITH2(cvtqs)
426
FARITH2(cvtqt)
427
FARITH2(cvtlq)
428
FARITH2(cvtql)
429
FARITH2(cvtqlv)
430
FARITH2(cvtqlsv)
431

    
432
#define FARITH3(name)                                                     \
433
static always_inline void glue(gen_f, name) (int ra, int rb, int rc)      \
434
{                                                                         \
435
    if (unlikely(rc == 31))                                               \
436
        return;                                                           \
437
                                                                          \
438
    if (ra != 31) {                                                       \
439
        if (rb != 31)                                                     \
440
            gen_helper_ ## name (cpu_fir[rc], cpu_fir[ra], cpu_fir[rb]);  \
441
        else {                                                            \
442
            TCGv tmp = tcg_const_i64(0);                                  \
443
            gen_helper_ ## name (cpu_fir[rc], cpu_fir[ra], tmp);          \
444
            tcg_temp_free(tmp);                                           \
445
        }                                                                 \
446
    } else {                                                              \
447
        TCGv tmp = tcg_const_i64(0);                                      \
448
        if (rb != 31)                                                     \
449
            gen_helper_ ## name (cpu_fir[rc], tmp, cpu_fir[rb]);          \
450
        else                                                              \
451
            gen_helper_ ## name (cpu_fir[rc], tmp, tmp);                   \
452
        tcg_temp_free(tmp);                                               \
453
    }                                                                     \
454
}
455

    
456
FARITH3(addf)
457
FARITH3(subf)
458
FARITH3(mulf)
459
FARITH3(divf)
460
FARITH3(addg)
461
FARITH3(subg)
462
FARITH3(mulg)
463
FARITH3(divg)
464
FARITH3(cmpgeq)
465
FARITH3(cmpglt)
466
FARITH3(cmpgle)
467
FARITH3(adds)
468
FARITH3(subs)
469
FARITH3(muls)
470
FARITH3(divs)
471
FARITH3(addt)
472
FARITH3(subt)
473
FARITH3(mult)
474
FARITH3(divt)
475
FARITH3(cmptun)
476
FARITH3(cmpteq)
477
FARITH3(cmptlt)
478
FARITH3(cmptle)
479
FARITH3(cpys)
480
FARITH3(cpysn)
481
FARITH3(cpyse)
482

    
483
#define FCMOV(name)                                                   \
484
static always_inline void glue(gen_f, name) (int ra, int rb, int rc)  \
485
{                                                                     \
486
    int l1;                                                           \
487
    TCGv tmp;                                                         \
488
                                                                      \
489
    if (unlikely(rc == 31))                                           \
490
        return;                                                       \
491
                                                                      \
492
    l1 = gen_new_label();                                             \
493
    tmp = tcg_temp_new();                                 \
494
    if (ra != 31) {                                                   \
495
        tmp = tcg_temp_new();                             \
496
        gen_helper_ ## name (tmp, cpu_fir[ra]);                       \
497
    } else  {                                                         \
498
        tmp = tcg_const_i64(0);                                       \
499
        gen_helper_ ## name (tmp, tmp);                               \
500
    }                                                                 \
501
    tcg_gen_brcondi_i64(TCG_COND_EQ, tmp, 0, l1);                     \
502
    if (rb != 31)                                                     \
503
        tcg_gen_mov_i64(cpu_fir[rc], cpu_fir[ra]);                    \
504
    else                                                              \
505
        tcg_gen_movi_i64(cpu_fir[rc], 0);                             \
506
    gen_set_label(l1);                                                \
507
}
508
FCMOV(cmpfeq)
509
FCMOV(cmpfne)
510
FCMOV(cmpflt)
511
FCMOV(cmpfge)
512
FCMOV(cmpfle)
513
FCMOV(cmpfgt)
514

    
515
/* EXTWH, EXTWH, EXTLH, EXTQH */
516
static always_inline void gen_ext_h(void (*tcg_gen_ext_i64)(TCGv t0, TCGv t1),
517
                                    int ra, int rb, int rc,
518
                                    int islit, uint8_t lit)
519
{
520
    if (unlikely(rc == 31))
521
        return;
522

    
523
    if (ra != 31) {
524
        if (islit) {
525
            if (lit != 0)
526
                tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 64 - ((lit & 7) * 8));
527
            else
528
                tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
529
        } else {
530
            TCGv tmp1, tmp2;
531
            tmp1 = tcg_temp_new();
532
            tcg_gen_andi_i64(tmp1, cpu_ir[rb], 7);
533
            tcg_gen_shli_i64(tmp1, tmp1, 3);
534
            tmp2 = tcg_const_i64(64);
535
            tcg_gen_sub_i64(tmp1, tmp2, tmp1);
536
            tcg_temp_free(tmp2);
537
            tcg_gen_shl_i64(cpu_ir[rc], cpu_ir[ra], tmp1);
538
            tcg_temp_free(tmp1);
539
        }
540
        if (tcg_gen_ext_i64)
541
            tcg_gen_ext_i64(cpu_ir[rc], cpu_ir[rc]);
542
    } else
543
        tcg_gen_movi_i64(cpu_ir[rc], 0);
544
}
545

    
546
/* EXTBL, EXTWL, EXTWL, EXTLL, EXTQL */
547
static always_inline void gen_ext_l(void (*tcg_gen_ext_i64)(TCGv t0, TCGv t1),
548
                                    int ra, int rb, int rc,
549
                                    int islit, uint8_t lit)
550
{
551
    if (unlikely(rc == 31))
552
        return;
553

    
554
    if (ra != 31) {
555
        if (islit) {
556
                tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[ra], (lit & 7) * 8);
557
        } else {
558
            TCGv tmp = tcg_temp_new();
559
            tcg_gen_andi_i64(tmp, cpu_ir[rb], 7);
560
            tcg_gen_shli_i64(tmp, tmp, 3);
561
            tcg_gen_shr_i64(cpu_ir[rc], cpu_ir[ra], tmp);
562
            tcg_temp_free(tmp);
563
        }
564
        if (tcg_gen_ext_i64)
565
            tcg_gen_ext_i64(cpu_ir[rc], cpu_ir[rc]);
566
    } else
567
        tcg_gen_movi_i64(cpu_ir[rc], 0);
568
}
569

    
570
/* Code to call arith3 helpers */
571
#define ARITH3(name)                                                  \
572
static always_inline void glue(gen_, name) (int ra, int rb, int rc,   \
573
                                            int islit, uint8_t lit)   \
574
{                                                                     \
575
    if (unlikely(rc == 31))                                           \
576
        return;                                                       \
577
                                                                      \
578
    if (ra != 31) {                                                   \
579
        if (islit) {                                                  \
580
            TCGv tmp = tcg_const_i64(lit);                            \
581
            gen_helper_ ## name(cpu_ir[rc], cpu_ir[ra], tmp);         \
582
            tcg_temp_free(tmp);                                       \
583
        } else                                                        \
584
            gen_helper_ ## name (cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]); \
585
    } else {                                                          \
586
        TCGv tmp1 = tcg_const_i64(0);                                 \
587
        if (islit) {                                                  \
588
            TCGv tmp2 = tcg_const_i64(lit);                           \
589
            gen_helper_ ## name (cpu_ir[rc], tmp1, tmp2);             \
590
            tcg_temp_free(tmp2);                                      \
591
        } else                                                        \
592
            gen_helper_ ## name (cpu_ir[rc], tmp1, cpu_ir[rb]);       \
593
        tcg_temp_free(tmp1);                                          \
594
    }                                                                 \
595
}
596
ARITH3(cmpbge)
597
ARITH3(addlv)
598
ARITH3(sublv)
599
ARITH3(addqv)
600
ARITH3(subqv)
601
ARITH3(mskbl)
602
ARITH3(insbl)
603
ARITH3(mskwl)
604
ARITH3(inswl)
605
ARITH3(mskll)
606
ARITH3(insll)
607
ARITH3(zap)
608
ARITH3(zapnot)
609
ARITH3(mskql)
610
ARITH3(insql)
611
ARITH3(mskwh)
612
ARITH3(inswh)
613
ARITH3(msklh)
614
ARITH3(inslh)
615
ARITH3(mskqh)
616
ARITH3(insqh)
617
ARITH3(umulh)
618
ARITH3(mullv)
619
ARITH3(mulqv)
620

    
621
static always_inline void gen_cmp(TCGCond cond,
622
                                  int ra, int rb, int rc,
623
                                  int islit, uint8_t lit)
624
{
625
    int l1, l2;
626
    TCGv tmp;
627

    
628
    if (unlikely(rc == 31))
629
    return;
630

    
631
    l1 = gen_new_label();
632
    l2 = gen_new_label();
633

    
634
    if (ra != 31) {
635
        tmp = tcg_temp_new();
636
        tcg_gen_mov_i64(tmp, cpu_ir[ra]);
637
    } else
638
        tmp = tcg_const_i64(0);
639
    if (islit)
640
        tcg_gen_brcondi_i64(cond, tmp, lit, l1);
641
    else
642
        tcg_gen_brcond_i64(cond, tmp, cpu_ir[rb], l1);
643

    
644
    tcg_gen_movi_i64(cpu_ir[rc], 0);
645
    tcg_gen_br(l2);
646
    gen_set_label(l1);
647
    tcg_gen_movi_i64(cpu_ir[rc], 1);
648
    gen_set_label(l2);
649
}
650

    
651
static always_inline int translate_one (DisasContext *ctx, uint32_t insn)
652
{
653
    uint32_t palcode;
654
    int32_t disp21, disp16, disp12;
655
    uint16_t fn11, fn16;
656
    uint8_t opc, ra, rb, rc, sbz, fpfn, fn7, fn2, islit;
657
    uint8_t lit;
658
    int ret;
659

    
660
    /* Decode all instruction fields */
661
    opc = insn >> 26;
662
    ra = (insn >> 21) & 0x1F;
663
    rb = (insn >> 16) & 0x1F;
664
    rc = insn & 0x1F;
665
    sbz = (insn >> 13) & 0x07;
666
    islit = (insn >> 12) & 1;
667
    if (rb == 31 && !islit) {
668
        islit = 1;
669
        lit = 0;
670
    } else
671
        lit = (insn >> 13) & 0xFF;
672
    palcode = insn & 0x03FFFFFF;
673
    disp21 = ((int32_t)((insn & 0x001FFFFF) << 11)) >> 11;
674
    disp16 = (int16_t)(insn & 0x0000FFFF);
675
    disp12 = (int32_t)((insn & 0x00000FFF) << 20) >> 20;
676
    fn16 = insn & 0x0000FFFF;
677
    fn11 = (insn >> 5) & 0x000007FF;
678
    fpfn = fn11 & 0x3F;
679
    fn7 = (insn >> 5) & 0x0000007F;
680
    fn2 = (insn >> 5) & 0x00000003;
681
    ret = 0;
682
    LOG_DISAS("opc %02x ra %d rb %d rc %d disp16 %04x\n",
683
              opc, ra, rb, rc, disp16);
684
    switch (opc) {
685
    case 0x00:
686
        /* CALL_PAL */
687
        if (palcode >= 0x80 && palcode < 0xC0) {
688
            /* Unprivileged PAL call */
689
            gen_excp(ctx, EXCP_CALL_PAL + ((palcode & 0x3F) << 6), 0);
690
#if !defined (CONFIG_USER_ONLY)
691
        } else if (palcode < 0x40) {
692
            /* Privileged PAL code */
693
            if (ctx->mem_idx & 1)
694
                goto invalid_opc;
695
            else
696
                gen_excp(ctx, EXCP_CALL_PALP + ((palcode & 0x3F) << 6), 0);
697
#endif
698
        } else {
699
            /* Invalid PAL call */
700
            goto invalid_opc;
701
        }
702
        ret = 3;
703
        break;
704
    case 0x01:
705
        /* OPC01 */
706
        goto invalid_opc;
707
    case 0x02:
708
        /* OPC02 */
709
        goto invalid_opc;
710
    case 0x03:
711
        /* OPC03 */
712
        goto invalid_opc;
713
    case 0x04:
714
        /* OPC04 */
715
        goto invalid_opc;
716
    case 0x05:
717
        /* OPC05 */
718
        goto invalid_opc;
719
    case 0x06:
720
        /* OPC06 */
721
        goto invalid_opc;
722
    case 0x07:
723
        /* OPC07 */
724
        goto invalid_opc;
725
    case 0x08:
726
        /* LDA */
727
        if (likely(ra != 31)) {
728
            if (rb != 31)
729
                tcg_gen_addi_i64(cpu_ir[ra], cpu_ir[rb], disp16);
730
            else
731
                tcg_gen_movi_i64(cpu_ir[ra], disp16);
732
        }
733
        break;
734
    case 0x09:
735
        /* LDAH */
736
        if (likely(ra != 31)) {
737
            if (rb != 31)
738
                tcg_gen_addi_i64(cpu_ir[ra], cpu_ir[rb], disp16 << 16);
739
            else
740
                tcg_gen_movi_i64(cpu_ir[ra], disp16 << 16);
741
        }
742
        break;
743
    case 0x0A:
744
        /* LDBU */
745
        if (!(ctx->amask & AMASK_BWX))
746
            goto invalid_opc;
747
        gen_load_mem(ctx, &tcg_gen_qemu_ld8u, ra, rb, disp16, 0, 0);
748
        break;
749
    case 0x0B:
750
        /* LDQ_U */
751
        gen_load_mem(ctx, &tcg_gen_qemu_ld64, ra, rb, disp16, 0, 1);
752
        break;
753
    case 0x0C:
754
        /* LDWU */
755
        if (!(ctx->amask & AMASK_BWX))
756
            goto invalid_opc;
757
        gen_load_mem(ctx, &tcg_gen_qemu_ld16u, ra, rb, disp16, 0, 0);
758
        break;
759
    case 0x0D:
760
        /* STW */
761
        gen_store_mem(ctx, &tcg_gen_qemu_st16, ra, rb, disp16, 0, 0, 0);
762
        break;
763
    case 0x0E:
764
        /* STB */
765
        gen_store_mem(ctx, &tcg_gen_qemu_st8, ra, rb, disp16, 0, 0, 0);
766
        break;
767
    case 0x0F:
768
        /* STQ_U */
769
        gen_store_mem(ctx, &tcg_gen_qemu_st64, ra, rb, disp16, 0, 1, 0);
770
        break;
771
    case 0x10:
772
        switch (fn7) {
773
        case 0x00:
774
            /* ADDL */
775
            if (likely(rc != 31)) {
776
                if (ra != 31) {
777
                    if (islit) {
778
                        tcg_gen_addi_i64(cpu_ir[rc], cpu_ir[ra], lit);
779
                        tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
780
                    } else {
781
                        tcg_gen_add_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
782
                        tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
783
                    }
784
                } else {
785
                    if (islit)
786
                        tcg_gen_movi_i64(cpu_ir[rc], lit);
787
                    else
788
                        tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
789
                }
790
            }
791
            break;
792
        case 0x02:
793
            /* S4ADDL */
794
            if (likely(rc != 31)) {
795
                if (ra != 31) {
796
                    TCGv tmp = tcg_temp_new();
797
                    tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
798
                    if (islit)
799
                        tcg_gen_addi_i64(tmp, tmp, lit);
800
                    else
801
                        tcg_gen_add_i64(tmp, tmp, cpu_ir[rb]);
802
                    tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
803
                    tcg_temp_free(tmp);
804
                } else {
805
                    if (islit)
806
                        tcg_gen_movi_i64(cpu_ir[rc], lit);
807
                    else
808
                        tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
809
                }
810
            }
811
            break;
812
        case 0x09:
813
            /* SUBL */
814
            if (likely(rc != 31)) {
815
                if (ra != 31) {
816
                    if (islit)
817
                        tcg_gen_subi_i64(cpu_ir[rc], cpu_ir[ra], lit);
818
                    else
819
                        tcg_gen_sub_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
820
                    tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
821
                } else {
822
                    if (islit)
823
                        tcg_gen_movi_i64(cpu_ir[rc], -lit);
824
                    else {
825
                        tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
826
                        tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
827
                }
828
            }
829
            break;
830
        case 0x0B:
831
            /* S4SUBL */
832
            if (likely(rc != 31)) {
833
                if (ra != 31) {
834
                    TCGv tmp = tcg_temp_new();
835
                    tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
836
                    if (islit)
837
                        tcg_gen_subi_i64(tmp, tmp, lit);
838
                    else
839
                        tcg_gen_sub_i64(tmp, tmp, cpu_ir[rb]);
840
                    tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
841
                    tcg_temp_free(tmp);
842
                } else {
843
                    if (islit)
844
                        tcg_gen_movi_i64(cpu_ir[rc], -lit);
845
                    else {
846
                        tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
847
                        tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
848
                    }
849
                }
850
            }
851
            break;
852
        case 0x0F:
853
            /* CMPBGE */
854
            gen_cmpbge(ra, rb, rc, islit, lit);
855
            break;
856
        case 0x12:
857
            /* S8ADDL */
858
            if (likely(rc != 31)) {
859
                if (ra != 31) {
860
                    TCGv tmp = tcg_temp_new();
861
                    tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
862
                    if (islit)
863
                        tcg_gen_addi_i64(tmp, tmp, lit);
864
                    else
865
                        tcg_gen_add_i64(tmp, tmp, cpu_ir[rb]);
866
                    tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
867
                    tcg_temp_free(tmp);
868
                } else {
869
                    if (islit)
870
                        tcg_gen_movi_i64(cpu_ir[rc], lit);
871
                    else
872
                        tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
873
                }
874
            }
875
            break;
876
        case 0x1B:
877
            /* S8SUBL */
878
            if (likely(rc != 31)) {
879
                if (ra != 31) {
880
                    TCGv tmp = tcg_temp_new();
881
                    tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
882
                    if (islit)
883
                        tcg_gen_subi_i64(tmp, tmp, lit);
884
                    else
885
                       tcg_gen_sub_i64(tmp, tmp, cpu_ir[rb]);
886
                    tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
887
                    tcg_temp_free(tmp);
888
                } else {
889
                    if (islit)
890
                        tcg_gen_movi_i64(cpu_ir[rc], -lit);
891
                    else
892
                        tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
893
                        tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
894
                    }
895
                }
896
            }
897
            break;
898
        case 0x1D:
899
            /* CMPULT */
900
            gen_cmp(TCG_COND_LTU, ra, rb, rc, islit, lit);
901
            break;
902
        case 0x20:
903
            /* ADDQ */
904
            if (likely(rc != 31)) {
905
                if (ra != 31) {
906
                    if (islit)
907
                        tcg_gen_addi_i64(cpu_ir[rc], cpu_ir[ra], lit);
908
                    else
909
                        tcg_gen_add_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
910
                } else {
911
                    if (islit)
912
                        tcg_gen_movi_i64(cpu_ir[rc], lit);
913
                    else
914
                        tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
915
                }
916
            }
917
            break;
918
        case 0x22:
919
            /* S4ADDQ */
920
            if (likely(rc != 31)) {
921
                if (ra != 31) {
922
                    TCGv tmp = tcg_temp_new();
923
                    tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
924
                    if (islit)
925
                        tcg_gen_addi_i64(cpu_ir[rc], tmp, lit);
926
                    else
927
                        tcg_gen_add_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
928
                    tcg_temp_free(tmp);
929
                } else {
930
                    if (islit)
931
                        tcg_gen_movi_i64(cpu_ir[rc], lit);
932
                    else
933
                        tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
934
                }
935
            }
936
            break;
937
        case 0x29:
938
            /* SUBQ */
939
            if (likely(rc != 31)) {
940
                if (ra != 31) {
941
                    if (islit)
942
                        tcg_gen_subi_i64(cpu_ir[rc], cpu_ir[ra], lit);
943
                    else
944
                        tcg_gen_sub_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
945
                } else {
946
                    if (islit)
947
                        tcg_gen_movi_i64(cpu_ir[rc], -lit);
948
                    else
949
                        tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
950
                }
951
            }
952
            break;
953
        case 0x2B:
954
            /* S4SUBQ */
955
            if (likely(rc != 31)) {
956
                if (ra != 31) {
957
                    TCGv tmp = tcg_temp_new();
958
                    tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
959
                    if (islit)
960
                        tcg_gen_subi_i64(cpu_ir[rc], tmp, lit);
961
                    else
962
                        tcg_gen_sub_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
963
                    tcg_temp_free(tmp);
964
                } else {
965
                    if (islit)
966
                        tcg_gen_movi_i64(cpu_ir[rc], -lit);
967
                    else
968
                        tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
969
                }
970
            }
971
            break;
972
        case 0x2D:
973
            /* CMPEQ */
974
            gen_cmp(TCG_COND_EQ, ra, rb, rc, islit, lit);
975
            break;
976
        case 0x32:
977
            /* S8ADDQ */
978
            if (likely(rc != 31)) {
979
                if (ra != 31) {
980
                    TCGv tmp = tcg_temp_new();
981
                    tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
982
                    if (islit)
983
                        tcg_gen_addi_i64(cpu_ir[rc], tmp, lit);
984
                    else
985
                        tcg_gen_add_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
986
                    tcg_temp_free(tmp);
987
                } else {
988
                    if (islit)
989
                        tcg_gen_movi_i64(cpu_ir[rc], lit);
990
                    else
991
                        tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
992
                }
993
            }
994
            break;
995
        case 0x3B:
996
            /* S8SUBQ */
997
            if (likely(rc != 31)) {
998
                if (ra != 31) {
999
                    TCGv tmp = tcg_temp_new();
1000
                    tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
1001
                    if (islit)
1002
                        tcg_gen_subi_i64(cpu_ir[rc], tmp, lit);
1003
                    else
1004
                        tcg_gen_sub_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
1005
                    tcg_temp_free(tmp);
1006
                } else {
1007
                    if (islit)
1008
                        tcg_gen_movi_i64(cpu_ir[rc], -lit);
1009
                    else
1010
                        tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
1011
                }
1012
            }
1013
            break;
1014
        case 0x3D:
1015
            /* CMPULE */
1016
            gen_cmp(TCG_COND_LEU, ra, rb, rc, islit, lit);
1017
            break;
1018
        case 0x40:
1019
            /* ADDL/V */
1020
            gen_addlv(ra, rb, rc, islit, lit);
1021
            break;
1022
        case 0x49:
1023
            /* SUBL/V */
1024
            gen_sublv(ra, rb, rc, islit, lit);
1025
            break;
1026
        case 0x4D:
1027
            /* CMPLT */
1028
            gen_cmp(TCG_COND_LT, ra, rb, rc, islit, lit);
1029
            break;
1030
        case 0x60:
1031
            /* ADDQ/V */
1032
            gen_addqv(ra, rb, rc, islit, lit);
1033
            break;
1034
        case 0x69:
1035
            /* SUBQ/V */
1036
            gen_subqv(ra, rb, rc, islit, lit);
1037
            break;
1038
        case 0x6D:
1039
            /* CMPLE */
1040
            gen_cmp(TCG_COND_LE, ra, rb, rc, islit, lit);
1041
            break;
1042
        default:
1043
            goto invalid_opc;
1044
        }
1045
        break;
1046
    case 0x11:
1047
        switch (fn7) {
1048
        case 0x00:
1049
            /* AND */
1050
            if (likely(rc != 31)) {
1051
                if (ra == 31)
1052
                    tcg_gen_movi_i64(cpu_ir[rc], 0);
1053
                else if (islit)
1054
                    tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[ra], lit);
1055
                else
1056
                    tcg_gen_and_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1057
            }
1058
            break;
1059
        case 0x08:
1060
            /* BIC */
1061
            if (likely(rc != 31)) {
1062
                if (ra != 31) {
1063
                    if (islit)
1064
                        tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
1065
                    else
1066
                        tcg_gen_andc_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1067
                } else
1068
                    tcg_gen_movi_i64(cpu_ir[rc], 0);
1069
            }
1070
            break;
1071
        case 0x14:
1072
            /* CMOVLBS */
1073
            gen_cmov(TCG_COND_EQ, ra, rb, rc, islit, lit, 1);
1074
            break;
1075
        case 0x16:
1076
            /* CMOVLBC */
1077
            gen_cmov(TCG_COND_NE, ra, rb, rc, islit, lit, 1);
1078
            break;
1079
        case 0x20:
1080
            /* BIS */
1081
            if (likely(rc != 31)) {
1082
                if (ra != 31) {
1083
                    if (islit)
1084
                        tcg_gen_ori_i64(cpu_ir[rc], cpu_ir[ra], lit);
1085
                    else
1086
                        tcg_gen_or_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1087
                } else {
1088
                    if (islit)
1089
                        tcg_gen_movi_i64(cpu_ir[rc], lit);
1090
                    else
1091
                        tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
1092
                }
1093
            }
1094
            break;
1095
        case 0x24:
1096
            /* CMOVEQ */
1097
            gen_cmov(TCG_COND_NE, ra, rb, rc, islit, lit, 0);
1098
            break;
1099
        case 0x26:
1100
            /* CMOVNE */
1101
            gen_cmov(TCG_COND_EQ, ra, rb, rc, islit, lit, 0);
1102
            break;
1103
        case 0x28:
1104
            /* ORNOT */
1105
            if (likely(rc != 31)) {
1106
                if (ra != 31) {
1107
                    if (islit)
1108
                        tcg_gen_ori_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
1109
                    else
1110
                        tcg_gen_orc_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1111
                } else {
1112
                    if (islit)
1113
                        tcg_gen_movi_i64(cpu_ir[rc], ~lit);
1114
                    else
1115
                        tcg_gen_not_i64(cpu_ir[rc], cpu_ir[rb]);
1116
                }
1117
            }
1118
            break;
1119
        case 0x40:
1120
            /* XOR */
1121
            if (likely(rc != 31)) {
1122
                if (ra != 31) {
1123
                    if (islit)
1124
                        tcg_gen_xori_i64(cpu_ir[rc], cpu_ir[ra], lit);
1125
                    else
1126
                        tcg_gen_xor_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1127
                } else {
1128
                    if (islit)
1129
                        tcg_gen_movi_i64(cpu_ir[rc], lit);
1130
                    else
1131
                        tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
1132
                }
1133
            }
1134
            break;
1135
        case 0x44:
1136
            /* CMOVLT */
1137
            gen_cmov(TCG_COND_GE, ra, rb, rc, islit, lit, 0);
1138
            break;
1139
        case 0x46:
1140
            /* CMOVGE */
1141
            gen_cmov(TCG_COND_LT, ra, rb, rc, islit, lit, 0);
1142
            break;
1143
        case 0x48:
1144
            /* EQV */
1145
            if (likely(rc != 31)) {
1146
                if (ra != 31) {
1147
                    if (islit)
1148
                        tcg_gen_xori_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
1149
                    else
1150
                        tcg_gen_eqv_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1151
                } else {
1152
                    if (islit)
1153
                        tcg_gen_movi_i64(cpu_ir[rc], ~lit);
1154
                    else
1155
                        tcg_gen_not_i64(cpu_ir[rc], cpu_ir[rb]);
1156
                }
1157
            }
1158
            break;
1159
        case 0x61:
1160
            /* AMASK */
1161
            if (likely(rc != 31)) {
1162
                if (islit)
1163
                    tcg_gen_movi_i64(cpu_ir[rc], lit);
1164
                else
1165
                    tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
1166
                switch (ctx->env->implver) {
1167
                case IMPLVER_2106x:
1168
                    /* EV4, EV45, LCA, LCA45 & EV5 */
1169
                    break;
1170
                case IMPLVER_21164:
1171
                case IMPLVER_21264:
1172
                case IMPLVER_21364:
1173
                    tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[rc],
1174
                                     ~(uint64_t)ctx->amask);
1175
                    break;
1176
                }
1177
            }
1178
            break;
1179
        case 0x64:
1180
            /* CMOVLE */
1181
            gen_cmov(TCG_COND_GT, ra, rb, rc, islit, lit, 0);
1182
            break;
1183
        case 0x66:
1184
            /* CMOVGT */
1185
            gen_cmov(TCG_COND_LE, ra, rb, rc, islit, lit, 0);
1186
            break;
1187
        case 0x6C:
1188
            /* IMPLVER */
1189
            if (rc != 31)
1190
                tcg_gen_movi_i64(cpu_ir[rc], ctx->env->implver);
1191
            break;
1192
        default:
1193
            goto invalid_opc;
1194
        }
1195
        break;
1196
    case 0x12:
1197
        switch (fn7) {
1198
        case 0x02:
1199
            /* MSKBL */
1200
            gen_mskbl(ra, rb, rc, islit, lit);
1201
            break;
1202
        case 0x06:
1203
            /* EXTBL */
1204
            gen_ext_l(&tcg_gen_ext8u_i64, ra, rb, rc, islit, lit);
1205
            break;
1206
        case 0x0B:
1207
            /* INSBL */
1208
            gen_insbl(ra, rb, rc, islit, lit);
1209
            break;
1210
        case 0x12:
1211
            /* MSKWL */
1212
            gen_mskwl(ra, rb, rc, islit, lit);
1213
            break;
1214
        case 0x16:
1215
            /* EXTWL */
1216
            gen_ext_l(&tcg_gen_ext16u_i64, ra, rb, rc, islit, lit);
1217
            break;
1218
        case 0x1B:
1219
            /* INSWL */
1220
            gen_inswl(ra, rb, rc, islit, lit);
1221
            break;
1222
        case 0x22:
1223
            /* MSKLL */
1224
            gen_mskll(ra, rb, rc, islit, lit);
1225
            break;
1226
        case 0x26:
1227
            /* EXTLL */
1228
            gen_ext_l(&tcg_gen_ext32u_i64, ra, rb, rc, islit, lit);
1229
            break;
1230
        case 0x2B:
1231
            /* INSLL */
1232
            gen_insll(ra, rb, rc, islit, lit);
1233
            break;
1234
        case 0x30:
1235
            /* ZAP */
1236
            gen_zap(ra, rb, rc, islit, lit);
1237
            break;
1238
        case 0x31:
1239
            /* ZAPNOT */
1240
            gen_zapnot(ra, rb, rc, islit, lit);
1241
            break;
1242
        case 0x32:
1243
            /* MSKQL */
1244
            gen_mskql(ra, rb, rc, islit, lit);
1245
            break;
1246
        case 0x34:
1247
            /* SRL */
1248
            if (likely(rc != 31)) {
1249
                if (ra != 31) {
1250
                    if (islit)
1251
                        tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
1252
                    else {
1253
                        TCGv shift = tcg_temp_new();
1254
                        tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
1255
                        tcg_gen_shr_i64(cpu_ir[rc], cpu_ir[ra], shift);
1256
                        tcg_temp_free(shift);
1257
                    }
1258
                } else
1259
                    tcg_gen_movi_i64(cpu_ir[rc], 0);
1260
            }
1261
            break;
1262
        case 0x36:
1263
            /* EXTQL */
1264
            gen_ext_l(NULL, ra, rb, rc, islit, lit);
1265
            break;
1266
        case 0x39:
1267
            /* SLL */
1268
            if (likely(rc != 31)) {
1269
                if (ra != 31) {
1270
                    if (islit)
1271
                        tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
1272
                    else {
1273
                        TCGv shift = tcg_temp_new();
1274
                        tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
1275
                        tcg_gen_shl_i64(cpu_ir[rc], cpu_ir[ra], shift);
1276
                        tcg_temp_free(shift);
1277
                    }
1278
                } else
1279
                    tcg_gen_movi_i64(cpu_ir[rc], 0);
1280
            }
1281
            break;
1282
        case 0x3B:
1283
            /* INSQL */
1284
            gen_insql(ra, rb, rc, islit, lit);
1285
            break;
1286
        case 0x3C:
1287
            /* SRA */
1288
            if (likely(rc != 31)) {
1289
                if (ra != 31) {
1290
                    if (islit)
1291
                        tcg_gen_sari_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
1292
                    else {
1293
                        TCGv shift = tcg_temp_new();
1294
                        tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
1295
                        tcg_gen_sar_i64(cpu_ir[rc], cpu_ir[ra], shift);
1296
                        tcg_temp_free(shift);
1297
                    }
1298
                } else
1299
                    tcg_gen_movi_i64(cpu_ir[rc], 0);
1300
            }
1301
            break;
1302
        case 0x52:
1303
            /* MSKWH */
1304
            gen_mskwh(ra, rb, rc, islit, lit);
1305
            break;
1306
        case 0x57:
1307
            /* INSWH */
1308
            gen_inswh(ra, rb, rc, islit, lit);
1309
            break;
1310
        case 0x5A:
1311
            /* EXTWH */
1312
            gen_ext_h(&tcg_gen_ext16u_i64, ra, rb, rc, islit, lit);
1313
            break;
1314
        case 0x62:
1315
            /* MSKLH */
1316
            gen_msklh(ra, rb, rc, islit, lit);
1317
            break;
1318
        case 0x67:
1319
            /* INSLH */
1320
            gen_inslh(ra, rb, rc, islit, lit);
1321
            break;
1322
        case 0x6A:
1323
            /* EXTLH */
1324
            gen_ext_h(&tcg_gen_ext16u_i64, ra, rb, rc, islit, lit);
1325
            break;
1326
        case 0x72:
1327
            /* MSKQH */
1328
            gen_mskqh(ra, rb, rc, islit, lit);
1329
            break;
1330
        case 0x77:
1331
            /* INSQH */
1332
            gen_insqh(ra, rb, rc, islit, lit);
1333
            break;
1334
        case 0x7A:
1335
            /* EXTQH */
1336
            gen_ext_h(NULL, ra, rb, rc, islit, lit);
1337
            break;
1338
        default:
1339
            goto invalid_opc;
1340
        }
1341
        break;
1342
    case 0x13:
1343
        switch (fn7) {
1344
        case 0x00:
1345
            /* MULL */
1346
            if (likely(rc != 31)) {
1347
                if (ra == 31)
1348
                    tcg_gen_movi_i64(cpu_ir[rc], 0);
1349
                else {
1350
                    if (islit)
1351
                        tcg_gen_muli_i64(cpu_ir[rc], cpu_ir[ra], lit);
1352
                    else
1353
                        tcg_gen_mul_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1354
                    tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1355
                }
1356
            }
1357
            break;
1358
        case 0x20:
1359
            /* MULQ */
1360
            if (likely(rc != 31)) {
1361
                if (ra == 31)
1362
                    tcg_gen_movi_i64(cpu_ir[rc], 0);
1363
                else if (islit)
1364
                    tcg_gen_muli_i64(cpu_ir[rc], cpu_ir[ra], lit);
1365
                else
1366
                    tcg_gen_mul_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1367
            }
1368
            break;
1369
        case 0x30:
1370
            /* UMULH */
1371
            gen_umulh(ra, rb, rc, islit, lit);
1372
            break;
1373
        case 0x40:
1374
            /* MULL/V */
1375
            gen_mullv(ra, rb, rc, islit, lit);
1376
            break;
1377
        case 0x60:
1378
            /* MULQ/V */
1379
            gen_mulqv(ra, rb, rc, islit, lit);
1380
            break;
1381
        default:
1382
            goto invalid_opc;
1383
        }
1384
        break;
1385
    case 0x14:
1386
        switch (fpfn) { /* f11 & 0x3F */
1387
        case 0x04:
1388
            /* ITOFS */
1389
            if (!(ctx->amask & AMASK_FIX))
1390
                goto invalid_opc;
1391
            if (likely(rc != 31)) {
1392
                if (ra != 31) {
1393
                    TCGv_i32 tmp = tcg_temp_new_i32();
1394
                    tcg_gen_trunc_i64_i32(tmp, cpu_ir[ra]);
1395
                    gen_helper_memory_to_s(cpu_fir[rc], tmp);
1396
                    tcg_temp_free_i32(tmp);
1397
                } else
1398
                    tcg_gen_movi_i64(cpu_fir[rc], 0);
1399
            }
1400
            break;
1401
        case 0x0A:
1402
            /* SQRTF */
1403
            if (!(ctx->amask & AMASK_FIX))
1404
                goto invalid_opc;
1405
            gen_fsqrtf(rb, rc);
1406
            break;
1407
        case 0x0B:
1408
            /* SQRTS */
1409
            if (!(ctx->amask & AMASK_FIX))
1410
                goto invalid_opc;
1411
            gen_fsqrts(rb, rc);
1412
            break;
1413
        case 0x14:
1414
            /* ITOFF */
1415
            if (!(ctx->amask & AMASK_FIX))
1416
                goto invalid_opc;
1417
            if (likely(rc != 31)) {
1418
                if (ra != 31) {
1419
                    TCGv_i32 tmp = tcg_temp_new_i32();
1420
                    tcg_gen_trunc_i64_i32(tmp, cpu_ir[ra]);
1421
                    gen_helper_memory_to_f(cpu_fir[rc], tmp);
1422
                    tcg_temp_free_i32(tmp);
1423
                } else
1424
                    tcg_gen_movi_i64(cpu_fir[rc], 0);
1425
            }
1426
            break;
1427
        case 0x24:
1428
            /* ITOFT */
1429
            if (!(ctx->amask & AMASK_FIX))
1430
                goto invalid_opc;
1431
            if (likely(rc != 31)) {
1432
                if (ra != 31)
1433
                    tcg_gen_mov_i64(cpu_fir[rc], cpu_ir[ra]);
1434
                else
1435
                    tcg_gen_movi_i64(cpu_fir[rc], 0);
1436
            }
1437
            break;
1438
        case 0x2A:
1439
            /* SQRTG */
1440
            if (!(ctx->amask & AMASK_FIX))
1441
                goto invalid_opc;
1442
            gen_fsqrtg(rb, rc);
1443
            break;
1444
        case 0x02B:
1445
            /* SQRTT */
1446
            if (!(ctx->amask & AMASK_FIX))
1447
                goto invalid_opc;
1448
            gen_fsqrtt(rb, rc);
1449
            break;
1450
        default:
1451
            goto invalid_opc;
1452
        }
1453
        break;
1454
    case 0x15:
1455
        /* VAX floating point */
1456
        /* XXX: rounding mode and trap are ignored (!) */
1457
        switch (fpfn) { /* f11 & 0x3F */
1458
        case 0x00:
1459
            /* ADDF */
1460
            gen_faddf(ra, rb, rc);
1461
            break;
1462
        case 0x01:
1463
            /* SUBF */
1464
            gen_fsubf(ra, rb, rc);
1465
            break;
1466
        case 0x02:
1467
            /* MULF */
1468
            gen_fmulf(ra, rb, rc);
1469
            break;
1470
        case 0x03:
1471
            /* DIVF */
1472
            gen_fdivf(ra, rb, rc);
1473
            break;
1474
        case 0x1E:
1475
            /* CVTDG */
1476
#if 0 // TODO
1477
            gen_fcvtdg(rb, rc);
1478
#else
1479
            goto invalid_opc;
1480
#endif
1481
            break;
1482
        case 0x20:
1483
            /* ADDG */
1484
            gen_faddg(ra, rb, rc);
1485
            break;
1486
        case 0x21:
1487
            /* SUBG */
1488
            gen_fsubg(ra, rb, rc);
1489
            break;
1490
        case 0x22:
1491
            /* MULG */
1492
            gen_fmulg(ra, rb, rc);
1493
            break;
1494
        case 0x23:
1495
            /* DIVG */
1496
            gen_fdivg(ra, rb, rc);
1497
            break;
1498
        case 0x25:
1499
            /* CMPGEQ */
1500
            gen_fcmpgeq(ra, rb, rc);
1501
            break;
1502
        case 0x26:
1503
            /* CMPGLT */
1504
            gen_fcmpglt(ra, rb, rc);
1505
            break;
1506
        case 0x27:
1507
            /* CMPGLE */
1508
            gen_fcmpgle(ra, rb, rc);
1509
            break;
1510
        case 0x2C:
1511
            /* CVTGF */
1512
            gen_fcvtgf(rb, rc);
1513
            break;
1514
        case 0x2D:
1515
            /* CVTGD */
1516
#if 0 // TODO
1517
            gen_fcvtgd(rb, rc);
1518
#else
1519
            goto invalid_opc;
1520
#endif
1521
            break;
1522
        case 0x2F:
1523
            /* CVTGQ */
1524
            gen_fcvtgq(rb, rc);
1525
            break;
1526
        case 0x3C:
1527
            /* CVTQF */
1528
            gen_fcvtqf(rb, rc);
1529
            break;
1530
        case 0x3E:
1531
            /* CVTQG */
1532
            gen_fcvtqg(rb, rc);
1533
            break;
1534
        default:
1535
            goto invalid_opc;
1536
        }
1537
        break;
1538
    case 0x16:
1539
        /* IEEE floating-point */
1540
        /* XXX: rounding mode and traps are ignored (!) */
1541
        switch (fpfn) { /* f11 & 0x3F */
1542
        case 0x00:
1543
            /* ADDS */
1544
            gen_fadds(ra, rb, rc);
1545
            break;
1546
        case 0x01:
1547
            /* SUBS */
1548
            gen_fsubs(ra, rb, rc);
1549
            break;
1550
        case 0x02:
1551
            /* MULS */
1552
            gen_fmuls(ra, rb, rc);
1553
            break;
1554
        case 0x03:
1555
            /* DIVS */
1556
            gen_fdivs(ra, rb, rc);
1557
            break;
1558
        case 0x20:
1559
            /* ADDT */
1560
            gen_faddt(ra, rb, rc);
1561
            break;
1562
        case 0x21:
1563
            /* SUBT */
1564
            gen_fsubt(ra, rb, rc);
1565
            break;
1566
        case 0x22:
1567
            /* MULT */
1568
            gen_fmult(ra, rb, rc);
1569
            break;
1570
        case 0x23:
1571
            /* DIVT */
1572
            gen_fdivt(ra, rb, rc);
1573
            break;
1574
        case 0x24:
1575
            /* CMPTUN */
1576
            gen_fcmptun(ra, rb, rc);
1577
            break;
1578
        case 0x25:
1579
            /* CMPTEQ */
1580
            gen_fcmpteq(ra, rb, rc);
1581
            break;
1582
        case 0x26:
1583
            /* CMPTLT */
1584
            gen_fcmptlt(ra, rb, rc);
1585
            break;
1586
        case 0x27:
1587
            /* CMPTLE */
1588
            gen_fcmptle(ra, rb, rc);
1589
            break;
1590
        case 0x2C:
1591
            /* XXX: incorrect */
1592
            if (fn11 == 0x2AC || fn11 == 0x6AC) {
1593
                /* CVTST */
1594
                gen_fcvtst(rb, rc);
1595
            } else {
1596
                /* CVTTS */
1597
                gen_fcvtts(rb, rc);
1598
            }
1599
            break;
1600
        case 0x2F:
1601
            /* CVTTQ */
1602
            gen_fcvttq(rb, rc);
1603
            break;
1604
        case 0x3C:
1605
            /* CVTQS */
1606
            gen_fcvtqs(rb, rc);
1607
            break;
1608
        case 0x3E:
1609
            /* CVTQT */
1610
            gen_fcvtqt(rb, rc);
1611
            break;
1612
        default:
1613
            goto invalid_opc;
1614
        }
1615
        break;
1616
    case 0x17:
1617
        switch (fn11) {
1618
        case 0x010:
1619
            /* CVTLQ */
1620
            gen_fcvtlq(rb, rc);
1621
            break;
1622
        case 0x020:
1623
            if (likely(rc != 31)) {
1624
                if (ra == rb)
1625
                    /* FMOV */
1626
                    tcg_gen_mov_i64(cpu_fir[rc], cpu_fir[ra]);
1627
                else
1628
                    /* CPYS */
1629
                    gen_fcpys(ra, rb, rc);
1630
            }
1631
            break;
1632
        case 0x021:
1633
            /* CPYSN */
1634
            gen_fcpysn(ra, rb, rc);
1635
            break;
1636
        case 0x022:
1637
            /* CPYSE */
1638
            gen_fcpyse(ra, rb, rc);
1639
            break;
1640
        case 0x024:
1641
            /* MT_FPCR */
1642
            if (likely(ra != 31))
1643
                gen_helper_store_fpcr(cpu_fir[ra]);
1644
            else {
1645
                TCGv tmp = tcg_const_i64(0);
1646
                gen_helper_store_fpcr(tmp);
1647
                tcg_temp_free(tmp);
1648
            }
1649
            break;
1650
        case 0x025:
1651
            /* MF_FPCR */
1652
            if (likely(ra != 31))
1653
                gen_helper_load_fpcr(cpu_fir[ra]);
1654
            break;
1655
        case 0x02A:
1656
            /* FCMOVEQ */
1657
            gen_fcmpfeq(ra, rb, rc);
1658
            break;
1659
        case 0x02B:
1660
            /* FCMOVNE */
1661
            gen_fcmpfne(ra, rb, rc);
1662
            break;
1663
        case 0x02C:
1664
            /* FCMOVLT */
1665
            gen_fcmpflt(ra, rb, rc);
1666
            break;
1667
        case 0x02D:
1668
            /* FCMOVGE */
1669
            gen_fcmpfge(ra, rb, rc);
1670
            break;
1671
        case 0x02E:
1672
            /* FCMOVLE */
1673
            gen_fcmpfle(ra, rb, rc);
1674
            break;
1675
        case 0x02F:
1676
            /* FCMOVGT */
1677
            gen_fcmpfgt(ra, rb, rc);
1678
            break;
1679
        case 0x030:
1680
            /* CVTQL */
1681
            gen_fcvtql(rb, rc);
1682
            break;
1683
        case 0x130:
1684
            /* CVTQL/V */
1685
            gen_fcvtqlv(rb, rc);
1686
            break;
1687
        case 0x530:
1688
            /* CVTQL/SV */
1689
            gen_fcvtqlsv(rb, rc);
1690
            break;
1691
        default:
1692
            goto invalid_opc;
1693
        }
1694
        break;
1695
    case 0x18:
1696
        switch ((uint16_t)disp16) {
1697
        case 0x0000:
1698
            /* TRAPB */
1699
            /* No-op. Just exit from the current tb */
1700
            ret = 2;
1701
            break;
1702
        case 0x0400:
1703
            /* EXCB */
1704
            /* No-op. Just exit from the current tb */
1705
            ret = 2;
1706
            break;
1707
        case 0x4000:
1708
            /* MB */
1709
            /* No-op */
1710
            break;
1711
        case 0x4400:
1712
            /* WMB */
1713
            /* No-op */
1714
            break;
1715
        case 0x8000:
1716
            /* FETCH */
1717
            /* No-op */
1718
            break;
1719
        case 0xA000:
1720
            /* FETCH_M */
1721
            /* No-op */
1722
            break;
1723
        case 0xC000:
1724
            /* RPCC */
1725
            if (ra != 31)
1726
                gen_helper_load_pcc(cpu_ir[ra]);
1727
            break;
1728
        case 0xE000:
1729
            /* RC */
1730
            if (ra != 31)
1731
                gen_helper_rc(cpu_ir[ra]);
1732
            break;
1733
        case 0xE800:
1734
            /* ECB */
1735
            break;
1736
        case 0xF000:
1737
            /* RS */
1738
            if (ra != 31)
1739
                gen_helper_rs(cpu_ir[ra]);
1740
            break;
1741
        case 0xF800:
1742
            /* WH64 */
1743
            /* No-op */
1744
            break;
1745
        default:
1746
            goto invalid_opc;
1747
        }
1748
        break;
1749
    case 0x19:
1750
        /* HW_MFPR (PALcode) */
1751
#if defined (CONFIG_USER_ONLY)
1752
        goto invalid_opc;
1753
#else
1754
        if (!ctx->pal_mode)
1755
            goto invalid_opc;
1756
        if (ra != 31) {
1757
            TCGv tmp = tcg_const_i32(insn & 0xFF);
1758
            gen_helper_mfpr(cpu_ir[ra], tmp, cpu_ir[ra]);
1759
            tcg_temp_free(tmp);
1760
        }
1761
        break;
1762
#endif
1763
    case 0x1A:
1764
        if (rb != 31)
1765
            tcg_gen_andi_i64(cpu_pc, cpu_ir[rb], ~3);
1766
        else
1767
            tcg_gen_movi_i64(cpu_pc, 0);
1768
        if (ra != 31)
1769
            tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
1770
        /* Those four jumps only differ by the branch prediction hint */
1771
        switch (fn2) {
1772
        case 0x0:
1773
            /* JMP */
1774
            break;
1775
        case 0x1:
1776
            /* JSR */
1777
            break;
1778
        case 0x2:
1779
            /* RET */
1780
            break;
1781
        case 0x3:
1782
            /* JSR_COROUTINE */
1783
            break;
1784
        }
1785
        ret = 1;
1786
        break;
1787
    case 0x1B:
1788
        /* HW_LD (PALcode) */
1789
#if defined (CONFIG_USER_ONLY)
1790
        goto invalid_opc;
1791
#else
1792
        if (!ctx->pal_mode)
1793
            goto invalid_opc;
1794
        if (ra != 31) {
1795
            TCGv addr = tcg_temp_new();
1796
            if (rb != 31)
1797
                tcg_gen_addi_i64(addr, cpu_ir[rb], disp12);
1798
            else
1799
                tcg_gen_movi_i64(addr, disp12);
1800
            switch ((insn >> 12) & 0xF) {
1801
            case 0x0:
1802
                /* Longword physical access (hw_ldl/p) */
1803
                gen_helper_ldl_raw(cpu_ir[ra], addr);
1804
                break;
1805
            case 0x1:
1806
                /* Quadword physical access (hw_ldq/p) */
1807
                gen_helper_ldq_raw(cpu_ir[ra], addr);
1808
                break;
1809
            case 0x2:
1810
                /* Longword physical access with lock (hw_ldl_l/p) */
1811
                gen_helper_ldl_l_raw(cpu_ir[ra], addr);
1812
                break;
1813
            case 0x3:
1814
                /* Quadword physical access with lock (hw_ldq_l/p) */
1815
                gen_helper_ldq_l_raw(cpu_ir[ra], addr);
1816
                break;
1817
            case 0x4:
1818
                /* Longword virtual PTE fetch (hw_ldl/v) */
1819
                tcg_gen_qemu_ld32s(cpu_ir[ra], addr, 0);
1820
                break;
1821
            case 0x5:
1822
                /* Quadword virtual PTE fetch (hw_ldq/v) */
1823
                tcg_gen_qemu_ld64(cpu_ir[ra], addr, 0);
1824
                break;
1825
            case 0x6:
1826
                /* Incpu_ir[ra]id */
1827
                goto invalid_opc;
1828
            case 0x7:
1829
                /* Incpu_ir[ra]id */
1830
                goto invalid_opc;
1831
            case 0x8:
1832
                /* Longword virtual access (hw_ldl) */
1833
                gen_helper_st_virt_to_phys(addr, addr);
1834
                gen_helper_ldl_raw(cpu_ir[ra], addr);
1835
                break;
1836
            case 0x9:
1837
                /* Quadword virtual access (hw_ldq) */
1838
                gen_helper_st_virt_to_phys(addr, addr);
1839
                gen_helper_ldq_raw(cpu_ir[ra], addr);
1840
                break;
1841
            case 0xA:
1842
                /* Longword virtual access with protection check (hw_ldl/w) */
1843
                tcg_gen_qemu_ld32s(cpu_ir[ra], addr, 0);
1844
                break;
1845
            case 0xB:
1846
                /* Quadword virtual access with protection check (hw_ldq/w) */
1847
                tcg_gen_qemu_ld64(cpu_ir[ra], addr, 0);
1848
                break;
1849
            case 0xC:
1850
                /* Longword virtual access with alt access mode (hw_ldl/a)*/
1851
                gen_helper_set_alt_mode();
1852
                gen_helper_st_virt_to_phys(addr, addr);
1853
                gen_helper_ldl_raw(cpu_ir[ra], addr);
1854
                gen_helper_restore_mode();
1855
                break;
1856
            case 0xD:
1857
                /* Quadword virtual access with alt access mode (hw_ldq/a) */
1858
                gen_helper_set_alt_mode();
1859
                gen_helper_st_virt_to_phys(addr, addr);
1860
                gen_helper_ldq_raw(cpu_ir[ra], addr);
1861
                gen_helper_restore_mode();
1862
                break;
1863
            case 0xE:
1864
                /* Longword virtual access with alternate access mode and
1865
                 * protection checks (hw_ldl/wa)
1866
                 */
1867
                gen_helper_set_alt_mode();
1868
                gen_helper_ldl_data(cpu_ir[ra], addr);
1869
                gen_helper_restore_mode();
1870
                break;
1871
            case 0xF:
1872
                /* Quadword virtual access with alternate access mode and
1873
                 * protection checks (hw_ldq/wa)
1874
                 */
1875
                gen_helper_set_alt_mode();
1876
                gen_helper_ldq_data(cpu_ir[ra], addr);
1877
                gen_helper_restore_mode();
1878
                break;
1879
            }
1880
            tcg_temp_free(addr);
1881
        }
1882
        break;
1883
#endif
1884
    case 0x1C:
1885
        switch (fn7) {
1886
        case 0x00:
1887
            /* SEXTB */
1888
            if (!(ctx->amask & AMASK_BWX))
1889
                goto invalid_opc;
1890
            if (likely(rc != 31)) {
1891
                if (islit)
1892
                    tcg_gen_movi_i64(cpu_ir[rc], (int64_t)((int8_t)lit));
1893
                else
1894
                    tcg_gen_ext8s_i64(cpu_ir[rc], cpu_ir[rb]);
1895
            }
1896
            break;
1897
        case 0x01:
1898
            /* SEXTW */
1899
            if (!(ctx->amask & AMASK_BWX))
1900
                goto invalid_opc;
1901
            if (likely(rc != 31)) {
1902
                if (islit)
1903
                    tcg_gen_movi_i64(cpu_ir[rc], (int64_t)((int16_t)lit));
1904
                else
1905
                    tcg_gen_ext16s_i64(cpu_ir[rc], cpu_ir[rb]);
1906
            }
1907
            break;
1908
        case 0x30:
1909
            /* CTPOP */
1910
            if (!(ctx->amask & AMASK_CIX))
1911
                goto invalid_opc;
1912
            if (likely(rc != 31)) {
1913
                if (islit)
1914
                    tcg_gen_movi_i64(cpu_ir[rc], ctpop64(lit));
1915
                else
1916
                    gen_helper_ctpop(cpu_ir[rc], cpu_ir[rb]);
1917
            }
1918
            break;
1919
        case 0x31:
1920
            /* PERR */
1921
            if (!(ctx->amask & AMASK_MVI))
1922
                goto invalid_opc;
1923
            /* XXX: TODO */
1924
            goto invalid_opc;
1925
            break;
1926
        case 0x32:
1927
            /* CTLZ */
1928
            if (!(ctx->amask & AMASK_CIX))
1929
                goto invalid_opc;
1930
            if (likely(rc != 31)) {
1931
                if (islit)
1932
                    tcg_gen_movi_i64(cpu_ir[rc], clz64(lit));
1933
                else
1934
                    gen_helper_ctlz(cpu_ir[rc], cpu_ir[rb]);
1935
            }
1936
            break;
1937
        case 0x33:
1938
            /* CTTZ */
1939
            if (!(ctx->amask & AMASK_CIX))
1940
                goto invalid_opc;
1941
            if (likely(rc != 31)) {
1942
                if (islit)
1943
                    tcg_gen_movi_i64(cpu_ir[rc], ctz64(lit));
1944
                else
1945
                    gen_helper_cttz(cpu_ir[rc], cpu_ir[rb]);
1946
            }
1947
            break;
1948
        case 0x34:
1949
            /* UNPKBW */
1950
            if (!(ctx->amask & AMASK_MVI))
1951
                goto invalid_opc;
1952
            /* XXX: TODO */
1953
            goto invalid_opc;
1954
            break;
1955
        case 0x35:
1956
            /* UNPKWL */
1957
            if (!(ctx->amask & AMASK_MVI))
1958
                goto invalid_opc;
1959
            /* XXX: TODO */
1960
            goto invalid_opc;
1961
            break;
1962
        case 0x36:
1963
            /* PKWB */
1964
            if (!(ctx->amask & AMASK_MVI))
1965
                goto invalid_opc;
1966
            /* XXX: TODO */
1967
            goto invalid_opc;
1968
            break;
1969
        case 0x37:
1970
            /* PKLB */
1971
            if (!(ctx->amask & AMASK_MVI))
1972
                goto invalid_opc;
1973
            /* XXX: TODO */
1974
            goto invalid_opc;
1975
            break;
1976
        case 0x38:
1977
            /* MINSB8 */
1978
            if (!(ctx->amask & AMASK_MVI))
1979
                goto invalid_opc;
1980
            /* XXX: TODO */
1981
            goto invalid_opc;
1982
            break;
1983
        case 0x39:
1984
            /* MINSW4 */
1985
            if (!(ctx->amask & AMASK_MVI))
1986
                goto invalid_opc;
1987
            /* XXX: TODO */
1988
            goto invalid_opc;
1989
            break;
1990
        case 0x3A:
1991
            /* MINUB8 */
1992
            if (!(ctx->amask & AMASK_MVI))
1993
                goto invalid_opc;
1994
            /* XXX: TODO */
1995
            goto invalid_opc;
1996
            break;
1997
        case 0x3B:
1998
            /* MINUW4 */
1999
            if (!(ctx->amask & AMASK_MVI))
2000
                goto invalid_opc;
2001
            /* XXX: TODO */
2002
            goto invalid_opc;
2003
            break;
2004
        case 0x3C:
2005
            /* MAXUB8 */
2006
            if (!(ctx->amask & AMASK_MVI))
2007
                goto invalid_opc;
2008
            /* XXX: TODO */
2009
            goto invalid_opc;
2010
            break;
2011
        case 0x3D:
2012
            /* MAXUW4 */
2013
            if (!(ctx->amask & AMASK_MVI))
2014
                goto invalid_opc;
2015
            /* XXX: TODO */
2016
            goto invalid_opc;
2017
            break;
2018
        case 0x3E:
2019
            /* MAXSB8 */
2020
            if (!(ctx->amask & AMASK_MVI))
2021
                goto invalid_opc;
2022
            /* XXX: TODO */
2023
            goto invalid_opc;
2024
            break;
2025
        case 0x3F:
2026
            /* MAXSW4 */
2027
            if (!(ctx->amask & AMASK_MVI))
2028
                goto invalid_opc;
2029
            /* XXX: TODO */
2030
            goto invalid_opc;
2031
            break;
2032
        case 0x70:
2033
            /* FTOIT */
2034
            if (!(ctx->amask & AMASK_FIX))
2035
                goto invalid_opc;
2036
            if (likely(rc != 31)) {
2037
                if (ra != 31)
2038
                    tcg_gen_mov_i64(cpu_ir[rc], cpu_fir[ra]);
2039
                else
2040
                    tcg_gen_movi_i64(cpu_ir[rc], 0);
2041
            }
2042
            break;
2043
        case 0x78:
2044
            /* FTOIS */
2045
            if (!(ctx->amask & AMASK_FIX))
2046
                goto invalid_opc;
2047
            if (rc != 31) {
2048
                TCGv_i32 tmp1 = tcg_temp_new_i32();
2049
                if (ra != 31)
2050
                    gen_helper_s_to_memory(tmp1, cpu_fir[ra]);
2051
                else {
2052
                    TCGv tmp2 = tcg_const_i64(0);
2053
                    gen_helper_s_to_memory(tmp1, tmp2);
2054
                    tcg_temp_free(tmp2);
2055
                }
2056
                tcg_gen_ext_i32_i64(cpu_ir[rc], tmp1);
2057
                tcg_temp_free_i32(tmp1);
2058
            }
2059
            break;
2060
        default:
2061
            goto invalid_opc;
2062
        }
2063
        break;
2064
    case 0x1D:
2065
        /* HW_MTPR (PALcode) */
2066
#if defined (CONFIG_USER_ONLY)
2067
        goto invalid_opc;
2068
#else
2069
        if (!ctx->pal_mode)
2070
            goto invalid_opc;
2071
        else {
2072
            TCGv tmp1 = tcg_const_i32(insn & 0xFF);
2073
            if (ra != 31)
2074
                gen_helper_mtpr(tmp1, cpu_ir[ra]);
2075
            else {
2076
                TCGv tmp2 = tcg_const_i64(0);
2077
                gen_helper_mtpr(tmp1, tmp2);
2078
                tcg_temp_free(tmp2);
2079
            }
2080
            tcg_temp_free(tmp1);
2081
            ret = 2;
2082
        }
2083
        break;
2084
#endif
2085
    case 0x1E:
2086
        /* HW_REI (PALcode) */
2087
#if defined (CONFIG_USER_ONLY)
2088
        goto invalid_opc;
2089
#else
2090
        if (!ctx->pal_mode)
2091
            goto invalid_opc;
2092
        if (rb == 31) {
2093
            /* "Old" alpha */
2094
            gen_helper_hw_rei();
2095
        } else {
2096
            TCGv tmp;
2097

    
2098
            if (ra != 31) {
2099
                tmp = tcg_temp_new();
2100
                tcg_gen_addi_i64(tmp, cpu_ir[rb], (((int64_t)insn << 51) >> 51));
2101
            } else
2102
                tmp = tcg_const_i64(((int64_t)insn << 51) >> 51);
2103
            gen_helper_hw_ret(tmp);
2104
            tcg_temp_free(tmp);
2105
        }
2106
        ret = 2;
2107
        break;
2108
#endif
2109
    case 0x1F:
2110
        /* HW_ST (PALcode) */
2111
#if defined (CONFIG_USER_ONLY)
2112
        goto invalid_opc;
2113
#else
2114
        if (!ctx->pal_mode)
2115
            goto invalid_opc;
2116
        else {
2117
            TCGv addr, val;
2118
            addr = tcg_temp_new();
2119
            if (rb != 31)
2120
                tcg_gen_addi_i64(addr, cpu_ir[rb], disp12);
2121
            else
2122
                tcg_gen_movi_i64(addr, disp12);
2123
            if (ra != 31)
2124
                val = cpu_ir[ra];
2125
            else {
2126
                val = tcg_temp_new();
2127
                tcg_gen_movi_i64(val, 0);
2128
            }
2129
            switch ((insn >> 12) & 0xF) {
2130
            case 0x0:
2131
                /* Longword physical access */
2132
                gen_helper_stl_raw(val, addr);
2133
                break;
2134
            case 0x1:
2135
                /* Quadword physical access */
2136
                gen_helper_stq_raw(val, addr);
2137
                break;
2138
            case 0x2:
2139
                /* Longword physical access with lock */
2140
                gen_helper_stl_c_raw(val, val, addr);
2141
                break;
2142
            case 0x3:
2143
                /* Quadword physical access with lock */
2144
                gen_helper_stq_c_raw(val, val, addr);
2145
                break;
2146
            case 0x4:
2147
                /* Longword virtual access */
2148
                gen_helper_st_virt_to_phys(addr, addr);
2149
                gen_helper_stl_raw(val, addr);
2150
                break;
2151
            case 0x5:
2152
                /* Quadword virtual access */
2153
                gen_helper_st_virt_to_phys(addr, addr);
2154
                gen_helper_stq_raw(val, addr);
2155
                break;
2156
            case 0x6:
2157
                /* Invalid */
2158
                goto invalid_opc;
2159
            case 0x7:
2160
                /* Invalid */
2161
                goto invalid_opc;
2162
            case 0x8:
2163
                /* Invalid */
2164
                goto invalid_opc;
2165
            case 0x9:
2166
                /* Invalid */
2167
                goto invalid_opc;
2168
            case 0xA:
2169
                /* Invalid */
2170
                goto invalid_opc;
2171
            case 0xB:
2172
                /* Invalid */
2173
                goto invalid_opc;
2174
            case 0xC:
2175
                /* Longword virtual access with alternate access mode */
2176
                gen_helper_set_alt_mode();
2177
                gen_helper_st_virt_to_phys(addr, addr);
2178
                gen_helper_stl_raw(val, addr);
2179
                gen_helper_restore_mode();
2180
                break;
2181
            case 0xD:
2182
                /* Quadword virtual access with alternate access mode */
2183
                gen_helper_set_alt_mode();
2184
                gen_helper_st_virt_to_phys(addr, addr);
2185
                gen_helper_stl_raw(val, addr);
2186
                gen_helper_restore_mode();
2187
                break;
2188
            case 0xE:
2189
                /* Invalid */
2190
                goto invalid_opc;
2191
            case 0xF:
2192
                /* Invalid */
2193
                goto invalid_opc;
2194
            }
2195
            if (ra == 31)
2196
                tcg_temp_free(val);
2197
            tcg_temp_free(addr);
2198
        }
2199
        break;
2200
#endif
2201
    case 0x20:
2202
        /* LDF */
2203
        gen_load_mem(ctx, &gen_qemu_ldf, ra, rb, disp16, 1, 0);
2204
        break;
2205
    case 0x21:
2206
        /* LDG */
2207
        gen_load_mem(ctx, &gen_qemu_ldg, ra, rb, disp16, 1, 0);
2208
        break;
2209
    case 0x22:
2210
        /* LDS */
2211
        gen_load_mem(ctx, &gen_qemu_lds, ra, rb, disp16, 1, 0);
2212
        break;
2213
    case 0x23:
2214
        /* LDT */
2215
        gen_load_mem(ctx, &tcg_gen_qemu_ld64, ra, rb, disp16, 1, 0);
2216
        break;
2217
    case 0x24:
2218
        /* STF */
2219
        gen_store_mem(ctx, &gen_qemu_stf, ra, rb, disp16, 1, 0, 0);
2220
        break;
2221
    case 0x25:
2222
        /* STG */
2223
        gen_store_mem(ctx, &gen_qemu_stg, ra, rb, disp16, 1, 0, 0);
2224
        break;
2225
    case 0x26:
2226
        /* STS */
2227
        gen_store_mem(ctx, &gen_qemu_sts, ra, rb, disp16, 1, 0, 0);
2228
        break;
2229
    case 0x27:
2230
        /* STT */
2231
        gen_store_mem(ctx, &tcg_gen_qemu_st64, ra, rb, disp16, 1, 0, 0);
2232
        break;
2233
    case 0x28:
2234
        /* LDL */
2235
        gen_load_mem(ctx, &tcg_gen_qemu_ld32s, ra, rb, disp16, 0, 0);
2236
        break;
2237
    case 0x29:
2238
        /* LDQ */
2239
        gen_load_mem(ctx, &tcg_gen_qemu_ld64, ra, rb, disp16, 0, 0);
2240
        break;
2241
    case 0x2A:
2242
        /* LDL_L */
2243
        gen_load_mem(ctx, &gen_qemu_ldl_l, ra, rb, disp16, 0, 0);
2244
        break;
2245
    case 0x2B:
2246
        /* LDQ_L */
2247
        gen_load_mem(ctx, &gen_qemu_ldq_l, ra, rb, disp16, 0, 0);
2248
        break;
2249
    case 0x2C:
2250
        /* STL */
2251
        gen_store_mem(ctx, &tcg_gen_qemu_st32, ra, rb, disp16, 0, 0, 0);
2252
        break;
2253
    case 0x2D:
2254
        /* STQ */
2255
        gen_store_mem(ctx, &tcg_gen_qemu_st64, ra, rb, disp16, 0, 0, 0);
2256
        break;
2257
    case 0x2E:
2258
        /* STL_C */
2259
        gen_store_mem(ctx, &gen_qemu_stl_c, ra, rb, disp16, 0, 0, 1);
2260
        break;
2261
    case 0x2F:
2262
        /* STQ_C */
2263
        gen_store_mem(ctx, &gen_qemu_stq_c, ra, rb, disp16, 0, 0, 1);
2264
        break;
2265
    case 0x30:
2266
        /* BR */
2267
        if (ra != 31)
2268
            tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
2269
        tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp21 << 2));
2270
        ret = 1;
2271
        break;
2272
    case 0x31: /* FBEQ */
2273
    case 0x32: /* FBLT */
2274
    case 0x33: /* FBLE */
2275
        gen_fbcond(ctx, opc, ra, disp16);
2276
        ret = 1;
2277
        break;
2278
    case 0x34:
2279
        /* BSR */
2280
        if (ra != 31)
2281
            tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
2282
        tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp21 << 2));
2283
        ret = 1;
2284
        break;
2285
    case 0x35: /* FBNE */
2286
    case 0x36: /* FBGE */
2287
    case 0x37: /* FBGT */
2288
        gen_fbcond(ctx, opc, ra, disp16);
2289
        ret = 1;
2290
        break;
2291
    case 0x38:
2292
        /* BLBC */
2293
        gen_bcond(ctx, TCG_COND_EQ, ra, disp21, 1);
2294
        ret = 1;
2295
        break;
2296
    case 0x39:
2297
        /* BEQ */
2298
        gen_bcond(ctx, TCG_COND_EQ, ra, disp21, 0);
2299
        ret = 1;
2300
        break;
2301
    case 0x3A:
2302
        /* BLT */
2303
        gen_bcond(ctx, TCG_COND_LT, ra, disp21, 0);
2304
        ret = 1;
2305
        break;
2306
    case 0x3B:
2307
        /* BLE */
2308
        gen_bcond(ctx, TCG_COND_LE, ra, disp21, 0);
2309
        ret = 1;
2310
        break;
2311
    case 0x3C:
2312
        /* BLBS */
2313
        gen_bcond(ctx, TCG_COND_NE, ra, disp21, 1);
2314
        ret = 1;
2315
        break;
2316
    case 0x3D:
2317
        /* BNE */
2318
        gen_bcond(ctx, TCG_COND_NE, ra, disp21, 0);
2319
        ret = 1;
2320
        break;
2321
    case 0x3E:
2322
        /* BGE */
2323
        gen_bcond(ctx, TCG_COND_GE, ra, disp21, 0);
2324
        ret = 1;
2325
        break;
2326
    case 0x3F:
2327
        /* BGT */
2328
        gen_bcond(ctx, TCG_COND_GT, ra, disp21, 0);
2329
        ret = 1;
2330
        break;
2331
    invalid_opc:
2332
        gen_invalid(ctx);
2333
        ret = 3;
2334
        break;
2335
    }
2336

    
2337
    return ret;
2338
}
2339

    
2340
static always_inline void gen_intermediate_code_internal (CPUState *env,
2341
                                                          TranslationBlock *tb,
2342
                                                          int search_pc)
2343
{
2344
#if defined ALPHA_DEBUG_DISAS
2345
    static int insn_count;
2346
#endif
2347
    DisasContext ctx, *ctxp = &ctx;
2348
    target_ulong pc_start;
2349
    uint32_t insn;
2350
    uint16_t *gen_opc_end;
2351
    CPUBreakpoint *bp;
2352
    int j, lj = -1;
2353
    int ret;
2354
    int num_insns;
2355
    int max_insns;
2356

    
2357
    pc_start = tb->pc;
2358
    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
2359
    ctx.pc = pc_start;
2360
    ctx.amask = env->amask;
2361
    ctx.env = env;
2362
#if defined (CONFIG_USER_ONLY)
2363
    ctx.mem_idx = 0;
2364
#else
2365
    ctx.mem_idx = ((env->ps >> 3) & 3);
2366
    ctx.pal_mode = env->ipr[IPR_EXC_ADDR] & 1;
2367
#endif
2368
    num_insns = 0;
2369
    max_insns = tb->cflags & CF_COUNT_MASK;
2370
    if (max_insns == 0)
2371
        max_insns = CF_COUNT_MASK;
2372

    
2373
    gen_icount_start();
2374
    for (ret = 0; ret == 0;) {
2375
        if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) {
2376
            TAILQ_FOREACH(bp, &env->breakpoints, entry) {
2377
                if (bp->pc == ctx.pc) {
2378
                    gen_excp(&ctx, EXCP_DEBUG, 0);
2379
                    break;
2380
                }
2381
            }
2382
        }
2383
        if (search_pc) {
2384
            j = gen_opc_ptr - gen_opc_buf;
2385
            if (lj < j) {
2386
                lj++;
2387
                while (lj < j)
2388
                    gen_opc_instr_start[lj++] = 0;
2389
            }
2390
            gen_opc_pc[lj] = ctx.pc;
2391
            gen_opc_instr_start[lj] = 1;
2392
            gen_opc_icount[lj] = num_insns;
2393
        }
2394
        if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
2395
            gen_io_start();
2396
#if defined ALPHA_DEBUG_DISAS
2397
        insn_count++;
2398
        LOG_DISAS("pc " TARGET_FMT_lx " mem_idx %d\n",
2399
                  ctx.pc, ctx.mem_idx);
2400
#endif
2401
        insn = ldl_code(ctx.pc);
2402
#if defined ALPHA_DEBUG_DISAS
2403
        insn_count++;
2404
        LOG_DISAS("opcode %08x %d\n", insn, insn_count);
2405
#endif
2406
        num_insns++;
2407
        ctx.pc += 4;
2408
        ret = translate_one(ctxp, insn);
2409
        if (ret != 0)
2410
            break;
2411
        /* if we reach a page boundary or are single stepping, stop
2412
         * generation
2413
         */
2414
        if (env->singlestep_enabled) {
2415
            gen_excp(&ctx, EXCP_DEBUG, 0);
2416
            break;
2417
        }
2418

    
2419
        if ((ctx.pc & (TARGET_PAGE_SIZE - 1)) == 0)
2420
            break;
2421

    
2422
        if (gen_opc_ptr >= gen_opc_end)
2423
            break;
2424

    
2425
        if (num_insns >= max_insns)
2426
            break;
2427

    
2428
        if (singlestep) {
2429
            break;
2430
        }
2431
    }
2432
    if (ret != 1 && ret != 3) {
2433
        tcg_gen_movi_i64(cpu_pc, ctx.pc);
2434
    }
2435
#if defined (DO_TB_FLUSH)
2436
    gen_helper_tb_flush();
2437
#endif
2438
    if (tb->cflags & CF_LAST_IO)
2439
        gen_io_end();
2440
    /* Generate the return instruction */
2441
    tcg_gen_exit_tb(0);
2442
    gen_icount_end(tb, num_insns);
2443
    *gen_opc_ptr = INDEX_op_end;
2444
    if (search_pc) {
2445
        j = gen_opc_ptr - gen_opc_buf;
2446
        lj++;
2447
        while (lj <= j)
2448
            gen_opc_instr_start[lj++] = 0;
2449
    } else {
2450
        tb->size = ctx.pc - pc_start;
2451
        tb->icount = num_insns;
2452
    }
2453
#if defined ALPHA_DEBUG_DISAS
2454
    log_cpu_state_mask(CPU_LOG_TB_CPU, env, 0);
2455
    if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
2456
        qemu_log("IN: %s\n", lookup_symbol(pc_start));
2457
        log_target_disas(pc_start, ctx.pc - pc_start, 1);
2458
        qemu_log("\n");
2459
    }
2460
#endif
2461
}
2462

    
2463
void gen_intermediate_code (CPUState *env, struct TranslationBlock *tb)
2464
{
2465
    gen_intermediate_code_internal(env, tb, 0);
2466
}
2467

    
2468
void gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
2469
{
2470
    gen_intermediate_code_internal(env, tb, 1);
2471
}
2472

    
2473
CPUAlphaState * cpu_alpha_init (const char *cpu_model)
2474
{
2475
    CPUAlphaState *env;
2476
    uint64_t hwpcb;
2477

    
2478
    env = qemu_mallocz(sizeof(CPUAlphaState));
2479
    cpu_exec_init(env);
2480
    alpha_translate_init();
2481
    tlb_flush(env, 1);
2482
    /* XXX: should not be hardcoded */
2483
    env->implver = IMPLVER_2106x;
2484
    env->ps = 0x1F00;
2485
#if defined (CONFIG_USER_ONLY)
2486
    env->ps |= 1 << 3;
2487
#endif
2488
    pal_init(env);
2489
    /* Initialize IPR */
2490
    hwpcb = env->ipr[IPR_PCBB];
2491
    env->ipr[IPR_ASN] = 0;
2492
    env->ipr[IPR_ASTEN] = 0;
2493
    env->ipr[IPR_ASTSR] = 0;
2494
    env->ipr[IPR_DATFX] = 0;
2495
    /* XXX: fix this */
2496
    //    env->ipr[IPR_ESP] = ldq_raw(hwpcb + 8);
2497
    //    env->ipr[IPR_KSP] = ldq_raw(hwpcb + 0);
2498
    //    env->ipr[IPR_SSP] = ldq_raw(hwpcb + 16);
2499
    //    env->ipr[IPR_USP] = ldq_raw(hwpcb + 24);
2500
    env->ipr[IPR_FEN] = 0;
2501
    env->ipr[IPR_IPL] = 31;
2502
    env->ipr[IPR_MCES] = 0;
2503
    env->ipr[IPR_PERFMON] = 0; /* Implementation specific */
2504
    //    env->ipr[IPR_PTBR] = ldq_raw(hwpcb + 32);
2505
    env->ipr[IPR_SISR] = 0;
2506
    env->ipr[IPR_VIRBND] = -1ULL;
2507

    
2508
    return env;
2509
}
2510

    
2511
void gen_pc_load(CPUState *env, TranslationBlock *tb,
2512
                unsigned long searched_pc, int pc_pos, void *puc)
2513
{
2514
    env->pc = gen_opc_pc[pc_pos];
2515
}