← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to target-sparc/op.c

  • Committer: ths
  • Date: 2007-05-05 19:24:38 UTC
  • Revision ID: git-v1:608e8ce280cee231b3de0e7922060efd23447a54
Linker scripts for MIPS hosts.


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

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-sparc/op.c
 
1
/*
 
2
   SPARC micro operations
 
3
 
 
4
   Copyright (C) 2003 Thomas M. Ogrisegg <tom@fnord.at>
 
5
 
 
6
   This library is free software; you can redistribute it and/or
 
7
   modify it under the terms of the GNU Lesser General Public
 
8
   License as published by the Free Software Foundation; either
 
9
   version 2 of the License, or (at your option) any later version.
 
10
 
 
11
   This library is distributed in the hope that it will be useful,
 
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
   Lesser General Public License for more details.
 
15
 
 
16
   You should have received a copy of the GNU Lesser General Public
 
17
   License along with this library; if not, write to the Free Software
 
18
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
*/
 
20
 
 
21
#include "exec.h"
 
22
 
 
23
 /*XXX*/
 
24
#define REGNAME g0
 
25
#define REG (env->gregs[0])
 
26
#include "op_template.h"
 
27
#define REGNAME g1
 
28
#define REG (env->gregs[1])
 
29
#include "op_template.h"
 
30
#define REGNAME g2
 
31
#define REG (env->gregs[2])
 
32
#include "op_template.h"
 
33
#define REGNAME g3
 
34
#define REG (env->gregs[3])
 
35
#include "op_template.h"
 
36
#define REGNAME g4
 
37
#define REG (env->gregs[4])
 
38
#include "op_template.h"
 
39
#define REGNAME g5
 
40
#define REG (env->gregs[5])
 
41
#include "op_template.h"
 
42
#define REGNAME g6
 
43
#define REG (env->gregs[6])
 
44
#include "op_template.h"
 
45
#define REGNAME g7
 
46
#define REG (env->gregs[7])
 
47
#include "op_template.h"
 
48
#define REGNAME i0
 
49
#define REG (REGWPTR[16])
 
50
#include "op_template.h"
 
51
#define REGNAME i1
 
52
#define REG (REGWPTR[17])
 
53
#include "op_template.h"
 
54
#define REGNAME i2
 
55
#define REG (REGWPTR[18])
 
56
#include "op_template.h"
 
57
#define REGNAME i3
 
58
#define REG (REGWPTR[19])
 
59
#include "op_template.h"
 
60
#define REGNAME i4
 
61
#define REG (REGWPTR[20])
 
62
#include "op_template.h"
 
63
#define REGNAME i5
 
64
#define REG (REGWPTR[21])
 
65
#include "op_template.h"
 
66
#define REGNAME i6
 
67
#define REG (REGWPTR[22])
 
68
#include "op_template.h"
 
69
#define REGNAME i7
 
70
#define REG (REGWPTR[23])
 
71
#include "op_template.h"
 
72
#define REGNAME l0
 
73
#define REG (REGWPTR[8])
 
74
#include "op_template.h"
 
75
#define REGNAME l1
 
76
#define REG (REGWPTR[9])
 
77
#include "op_template.h"
 
78
#define REGNAME l2
 
79
#define REG (REGWPTR[10])
 
80
#include "op_template.h"
 
81
#define REGNAME l3
 
82
#define REG (REGWPTR[11])
 
83
#include "op_template.h"
 
84
#define REGNAME l4
 
85
#define REG (REGWPTR[12])
 
86
#include "op_template.h"
 
87
#define REGNAME l5
 
88
#define REG (REGWPTR[13])
 
89
#include "op_template.h"
 
90
#define REGNAME l6
 
91
#define REG (REGWPTR[14])
 
92
#include "op_template.h"
 
93
#define REGNAME l7
 
94
#define REG (REGWPTR[15])
 
95
#include "op_template.h"
 
96
#define REGNAME o0
 
97
#define REG (REGWPTR[0])
 
98
#include "op_template.h"
 
99
#define REGNAME o1
 
100
#define REG (REGWPTR[1])
 
101
#include "op_template.h"
 
102
#define REGNAME o2
 
103
#define REG (REGWPTR[2])
 
104
#include "op_template.h"
 
105
#define REGNAME o3
 
106
#define REG (REGWPTR[3])
 
107
#include "op_template.h"
 
108
#define REGNAME o4
 
109
#define REG (REGWPTR[4])
 
110
#include "op_template.h"
 
111
#define REGNAME o5
 
112
#define REG (REGWPTR[5])
 
113
#include "op_template.h"
 
114
#define REGNAME o6
 
115
#define REG (REGWPTR[6])
 
116
#include "op_template.h"
 
117
#define REGNAME o7
 
118
#define REG (REGWPTR[7])
 
119
#include "op_template.h"
 
120
 
 
121
#define REGNAME f0
 
122
#define REG (env->fpr[0])
 
123
#include "fop_template.h"
 
124
#define REGNAME f1
 
125
#define REG (env->fpr[1])
 
126
#include "fop_template.h"
 
127
#define REGNAME f2
 
128
#define REG (env->fpr[2])
 
129
#include "fop_template.h"
 
130
#define REGNAME f3
 
131
#define REG (env->fpr[3])
 
132
#include "fop_template.h"
 
133
#define REGNAME f4
 
134
#define REG (env->fpr[4])
 
135
#include "fop_template.h"
 
136
#define REGNAME f5
 
137
#define REG (env->fpr[5])
 
138
#include "fop_template.h"
 
139
#define REGNAME f6
 
140
#define REG (env->fpr[6])
 
141
#include "fop_template.h"
 
142
#define REGNAME f7
 
143
#define REG (env->fpr[7])
 
144
#include "fop_template.h"
 
145
#define REGNAME f8
 
146
#define REG (env->fpr[8])
 
147
#include "fop_template.h"
 
148
#define REGNAME f9
 
149
#define REG (env->fpr[9])
 
150
#include "fop_template.h"
 
151
#define REGNAME f10
 
152
#define REG (env->fpr[10])
 
153
#include "fop_template.h"
 
154
#define REGNAME f11
 
155
#define REG (env->fpr[11])
 
156
#include "fop_template.h"
 
157
#define REGNAME f12
 
158
#define REG (env->fpr[12])
 
159
#include "fop_template.h"
 
160
#define REGNAME f13
 
161
#define REG (env->fpr[13])
 
162
#include "fop_template.h"
 
163
#define REGNAME f14
 
164
#define REG (env->fpr[14])
 
165
#include "fop_template.h"
 
166
#define REGNAME f15
 
167
#define REG (env->fpr[15])
 
168
#include "fop_template.h"
 
169
#define REGNAME f16
 
170
#define REG (env->fpr[16])
 
171
#include "fop_template.h"
 
172
#define REGNAME f17
 
173
#define REG (env->fpr[17])
 
174
#include "fop_template.h"
 
175
#define REGNAME f18
 
176
#define REG (env->fpr[18])
 
177
#include "fop_template.h"
 
178
#define REGNAME f19
 
179
#define REG (env->fpr[19])
 
180
#include "fop_template.h"
 
181
#define REGNAME f20
 
182
#define REG (env->fpr[20])
 
183
#include "fop_template.h"
 
184
#define REGNAME f21
 
185
#define REG (env->fpr[21])
 
186
#include "fop_template.h"
 
187
#define REGNAME f22
 
188
#define REG (env->fpr[22])
 
189
#include "fop_template.h"
 
190
#define REGNAME f23
 
191
#define REG (env->fpr[23])
 
192
#include "fop_template.h"
 
193
#define REGNAME f24
 
194
#define REG (env->fpr[24])
 
195
#include "fop_template.h"
 
196
#define REGNAME f25
 
197
#define REG (env->fpr[25])
 
198
#include "fop_template.h"
 
199
#define REGNAME f26
 
200
#define REG (env->fpr[26])
 
201
#include "fop_template.h"
 
202
#define REGNAME f27
 
203
#define REG (env->fpr[27])
 
204
#include "fop_template.h"
 
205
#define REGNAME f28
 
206
#define REG (env->fpr[28])
 
207
#include "fop_template.h"
 
208
#define REGNAME f29
 
209
#define REG (env->fpr[29])
 
210
#include "fop_template.h"
 
211
#define REGNAME f30
 
212
#define REG (env->fpr[30])
 
213
#include "fop_template.h"
 
214
#define REGNAME f31
 
215
#define REG (env->fpr[31])
 
216
#include "fop_template.h"
 
217
 
 
218
#ifdef TARGET_SPARC64
 
219
#define REGNAME f32
 
220
#define REG (env->fpr[32])
 
221
#include "fop_template.h"
 
222
#define REGNAME f34
 
223
#define REG (env->fpr[34])
 
224
#include "fop_template.h"
 
225
#define REGNAME f36
 
226
#define REG (env->fpr[36])
 
227
#include "fop_template.h"
 
228
#define REGNAME f38
 
229
#define REG (env->fpr[38])
 
230
#include "fop_template.h"
 
231
#define REGNAME f40
 
232
#define REG (env->fpr[40])
 
233
#include "fop_template.h"
 
234
#define REGNAME f42
 
235
#define REG (env->fpr[42])
 
236
#include "fop_template.h"
 
237
#define REGNAME f44
 
238
#define REG (env->fpr[44])
 
239
#include "fop_template.h"
 
240
#define REGNAME f46
 
241
#define REG (env->fpr[46])
 
242
#include "fop_template.h"
 
243
#define REGNAME f48
 
244
#define REG (env->fpr[47])
 
245
#include "fop_template.h"
 
246
#define REGNAME f50
 
247
#define REG (env->fpr[50])
 
248
#include "fop_template.h"
 
249
#define REGNAME f52
 
250
#define REG (env->fpr[52])
 
251
#include "fop_template.h"
 
252
#define REGNAME f54
 
253
#define REG (env->fpr[54])
 
254
#include "fop_template.h"
 
255
#define REGNAME f56
 
256
#define REG (env->fpr[56])
 
257
#include "fop_template.h"
 
258
#define REGNAME f58
 
259
#define REG (env->fpr[58])
 
260
#include "fop_template.h"
 
261
#define REGNAME f60
 
262
#define REG (env->fpr[60])
 
263
#include "fop_template.h"
 
264
#define REGNAME f62
 
265
#define REG (env->fpr[62])
 
266
#include "fop_template.h"
 
267
#endif
 
268
 
 
269
#ifdef TARGET_SPARC64
 
270
#ifdef WORDS_BIGENDIAN
 
271
typedef union UREG64 {
 
272
    struct { uint16_t v3, v2, v1, v0; } w;
 
273
    struct { uint32_t v1, v0; } l;
 
274
    uint64_t q;
 
275
} UREG64;
 
276
#else
 
277
typedef union UREG64 {
 
278
    struct { uint16_t v0, v1, v2, v3; } w;
 
279
    struct { uint32_t v0, v1; } l;
 
280
    uint64_t q;
 
281
} UREG64;
 
282
#endif
 
283
 
 
284
#define PARAMQ1 \
 
285
({\
 
286
    UREG64 __p;\
 
287
    __p.l.v1 = PARAM1;\
 
288
    __p.l.v0 = PARAM2;\
 
289
    __p.q;\
 
290
}) 
 
291
 
 
292
void OPPROTO op_movq_T0_im64(void)
 
293
{
 
294
    T0 = PARAMQ1;
 
295
}
 
296
 
 
297
void OPPROTO op_movq_T1_im64(void)
 
298
{
 
299
    T1 = PARAMQ1;
 
300
}
 
301
 
 
302
#define XFLAG_SET(x) ((env->xcc&x)?1:0)
 
303
 
 
304
#else
 
305
#define EIP (env->pc)
 
306
#endif
 
307
 
 
308
#define FLAG_SET(x) ((env->psr&x)?1:0)
 
309
 
 
310
void OPPROTO op_movl_T0_0(void)
 
311
{
 
312
    T0 = 0;
 
313
}
 
314
 
 
315
void OPPROTO op_movl_T0_im(void)
 
316
{
 
317
    T0 = (uint32_t)PARAM1;
 
318
}
 
319
 
 
320
void OPPROTO op_movl_T1_im(void)
 
321
{
 
322
    T1 = (uint32_t)PARAM1;
 
323
}
 
324
 
 
325
void OPPROTO op_movl_T2_im(void)
 
326
{
 
327
    T2 = (uint32_t)PARAM1;
 
328
}
 
329
 
 
330
void OPPROTO op_movl_T0_sim(void)
 
331
{
 
332
    T0 = (int32_t)PARAM1;
 
333
}
 
334
 
 
335
void OPPROTO op_movl_T1_sim(void)
 
336
{
 
337
    T1 = (int32_t)PARAM1;
 
338
}
 
339
 
 
340
void OPPROTO op_movl_T2_sim(void)
 
341
{
 
342
    T2 = (int32_t)PARAM1;
 
343
}
 
344
 
 
345
void OPPROTO op_movl_T0_env(void)
 
346
{
 
347
    T0 = *(uint32_t *)((char *)env + PARAM1);
 
348
}
 
349
 
 
350
void OPPROTO op_movl_env_T0(void)
 
351
{
 
352
    *(uint32_t *)((char *)env + PARAM1) = T0;
 
353
}
 
354
 
 
355
void OPPROTO op_movtl_T0_env(void)
 
356
{
 
357
    T0 = *(target_ulong *)((char *)env + PARAM1);
 
358
}
 
359
 
 
360
void OPPROTO op_movtl_env_T0(void)
 
361
{
 
362
    *(target_ulong *)((char *)env + PARAM1) = T0;
 
363
}
 
364
 
 
365
void OPPROTO op_add_T1_T0(void)
 
366
{
 
367
    T0 += T1;
 
368
}
 
369
 
 
370
void OPPROTO op_add_T1_T0_cc(void)
 
371
{
 
372
    target_ulong src1;
 
373
 
 
374
    src1 = T0;
 
375
    T0 += T1;
 
376
    env->psr = 0;
 
377
#ifdef TARGET_SPARC64
 
378
    if (!(T0 & 0xffffffff))
 
379
        env->psr |= PSR_ZERO;
 
380
    if ((int32_t) T0 < 0)
 
381
        env->psr |= PSR_NEG;
 
382
    if ((T0 & 0xffffffff) < (src1 & 0xffffffff))
 
383
        env->psr |= PSR_CARRY;
 
384
    if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
 
385
         ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
 
386
        env->psr |= PSR_OVF;
 
387
 
 
388
    env->xcc = 0;
 
389
    if (!T0)
 
390
        env->xcc |= PSR_ZERO;
 
391
    if ((int64_t) T0 < 0)
 
392
        env->xcc |= PSR_NEG;
 
393
    if (T0 < src1)
 
394
        env->xcc |= PSR_CARRY;
 
395
    if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63))
 
396
        env->xcc |= PSR_OVF;
 
397
#else
 
398
    if (!T0)
 
399
        env->psr |= PSR_ZERO;
 
400
    if ((int32_t) T0 < 0)
 
401
        env->psr |= PSR_NEG;
 
402
    if (T0 < src1)
 
403
        env->psr |= PSR_CARRY;
 
404
    if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
 
405
        env->psr |= PSR_OVF;
 
406
#endif
 
407
    FORCE_RET();
 
408
}
 
409
 
 
410
void OPPROTO op_addx_T1_T0(void)
 
411
{
 
412
    T0 += T1 + FLAG_SET(PSR_CARRY);
 
413
}
 
414
 
 
415
void OPPROTO op_addx_T1_T0_cc(void)
 
416
{
 
417
    target_ulong src1;
 
418
    src1 = T0;
 
419
    if (FLAG_SET(PSR_CARRY))
 
420
    {
 
421
      T0 += T1 + 1;
 
422
      env->psr = 0;
 
423
#ifdef TARGET_SPARC64
 
424
      if ((T0 & 0xffffffff) <= (src1 & 0xffffffff))
 
425
        env->psr |= PSR_CARRY;
 
426
      env->xcc = 0;
 
427
      if (T0 <= src1)
 
428
        env->xcc |= PSR_CARRY;
 
429
#else
 
430
      if (T0 <= src1)
 
431
        env->psr |= PSR_CARRY;
 
432
#endif
 
433
    }
 
434
    else
 
435
    {
 
436
      T0 += T1;
 
437
      env->psr = 0;
 
438
#ifdef TARGET_SPARC64
 
439
      if ((T0 & 0xffffffff) < (src1 & 0xffffffff))
 
440
        env->psr |= PSR_CARRY;
 
441
      env->xcc = 0;
 
442
      if (T0 < src1)
 
443
        env->xcc |= PSR_CARRY;
 
444
#else
 
445
      if (T0 < src1)
 
446
        env->psr |= PSR_CARRY;
 
447
#endif
 
448
    }
 
449
#ifdef TARGET_SPARC64
 
450
    if (!(T0 & 0xffffffff))
 
451
        env->psr |= PSR_ZERO;
 
452
    if ((int32_t) T0 < 0)
 
453
        env->psr |= PSR_NEG;
 
454
    if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
 
455
         ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
 
456
        env->psr |= PSR_OVF;
 
457
 
 
458
    if (!T0)
 
459
        env->xcc |= PSR_ZERO;
 
460
    if ((int64_t) T0 < 0)
 
461
        env->xcc |= PSR_NEG;
 
462
    if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63))
 
463
        env->xcc |= PSR_OVF;
 
464
#else
 
465
    if (!T0)
 
466
        env->psr |= PSR_ZERO;
 
467
    if ((int32_t) T0 < 0)
 
468
        env->psr |= PSR_NEG;
 
469
    if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
 
470
        env->psr |= PSR_OVF;
 
471
#endif
 
472
    FORCE_RET();
 
473
}
 
474
 
 
475
void OPPROTO op_tadd_T1_T0_cc(void)
 
476
{
 
477
    target_ulong src1;
 
478
 
 
479
    src1 = T0;
 
480
    T0 += T1;
 
481
    env->psr = 0;
 
482
#ifdef TARGET_SPARC64
 
483
    if (!(T0 & 0xffffffff))
 
484
        env->psr |= PSR_ZERO;
 
485
    if ((int32_t) T0 < 0)
 
486
        env->psr |= PSR_NEG;
 
487
    if ((T0 & 0xffffffff) < (src1 & 0xffffffff))
 
488
        env->psr |= PSR_CARRY;
 
489
    if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
 
490
         ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
 
491
        env->psr |= PSR_OVF;
 
492
    if ((src1 & 0x03) || (T1 & 0x03))
 
493
        env->psr |= PSR_OVF;
 
494
 
 
495
    env->xcc = 0;
 
496
    if (!T0)
 
497
        env->xcc |= PSR_ZERO;
 
498
    if ((int64_t) T0 < 0)
 
499
        env->xcc |= PSR_NEG;
 
500
    if (T0 < src1)
 
501
        env->xcc |= PSR_CARRY;
 
502
    if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63))
 
503
        env->xcc |= PSR_OVF;
 
504
#else
 
505
    if (!T0)
 
506
        env->psr |= PSR_ZERO;
 
507
    if ((int32_t) T0 < 0)
 
508
        env->psr |= PSR_NEG;
 
509
    if (T0 < src1)
 
510
        env->psr |= PSR_CARRY;
 
511
    if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
 
512
        env->psr |= PSR_OVF;
 
513
    if ((src1 & 0x03) || (T1 & 0x03))
 
514
        env->psr |= PSR_OVF;
 
515
#endif
 
516
    FORCE_RET();
 
517
}
 
518
 
 
519
void OPPROTO op_tadd_T1_T0_ccTV(void)
 
520
{
 
521
    target_ulong src1;
 
522
 
 
523
    if ((T0 & 0x03) || (T1 & 0x03))
 
524
        raise_exception(TT_TOVF);
 
525
 
 
526
    src1 = T0;
 
527
    T0 += T1;
 
528
 
 
529
#ifdef TARGET_SPARC64
 
530
    if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
 
531
         ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
 
532
        raise_exception(TT_TOVF);
 
533
#else
 
534
    if ((src1 & 0x03) || (T1 & 0x03))
 
535
        raise_exception(TT_TOVF);
 
536
#endif
 
537
 
 
538
    env->psr = 0;
 
539
#ifdef TARGET_SPARC64
 
540
    if (!(T0 & 0xffffffff))
 
541
        env->psr |= PSR_ZERO;
 
542
    if ((int32_t) T0 < 0)
 
543
        env->psr |= PSR_NEG;
 
544
    if ((T0 & 0xffffffff) < (src1 & 0xffffffff))
 
545
        env->psr |= PSR_CARRY;
 
546
 
 
547
    env->xcc = 0;
 
548
    if (!T0)
 
549
        env->xcc |= PSR_ZERO;
 
550
    if ((int64_t) T0 < 0)
 
551
        env->xcc |= PSR_NEG;
 
552
    if (T0 < src1)
 
553
        env->xcc |= PSR_CARRY;
 
554
#else
 
555
    if (!T0)
 
556
        env->psr |= PSR_ZERO;
 
557
    if ((int32_t) T0 < 0)
 
558
        env->psr |= PSR_NEG;
 
559
    if (T0 < src1)
 
560
        env->psr |= PSR_CARRY;
 
561
#endif
 
562
    FORCE_RET();
 
563
}
 
564
 
 
565
void OPPROTO op_sub_T1_T0(void)
 
566
{
 
567
    T0 -= T1;
 
568
}
 
569
 
 
570
void OPPROTO op_sub_T1_T0_cc(void)
 
571
{
 
572
    target_ulong src1;
 
573
 
 
574
    src1 = T0;
 
575
    T0 -= T1;
 
576
    env->psr = 0;
 
577
#ifdef TARGET_SPARC64
 
578
    if (!(T0 & 0xffffffff))
 
579
        env->psr |= PSR_ZERO;
 
580
    if ((int32_t) T0 < 0)
 
581
        env->psr |= PSR_NEG;
 
582
    if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
 
583
        env->psr |= PSR_CARRY;
 
584
    if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
 
585
         ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
 
586
        env->psr |= PSR_OVF;
 
587
 
 
588
    env->xcc = 0;
 
589
    if (!T0)
 
590
        env->xcc |= PSR_ZERO;
 
591
    if ((int64_t) T0 < 0)
 
592
        env->xcc |= PSR_NEG;
 
593
    if (src1 < T1)
 
594
        env->xcc |= PSR_CARRY;
 
595
    if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63))
 
596
        env->xcc |= PSR_OVF;
 
597
#else
 
598
    if (!T0)
 
599
        env->psr |= PSR_ZERO;
 
600
    if ((int32_t) T0 < 0)
 
601
        env->psr |= PSR_NEG;
 
602
    if (src1 < T1)
 
603
        env->psr |= PSR_CARRY;
 
604
    if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
 
605
        env->psr |= PSR_OVF;
 
606
#endif
 
607
    FORCE_RET();
 
608
}
 
609
 
 
610
void OPPROTO op_subx_T1_T0(void)
 
611
{
 
612
    T0 -= T1 + FLAG_SET(PSR_CARRY);
 
613
}
 
614
 
 
615
void OPPROTO op_subx_T1_T0_cc(void)
 
616
{
 
617
    target_ulong src1;
 
618
    src1 = T0;
 
619
    if (FLAG_SET(PSR_CARRY))
 
620
    {
 
621
      T0 -= T1 + 1;
 
622
      env->psr = 0;
 
623
#ifdef TARGET_SPARC64
 
624
      if ((src1 & 0xffffffff) <= (T1 & 0xffffffff))
 
625
        env->psr |= PSR_CARRY;
 
626
      env->xcc = 0;
 
627
      if (src1 <= T1)
 
628
        env->xcc |= PSR_CARRY;
 
629
#else
 
630
      if (src1 <= T1)
 
631
        env->psr |= PSR_CARRY;
 
632
#endif
 
633
    }
 
634
    else
 
635
    {
 
636
      T0 -= T1;
 
637
      env->psr = 0;
 
638
#ifdef TARGET_SPARC64
 
639
      if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
 
640
        env->psr |= PSR_CARRY;
 
641
      env->xcc = 0;
 
642
      if (src1 < T1)
 
643
        env->xcc |= PSR_CARRY;
 
644
#else
 
645
      if (src1 < T1)
 
646
        env->psr |= PSR_CARRY;
 
647
#endif
 
648
    }
 
649
#ifdef TARGET_SPARC64
 
650
    if (!(T0 & 0xffffffff))
 
651
        env->psr |= PSR_ZERO;
 
652
    if ((int32_t) T0 < 0)
 
653
        env->psr |= PSR_NEG;
 
654
    if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
 
655
         ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
 
656
        env->psr |= PSR_OVF;
 
657
 
 
658
    if (!T0)
 
659
        env->xcc |= PSR_ZERO;
 
660
    if ((int64_t) T0 < 0)
 
661
        env->xcc |= PSR_NEG;
 
662
    if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63))
 
663
        env->xcc |= PSR_OVF;
 
664
#else
 
665
    if (!T0)
 
666
        env->psr |= PSR_ZERO;
 
667
    if ((int32_t) T0 < 0)
 
668
        env->psr |= PSR_NEG;
 
669
    if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
 
670
        env->psr |= PSR_OVF;
 
671
#endif
 
672
    FORCE_RET();
 
673
}
 
674
 
 
675
void OPPROTO op_tsub_T1_T0_cc(void)
 
676
{
 
677
    target_ulong src1;
 
678
 
 
679
    src1 = T0;
 
680
    T0 -= T1;
 
681
    env->psr = 0;
 
682
#ifdef TARGET_SPARC64
 
683
    if (!(T0 & 0xffffffff))
 
684
        env->psr |= PSR_ZERO;
 
685
    if ((int32_t) T0 < 0)
 
686
        env->psr |= PSR_NEG;
 
687
    if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
 
688
        env->psr |= PSR_CARRY;
 
689
    if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
 
690
         ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
 
691
        env->psr |= PSR_OVF;
 
692
    if ((src1 & 0x03) || (T1 & 0x03))
 
693
        env->psr |= PSR_OVF;
 
694
 
 
695
    env->xcc = 0;
 
696
    if (!T0)
 
697
        env->xcc |= PSR_ZERO;
 
698
    if ((int64_t) T0 < 0)
 
699
        env->xcc |= PSR_NEG;
 
700
    if (src1 < T1)
 
701
        env->xcc |= PSR_CARRY;
 
702
    if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63))
 
703
        env->xcc |= PSR_OVF;
 
704
#else
 
705
    if (!T0)
 
706
        env->psr |= PSR_ZERO;
 
707
    if ((int32_t) T0 < 0)
 
708
        env->psr |= PSR_NEG;
 
709
    if (src1 < T1)
 
710
        env->psr |= PSR_CARRY;
 
711
    if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
 
712
        env->psr |= PSR_OVF;
 
713
    if ((src1 & 0x03) || (T1 & 0x03))
 
714
        env->psr |= PSR_OVF;
 
715
#endif
 
716
    FORCE_RET();
 
717
}
 
718
 
 
719
void OPPROTO op_tsub_T1_T0_ccTV(void)
 
720
{
 
721
    target_ulong src1;
 
722
 
 
723
    if ((T0 & 0x03) || (T1 & 0x03))
 
724
        raise_exception(TT_TOVF);
 
725
 
 
726
    src1 = T0;
 
727
    T0 -= T1;
 
728
 
 
729
#ifdef TARGET_SPARC64
 
730
    if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
 
731
         ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
 
732
        raise_exception(TT_TOVF);
 
733
#else
 
734
    if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
 
735
        raise_exception(TT_TOVF);
 
736
#endif
 
737
 
 
738
    env->psr = 0;
 
739
#ifdef TARGET_SPARC64
 
740
    if (!(T0 & 0xffffffff))
 
741
        env->psr |= PSR_ZERO;
 
742
    if ((int32_t) T0 < 0)
 
743
        env->psr |= PSR_NEG;
 
744
    if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
 
745
        env->psr |= PSR_CARRY;
 
746
 
 
747
    env->xcc = 0;
 
748
    if (!T0)
 
749
        env->xcc |= PSR_ZERO;
 
750
    if ((int64_t) T0 < 0)
 
751
        env->xcc |= PSR_NEG;
 
752
    if (src1 < T1)
 
753
        env->xcc |= PSR_CARRY;
 
754
#else
 
755
    if (!T0)
 
756
        env->psr |= PSR_ZERO;
 
757
    if ((int32_t) T0 < 0)
 
758
        env->psr |= PSR_NEG;
 
759
    if (src1 < T1)
 
760
        env->psr |= PSR_CARRY;
 
761
#endif
 
762
    FORCE_RET();
 
763
}
 
764
 
 
765
void OPPROTO op_and_T1_T0(void)
 
766
{
 
767
    T0 &= T1;
 
768
}
 
769
 
 
770
void OPPROTO op_or_T1_T0(void)
 
771
{
 
772
    T0 |= T1;
 
773
}
 
774
 
 
775
void OPPROTO op_xor_T1_T0(void)
 
776
{
 
777
    T0 ^= T1;
 
778
}
 
779
 
 
780
void OPPROTO op_andn_T1_T0(void)
 
781
{
 
782
    T0 &= ~T1;
 
783
}
 
784
 
 
785
void OPPROTO op_orn_T1_T0(void)
 
786
{
 
787
    T0 |= ~T1;
 
788
}
 
789
 
 
790
void OPPROTO op_xnor_T1_T0(void)
 
791
{
 
792
    T0 ^= ~T1;
 
793
}
 
794
 
 
795
void OPPROTO op_umul_T1_T0(void)
 
796
{
 
797
    uint64_t res;
 
798
    res = (uint64_t) T0 * (uint64_t) T1;
 
799
#ifdef TARGET_SPARC64
 
800
    T0 = res;
 
801
#else
 
802
    T0 = res & 0xffffffff;
 
803
#endif
 
804
    env->y = res >> 32;
 
805
}
 
806
 
 
807
void OPPROTO op_smul_T1_T0(void)
 
808
{
 
809
    uint64_t res;
 
810
    res = (int64_t) ((int32_t) T0) * (int64_t) ((int32_t) T1);
 
811
#ifdef TARGET_SPARC64
 
812
    T0 = res;
 
813
#else
 
814
    T0 = res & 0xffffffff;
 
815
#endif
 
816
    env->y = res >> 32;
 
817
}
 
818
 
 
819
void OPPROTO op_mulscc_T1_T0(void)
 
820
{
 
821
    unsigned int b1, N, V, b2;
 
822
    target_ulong src1;
 
823
 
 
824
    N = FLAG_SET(PSR_NEG);
 
825
    V = FLAG_SET(PSR_OVF);
 
826
    b1 = N ^ V;
 
827
    b2 = T0 & 1;
 
828
    T0 = (b1 << 31) | (T0 >> 1);
 
829
    if (!(env->y & 1))
 
830
        T1 = 0;
 
831
    /* do addition and update flags */
 
832
    src1 = T0;
 
833
    T0 += T1;
 
834
    env->psr = 0;
 
835
    if (!T0)
 
836
        env->psr |= PSR_ZERO;
 
837
    if ((int32_t) T0 < 0)
 
838
        env->psr |= PSR_NEG;
 
839
    if (T0 < src1)
 
840
        env->psr |= PSR_CARRY;
 
841
    if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
 
842
        env->psr |= PSR_OVF;
 
843
    env->y = (b2 << 31) | (env->y >> 1);
 
844
    FORCE_RET();
 
845
}
 
846
 
 
847
void OPPROTO op_udiv_T1_T0(void)
 
848
{
 
849
    uint64_t x0;
 
850
    uint32_t x1;
 
851
 
 
852
    x0 = T0 | ((uint64_t) (env->y) << 32);
 
853
    x1 = T1;
 
854
 
 
855
    if (x1 == 0) {
 
856
        raise_exception(TT_DIV_ZERO);
 
857
    }
 
858
 
 
859
    x0 = x0 / x1;
 
860
    if (x0 > 0xffffffff) {
 
861
        T0 = 0xffffffff;
 
862
        T1 = 1;
 
863
    } else {
 
864
        T0 = x0;
 
865
        T1 = 0;
 
866
    }
 
867
    FORCE_RET();
 
868
}
 
869
 
 
870
void OPPROTO op_sdiv_T1_T0(void)
 
871
{
 
872
    int64_t x0;
 
873
    int32_t x1;
 
874
 
 
875
    x0 = T0 | ((int64_t) (env->y) << 32);
 
876
    x1 = T1;
 
877
 
 
878
    if (x1 == 0) {
 
879
        raise_exception(TT_DIV_ZERO);
 
880
    }
 
881
 
 
882
    x0 = x0 / x1;
 
883
    if ((int32_t) x0 != x0) {
 
884
        T0 = x0 < 0? 0x80000000: 0x7fffffff;
 
885
        T1 = 1;
 
886
    } else {
 
887
        T0 = x0;
 
888
        T1 = 0;
 
889
    }
 
890
    FORCE_RET();
 
891
}
 
892
 
 
893
void OPPROTO op_div_cc(void)
 
894
{
 
895
    env->psr = 0;
 
896
#ifdef TARGET_SPARC64
 
897
    if (!T0)
 
898
        env->psr |= PSR_ZERO;
 
899
    if ((int32_t) T0 < 0)
 
900
        env->psr |= PSR_NEG;
 
901
    if (T1)
 
902
        env->psr |= PSR_OVF;
 
903
 
 
904
    env->xcc = 0;
 
905
    if (!T0)
 
906
        env->xcc |= PSR_ZERO;
 
907
    if ((int64_t) T0 < 0)
 
908
        env->xcc |= PSR_NEG;
 
909
#else
 
910
    if (!T0)
 
911
        env->psr |= PSR_ZERO;
 
912
    if ((int32_t) T0 < 0)
 
913
        env->psr |= PSR_NEG;
 
914
    if (T1)
 
915
        env->psr |= PSR_OVF;
 
916
#endif
 
917
    FORCE_RET();
 
918
}
 
919
 
 
920
#ifdef TARGET_SPARC64
 
921
void OPPROTO op_mulx_T1_T0(void)
 
922
{
 
923
    T0 *= T1;
 
924
    FORCE_RET();
 
925
}
 
926
 
 
927
void OPPROTO op_udivx_T1_T0(void)
 
928
{
 
929
    if (T1 == 0) {
 
930
        raise_exception(TT_DIV_ZERO);
 
931
    }
 
932
    T0 /= T1;
 
933
    FORCE_RET();
 
934
}
 
935
 
 
936
void OPPROTO op_sdivx_T1_T0(void)
 
937
{
 
938
    if (T1 == 0) {
 
939
        raise_exception(TT_DIV_ZERO);
 
940
    }
 
941
    if (T0 == INT64_MIN && T1 == -1)
 
942
        T0 = INT64_MIN;
 
943
    else
 
944
        T0 /= (target_long) T1;
 
945
    FORCE_RET();
 
946
}
 
947
#endif
 
948
 
 
949
void OPPROTO op_logic_T0_cc(void)
 
950
{
 
951
    env->psr = 0;
 
952
#ifdef TARGET_SPARC64
 
953
    if (!(T0 & 0xffffffff))
 
954
        env->psr |= PSR_ZERO;
 
955
    if ((int32_t) T0 < 0)
 
956
        env->psr |= PSR_NEG;
 
957
 
 
958
    env->xcc = 0;
 
959
    if (!T0)
 
960
        env->xcc |= PSR_ZERO;
 
961
    if ((int64_t) T0 < 0)
 
962
        env->xcc |= PSR_NEG;
 
963
#else
 
964
    if (!T0)
 
965
        env->psr |= PSR_ZERO;
 
966
    if ((int32_t) T0 < 0)
 
967
        env->psr |= PSR_NEG;
 
968
#endif
 
969
    FORCE_RET();
 
970
}
 
971
 
 
972
void OPPROTO op_sll(void)
 
973
{
 
974
    T0 <<= (T1 & 0x1f);
 
975
}
 
976
 
 
977
#ifdef TARGET_SPARC64
 
978
void OPPROTO op_sllx(void)
 
979
{
 
980
    T0 <<= (T1 & 0x3f);
 
981
}
 
982
 
 
983
void OPPROTO op_srl(void)
 
984
{
 
985
    T0 = (T0 & 0xffffffff) >> (T1 & 0x1f);
 
986
}
 
987
 
 
988
void OPPROTO op_srlx(void)
 
989
{
 
990
    T0 >>= (T1 & 0x3f);
 
991
}
 
992
 
 
993
void OPPROTO op_sra(void)
 
994
{
 
995
    T0 = ((int32_t) (T0 & 0xffffffff)) >> (T1 & 0x1f);
 
996
}
 
997
 
 
998
void OPPROTO op_srax(void)
 
999
{
 
1000
    T0 = ((int64_t) T0) >> (T1 & 0x3f);
 
1001
}
 
1002
#else
 
1003
void OPPROTO op_srl(void)
 
1004
{
 
1005
    T0 >>= (T1 & 0x1f);
 
1006
}
 
1007
 
 
1008
void OPPROTO op_sra(void)
 
1009
{
 
1010
    T0 = ((int32_t) T0) >> (T1 & 0x1f);
 
1011
}
 
1012
#endif
 
1013
 
 
1014
/* Load and store */
 
1015
#define MEMSUFFIX _raw
 
1016
#include "op_mem.h"
 
1017
#if !defined(CONFIG_USER_ONLY)
 
1018
#define MEMSUFFIX _user
 
1019
#include "op_mem.h"
 
1020
 
 
1021
#define MEMSUFFIX _kernel
 
1022
#include "op_mem.h"
 
1023
#endif
 
1024
 
 
1025
void OPPROTO op_ldfsr(void)
 
1026
{
 
1027
    PUT_FSR32(env, *((uint32_t *) &FT0));
 
1028
    helper_ldfsr();
 
1029
}
 
1030
 
 
1031
void OPPROTO op_stfsr(void)
 
1032
{
 
1033
    *((uint32_t *) &FT0) = GET_FSR32(env);
 
1034
}
 
1035
 
 
1036
#ifndef TARGET_SPARC64
 
1037
void OPPROTO op_rdpsr(void)
 
1038
{
 
1039
    do_rdpsr();
 
1040
}
 
1041
 
 
1042
void OPPROTO op_wrpsr(void)
 
1043
{
 
1044
    do_wrpsr();
 
1045
    FORCE_RET();
 
1046
}
 
1047
 
 
1048
void OPPROTO op_wrwim(void)
 
1049
{
 
1050
#if NWINDOWS == 32
 
1051
    env->wim = T0;
 
1052
#else
 
1053
    env->wim = T0 & ((1 << NWINDOWS) - 1);
 
1054
#endif
 
1055
}
 
1056
 
 
1057
void OPPROTO op_rett(void)
 
1058
{
 
1059
    helper_rett();
 
1060
    FORCE_RET();
 
1061
}
 
1062
 
 
1063
/* XXX: use another pointer for %iN registers to avoid slow wrapping
 
1064
   handling ? */
 
1065
void OPPROTO op_save(void)
 
1066
{
 
1067
    uint32_t cwp;
 
1068
    cwp = (env->cwp - 1) & (NWINDOWS - 1); 
 
1069
    if (env->wim & (1 << cwp)) {
 
1070
        raise_exception(TT_WIN_OVF);
 
1071
    }
 
1072
    set_cwp(cwp);
 
1073
    FORCE_RET();
 
1074
}
 
1075
 
 
1076
void OPPROTO op_restore(void)
 
1077
{
 
1078
    uint32_t cwp;
 
1079
    cwp = (env->cwp + 1) & (NWINDOWS - 1); 
 
1080
    if (env->wim & (1 << cwp)) {
 
1081
        raise_exception(TT_WIN_UNF);
 
1082
    }
 
1083
    set_cwp(cwp);
 
1084
    FORCE_RET();
 
1085
}
 
1086
#else
 
1087
void OPPROTO op_rdccr(void)
 
1088
{
 
1089
    T0 = GET_CCR(env);
 
1090
}
 
1091
 
 
1092
void OPPROTO op_wrccr(void)
 
1093
{
 
1094
    PUT_CCR(env, T0);
 
1095
}
 
1096
 
 
1097
void OPPROTO op_rdtick(void)
 
1098
{
 
1099
    T0 = 0; // XXX read cycle counter and bit 31
 
1100
}
 
1101
 
 
1102
void OPPROTO op_wrtick(void)
 
1103
{
 
1104
    T0 = 0; // XXX write cycle counter and bit 31
 
1105
}
 
1106
 
 
1107
void OPPROTO op_rdtpc(void)
 
1108
{
 
1109
    T0 = env->tpc[env->tl];
 
1110
}
 
1111
 
 
1112
void OPPROTO op_wrtpc(void)
 
1113
{
 
1114
    env->tpc[env->tl] = T0;
 
1115
}
 
1116
 
 
1117
void OPPROTO op_rdtnpc(void)
 
1118
{
 
1119
    T0 = env->tnpc[env->tl];
 
1120
}
 
1121
 
 
1122
void OPPROTO op_wrtnpc(void)
 
1123
{
 
1124
    env->tnpc[env->tl] = T0;
 
1125
}
 
1126
 
 
1127
void OPPROTO op_rdtstate(void)
 
1128
{
 
1129
    T0 = env->tstate[env->tl];
 
1130
}
 
1131
 
 
1132
void OPPROTO op_wrtstate(void)
 
1133
{
 
1134
    env->tstate[env->tl] = T0;
 
1135
}
 
1136
 
 
1137
void OPPROTO op_rdtt(void)
 
1138
{
 
1139
    T0 = env->tt[env->tl];
 
1140
}
 
1141
 
 
1142
void OPPROTO op_wrtt(void)
 
1143
{
 
1144
    env->tt[env->tl] = T0;
 
1145
}
 
1146
 
 
1147
void OPPROTO op_rdpstate(void)
 
1148
{
 
1149
    T0 = env->pstate;
 
1150
}
 
1151
 
 
1152
void OPPROTO op_wrpstate(void)
 
1153
{
 
1154
    do_wrpstate();
 
1155
}
 
1156
 
 
1157
// CWP handling is reversed in V9, but we still use the V8 register
 
1158
// order.
 
1159
void OPPROTO op_rdcwp(void)
 
1160
{
 
1161
    T0 = NWINDOWS - 1 - env->cwp;
 
1162
}
 
1163
 
 
1164
void OPPROTO op_wrcwp(void)
 
1165
{
 
1166
    env->cwp = NWINDOWS - 1 - T0;
 
1167
}
 
1168
 
 
1169
/* XXX: use another pointer for %iN registers to avoid slow wrapping
 
1170
   handling ? */
 
1171
void OPPROTO op_save(void)
 
1172
{
 
1173
    uint32_t cwp;
 
1174
    cwp = (env->cwp - 1) & (NWINDOWS - 1); 
 
1175
    if (env->cansave == 0) {
 
1176
        raise_exception(TT_SPILL | (env->otherwin != 0 ? 
 
1177
                                    (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
 
1178
                                    ((env->wstate & 0x7) << 2)));
 
1179
    } else {
 
1180
        if (env->cleanwin - env->canrestore == 0) {
 
1181
            // XXX Clean windows without trap
 
1182
            raise_exception(TT_CLRWIN);
 
1183
        } else {
 
1184
            env->cansave--;
 
1185
            env->canrestore++;
 
1186
            set_cwp(cwp);
 
1187
        }
 
1188
    }
 
1189
    FORCE_RET();
 
1190
}
 
1191
 
 
1192
void OPPROTO op_restore(void)
 
1193
{
 
1194
    uint32_t cwp;
 
1195
    cwp = (env->cwp + 1) & (NWINDOWS - 1); 
 
1196
    if (env->canrestore == 0) {
 
1197
        raise_exception(TT_FILL | (env->otherwin != 0 ? 
 
1198
                                   (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
 
1199
                                   ((env->wstate & 0x7) << 2)));
 
1200
    } else {
 
1201
        env->cansave++;
 
1202
        env->canrestore--;
 
1203
        set_cwp(cwp);
 
1204
    }
 
1205
    FORCE_RET();
 
1206
}
 
1207
#endif
 
1208
 
 
1209
void OPPROTO op_exception(void)
 
1210
{
 
1211
    env->exception_index = PARAM1;
 
1212
    cpu_loop_exit();
 
1213
}
 
1214
 
 
1215
void OPPROTO op_trap_T0(void)
 
1216
{
 
1217
    env->exception_index = TT_TRAP + (T0 & 0x7f);
 
1218
    cpu_loop_exit();
 
1219
}
 
1220
 
 
1221
void OPPROTO op_trapcc_T0(void)
 
1222
{
 
1223
    if (T2) {
 
1224
        env->exception_index = TT_TRAP + (T0 & 0x7f);
 
1225
        cpu_loop_exit();
 
1226
    }
 
1227
    FORCE_RET();
 
1228
}
 
1229
 
 
1230
void OPPROTO op_fpexception_im(void)
 
1231
{
 
1232
    env->exception_index = TT_FP_EXCP;
 
1233
    env->fsr &= ~FSR_FTT_MASK;
 
1234
    env->fsr |= PARAM1;
 
1235
    cpu_loop_exit();
 
1236
    FORCE_RET();
 
1237
}
 
1238
 
 
1239
void OPPROTO op_debug(void)
 
1240
{
 
1241
    helper_debug();
 
1242
}
 
1243
 
 
1244
void OPPROTO op_exit_tb(void)
 
1245
{
 
1246
    EXIT_TB();
 
1247
}
 
1248
 
 
1249
void OPPROTO op_eval_ba(void)
 
1250
{
 
1251
    T2 = 1;
 
1252
}
 
1253
 
 
1254
void OPPROTO op_eval_be(void)
 
1255
{
 
1256
    T2 = FLAG_SET(PSR_ZERO);
 
1257
}
 
1258
 
 
1259
void OPPROTO op_eval_ble(void)
 
1260
{
 
1261
    target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
 
1262
    
 
1263
    T2 = Z | (N ^ V);
 
1264
}
 
1265
 
 
1266
void OPPROTO op_eval_bl(void)
 
1267
{
 
1268
    target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
 
1269
 
 
1270
    T2 = N ^ V;
 
1271
}
 
1272
 
 
1273
void OPPROTO op_eval_bleu(void)
 
1274
{
 
1275
    target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
 
1276
 
 
1277
    T2 = C | Z;
 
1278
}
 
1279
 
 
1280
void OPPROTO op_eval_bcs(void)
 
1281
{
 
1282
    T2 = FLAG_SET(PSR_CARRY);
 
1283
}
 
1284
 
 
1285
void OPPROTO op_eval_bvs(void)
 
1286
{
 
1287
    T2 = FLAG_SET(PSR_OVF);
 
1288
}
 
1289
 
 
1290
void OPPROTO op_eval_bn(void)
 
1291
{
 
1292
    T2 = 0;
 
1293
}
 
1294
 
 
1295
void OPPROTO op_eval_bneg(void)
 
1296
{
 
1297
    T2 = FLAG_SET(PSR_NEG);
 
1298
}
 
1299
 
 
1300
void OPPROTO op_eval_bne(void)
 
1301
{
 
1302
    T2 = !FLAG_SET(PSR_ZERO);
 
1303
}
 
1304
 
 
1305
void OPPROTO op_eval_bg(void)
 
1306
{
 
1307
    target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
 
1308
 
 
1309
    T2 = !(Z | (N ^ V));
 
1310
}
 
1311
 
 
1312
void OPPROTO op_eval_bge(void)
 
1313
{
 
1314
    target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
 
1315
 
 
1316
    T2 = !(N ^ V);
 
1317
}
 
1318
 
 
1319
void OPPROTO op_eval_bgu(void)
 
1320
{
 
1321
    target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
 
1322
 
 
1323
    T2 = !(C | Z);
 
1324
}
 
1325
 
 
1326
void OPPROTO op_eval_bcc(void)
 
1327
{
 
1328
    T2 = !FLAG_SET(PSR_CARRY);
 
1329
}
 
1330
 
 
1331
void OPPROTO op_eval_bpos(void)
 
1332
{
 
1333
    T2 = !FLAG_SET(PSR_NEG);
 
1334
}
 
1335
 
 
1336
void OPPROTO op_eval_bvc(void)
 
1337
{
 
1338
    T2 = !FLAG_SET(PSR_OVF);
 
1339
}
 
1340
 
 
1341
#ifdef TARGET_SPARC64
 
1342
void OPPROTO op_eval_xbe(void)
 
1343
{
 
1344
    T2 = XFLAG_SET(PSR_ZERO);
 
1345
}
 
1346
 
 
1347
void OPPROTO op_eval_xble(void)
 
1348
{
 
1349
    target_ulong Z = XFLAG_SET(PSR_ZERO), N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
 
1350
    
 
1351
    T2 = Z | (N ^ V);
 
1352
}
 
1353
 
 
1354
void OPPROTO op_eval_xbl(void)
 
1355
{
 
1356
    target_ulong N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
 
1357
 
 
1358
    T2 = N ^ V;
 
1359
}
 
1360
 
 
1361
void OPPROTO op_eval_xbleu(void)
 
1362
{
 
1363
    target_ulong Z = XFLAG_SET(PSR_ZERO), C = XFLAG_SET(PSR_CARRY);
 
1364
 
 
1365
    T2 = C | Z;
 
1366
}
 
1367
 
 
1368
void OPPROTO op_eval_xbcs(void)
 
1369
{
 
1370
    T2 = XFLAG_SET(PSR_CARRY);
 
1371
}
 
1372
 
 
1373
void OPPROTO op_eval_xbvs(void)
 
1374
{
 
1375
    T2 = XFLAG_SET(PSR_OVF);
 
1376
}
 
1377
 
 
1378
void OPPROTO op_eval_xbneg(void)
 
1379
{
 
1380
    T2 = XFLAG_SET(PSR_NEG);
 
1381
}
 
1382
 
 
1383
void OPPROTO op_eval_xbne(void)
 
1384
{
 
1385
    T2 = !XFLAG_SET(PSR_ZERO);
 
1386
}
 
1387
 
 
1388
void OPPROTO op_eval_xbg(void)
 
1389
{
 
1390
    target_ulong Z = XFLAG_SET(PSR_ZERO), N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
 
1391
 
 
1392
    T2 = !(Z | (N ^ V));
 
1393
}
 
1394
 
 
1395
void OPPROTO op_eval_xbge(void)
 
1396
{
 
1397
    target_ulong N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
 
1398
 
 
1399
    T2 = !(N ^ V);
 
1400
}
 
1401
 
 
1402
void OPPROTO op_eval_xbgu(void)
 
1403
{
 
1404
    target_ulong Z = XFLAG_SET(PSR_ZERO), C = XFLAG_SET(PSR_CARRY);
 
1405
 
 
1406
    T2 = !(C | Z);
 
1407
}
 
1408
 
 
1409
void OPPROTO op_eval_xbcc(void)
 
1410
{
 
1411
    T2 = !XFLAG_SET(PSR_CARRY);
 
1412
}
 
1413
 
 
1414
void OPPROTO op_eval_xbpos(void)
 
1415
{
 
1416
    T2 = !XFLAG_SET(PSR_NEG);
 
1417
}
 
1418
 
 
1419
void OPPROTO op_eval_xbvc(void)
 
1420
{
 
1421
    T2 = !XFLAG_SET(PSR_OVF);
 
1422
}
 
1423
#endif
 
1424
 
 
1425
#define FCC
 
1426
#define FFLAG_SET(x) (env->fsr & x? 1: 0)
 
1427
#include "fbranch_template.h"
 
1428
 
 
1429
#ifdef TARGET_SPARC64
 
1430
#define FCC _fcc1
 
1431
#define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 32))? 1: 0)
 
1432
#include "fbranch_template.h"
 
1433
#define FCC _fcc2
 
1434
#define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 34))? 1: 0)
 
1435
#include "fbranch_template.h"
 
1436
#define FCC _fcc3
 
1437
#define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 36))? 1: 0)
 
1438
#include "fbranch_template.h"
 
1439
#endif
 
1440
 
 
1441
#ifdef TARGET_SPARC64
 
1442
void OPPROTO op_eval_brz(void)
 
1443
{
 
1444
    T2 = (T0 == 0);
 
1445
}
 
1446
 
 
1447
void OPPROTO op_eval_brnz(void)
 
1448
{
 
1449
    T2 = (T0 != 0);
 
1450
}
 
1451
 
 
1452
void OPPROTO op_eval_brlz(void)
 
1453
{
 
1454
    T2 = ((int64_t)T0 < 0);
 
1455
}
 
1456
 
 
1457
void OPPROTO op_eval_brlez(void)
 
1458
{
 
1459
    T2 = ((int64_t)T0 <= 0);
 
1460
}
 
1461
 
 
1462
void OPPROTO op_eval_brgz(void)
 
1463
{
 
1464
    T2 = ((int64_t)T0 > 0);
 
1465
}
 
1466
 
 
1467
void OPPROTO op_eval_brgez(void)
 
1468
{
 
1469
    T2 = ((int64_t)T0 >= 0);
 
1470
}
 
1471
 
 
1472
void OPPROTO op_jmp_im64(void)
 
1473
{
 
1474
    env->pc = PARAMQ1;
 
1475
}
 
1476
 
 
1477
void OPPROTO op_movq_npc_im64(void)
 
1478
{
 
1479
    env->npc = PARAMQ1;
 
1480
}
 
1481
#endif
 
1482
 
 
1483
void OPPROTO op_jmp_im(void)
 
1484
{
 
1485
    env->pc = (uint32_t)PARAM1;
 
1486
}
 
1487
 
 
1488
void OPPROTO op_movl_npc_im(void)
 
1489
{
 
1490
    env->npc = (uint32_t)PARAM1;
 
1491
}
 
1492
 
 
1493
void OPPROTO op_movl_npc_T0(void)
 
1494
{
 
1495
    if (T0 & 0x3)
 
1496
        raise_exception(TT_UNALIGNED);
 
1497
    else
 
1498
        env->npc = T0;
 
1499
}
 
1500
 
 
1501
void OPPROTO op_mov_pc_npc(void)
 
1502
{
 
1503
    env->pc = env->npc;
 
1504
}
 
1505
 
 
1506
void OPPROTO op_next_insn(void)
 
1507
{
 
1508
    env->pc = env->npc;
 
1509
    env->npc = env->npc + 4;
 
1510
}
 
1511
 
 
1512
void OPPROTO op_goto_tb0(void)
 
1513
{
 
1514
    GOTO_TB(op_goto_tb0, PARAM1, 0);
 
1515
}
 
1516
 
 
1517
void OPPROTO op_goto_tb1(void)
 
1518
{
 
1519
    GOTO_TB(op_goto_tb1, PARAM1, 1);
 
1520
}
 
1521
 
 
1522
void OPPROTO op_jmp_label(void)
 
1523
{
 
1524
    GOTO_LABEL_PARAM(1);
 
1525
}
 
1526
 
 
1527
void OPPROTO op_jnz_T2_label(void)
 
1528
{
 
1529
    if (T2)
 
1530
        GOTO_LABEL_PARAM(1);
 
1531
    FORCE_RET();
 
1532
}
 
1533
 
 
1534
void OPPROTO op_jz_T2_label(void)
 
1535
{
 
1536
    if (!T2)
 
1537
        GOTO_LABEL_PARAM(1);
 
1538
    FORCE_RET();
 
1539
}
 
1540
 
 
1541
void OPPROTO op_flush_T0(void)
 
1542
{
 
1543
    helper_flush(T0);
 
1544
}
 
1545
 
 
1546
void OPPROTO op_clear_ieee_excp_and_FTT(void)
 
1547
{
 
1548
    env->fsr &= ~(FSR_FTT_MASK | FSR_CEXC_MASK);;
 
1549
}
 
1550
 
 
1551
#define F_OP(name, p) void OPPROTO op_f##name##p(void)
 
1552
 
 
1553
#define F_BINOP(name)                                           \
 
1554
    F_OP(name, s)                                               \
 
1555
    {                                                           \
 
1556
        set_float_exception_flags(0, &env->fp_status);          \
 
1557
        FT0 = float32_ ## name (FT0, FT1, &env->fp_status);     \
 
1558
        check_ieee_exceptions();                                \
 
1559
    }                                                           \
 
1560
    F_OP(name, d)                                               \
 
1561
    {                                                           \
 
1562
        set_float_exception_flags(0, &env->fp_status);          \
 
1563
        DT0 = float64_ ## name (DT0, DT1, &env->fp_status);     \
 
1564
        check_ieee_exceptions();                                \
 
1565
    }
 
1566
 
 
1567
F_BINOP(add);
 
1568
F_BINOP(sub);
 
1569
F_BINOP(mul);
 
1570
F_BINOP(div);
 
1571
#undef F_BINOP
 
1572
 
 
1573
void OPPROTO op_fsmuld(void)
 
1574
{
 
1575
    set_float_exception_flags(0, &env->fp_status);
 
1576
    DT0 = float64_mul(float32_to_float64(FT0, &env->fp_status),
 
1577
                      float32_to_float64(FT1, &env->fp_status),
 
1578
                      &env->fp_status);
 
1579
    check_ieee_exceptions();
 
1580
}
 
1581
 
 
1582
#define F_HELPER(name)    \
 
1583
    F_OP(name, s)         \
 
1584
    {                     \
 
1585
        do_f##name##s();  \
 
1586
    }                     \
 
1587
    F_OP(name, d)         \
 
1588
    {                     \
 
1589
        do_f##name##d();  \
 
1590
    }
 
1591
 
 
1592
F_HELPER(sqrt);
 
1593
 
 
1594
F_OP(neg, s)
 
1595
{
 
1596
    FT0 = float32_chs(FT1);
 
1597
}
 
1598
 
 
1599
F_OP(abs, s)
 
1600
{
 
1601
    do_fabss();
 
1602
}
 
1603
 
 
1604
F_HELPER(cmp);
 
1605
F_HELPER(cmpe);
 
1606
 
 
1607
#ifdef TARGET_SPARC64
 
1608
F_OP(neg, d)
 
1609
{
 
1610
    DT0 = float64_chs(DT1);
 
1611
}
 
1612
 
 
1613
F_OP(abs, d)
 
1614
{
 
1615
    do_fabsd();
 
1616
}
 
1617
 
 
1618
void OPPROTO op_fcmps_fcc1(void)
 
1619
{
 
1620
    do_fcmps_fcc1();
 
1621
}
 
1622
 
 
1623
void OPPROTO op_fcmpd_fcc1(void)
 
1624
{
 
1625
    do_fcmpd_fcc1();
 
1626
}
 
1627
 
 
1628
void OPPROTO op_fcmps_fcc2(void)
 
1629
{
 
1630
    do_fcmps_fcc2();
 
1631
}
 
1632
 
 
1633
void OPPROTO op_fcmpd_fcc2(void)
 
1634
{
 
1635
    do_fcmpd_fcc2();
 
1636
}
 
1637
 
 
1638
void OPPROTO op_fcmps_fcc3(void)
 
1639
{
 
1640
    do_fcmps_fcc3();
 
1641
}
 
1642
 
 
1643
void OPPROTO op_fcmpd_fcc3(void)
 
1644
{
 
1645
    do_fcmpd_fcc3();
 
1646
}
 
1647
 
 
1648
void OPPROTO op_fcmpes_fcc1(void)
 
1649
{
 
1650
    do_fcmpes_fcc1();
 
1651
}
 
1652
 
 
1653
void OPPROTO op_fcmped_fcc1(void)
 
1654
{
 
1655
    do_fcmped_fcc1();
 
1656
}
 
1657
 
 
1658
void OPPROTO op_fcmpes_fcc2(void)
 
1659
{
 
1660
    do_fcmpes_fcc2();
 
1661
}
 
1662
 
 
1663
void OPPROTO op_fcmped_fcc2(void)
 
1664
{
 
1665
    do_fcmped_fcc2();
 
1666
}
 
1667
 
 
1668
void OPPROTO op_fcmpes_fcc3(void)
 
1669
{
 
1670
    do_fcmpes_fcc3();
 
1671
}
 
1672
 
 
1673
void OPPROTO op_fcmped_fcc3(void)
 
1674
{
 
1675
    do_fcmped_fcc3();
 
1676
}
 
1677
 
 
1678
#endif
 
1679
 
 
1680
/* Integer to float conversion.  */
 
1681
#ifdef USE_INT_TO_FLOAT_HELPERS
 
1682
F_HELPER(ito);
 
1683
#else
 
1684
F_OP(ito, s)
 
1685
{
 
1686
    set_float_exception_flags(0, &env->fp_status);
 
1687
    FT0 = int32_to_float32(*((int32_t *)&FT1), &env->fp_status);
 
1688
    check_ieee_exceptions();
 
1689
}
 
1690
 
 
1691
F_OP(ito, d)
 
1692
{
 
1693
    set_float_exception_flags(0, &env->fp_status);
 
1694
    DT0 = int32_to_float64(*((int32_t *)&FT1), &env->fp_status);
 
1695
    check_ieee_exceptions();
 
1696
}
 
1697
 
 
1698
#ifdef TARGET_SPARC64
 
1699
F_OP(xto, s)
 
1700
{
 
1701
    set_float_exception_flags(0, &env->fp_status);
 
1702
    FT0 = int64_to_float32(*((int64_t *)&DT1), &env->fp_status);
 
1703
    check_ieee_exceptions();
 
1704
}
 
1705
 
 
1706
F_OP(xto, d)
 
1707
{
 
1708
    set_float_exception_flags(0, &env->fp_status);
 
1709
    DT0 = int64_to_float64(*((int64_t *)&DT1), &env->fp_status);
 
1710
    check_ieee_exceptions();
 
1711
}
 
1712
#endif
 
1713
#endif
 
1714
#undef F_HELPER
 
1715
 
 
1716
/* floating point conversion */
 
1717
void OPPROTO op_fdtos(void)
 
1718
{
 
1719
    set_float_exception_flags(0, &env->fp_status);
 
1720
    FT0 = float64_to_float32(DT1, &env->fp_status);
 
1721
    check_ieee_exceptions();
 
1722
}
 
1723
 
 
1724
void OPPROTO op_fstod(void)
 
1725
{
 
1726
    set_float_exception_flags(0, &env->fp_status);
 
1727
    DT0 = float32_to_float64(FT1, &env->fp_status);
 
1728
    check_ieee_exceptions();
 
1729
}
 
1730
 
 
1731
/* Float to integer conversion.  */
 
1732
void OPPROTO op_fstoi(void)
 
1733
{
 
1734
    set_float_exception_flags(0, &env->fp_status);
 
1735
    *((int32_t *)&FT0) = float32_to_int32_round_to_zero(FT1, &env->fp_status);
 
1736
    check_ieee_exceptions();
 
1737
}
 
1738
 
 
1739
void OPPROTO op_fdtoi(void)
 
1740
{
 
1741
    set_float_exception_flags(0, &env->fp_status);
 
1742
    *((int32_t *)&FT0) = float64_to_int32_round_to_zero(DT1, &env->fp_status);
 
1743
    check_ieee_exceptions();
 
1744
}
 
1745
 
 
1746
#ifdef TARGET_SPARC64
 
1747
void OPPROTO op_fstox(void)
 
1748
{
 
1749
    set_float_exception_flags(0, &env->fp_status);
 
1750
    *((int64_t *)&DT0) = float32_to_int64_round_to_zero(FT1, &env->fp_status);
 
1751
    check_ieee_exceptions();
 
1752
}
 
1753
 
 
1754
void OPPROTO op_fdtox(void)
 
1755
{
 
1756
    set_float_exception_flags(0, &env->fp_status);
 
1757
    *((int64_t *)&DT0) = float64_to_int64_round_to_zero(DT1, &env->fp_status);
 
1758
    check_ieee_exceptions();
 
1759
}
 
1760
 
 
1761
void OPPROTO op_fmovs_cc(void)
 
1762
{
 
1763
    if (T2)
 
1764
        FT0 = FT1;
 
1765
}
 
1766
 
 
1767
void OPPROTO op_fmovd_cc(void)
 
1768
{
 
1769
    if (T2)
 
1770
        DT0 = DT1;
 
1771
}
 
1772
 
 
1773
void OPPROTO op_mov_cc(void)
 
1774
{
 
1775
    if (T2)
 
1776
        T0 = T1;
 
1777
}
 
1778
 
 
1779
void OPPROTO op_flushw(void)
 
1780
{
 
1781
    if (env->cansave != NWINDOWS - 2) {
 
1782
        raise_exception(TT_SPILL | (env->otherwin != 0 ? 
 
1783
                                    (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
 
1784
                                    ((env->wstate & 0x7) << 2)));
 
1785
    }
 
1786
}
 
1787
 
 
1788
void OPPROTO op_saved(void)
 
1789
{
 
1790
    env->cansave++;
 
1791
    if (env->otherwin == 0)
 
1792
        env->canrestore--;
 
1793
    else
 
1794
        env->otherwin--;
 
1795
    FORCE_RET();
 
1796
}
 
1797
 
 
1798
void OPPROTO op_restored(void)
 
1799
{
 
1800
    env->canrestore++;
 
1801
    if (env->cleanwin < NWINDOWS - 1)
 
1802
        env->cleanwin++;
 
1803
    if (env->otherwin == 0)
 
1804
        env->cansave--;
 
1805
    else
 
1806
        env->otherwin--;
 
1807
    FORCE_RET();
 
1808
}
 
1809
 
 
1810
void OPPROTO op_popc(void)
 
1811
{
 
1812
    do_popc();
 
1813
}
 
1814
 
 
1815
void OPPROTO op_done(void)
 
1816
{
 
1817
    do_done();
 
1818
}
 
1819
 
 
1820
void OPPROTO op_retry(void)
 
1821
{
 
1822
    do_retry();
 
1823
}
 
1824
 
 
1825
void OPPROTO op_sir(void)
 
1826
{
 
1827
    T0 = 0;  // XXX
 
1828
}
 
1829
 
 
1830
void OPPROTO op_ld_asi_reg()
 
1831
{
 
1832
    T0 += PARAM1;
 
1833
    helper_ld_asi(env->asi, PARAM2, PARAM3);
 
1834
}
 
1835
 
 
1836
void OPPROTO op_st_asi_reg()
 
1837
{
 
1838
    T0 += PARAM1;
 
1839
    helper_st_asi(env->asi, PARAM2, PARAM3);
 
1840
}
 
1841
#endif
 
1842
 
 
1843
void OPPROTO op_ld_asi()
 
1844
{
 
1845
    helper_ld_asi(PARAM1, PARAM2, PARAM3);
 
1846
}
 
1847
 
 
1848
void OPPROTO op_st_asi()
 
1849
{
 
1850
    helper_st_asi(PARAM1, PARAM2, PARAM3);
 
1851
}
 
1852
 
 
1853
#ifdef TARGET_SPARC64
 
1854
// This function uses non-native bit order
 
1855
#define GET_FIELD(X, FROM, TO)                                  \
 
1856
    ((X) >> (63 - (TO)) & ((1ULL << ((TO) - (FROM) + 1)) - 1))
 
1857
 
 
1858
// This function uses the order in the manuals, i.e. bit 0 is 2^0
 
1859
#define GET_FIELD_SP(X, FROM, TO)               \
 
1860
    GET_FIELD(X, 63 - (TO), 63 - (FROM))
 
1861
 
 
1862
void OPPROTO op_array8()
 
1863
{
 
1864
    T0 = (GET_FIELD_SP(T0, 60, 63) << (17 + 2 * T1)) |
 
1865
        (GET_FIELD_SP(T0, 39, 39 + T1 - 1) << (17 + T1)) |
 
1866
        (GET_FIELD_SP(T0, 17 + T1 - 1, 17) << 17) |
 
1867
        (GET_FIELD_SP(T0, 56, 59) << 13) | (GET_FIELD_SP(T0, 35, 38) << 9) |
 
1868
        (GET_FIELD_SP(T0, 13, 16) << 5) | (((T0 >> 55) & 1) << 4) |
 
1869
        (GET_FIELD_SP(T0, 33, 34) << 2) | GET_FIELD_SP(T0, 11, 12);
 
1870
}
 
1871
 
 
1872
void OPPROTO op_array16()
 
1873
{
 
1874
    T0 = ((GET_FIELD_SP(T0, 60, 63) << (17 + 2 * T1)) |
 
1875
          (GET_FIELD_SP(T0, 39, 39 + T1 - 1) << (17 + T1)) |
 
1876
          (GET_FIELD_SP(T0, 17 + T1 - 1, 17) << 17) |
 
1877
          (GET_FIELD_SP(T0, 56, 59) << 13) | (GET_FIELD_SP(T0, 35, 38) << 9) |
 
1878
          (GET_FIELD_SP(T0, 13, 16) << 5) | (((T0 >> 55) & 1) << 4) |
 
1879
          (GET_FIELD_SP(T0, 33, 34) << 2) | GET_FIELD_SP(T0, 11, 12)) << 1;
 
1880
}
 
1881
 
 
1882
void OPPROTO op_array32()
 
1883
{
 
1884
    T0 = ((GET_FIELD_SP(T0, 60, 63) << (17 + 2 * T1)) |
 
1885
          (GET_FIELD_SP(T0, 39, 39 + T1 - 1) << (17 + T1)) |
 
1886
          (GET_FIELD_SP(T0, 17 + T1 - 1, 17) << 17) |
 
1887
          (GET_FIELD_SP(T0, 56, 59) << 13) | (GET_FIELD_SP(T0, 35, 38) << 9) |
 
1888
          (GET_FIELD_SP(T0, 13, 16) << 5) | (((T0 >> 55) & 1) << 4) |
 
1889
          (GET_FIELD_SP(T0, 33, 34) << 2) | GET_FIELD_SP(T0, 11, 12)) << 2;
 
1890
}
 
1891
 
 
1892
void OPPROTO op_alignaddr()
 
1893
{
 
1894
    uint64_t tmp;
 
1895
 
 
1896
    tmp = T0 + T1;
 
1897
    env->gsr &= ~7ULL;
 
1898
    env->gsr |= tmp & 7ULL;
 
1899
    T0 = tmp & ~7ULL;
 
1900
}
 
1901
 
 
1902
void OPPROTO op_faligndata()
 
1903
{
 
1904
    uint64_t tmp;
 
1905
 
 
1906
    tmp = (*((uint64_t *)&DT0)) << ((env->gsr & 7) * 8);
 
1907
    tmp |= (*((uint64_t *)&DT1)) >> (64 - (env->gsr & 7) * 8);
 
1908
    *((uint64_t *)&DT0) = tmp;
 
1909
}
 
1910
 
 
1911
void OPPROTO op_movl_FT0_0(void)
 
1912
{
 
1913
    *((uint32_t *)&FT0) = 0;
 
1914
}
 
1915
 
 
1916
void OPPROTO op_movl_DT0_0(void)
 
1917
{
 
1918
    *((uint64_t *)&DT0) = 0;
 
1919
}
 
1920
 
 
1921
void OPPROTO op_movl_FT0_1(void)
 
1922
{
 
1923
    *((uint32_t *)&FT0) = 0xffffffff;
 
1924
}
 
1925
 
 
1926
void OPPROTO op_movl_DT0_1(void)
 
1927
{
 
1928
    *((uint64_t *)&DT0) = 0xffffffffffffffffULL;
 
1929
}
 
1930
 
 
1931
void OPPROTO op_fnot(void)
 
1932
{
 
1933
    *(uint64_t *)&DT0 = ~*(uint64_t *)&DT1;
 
1934
}
 
1935
 
 
1936
void OPPROTO op_fnots(void)
 
1937
{
 
1938
    *(uint32_t *)&FT0 = ~*(uint32_t *)&FT1;
 
1939
}
 
1940
 
 
1941
void OPPROTO op_fnor(void)
 
1942
{
 
1943
    *(uint64_t *)&DT0 = ~(*(uint64_t *)&DT0 | *(uint64_t *)&DT1);
 
1944
}
 
1945
 
 
1946
void OPPROTO op_fnors(void)
 
1947
{
 
1948
    *(uint32_t *)&FT0 = ~(*(uint32_t *)&FT0 | *(uint32_t *)&FT1);
 
1949
}
 
1950
 
 
1951
void OPPROTO op_for(void)
 
1952
{
 
1953
    *(uint64_t *)&DT0 |= *(uint64_t *)&DT1;
 
1954
}
 
1955
 
 
1956
void OPPROTO op_fors(void)
 
1957
{
 
1958
    *(uint32_t *)&FT0 |= *(uint32_t *)&FT1;
 
1959
}
 
1960
 
 
1961
void OPPROTO op_fxor(void)
 
1962
{
 
1963
    *(uint64_t *)&DT0 ^= *(uint64_t *)&DT1;
 
1964
}
 
1965
 
 
1966
void OPPROTO op_fxors(void)
 
1967
{
 
1968
    *(uint32_t *)&FT0 ^= *(uint32_t *)&FT1;
 
1969
}
 
1970
 
 
1971
void OPPROTO op_fand(void)
 
1972
{
 
1973
    *(uint64_t *)&DT0 &= *(uint64_t *)&DT1;
 
1974
}
 
1975
 
 
1976
void OPPROTO op_fands(void)
 
1977
{
 
1978
    *(uint32_t *)&FT0 &= *(uint32_t *)&FT1;
 
1979
}
 
1980
 
 
1981
void OPPROTO op_fornot(void)
 
1982
{
 
1983
    *(uint64_t *)&DT0 = *(uint64_t *)&DT0 | ~*(uint64_t *)&DT1;
 
1984
}
 
1985
 
 
1986
void OPPROTO op_fornots(void)
 
1987
{
 
1988
    *(uint32_t *)&FT0 = *(uint32_t *)&FT0 | ~*(uint32_t *)&FT1;
 
1989
}
 
1990
 
 
1991
void OPPROTO op_fandnot(void)
 
1992
{
 
1993
    *(uint64_t *)&DT0 = *(uint64_t *)&DT0 & ~*(uint64_t *)&DT1;
 
1994
}
 
1995
 
 
1996
void OPPROTO op_fandnots(void)
 
1997
{
 
1998
    *(uint32_t *)&FT0 = *(uint32_t *)&FT0 & ~*(uint32_t *)&FT1;
 
1999
}
 
2000
 
 
2001
void OPPROTO op_fnand(void)
 
2002
{
 
2003
    *(uint64_t *)&DT0 = ~(*(uint64_t *)&DT0 & *(uint64_t *)&DT1);
 
2004
}
 
2005
 
 
2006
void OPPROTO op_fnands(void)
 
2007
{
 
2008
    *(uint32_t *)&FT0 = ~(*(uint32_t *)&FT0 & *(uint32_t *)&FT1);
 
2009
}
 
2010
 
 
2011
void OPPROTO op_fxnor(void)
 
2012
{
 
2013
    *(uint64_t *)&DT0 ^= ~*(uint64_t *)&DT1;
 
2014
}
 
2015
 
 
2016
void OPPROTO op_fxnors(void)
 
2017
{
 
2018
    *(uint32_t *)&FT0 ^= ~*(uint32_t *)&FT1;
 
2019
}
 
2020
 
 
2021
#ifdef WORDS_BIGENDIAN
 
2022
#define VIS_B64(n) b[7 - (n)]
 
2023
#define VIS_W64(n) w[3 - (n)]
 
2024
#define VIS_SW64(n) sw[3 - (n)]
 
2025
#define VIS_L64(n) l[1 - (n)]
 
2026
#define VIS_B32(n) b[3 - (n)]
 
2027
#define VIS_W32(n) w[1 - (n)]
 
2028
#else
 
2029
#define VIS_B64(n) b[n]
 
2030
#define VIS_W64(n) w[n]
 
2031
#define VIS_SW64(n) sw[n]
 
2032
#define VIS_L64(n) l[n]
 
2033
#define VIS_B32(n) b[n]
 
2034
#define VIS_W32(n) w[n]
 
2035
#endif
 
2036
 
 
2037
typedef union {
 
2038
    uint8_t b[8];
 
2039
    uint16_t w[4];
 
2040
    int16_t sw[4];
 
2041
    uint32_t l[2];
 
2042
    float64 d;
 
2043
} vis64;
 
2044
 
 
2045
typedef union {
 
2046
    uint8_t b[4];
 
2047
    uint16_t w[2];
 
2048
    uint32_t l;
 
2049
    float32 f;
 
2050
} vis32;
 
2051
 
 
2052
void OPPROTO op_fpmerge(void)
 
2053
{
 
2054
    vis64 s, d;
 
2055
 
 
2056
    s.d = DT0;
 
2057
    d.d = DT1;
 
2058
 
 
2059
    // Reverse calculation order to handle overlap
 
2060
    d.VIS_B64(7) = s.VIS_B64(3);
 
2061
    d.VIS_B64(6) = d.VIS_B64(3);
 
2062
    d.VIS_B64(5) = s.VIS_B64(2);
 
2063
    d.VIS_B64(4) = d.VIS_B64(2);
 
2064
    d.VIS_B64(3) = s.VIS_B64(1);
 
2065
    d.VIS_B64(2) = d.VIS_B64(1);
 
2066
    d.VIS_B64(1) = s.VIS_B64(0);
 
2067
    //d.VIS_B64(0) = d.VIS_B64(0);
 
2068
 
 
2069
    DT0 = d.d;
 
2070
}
 
2071
 
 
2072
void OPPROTO op_fmul8x16(void)
 
2073
{
 
2074
    vis64 s, d;
 
2075
    uint32_t tmp;
 
2076
 
 
2077
    s.d = DT0;
 
2078
    d.d = DT1;
 
2079
 
 
2080
#define PMUL(r)                                                 \
 
2081
    tmp = (int32_t)d.VIS_SW64(r) * (int32_t)s.VIS_B64(r);       \
 
2082
    if ((tmp & 0xff) > 0x7f)                                    \
 
2083
        tmp += 0x100;                                           \
 
2084
    d.VIS_W64(r) = tmp >> 8;
 
2085
 
 
2086
    PMUL(0);
 
2087
    PMUL(1);
 
2088
    PMUL(2);
 
2089
    PMUL(3);
 
2090
#undef PMUL
 
2091
 
 
2092
    DT0 = d.d;
 
2093
}
 
2094
 
 
2095
void OPPROTO op_fmul8x16al(void)
 
2096
{
 
2097
    vis64 s, d;
 
2098
    uint32_t tmp;
 
2099
 
 
2100
    s.d = DT0;
 
2101
    d.d = DT1;
 
2102
 
 
2103
#define PMUL(r)                                                 \
 
2104
    tmp = (int32_t)d.VIS_SW64(1) * (int32_t)s.VIS_B64(r);       \
 
2105
    if ((tmp & 0xff) > 0x7f)                                    \
 
2106
        tmp += 0x100;                                           \
 
2107
    d.VIS_W64(r) = tmp >> 8;
 
2108
 
 
2109
    PMUL(0);
 
2110
    PMUL(1);
 
2111
    PMUL(2);
 
2112
    PMUL(3);
 
2113
#undef PMUL
 
2114
 
 
2115
    DT0 = d.d;
 
2116
}
 
2117
 
 
2118
void OPPROTO op_fmul8x16au(void)
 
2119
{
 
2120
    vis64 s, d;
 
2121
    uint32_t tmp;
 
2122
 
 
2123
    s.d = DT0;
 
2124
    d.d = DT1;
 
2125
 
 
2126
#define PMUL(r)                                                 \
 
2127
    tmp = (int32_t)d.VIS_SW64(0) * (int32_t)s.VIS_B64(r);       \
 
2128
    if ((tmp & 0xff) > 0x7f)                                    \
 
2129
        tmp += 0x100;                                           \
 
2130
    d.VIS_W64(r) = tmp >> 8;
 
2131
 
 
2132
    PMUL(0);
 
2133
    PMUL(1);
 
2134
    PMUL(2);
 
2135
    PMUL(3);
 
2136
#undef PMUL
 
2137
 
 
2138
    DT0 = d.d;
 
2139
}
 
2140
 
 
2141
void OPPROTO op_fmul8sux16(void)
 
2142
{
 
2143
    vis64 s, d;
 
2144
    uint32_t tmp;
 
2145
 
 
2146
    s.d = DT0;
 
2147
    d.d = DT1;
 
2148
 
 
2149
#define PMUL(r)                                                         \
 
2150
    tmp = (int32_t)d.VIS_SW64(r) * ((int32_t)s.VIS_SW64(r) >> 8);       \
 
2151
    if ((tmp & 0xff) > 0x7f)                                            \
 
2152
        tmp += 0x100;                                                   \
 
2153
    d.VIS_W64(r) = tmp >> 8;
 
2154
 
 
2155
    PMUL(0);
 
2156
    PMUL(1);
 
2157
    PMUL(2);
 
2158
    PMUL(3);
 
2159
#undef PMUL
 
2160
 
 
2161
    DT0 = d.d;
 
2162
}
 
2163
 
 
2164
void OPPROTO op_fmul8ulx16(void)
 
2165
{
 
2166
    vis64 s, d;
 
2167
    uint32_t tmp;
 
2168
 
 
2169
    s.d = DT0;
 
2170
    d.d = DT1;
 
2171
 
 
2172
#define PMUL(r)                                                         \
 
2173
    tmp = (int32_t)d.VIS_SW64(r) * ((uint32_t)s.VIS_B64(r * 2));        \
 
2174
    if ((tmp & 0xff) > 0x7f)                                            \
 
2175
        tmp += 0x100;                                                   \
 
2176
    d.VIS_W64(r) = tmp >> 8;
 
2177
 
 
2178
    PMUL(0);
 
2179
    PMUL(1);
 
2180
    PMUL(2);
 
2181
    PMUL(3);
 
2182
#undef PMUL
 
2183
 
 
2184
    DT0 = d.d;
 
2185
}
 
2186
 
 
2187
void OPPROTO op_fmuld8sux16(void)
 
2188
{
 
2189
    vis64 s, d;
 
2190
    uint32_t tmp;
 
2191
 
 
2192
    s.d = DT0;
 
2193
    d.d = DT1;
 
2194
 
 
2195
#define PMUL(r)                                                         \
 
2196
    tmp = (int32_t)d.VIS_SW64(r) * ((int32_t)s.VIS_SW64(r) >> 8);       \
 
2197
    if ((tmp & 0xff) > 0x7f)                                            \
 
2198
        tmp += 0x100;                                                   \
 
2199
    d.VIS_L64(r) = tmp;
 
2200
 
 
2201
    // Reverse calculation order to handle overlap
 
2202
    PMUL(1);
 
2203
    PMUL(0);
 
2204
#undef PMUL
 
2205
 
 
2206
    DT0 = d.d;
 
2207
}
 
2208
 
 
2209
void OPPROTO op_fmuld8ulx16(void)
 
2210
{
 
2211
    vis64 s, d;
 
2212
    uint32_t tmp;
 
2213
 
 
2214
    s.d = DT0;
 
2215
    d.d = DT1;
 
2216
 
 
2217
#define PMUL(r)                                                         \
 
2218
    tmp = (int32_t)d.VIS_SW64(r) * ((uint32_t)s.VIS_B64(r * 2));        \
 
2219
    if ((tmp & 0xff) > 0x7f)                                            \
 
2220
        tmp += 0x100;                                                   \
 
2221
    d.VIS_L64(r) = tmp;
 
2222
 
 
2223
    // Reverse calculation order to handle overlap
 
2224
    PMUL(1);
 
2225
    PMUL(0);
 
2226
#undef PMUL
 
2227
 
 
2228
    DT0 = d.d;
 
2229
}
 
2230
 
 
2231
void OPPROTO op_fexpand(void)
 
2232
{
 
2233
    vis32 s;
 
2234
    vis64 d;
 
2235
 
 
2236
    s.l = (uint32_t)(*(uint64_t *)&DT0 & 0xffffffff);
 
2237
    d.d = DT1;
 
2238
    d.VIS_L64(0) = s.VIS_W32(0) << 4;
 
2239
    d.VIS_L64(1) = s.VIS_W32(1) << 4;
 
2240
    d.VIS_L64(2) = s.VIS_W32(2) << 4;
 
2241
    d.VIS_L64(3) = s.VIS_W32(3) << 4;
 
2242
 
 
2243
    DT0 = d.d;
 
2244
}
 
2245
 
 
2246
#define VIS_OP(name, F)                                 \
 
2247
    void OPPROTO name##16(void)                         \
 
2248
    {                                                   \
 
2249
        vis64 s, d;                                     \
 
2250
                                                        \
 
2251
        s.d = DT0;                                      \
 
2252
        d.d = DT1;                                      \
 
2253
                                                        \
 
2254
        d.VIS_W64(0) = F(d.VIS_W64(0), s.VIS_W64(0));   \
 
2255
        d.VIS_W64(1) = F(d.VIS_W64(1), s.VIS_W64(1));   \
 
2256
        d.VIS_W64(2) = F(d.VIS_W64(2), s.VIS_W64(2));   \
 
2257
        d.VIS_W64(3) = F(d.VIS_W64(3), s.VIS_W64(3));   \
 
2258
                                                        \
 
2259
        DT0 = d.d;                                      \
 
2260
    }                                                   \
 
2261
                                                        \
 
2262
    void OPPROTO name##16s(void)                        \
 
2263
    {                                                   \
 
2264
        vis32 s, d;                                     \
 
2265
                                                        \
 
2266
        s.f = FT0;                                      \
 
2267
        d.f = FT1;                                      \
 
2268
                                                        \
 
2269
        d.VIS_W32(0) = F(d.VIS_W32(0), s.VIS_W32(0));   \
 
2270
        d.VIS_W32(1) = F(d.VIS_W32(1), s.VIS_W32(1));   \
 
2271
                                                        \
 
2272
        FT0 = d.f;                                      \
 
2273
    }                                                   \
 
2274
                                                        \
 
2275
    void OPPROTO name##32(void)                         \
 
2276
    {                                                   \
 
2277
        vis64 s, d;                                     \
 
2278
                                                        \
 
2279
        s.d = DT0;                                      \
 
2280
        d.d = DT1;                                      \
 
2281
                                                        \
 
2282
        d.VIS_L64(0) = F(d.VIS_L64(0), s.VIS_L64(0));   \
 
2283
        d.VIS_L64(1) = F(d.VIS_L64(1), s.VIS_L64(1));   \
 
2284
                                                        \
 
2285
        DT0 = d.d;                                      \
 
2286
    }                                                   \
 
2287
                                                        \
 
2288
    void OPPROTO name##32s(void)                        \
 
2289
    {                                                   \
 
2290
        vis32 s, d;                                     \
 
2291
                                                        \
 
2292
        s.f = FT0;                                      \
 
2293
        d.f = FT1;                                      \
 
2294
                                                        \
 
2295
        d.l = F(d.l, s.l);                              \
 
2296
                                                        \
 
2297
        FT0 = d.f;                                      \
 
2298
    }
 
2299
 
 
2300
#define FADD(a, b) ((a) + (b))
 
2301
#define FSUB(a, b) ((a) - (b))
 
2302
VIS_OP(op_fpadd, FADD)
 
2303
VIS_OP(op_fpsub, FSUB)
 
2304
 
 
2305
#define VIS_CMPOP(name, F)                                        \
 
2306
    void OPPROTO name##16(void)                                   \
 
2307
    {                                                             \
 
2308
        vis64 s, d;                                               \
 
2309
                                                                  \
 
2310
        s.d = DT0;                                                \
 
2311
        d.d = DT1;                                                \
 
2312
                                                                  \
 
2313
        d.VIS_W64(0) = F(d.VIS_W64(0), s.VIS_W64(0))? 1: 0;       \
 
2314
        d.VIS_W64(0) |= F(d.VIS_W64(1), s.VIS_W64(1))? 2: 0;      \
 
2315
        d.VIS_W64(0) |= F(d.VIS_W64(2), s.VIS_W64(2))? 4: 0;      \
 
2316
        d.VIS_W64(0) |= F(d.VIS_W64(3), s.VIS_W64(3))? 8: 0;      \
 
2317
                                                                  \
 
2318
        DT0 = d.d;                                                \
 
2319
    }                                                             \
 
2320
                                                                  \
 
2321
    void OPPROTO name##32(void)                                   \
 
2322
    {                                                             \
 
2323
        vis64 s, d;                                               \
 
2324
                                                                  \
 
2325
        s.d = DT0;                                                \
 
2326
        d.d = DT1;                                                \
 
2327
                                                                  \
 
2328
        d.VIS_L64(0) = F(d.VIS_L64(0), s.VIS_L64(0))? 1: 0;       \
 
2329
        d.VIS_L64(0) |= F(d.VIS_L64(1), s.VIS_L64(1))? 2: 0;      \
 
2330
                                                                  \
 
2331
        DT0 = d.d;                                                \
 
2332
    }
 
2333
 
 
2334
#define FCMPGT(a, b) ((a) > (b))
 
2335
#define FCMPEQ(a, b) ((a) == (b))
 
2336
#define FCMPLE(a, b) ((a) <= (b))
 
2337
#define FCMPNE(a, b) ((a) != (b))
 
2338
 
 
2339
VIS_CMPOP(op_fcmpgt, FCMPGT)
 
2340
VIS_CMPOP(op_fcmpeq, FCMPEQ)
 
2341
VIS_CMPOP(op_fcmple, FCMPLE)
 
2342
VIS_CMPOP(op_fcmpne, FCMPNE)
 
2343
 
 
2344
#endif