← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to target-sh4/op_helper.c

  • Committer: ths
  • Date: 2007-10-08 12:45:38 UTC
  • Revision ID: git-v1:450d4ff553af32fc9d83fef20d7106b0151526b8
CRIS disassembler, originally from binutils, by Edgar E. Iglesias.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3356 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-sh4/op_helper.c
20
20
#include <assert.h>
21
21
#include "exec.h"
22
22
 
 
23
void do_raise_exception(void)
 
24
{
 
25
    cpu_loop_exit();
 
26
}
 
27
 
23
28
#ifndef CONFIG_USER_ONLY
24
29
 
25
30
#define MMUSUFFIX _mmu
 
31
#define GETPC() (__builtin_return_address(0))
26
32
 
27
33
#define SHIFT 0
28
34
#include "softmmu_template.h"
36
42
#define SHIFT 3
37
43
#include "softmmu_template.h"
38
44
 
39
 
void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 
45
void tlb_fill(target_ulong addr, int is_write, int is_user, void *retaddr)
40
46
{
41
47
    TranslationBlock *tb;
42
48
    CPUState *saved_env;
47
53
       generated code */
48
54
    saved_env = env;
49
55
    env = cpu_single_env;
50
 
    ret = cpu_sh4_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
 
56
    ret = cpu_sh4_handle_mmu_fault(env, addr, is_write, is_user, 1);
51
57
    if (ret) {
52
58
        if (retaddr) {
53
59
            /* now we have a real cpu fault */
59
65
                cpu_restore_state(tb, env, pc, NULL);
60
66
            }
61
67
        }
62
 
        cpu_loop_exit();
 
68
        do_raise_exception();
63
69
    }
64
70
    env = saved_env;
65
71
}
66
72
 
67
73
#endif
68
74
 
69
 
void helper_ldtlb(void)
70
 
{
71
 
#ifdef CONFIG_USER_ONLY
72
 
    /* XXXXX */
73
 
    assert(0);
74
 
#else
75
 
    cpu_load_tlb(env);
76
 
#endif
77
 
}
78
 
 
79
 
void helper_raise_illegal_instruction(void)
80
 
{
81
 
    env->exception_index = 0x180;
82
 
    cpu_loop_exit();
83
 
}
84
 
 
85
 
void helper_raise_slot_illegal_instruction(void)
86
 
{
87
 
    env->exception_index = 0x1a0;
88
 
    cpu_loop_exit();
89
 
}
90
 
 
91
 
void helper_debug(void)
92
 
{
93
 
    env->exception_index = EXCP_DEBUG;
94
 
    cpu_loop_exit();
95
 
}
96
 
 
97
 
void helper_sleep(uint32_t next_pc)
98
 
{
99
 
    env->halted = 1;
100
 
    env->exception_index = EXCP_HLT;
101
 
    env->pc = next_pc;
102
 
    cpu_loop_exit();
103
 
}
104
 
 
105
 
void helper_trapa(uint32_t tra)
106
 
{
107
 
    env->tra = tra << 2;
108
 
    env->exception_index = 0x160;
109
 
    cpu_loop_exit();
110
 
}
111
 
 
112
 
uint32_t helper_addc(uint32_t arg0, uint32_t arg1)
 
75
void helper_addc_T0_T1(void)
113
76
{
114
77
    uint32_t tmp0, tmp1;
115
78
 
116
 
    tmp1 = arg0 + arg1;
117
 
    tmp0 = arg1;
118
 
    arg1 = tmp1 + (env->sr & 1);
 
79
    tmp1 = T0 + T1;
 
80
    tmp0 = T1;
 
81
    T1 = tmp1 + (env->sr & 1);
119
82
    if (tmp0 > tmp1)
120
83
        env->sr |= SR_T;
121
84
    else
122
85
        env->sr &= ~SR_T;
123
 
    if (tmp1 > arg1)
 
86
    if (tmp1 > T1)
124
87
        env->sr |= SR_T;
125
 
    return arg1;
126
88
}
127
89
 
128
 
uint32_t helper_addv(uint32_t arg0, uint32_t arg1)
 
90
void helper_addv_T0_T1(void)
129
91
{
130
92
    uint32_t dest, src, ans;
131
93
 
132
 
    if ((int32_t) arg1 >= 0)
 
94
    if ((int32_t) T1 >= 0)
133
95
        dest = 0;
134
96
    else
135
97
        dest = 1;
136
 
    if ((int32_t) arg0 >= 0)
 
98
    if ((int32_t) T0 >= 0)
137
99
        src = 0;
138
100
    else
139
101
        src = 1;
140
102
    src += dest;
141
 
    arg1 += arg0;
142
 
    if ((int32_t) arg1 >= 0)
 
103
    T1 += T0;
 
104
    if ((int32_t) T1 >= 0)
143
105
        ans = 0;
144
106
    else
145
107
        ans = 1;
151
113
            env->sr &= ~SR_T;
152
114
    } else
153
115
        env->sr &= ~SR_T;
154
 
    return arg1;
155
116
}
156
117
 
157
118
#define T (env->sr & SR_T)
164
125
#define SETM env->sr |= SR_M
165
126
#define CLRM env->sr &= ~SR_M
166
127
 
167
 
uint32_t helper_div1(uint32_t arg0, uint32_t arg1)
 
128
void helper_div1_T0_T1(void)
168
129
{
169
130
    uint32_t tmp0, tmp2;
170
131
    uint8_t old_q, tmp1 = 0xff;
171
132
 
172
 
    //printf("div1 arg0=0x%08x arg1=0x%08x M=%d Q=%d T=%d\n", arg0, arg1, M, Q, T);
 
133
    //printf("div1 T0=0x%08x T1=0x%08x M=%d Q=%d T=%d\n", T0, T1, M, Q, T);
173
134
    old_q = Q;
174
 
    if ((0x80000000 & arg1) != 0)
 
135
    if ((0x80000000 & T1) != 0)
175
136
        SETQ;
176
137
    else
177
138
        CLRQ;
178
 
    tmp2 = arg0;
179
 
    arg1 <<= 1;
180
 
    arg1 |= T;
 
139
    tmp2 = T0;
 
140
    T1 <<= 1;
 
141
    T1 |= T;
181
142
    switch (old_q) {
182
143
    case 0:
183
144
        switch (M) {
184
145
        case 0:
185
 
            tmp0 = arg1;
186
 
            arg1 -= tmp2;
187
 
            tmp1 = arg1 > tmp0;
 
146
            tmp0 = T1;
 
147
            T1 -= tmp2;
 
148
            tmp1 = T1 > tmp0;
188
149
            switch (Q) {
189
150
            case 0:
190
151
                if (tmp1)
201
162
            }
202
163
            break;
203
164
        case 1:
204
 
            tmp0 = arg1;
205
 
            arg1 += tmp2;
206
 
            tmp1 = arg1 < tmp0;
 
165
            tmp0 = T1;
 
166
            T1 += tmp2;
 
167
            tmp1 = T1 < tmp0;
207
168
            switch (Q) {
208
169
            case 0:
209
170
                if (tmp1 == 0)
224
185
    case 1:
225
186
        switch (M) {
226
187
        case 0:
227
 
            tmp0 = arg1;
228
 
            arg1 += tmp2;
229
 
            tmp1 = arg1 < tmp0;
 
188
            tmp0 = T1;
 
189
            T1 += tmp2;
 
190
            tmp1 = T1 < tmp0;
230
191
            switch (Q) {
231
192
            case 0:
232
193
                if (tmp1)
243
204
            }
244
205
            break;
245
206
        case 1:
246
 
            tmp0 = arg1;
247
 
            arg1 -= tmp2;
248
 
            tmp1 = arg1 > tmp0;
 
207
            tmp0 = T1;
 
208
            T1 -= tmp2;
 
209
            tmp1 = T1 > tmp0;
249
210
            switch (Q) {
250
211
            case 0:
251
212
                if (tmp1 == 0)
268
229
        SETT;
269
230
    else
270
231
        CLRT;
271
 
    //printf("Output: arg1=0x%08x M=%d Q=%d T=%d\n", arg1, M, Q, T);
272
 
    return arg1;
273
 
}
274
 
 
275
 
void helper_macl(uint32_t arg0, uint32_t arg1)
 
232
    //printf("Output: T1=0x%08x M=%d Q=%d T=%d\n", T1, M, Q, T);
 
233
}
 
234
 
 
235
void helper_dmulsl_T0_T1()
 
236
{
 
237
    int64_t res;
 
238
 
 
239
    res = (int64_t) (int32_t) T0 *(int64_t) (int32_t) T1;
 
240
    env->mach = (res >> 32) & 0xffffffff;
 
241
    env->macl = res & 0xffffffff;
 
242
}
 
243
 
 
244
void helper_dmulul_T0_T1()
 
245
{
 
246
    uint64_t res;
 
247
 
 
248
    res = (uint64_t) (uint32_t) T0 *(uint64_t) (uint32_t) T1;
 
249
    env->mach = (res >> 32) & 0xffffffff;
 
250
    env->macl = res & 0xffffffff;
 
251
}
 
252
 
 
253
void helper_macl_T0_T1()
276
254
{
277
255
    int64_t res;
278
256
 
279
257
    res = ((uint64_t) env->mach << 32) | env->macl;
280
 
    res += (int64_t) (int32_t) arg0 *(int64_t) (int32_t) arg1;
 
258
    res += (int64_t) (int32_t) T0 *(int64_t) (int32_t) T1;
281
259
    env->mach = (res >> 32) & 0xffffffff;
282
260
    env->macl = res & 0xffffffff;
283
261
    if (env->sr & SR_S) {
288
266
    }
289
267
}
290
268
 
291
 
void helper_macw(uint32_t arg0, uint32_t arg1)
 
269
void helper_macw_T0_T1()
292
270
{
293
271
    int64_t res;
294
272
 
295
273
    res = ((uint64_t) env->mach << 32) | env->macl;
296
 
    res += (int64_t) (int16_t) arg0 *(int64_t) (int16_t) arg1;
 
274
    res += (int64_t) (int16_t) T0 *(int64_t) (int16_t) T1;
297
275
    env->mach = (res >> 32) & 0xffffffff;
298
276
    env->macl = res & 0xffffffff;
299
277
    if (env->sr & SR_S) {
307
285
    }
308
286
}
309
287
 
310
 
uint32_t helper_negc(uint32_t arg)
 
288
void helper_negc_T0()
311
289
{
312
290
    uint32_t temp;
313
291
 
314
 
    temp = -arg;
315
 
    arg = temp - (env->sr & SR_T);
 
292
    temp = -T0;
 
293
    T0 = temp - (env->sr & SR_T);
316
294
    if (0 < temp)
317
295
        env->sr |= SR_T;
318
296
    else
319
297
        env->sr &= ~SR_T;
320
 
    if (temp < arg)
 
298
    if (temp < T0)
321
299
        env->sr |= SR_T;
322
 
    return arg;
323
300
}
324
301
 
325
 
uint32_t helper_subc(uint32_t arg0, uint32_t arg1)
 
302
void helper_subc_T0_T1()
326
303
{
327
304
    uint32_t tmp0, tmp1;
328
305
 
329
 
    tmp1 = arg1 - arg0;
330
 
    tmp0 = arg1;
331
 
    arg1 = tmp1 - (env->sr & SR_T);
 
306
    tmp1 = T1 - T0;
 
307
    tmp0 = T1;
 
308
    T1 = tmp1 - (env->sr & SR_T);
332
309
    if (tmp0 < tmp1)
333
310
        env->sr |= SR_T;
334
311
    else
335
312
        env->sr &= ~SR_T;
336
 
    if (tmp1 < arg1)
 
313
    if (tmp1 < T1)
337
314
        env->sr |= SR_T;
338
 
    return arg1;
339
315
}
340
316
 
341
 
uint32_t helper_subv(uint32_t arg0, uint32_t arg1)
 
317
void helper_subv_T0_T1()
342
318
{
343
319
    int32_t dest, src, ans;
344
320
 
345
 
    if ((int32_t) arg1 >= 0)
 
321
    if ((int32_t) T1 >= 0)
346
322
        dest = 0;
347
323
    else
348
324
        dest = 1;
349
 
    if ((int32_t) arg0 >= 0)
 
325
    if ((int32_t) T0 >= 0)
350
326
        src = 0;
351
327
    else
352
328
        src = 1;
353
329
    src += dest;
354
 
    arg1 -= arg0;
355
 
    if ((int32_t) arg1 >= 0)
 
330
    T1 -= T0;
 
331
    if ((int32_t) T1 >= 0)
356
332
        ans = 0;
357
333
    else
358
334
        ans = 1;
364
340
            env->sr &= ~SR_T;
365
341
    } else
366
342
        env->sr &= ~SR_T;
367
 
    return arg1;
368
 
}
369
 
 
370
 
static inline void set_t(void)
371
 
{
372
 
    env->sr |= SR_T;
373
 
}
374
 
 
375
 
static inline void clr_t(void)
376
 
{
377
 
    env->sr &= ~SR_T;
378
 
}
379
 
 
380
 
void helper_ld_fpscr(uint32_t val)
381
 
{
382
 
    env->fpscr = val & 0x003fffff;
383
 
    if (val & 0x01)
384
 
        set_float_rounding_mode(float_round_to_zero, &env->fp_status);
385
 
    else
386
 
        set_float_rounding_mode(float_round_nearest_even, &env->fp_status);
387
 
}
388
 
 
389
 
uint32_t helper_fabs_FT(uint32_t t0)
390
 
{
391
 
    float32 ret = float32_abs(*(float32*)&t0);
392
 
    return *(uint32_t*)(&ret);
393
 
}
394
 
 
395
 
uint64_t helper_fabs_DT(uint64_t t0)
396
 
{
397
 
    float64 ret = float64_abs(*(float64*)&t0);
398
 
    return *(uint64_t*)(&ret);
399
 
}
400
 
 
401
 
uint32_t helper_fadd_FT(uint32_t t0, uint32_t t1)
402
 
{
403
 
    float32 ret = float32_add(*(float32*)&t0, *(float32*)&t1, &env->fp_status);
404
 
    return *(uint32_t*)(&ret);
405
 
}
406
 
 
407
 
uint64_t helper_fadd_DT(uint64_t t0, uint64_t t1)
408
 
{
409
 
    float64 ret = float64_add(*(float64*)&t0, *(float64*)&t1, &env->fp_status);
410
 
    return *(uint64_t*)(&ret);
411
 
}
412
 
 
413
 
void helper_fcmp_eq_FT(uint32_t t0, uint32_t t1)
414
 
{
415
 
    if (float32_compare(*(float32*)&t0, *(float32*)&t1, &env->fp_status) == 0)
416
 
        set_t();
417
 
    else
418
 
        clr_t();
419
 
}
420
 
 
421
 
void helper_fcmp_eq_DT(uint64_t t0, uint64_t t1)
422
 
{
423
 
    if (float64_compare(*(float64*)&t0, *(float64*)&t1, &env->fp_status) == 0)
424
 
        set_t();
425
 
    else
426
 
        clr_t();
427
 
}
428
 
 
429
 
void helper_fcmp_gt_FT(uint32_t t0, uint32_t t1)
430
 
{
431
 
    if (float32_compare(*(float32*)&t0, *(float32*)&t1, &env->fp_status) == 1)
432
 
        set_t();
433
 
    else
434
 
        clr_t();
435
 
}
436
 
 
437
 
void helper_fcmp_gt_DT(uint64_t t0, uint64_t t1)
438
 
{
439
 
    if (float64_compare(*(float64*)&t0, *(float64*)&t1, &env->fp_status) == 1)
440
 
        set_t();
441
 
    else
442
 
        clr_t();
443
 
}
444
 
 
445
 
uint64_t helper_fcnvsd_FT_DT(uint32_t t0)
446
 
{
447
 
    float64 ret = float32_to_float64(*(float32*)&t0, &env->fp_status);
448
 
    return *(uint64_t*)(&ret);
449
 
}
450
 
 
451
 
uint32_t helper_fcnvds_DT_FT(uint64_t t0)
452
 
{
453
 
    float32 ret = float64_to_float32(*(float64*)&t0, &env->fp_status);
454
 
    return *(uint32_t*)(&ret);
455
 
}
456
 
 
457
 
uint32_t helper_fdiv_FT(uint32_t t0, uint32_t t1)
458
 
{
459
 
    float32 ret = float32_div(*(float32*)&t0, *(float32*)&t1, &env->fp_status);
460
 
    return *(uint32_t*)(&ret);
461
 
}
462
 
 
463
 
uint64_t helper_fdiv_DT(uint64_t t0, uint64_t t1)
464
 
{
465
 
    float64 ret = float64_div(*(float64*)&t0, *(float64*)&t1, &env->fp_status);
466
 
    return *(uint64_t*)(&ret);
467
 
}
468
 
 
469
 
uint32_t helper_float_FT(uint32_t t0)
470
 
{
471
 
    float32 ret = int32_to_float32(t0, &env->fp_status);
472
 
    return *(uint32_t*)(&ret);
473
 
}
474
 
 
475
 
uint64_t helper_float_DT(uint32_t t0)
476
 
{
477
 
    float64 ret = int32_to_float64(t0, &env->fp_status);
478
 
    return *(uint64_t*)(&ret);
479
 
}
480
 
 
481
 
uint32_t helper_fmul_FT(uint32_t t0, uint32_t t1)
482
 
{
483
 
    float32 ret = float32_mul(*(float32*)&t0, *(float32*)&t1, &env->fp_status);
484
 
    return *(uint32_t*)(&ret);
485
 
}
486
 
 
487
 
uint64_t helper_fmul_DT(uint64_t t0, uint64_t t1)
488
 
{
489
 
    float64 ret = float64_mul(*(float64*)&t0, *(float64*)&t1, &env->fp_status);
490
 
    return *(uint64_t*)(&ret);
491
 
}
492
 
 
493
 
uint32_t helper_fneg_T(uint32_t t0)
494
 
{
495
 
    float32 ret = float32_chs(*(float32*)&t0);
496
 
    return *(uint32_t*)(&ret);
497
 
}
498
 
 
499
 
uint32_t helper_fsqrt_FT(uint32_t t0)
500
 
{
501
 
    float32 ret = float32_sqrt(*(float32*)&t0, &env->fp_status);
502
 
    return *(uint32_t*)(&ret);
503
 
}
504
 
 
505
 
uint64_t helper_fsqrt_DT(uint64_t t0)
506
 
{
507
 
    float64 ret = float64_sqrt(*(float64*)&t0, &env->fp_status);
508
 
    return *(uint64_t*)(&ret);
509
 
}
510
 
 
511
 
uint32_t helper_fsub_FT(uint32_t t0, uint32_t t1)
512
 
{
513
 
    float32 ret = float32_sub(*(float32*)&t0, *(float32*)&t1, &env->fp_status);
514
 
    return *(uint32_t*)(&ret);
515
 
}
516
 
 
517
 
uint64_t helper_fsub_DT(uint64_t t0, uint64_t t1)
518
 
{
519
 
    float64 ret = float64_sub(*(float64*)&t0, *(float64*)&t1, &env->fp_status);
520
 
    return *(uint64_t*)(&ret);
521
 
}
522
 
 
523
 
uint32_t helper_ftrc_FT(uint32_t t0)
524
 
{
525
 
    return float32_to_int32_round_to_zero(*(float32*)&t0, &env->fp_status);
526
 
}
527
 
 
528
 
uint32_t helper_ftrc_DT(uint64_t t0)
529
 
{
530
 
    return float64_to_int32_round_to_zero(*(float64*)&t0, &env->fp_status);
 
343
}
 
344
 
 
345
void helper_rotcl(uint32_t * addr)
 
346
{
 
347
    uint32_t new;
 
348
 
 
349
    new = (*addr << 1) | (env->sr & SR_T);
 
350
    if (*addr & 0x80000000)
 
351
        env->sr |= SR_T;
 
352
    else
 
353
        env->sr &= ~SR_T;
 
354
    *addr = new;
 
355
}
 
356
 
 
357
void helper_rotcr(uint32_t * addr)
 
358
{
 
359
    uint32_t new;
 
360
 
 
361
    new = (*addr >> 1) | ((env->sr & SR_T) ? 0x80000000 : 0);
 
362
    if (*addr & 1)
 
363
        env->sr |= SR_T;
 
364
    else
 
365
        env->sr &= ~SR_T;
 
366
    *addr = new;
531
367
}