← Back to branch summary

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

« back to all changes in this revision

Viewing changes to target-sh4/op_helper.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-sh4/op_helper.c
15
15
 *
16
16
 * You should have received a copy of the GNU Lesser General Public
17
17
 * License along with this library; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA  02110-1301 USA
19
19
 */
20
20
#include <assert.h>
21
21
#include "exec.h"
22
 
 
23
 
void do_raise_exception(void)
24
 
{
25
 
    cpu_loop_exit();
26
 
}
 
22
#include "helper.h"
27
23
 
28
24
#ifndef CONFIG_USER_ONLY
29
25
 
30
26
#define MMUSUFFIX _mmu
31
 
#ifdef __s390__
32
 
# define GETPC() ((void*)((unsigned long)__builtin_return_address(0) & 0x7fffffffUL))
33
 
#else
34
 
# define GETPC() (__builtin_return_address(0))
35
 
#endif
36
27
 
37
28
#define SHIFT 0
38
29
#include "softmmu_template.h"
69
60
                cpu_restore_state(tb, env, pc, NULL);
70
61
            }
71
62
        }
72
 
        do_raise_exception();
 
63
        cpu_loop_exit();
73
64
    }
74
65
    env = saved_env;
75
66
}
76
67
 
77
68
#endif
78
69
 
79
 
void helper_addc_T0_T1(void)
 
70
void helper_ldtlb(void)
 
71
{
 
72
#ifdef CONFIG_USER_ONLY
 
73
    /* XXXXX */
 
74
    assert(0);
 
75
#else
 
76
    cpu_load_tlb(env);
 
77
#endif
 
78
}
 
79
 
 
80
void helper_raise_illegal_instruction(void)
 
81
{
 
82
    env->exception_index = 0x180;
 
83
    cpu_loop_exit();
 
84
}
 
85
 
 
86
void helper_raise_slot_illegal_instruction(void)
 
87
{
 
88
    env->exception_index = 0x1a0;
 
89
    cpu_loop_exit();
 
90
}
 
91
 
 
92
void helper_raise_fpu_disable(void)
 
93
{
 
94
  env->exception_index = 0x800;
 
95
  cpu_loop_exit();
 
96
}
 
97
 
 
98
void helper_raise_slot_fpu_disable(void)
 
99
{
 
100
  env->exception_index = 0x820;
 
101
  cpu_loop_exit();
 
102
}
 
103
 
 
104
void helper_debug(void)
 
105
{
 
106
    env->exception_index = EXCP_DEBUG;
 
107
    cpu_loop_exit();
 
108
}
 
109
 
 
110
void helper_sleep(uint32_t next_pc)
 
111
{
 
112
    env->halted = 1;
 
113
    env->exception_index = EXCP_HLT;
 
114
    env->pc = next_pc;
 
115
    cpu_loop_exit();
 
116
}
 
117
 
 
118
void helper_trapa(uint32_t tra)
 
119
{
 
120
    env->tra = tra << 2;
 
121
    env->exception_index = 0x160;
 
122
    cpu_loop_exit();
 
123
}
 
124
 
 
125
uint32_t helper_addc(uint32_t arg0, uint32_t arg1)
80
126
{
81
127
    uint32_t tmp0, tmp1;
82
128
 
83
 
    tmp1 = T0 + T1;
84
 
    tmp0 = T1;
85
 
    T1 = tmp1 + (env->sr & 1);
 
129
    tmp1 = arg0 + arg1;
 
130
    tmp0 = arg1;
 
131
    arg1 = tmp1 + (env->sr & 1);
86
132
    if (tmp0 > tmp1)
87
133
        env->sr |= SR_T;
88
134
    else
89
135
        env->sr &= ~SR_T;
90
 
    if (tmp1 > T1)
 
136
    if (tmp1 > arg1)
91
137
        env->sr |= SR_T;
 
138
    return arg1;
92
139
}
93
140
 
94
 
void helper_addv_T0_T1(void)
 
141
uint32_t helper_addv(uint32_t arg0, uint32_t arg1)
95
142
{
96
143
    uint32_t dest, src, ans;
97
144
 
98
 
    if ((int32_t) T1 >= 0)
 
145
    if ((int32_t) arg1 >= 0)
99
146
        dest = 0;
100
147
    else
101
148
        dest = 1;
102
 
    if ((int32_t) T0 >= 0)
 
149
    if ((int32_t) arg0 >= 0)
103
150
        src = 0;
104
151
    else
105
152
        src = 1;
106
153
    src += dest;
107
 
    T1 += T0;
108
 
    if ((int32_t) T1 >= 0)
 
154
    arg1 += arg0;
 
155
    if ((int32_t) arg1 >= 0)
109
156
        ans = 0;
110
157
    else
111
158
        ans = 1;
117
164
            env->sr &= ~SR_T;
118
165
    } else
119
166
        env->sr &= ~SR_T;
 
167
    return arg1;
120
168
}
121
169
 
122
170
#define T (env->sr & SR_T)
129
177
#define SETM env->sr |= SR_M
130
178
#define CLRM env->sr &= ~SR_M
131
179
 
132
 
void helper_div1_T0_T1(void)
 
180
uint32_t helper_div1(uint32_t arg0, uint32_t arg1)
133
181
{
134
182
    uint32_t tmp0, tmp2;
135
183
    uint8_t old_q, tmp1 = 0xff;
136
184
 
137
 
    //printf("div1 T0=0x%08x T1=0x%08x M=%d Q=%d T=%d\n", T0, T1, M, Q, T);
 
185
    //printf("div1 arg0=0x%08x arg1=0x%08x M=%d Q=%d T=%d\n", arg0, arg1, M, Q, T);
138
186
    old_q = Q;
139
 
    if ((0x80000000 & T1) != 0)
 
187
    if ((0x80000000 & arg1) != 0)
140
188
        SETQ;
141
189
    else
142
190
        CLRQ;
143
 
    tmp2 = T0;
144
 
    T1 <<= 1;
145
 
    T1 |= T;
 
191
    tmp2 = arg0;
 
192
    arg1 <<= 1;
 
193
    arg1 |= T;
146
194
    switch (old_q) {
147
195
    case 0:
148
196
        switch (M) {
149
197
        case 0:
150
 
            tmp0 = T1;
151
 
            T1 -= tmp2;
152
 
            tmp1 = T1 > tmp0;
 
198
            tmp0 = arg1;
 
199
            arg1 -= tmp2;
 
200
            tmp1 = arg1 > tmp0;
153
201
            switch (Q) {
154
202
            case 0:
155
203
                if (tmp1)
166
214
            }
167
215
            break;
168
216
        case 1:
169
 
            tmp0 = T1;
170
 
            T1 += tmp2;
171
 
            tmp1 = T1 < tmp0;
 
217
            tmp0 = arg1;
 
218
            arg1 += tmp2;
 
219
            tmp1 = arg1 < tmp0;
172
220
            switch (Q) {
173
221
            case 0:
174
222
                if (tmp1 == 0)
189
237
    case 1:
190
238
        switch (M) {
191
239
        case 0:
192
 
            tmp0 = T1;
193
 
            T1 += tmp2;
194
 
            tmp1 = T1 < tmp0;
 
240
            tmp0 = arg1;
 
241
            arg1 += tmp2;
 
242
            tmp1 = arg1 < tmp0;
195
243
            switch (Q) {
196
244
            case 0:
197
245
                if (tmp1)
208
256
            }
209
257
            break;
210
258
        case 1:
211
 
            tmp0 = T1;
212
 
            T1 -= tmp2;
213
 
            tmp1 = T1 > tmp0;
 
259
            tmp0 = arg1;
 
260
            arg1 -= tmp2;
 
261
            tmp1 = arg1 > tmp0;
214
262
            switch (Q) {
215
263
            case 0:
216
264
                if (tmp1 == 0)
233
281
        SETT;
234
282
    else
235
283
        CLRT;
236
 
    //printf("Output: T1=0x%08x M=%d Q=%d T=%d\n", T1, M, Q, T);
237
 
}
238
 
 
239
 
void helper_dmulsl_T0_T1()
240
 
{
241
 
    int64_t res;
242
 
 
243
 
    res = (int64_t) (int32_t) T0 *(int64_t) (int32_t) T1;
244
 
    env->mach = (res >> 32) & 0xffffffff;
245
 
    env->macl = res & 0xffffffff;
246
 
}
247
 
 
248
 
void helper_dmulul_T0_T1()
249
 
{
250
 
    uint64_t res;
251
 
 
252
 
    res = (uint64_t) (uint32_t) T0 *(uint64_t) (uint32_t) T1;
253
 
    env->mach = (res >> 32) & 0xffffffff;
254
 
    env->macl = res & 0xffffffff;
255
 
}
256
 
 
257
 
void helper_macl_T0_T1()
 
284
    //printf("Output: arg1=0x%08x M=%d Q=%d T=%d\n", arg1, M, Q, T);
 
285
    return arg1;
 
286
}
 
287
 
 
288
void helper_macl(uint32_t arg0, uint32_t arg1)
258
289
{
259
290
    int64_t res;
260
291
 
261
292
    res = ((uint64_t) env->mach << 32) | env->macl;
262
 
    res += (int64_t) (int32_t) T0 *(int64_t) (int32_t) T1;
 
293
    res += (int64_t) (int32_t) arg0 *(int64_t) (int32_t) arg1;
263
294
    env->mach = (res >> 32) & 0xffffffff;
264
295
    env->macl = res & 0xffffffff;
265
296
    if (env->sr & SR_S) {
270
301
    }
271
302
}
272
303
 
273
 
void helper_macw_T0_T1()
 
304
void helper_macw(uint32_t arg0, uint32_t arg1)
274
305
{
275
306
    int64_t res;
276
307
 
277
308
    res = ((uint64_t) env->mach << 32) | env->macl;
278
 
    res += (int64_t) (int16_t) T0 *(int64_t) (int16_t) T1;
 
309
    res += (int64_t) (int16_t) arg0 *(int64_t) (int16_t) arg1;
279
310
    env->mach = (res >> 32) & 0xffffffff;
280
311
    env->macl = res & 0xffffffff;
281
312
    if (env->sr & SR_S) {
289
320
    }
290
321
}
291
322
 
292
 
void helper_negc_T0()
 
323
uint32_t helper_negc(uint32_t arg)
293
324
{
294
325
    uint32_t temp;
295
326
 
296
 
    temp = -T0;
297
 
    T0 = temp - (env->sr & SR_T);
 
327
    temp = -arg;
 
328
    arg = temp - (env->sr & SR_T);
298
329
    if (0 < temp)
299
330
        env->sr |= SR_T;
300
331
    else
301
332
        env->sr &= ~SR_T;
302
 
    if (temp < T0)
 
333
    if (temp < arg)
303
334
        env->sr |= SR_T;
 
335
    return arg;
304
336
}
305
337
 
306
 
void helper_subc_T0_T1()
 
338
uint32_t helper_subc(uint32_t arg0, uint32_t arg1)
307
339
{
308
340
    uint32_t tmp0, tmp1;
309
341
 
310
 
    tmp1 = T1 - T0;
311
 
    tmp0 = T1;
312
 
    T1 = tmp1 - (env->sr & SR_T);
 
342
    tmp1 = arg1 - arg0;
 
343
    tmp0 = arg1;
 
344
    arg1 = tmp1 - (env->sr & SR_T);
313
345
    if (tmp0 < tmp1)
314
346
        env->sr |= SR_T;
315
347
    else
316
348
        env->sr &= ~SR_T;
317
 
    if (tmp1 < T1)
 
349
    if (tmp1 < arg1)
318
350
        env->sr |= SR_T;
 
351
    return arg1;
319
352
}
320
353
 
321
 
void helper_subv_T0_T1()
 
354
uint32_t helper_subv(uint32_t arg0, uint32_t arg1)
322
355
{
323
356
    int32_t dest, src, ans;
324
357
 
325
 
    if ((int32_t) T1 >= 0)
 
358
    if ((int32_t) arg1 >= 0)
326
359
        dest = 0;
327
360
    else
328
361
        dest = 1;
329
 
    if ((int32_t) T0 >= 0)
 
362
    if ((int32_t) arg0 >= 0)
330
363
        src = 0;
331
364
    else
332
365
        src = 1;
333
366
    src += dest;
334
 
    T1 -= T0;
335
 
    if ((int32_t) T1 >= 0)
 
367
    arg1 -= arg0;
 
368
    if ((int32_t) arg1 >= 0)
336
369
        ans = 0;
337
370
    else
338
371
        ans = 1;
344
377
            env->sr &= ~SR_T;
345
378
    } else
346
379
        env->sr &= ~SR_T;
347
 
}
348
 
 
349
 
void helper_rotcl(uint32_t * addr)
350
 
{
351
 
    uint32_t new;
352
 
 
353
 
    new = (*addr << 1) | (env->sr & SR_T);
354
 
    if (*addr & 0x80000000)
355
 
        env->sr |= SR_T;
356
 
    else
357
 
        env->sr &= ~SR_T;
358
 
    *addr = new;
359
 
}
360
 
 
361
 
void helper_rotcr(uint32_t * addr)
362
 
{
363
 
    uint32_t new;
364
 
 
365
 
    new = (*addr >> 1) | ((env->sr & SR_T) ? 0x80000000 : 0);
366
 
    if (*addr & 1)
367
 
        env->sr |= SR_T;
368
 
    else
369
 
        env->sr &= ~SR_T;
370
 
    *addr = new;
 
380
    return arg1;
 
381
}
 
382
 
 
383
static inline void set_t(void)
 
384
{
 
385
    env->sr |= SR_T;
 
386
}
 
387
 
 
388
static inline void clr_t(void)
 
389
{
 
390
    env->sr &= ~SR_T;
 
391
}
 
392
 
 
393
void helper_ld_fpscr(uint32_t val)
 
394
{
 
395
    env->fpscr = val & 0x003fffff;
 
396
    if (val & 0x01)
 
397
        set_float_rounding_mode(float_round_to_zero, &env->fp_status);
 
398
    else
 
399
        set_float_rounding_mode(float_round_nearest_even, &env->fp_status);
 
400
}
 
401
 
 
402
uint32_t helper_fabs_FT(uint32_t t0)
 
403
{
 
404
    CPU_FloatU f;
 
405
    f.l = t0;
 
406
    f.f = float32_abs(f.f);
 
407
    return f.l;
 
408
}
 
409
 
 
410
uint64_t helper_fabs_DT(uint64_t t0)
 
411
{
 
412
    CPU_DoubleU d;
 
413
    d.ll = t0;
 
414
    d.d = float64_abs(d.d);
 
415
    return d.ll;
 
416
}
 
417
 
 
418
uint32_t helper_fadd_FT(uint32_t t0, uint32_t t1)
 
419
{
 
420
    CPU_FloatU f0, f1;
 
421
    f0.l = t0;
 
422
    f1.l = t1;
 
423
    f0.f = float32_add(f0.f, f1.f, &env->fp_status);
 
424
    return f0.l;
 
425
}
 
426
 
 
427
uint64_t helper_fadd_DT(uint64_t t0, uint64_t t1)
 
428
{
 
429
    CPU_DoubleU d0, d1;
 
430
    d0.ll = t0;
 
431
    d1.ll = t1;
 
432
    d0.d = float64_add(d0.d, d1.d, &env->fp_status);
 
433
    return d0.ll;
 
434
}
 
435
 
 
436
void helper_fcmp_eq_FT(uint32_t t0, uint32_t t1)
 
437
{
 
438
    CPU_FloatU f0, f1;
 
439
    f0.l = t0;
 
440
    f1.l = t1;
 
441
 
 
442
    if (float32_compare(f0.f, f1.f, &env->fp_status) == 0)
 
443
        set_t();
 
444
    else
 
445
        clr_t();
 
446
}
 
447
 
 
448
void helper_fcmp_eq_DT(uint64_t t0, uint64_t t1)
 
449
{
 
450
    CPU_DoubleU d0, d1;
 
451
    d0.ll = t0;
 
452
    d1.ll = t1;
 
453
 
 
454
    if (float64_compare(d0.d, d1.d, &env->fp_status) == 0)
 
455
        set_t();
 
456
    else
 
457
        clr_t();
 
458
}
 
459
 
 
460
void helper_fcmp_gt_FT(uint32_t t0, uint32_t t1)
 
461
{
 
462
    CPU_FloatU f0, f1;
 
463
    f0.l = t0;
 
464
    f1.l = t1;
 
465
 
 
466
    if (float32_compare(f0.f, f1.f, &env->fp_status) == 1)
 
467
        set_t();
 
468
    else
 
469
        clr_t();
 
470
}
 
471
 
 
472
void helper_fcmp_gt_DT(uint64_t t0, uint64_t t1)
 
473
{
 
474
    CPU_DoubleU d0, d1;
 
475
    d0.ll = t0;
 
476
    d1.ll = t1;
 
477
 
 
478
    if (float64_compare(d0.d, d1.d, &env->fp_status) == 1)
 
479
        set_t();
 
480
    else
 
481
        clr_t();
 
482
}
 
483
 
 
484
uint64_t helper_fcnvsd_FT_DT(uint32_t t0)
 
485
{
 
486
    CPU_DoubleU d;
 
487
    CPU_FloatU f;
 
488
    f.l = t0;
 
489
    d.d = float32_to_float64(f.f, &env->fp_status);
 
490
    return d.ll;
 
491
}
 
492
 
 
493
uint32_t helper_fcnvds_DT_FT(uint64_t t0)
 
494
{
 
495
    CPU_DoubleU d;
 
496
    CPU_FloatU f;
 
497
    d.ll = t0;
 
498
    f.f = float64_to_float32(d.d, &env->fp_status);
 
499
    return f.l;
 
500
}
 
501
 
 
502
uint32_t helper_fdiv_FT(uint32_t t0, uint32_t t1)
 
503
{
 
504
    CPU_FloatU f0, f1;
 
505
    f0.l = t0;
 
506
    f1.l = t1;
 
507
    f0.f = float32_div(f0.f, f1.f, &env->fp_status);
 
508
    return f0.l;
 
509
}
 
510
 
 
511
uint64_t helper_fdiv_DT(uint64_t t0, uint64_t t1)
 
512
{
 
513
    CPU_DoubleU d0, d1;
 
514
    d0.ll = t0;
 
515
    d1.ll = t1;
 
516
    d0.d = float64_div(d0.d, d1.d, &env->fp_status);
 
517
    return d0.ll;
 
518
}
 
519
 
 
520
uint32_t helper_float_FT(uint32_t t0)
 
521
{
 
522
    CPU_FloatU f;
 
523
    f.f = int32_to_float32(t0, &env->fp_status);
 
524
    return f.l;
 
525
}
 
526
 
 
527
uint64_t helper_float_DT(uint32_t t0)
 
528
{
 
529
    CPU_DoubleU d;
 
530
    d.d = int32_to_float64(t0, &env->fp_status);
 
531
    return d.ll;
 
532
}
 
533
 
 
534
uint32_t helper_fmac_FT(uint32_t t0, uint32_t t1, uint32_t t2)
 
535
{
 
536
    CPU_FloatU f0, f1, f2;
 
537
    f0.l = t0;
 
538
    f1.l = t1;
 
539
    f2.l = t2;
 
540
    f0.f = float32_mul(f0.f, f1.f, &env->fp_status);
 
541
    f0.f = float32_add(f0.f, f2.f, &env->fp_status);
 
542
    return f0.l;
 
543
}
 
544
 
 
545
uint32_t helper_fmul_FT(uint32_t t0, uint32_t t1)
 
546
{
 
547
    CPU_FloatU f0, f1;
 
548
    f0.l = t0;
 
549
    f1.l = t1;
 
550
    f0.f = float32_mul(f0.f, f1.f, &env->fp_status);
 
551
    return f0.l;
 
552
}
 
553
 
 
554
uint64_t helper_fmul_DT(uint64_t t0, uint64_t t1)
 
555
{
 
556
    CPU_DoubleU d0, d1;
 
557
    d0.ll = t0;
 
558
    d1.ll = t1;
 
559
    d0.d = float64_mul(d0.d, d1.d, &env->fp_status);
 
560
    return d0.ll;
 
561
}
 
562
 
 
563
uint32_t helper_fneg_T(uint32_t t0)
 
564
{
 
565
    CPU_FloatU f;
 
566
    f.l = t0;
 
567
    f.f = float32_chs(f.f);
 
568
    return f.l;
 
569
}
 
570
 
 
571
uint32_t helper_fsqrt_FT(uint32_t t0)
 
572
{
 
573
    CPU_FloatU f;
 
574
    f.l = t0;
 
575
    f.f = float32_sqrt(f.f, &env->fp_status);
 
576
    return f.l;
 
577
}
 
578
 
 
579
uint64_t helper_fsqrt_DT(uint64_t t0)
 
580
{
 
581
    CPU_DoubleU d;
 
582
    d.ll = t0;
 
583
    d.d = float64_sqrt(d.d, &env->fp_status);
 
584
    return d.ll;
 
585
}
 
586
 
 
587
uint32_t helper_fsub_FT(uint32_t t0, uint32_t t1)
 
588
{
 
589
    CPU_FloatU f0, f1;
 
590
    f0.l = t0;
 
591
    f1.l = t1;
 
592
    f0.f = float32_sub(f0.f, f1.f, &env->fp_status);
 
593
    return f0.l;
 
594
}
 
595
 
 
596
uint64_t helper_fsub_DT(uint64_t t0, uint64_t t1)
 
597
{
 
598
    CPU_DoubleU d0, d1;
 
599
    d0.ll = t0;
 
600
    d1.ll = t1;
 
601
    d0.d = float64_sub(d0.d, d1.d, &env->fp_status);
 
602
    return d0.ll;
 
603
}
 
604
 
 
605
uint32_t helper_ftrc_FT(uint32_t t0)
 
606
{
 
607
    CPU_FloatU f;
 
608
    f.l = t0;
 
609
    return float32_to_int32_round_to_zero(f.f, &env->fp_status);
 
610
}
 
611
 
 
612
uint32_t helper_ftrc_DT(uint64_t t0)
 
613
{
 
614
    CPU_DoubleU d;
 
615
    d.ll = t0;
 
616
    return float64_to_int32_round_to_zero(d.d, &env->fp_status);
371
617
}