Revision 1a2fb1c0 target-sparc/op.c
| b/target-sparc/op.c | ||
|---|---|---|
| 19 | 19 |
*/ |
| 20 | 20 |
|
| 21 | 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" |
|
| 22 |
#include "helper.h" |
|
| 120 | 23 |
|
| 121 | 24 |
#define REGNAME f0 |
| 122 | 25 |
#define REG (env->fpr[0]) |
| ... | ... | |
| 267 | 170 |
#endif |
| 268 | 171 |
|
| 269 | 172 |
#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 | 173 |
#define XFLAG_SET(x) ((env->xcc&x)?1:0) |
| 303 |
|
|
| 304 |
#else |
|
| 305 |
#define EIP (env->pc) |
|
| 306 | 174 |
#endif |
| 307 | 175 |
|
| 308 | 176 |
#define FLAG_SET(x) ((env->psr&x)?1:0) |
| 309 | 177 |
|
| 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 | 178 |
void OPPROTO op_add_T1_T0_cc(void) |
| 371 | 179 |
{
|
| 372 | 180 |
target_ulong src1; |
| ... | ... | |
| 565 | 373 |
FORCE_RET(); |
| 566 | 374 |
} |
| 567 | 375 |
|
| 568 |
void OPPROTO op_sub_T1_T0(void) |
|
| 569 |
{
|
|
| 570 |
T0 -= T1; |
|
| 571 |
} |
|
| 572 |
|
|
| 573 | 376 |
void OPPROTO op_sub_T1_T0_cc(void) |
| 574 | 377 |
{
|
| 575 | 378 |
target_ulong src1; |
| ... | ... | |
| 765 | 568 |
FORCE_RET(); |
| 766 | 569 |
} |
| 767 | 570 |
|
| 768 |
void OPPROTO op_and_T1_T0(void) |
|
| 769 |
{
|
|
| 770 |
T0 &= T1; |
|
| 771 |
} |
|
| 772 |
|
|
| 773 |
void OPPROTO op_or_T1_T0(void) |
|
| 774 |
{
|
|
| 775 |
T0 |= T1; |
|
| 776 |
} |
|
| 777 |
|
|
| 778 |
void OPPROTO op_xor_T1_T0(void) |
|
| 779 |
{
|
|
| 780 |
T0 ^= T1; |
|
| 781 |
} |
|
| 782 |
|
|
| 783 | 571 |
void OPPROTO op_andn_T1_T0(void) |
| 784 | 572 |
{
|
| 785 | 573 |
T0 &= ~T1; |
| ... | ... | |
| 921 | 709 |
} |
| 922 | 710 |
|
| 923 | 711 |
#ifdef TARGET_SPARC64 |
| 924 |
void OPPROTO op_mulx_T1_T0(void) |
|
| 925 |
{
|
|
| 926 |
T0 *= T1; |
|
| 927 |
FORCE_RET(); |
|
| 928 |
} |
|
| 929 |
|
|
| 930 | 712 |
void OPPROTO op_udivx_T1_T0(void) |
| 931 | 713 |
{
|
| 932 | 714 |
if (T1 == 0) {
|
| ... | ... | |
| 972 | 754 |
FORCE_RET(); |
| 973 | 755 |
} |
| 974 | 756 |
|
| 975 |
void OPPROTO op_sll(void) |
|
| 976 |
{
|
|
| 977 |
T0 <<= (T1 & 0x1f); |
|
| 978 |
} |
|
| 979 |
|
|
| 980 |
#ifdef TARGET_SPARC64 |
|
| 981 |
void OPPROTO op_sllx(void) |
|
| 982 |
{
|
|
| 983 |
T0 <<= (T1 & 0x3f); |
|
| 984 |
} |
|
| 985 |
|
|
| 986 |
void OPPROTO op_srl(void) |
|
| 987 |
{
|
|
| 988 |
T0 = (T0 & 0xffffffff) >> (T1 & 0x1f); |
|
| 989 |
} |
|
| 990 |
|
|
| 991 |
void OPPROTO op_srlx(void) |
|
| 992 |
{
|
|
| 993 |
T0 >>= (T1 & 0x3f); |
|
| 994 |
} |
|
| 995 |
|
|
| 996 |
void OPPROTO op_sra(void) |
|
| 997 |
{
|
|
| 998 |
T0 = ((int32_t) (T0 & 0xffffffff)) >> (T1 & 0x1f); |
|
| 999 |
} |
|
| 1000 |
|
|
| 1001 |
void OPPROTO op_srax(void) |
|
| 1002 |
{
|
|
| 1003 |
T0 = ((int64_t) T0) >> (T1 & 0x3f); |
|
| 1004 |
} |
|
| 1005 |
#else |
|
| 1006 |
void OPPROTO op_srl(void) |
|
| 1007 |
{
|
|
| 1008 |
T0 >>= (T1 & 0x1f); |
|
| 1009 |
} |
|
| 1010 |
|
|
| 1011 |
void OPPROTO op_sra(void) |
|
| 1012 |
{
|
|
| 1013 |
T0 = ((int32_t) T0) >> (T1 & 0x1f); |
|
| 1014 |
} |
|
| 1015 |
#endif |
|
| 1016 |
|
|
| 1017 | 757 |
/* Load and store */ |
| 1018 | 758 |
#define MEMSUFFIX _raw |
| 1019 | 759 |
#include "op_mem.h" |
| ... | ... | |
| 1042 | 782 |
} |
| 1043 | 783 |
|
| 1044 | 784 |
#ifndef TARGET_SPARC64 |
| 1045 |
void OPPROTO op_rdpsr(void) |
|
| 1046 |
{
|
|
| 1047 |
do_rdpsr(); |
|
| 1048 |
} |
|
| 1049 |
|
|
| 1050 |
void OPPROTO op_wrpsr(void) |
|
| 1051 |
{
|
|
| 1052 |
do_wrpsr(); |
|
| 1053 |
FORCE_RET(); |
|
| 1054 |
} |
|
| 1055 |
|
|
| 1056 |
void OPPROTO op_wrwim(void) |
|
| 1057 |
{
|
|
| 1058 |
#if NWINDOWS == 32 |
|
| 1059 |
env->wim = T0; |
|
| 1060 |
#else |
|
| 1061 |
env->wim = T0 & ((1 << NWINDOWS) - 1); |
|
| 1062 |
#endif |
|
| 1063 |
} |
|
| 1064 |
|
|
| 1065 |
void OPPROTO op_rett(void) |
|
| 1066 |
{
|
|
| 1067 |
helper_rett(); |
|
| 1068 |
FORCE_RET(); |
|
| 1069 |
} |
|
| 1070 |
|
|
| 1071 | 785 |
/* XXX: use another pointer for %iN registers to avoid slow wrapping |
| 1072 | 786 |
handling ? */ |
| 1073 | 787 |
void OPPROTO op_save(void) |
| ... | ... | |
| 1178 | 892 |
env->tt[env->tl] = T0; |
| 1179 | 893 |
} |
| 1180 | 894 |
|
| 1181 |
void OPPROTO op_rdpstate(void) |
|
| 1182 |
{
|
|
| 1183 |
T0 = env->pstate; |
|
| 1184 |
} |
|
| 1185 |
|
|
| 1186 |
void OPPROTO op_wrpstate(void) |
|
| 1187 |
{
|
|
| 1188 |
do_wrpstate(); |
|
| 1189 |
} |
|
| 1190 |
|
|
| 1191 | 895 |
// CWP handling is reversed in V9, but we still use the V8 register |
| 1192 | 896 |
// order. |
| 1193 | 897 |
void OPPROTO op_rdcwp(void) |
| ... | ... | |
| 1247 | 951 |
FORCE_RET(); |
| 1248 | 952 |
} |
| 1249 | 953 |
|
| 1250 |
void OPPROTO op_trap_T0(void) |
|
| 1251 |
{
|
|
| 1252 |
env->exception_index = TT_TRAP + (T0 & 0x7f); |
|
| 1253 |
cpu_loop_exit(); |
|
| 1254 |
FORCE_RET(); |
|
| 1255 |
} |
|
| 1256 |
|
|
| 1257 |
void OPPROTO op_trapcc_T0(void) |
|
| 1258 |
{
|
|
| 1259 |
if (T2) {
|
|
| 1260 |
env->exception_index = TT_TRAP + (T0 & 0x7f); |
|
| 1261 |
cpu_loop_exit(); |
|
| 1262 |
} |
|
| 1263 |
FORCE_RET(); |
|
| 1264 |
} |
|
| 1265 |
|
|
| 1266 | 954 |
void OPPROTO op_fpexception_im(void) |
| 1267 | 955 |
{
|
| 1268 | 956 |
env->exception_index = TT_FP_EXCP; |
| ... | ... | |
| 1272 | 960 |
FORCE_RET(); |
| 1273 | 961 |
} |
| 1274 | 962 |
|
| 1275 |
void OPPROTO op_debug(void) |
|
| 1276 |
{
|
|
| 1277 |
helper_debug(); |
|
| 1278 |
} |
|
| 1279 |
|
|
| 1280 | 963 |
void OPPROTO op_eval_ba(void) |
| 1281 | 964 |
{
|
| 1282 | 965 |
T2 = 1; |
| ... | ... | |
| 1499 | 1182 |
{
|
| 1500 | 1183 |
T2 = ((int64_t)T0 >= 0); |
| 1501 | 1184 |
} |
| 1502 |
|
|
| 1503 |
void OPPROTO op_jmp_im64(void) |
|
| 1504 |
{
|
|
| 1505 |
env->pc = PARAMQ1; |
|
| 1506 |
} |
|
| 1507 |
|
|
| 1508 |
void OPPROTO op_movq_npc_im64(void) |
|
| 1509 |
{
|
|
| 1510 |
env->npc = PARAMQ1; |
|
| 1511 |
} |
|
| 1512 | 1185 |
#endif |
| 1513 | 1186 |
|
| 1514 |
void OPPROTO op_jmp_im(void) |
|
| 1515 |
{
|
|
| 1516 |
env->pc = (uint32_t)PARAM1; |
|
| 1517 |
} |
|
| 1518 |
|
|
| 1519 |
void OPPROTO op_movl_npc_im(void) |
|
| 1520 |
{
|
|
| 1521 |
env->npc = (uint32_t)PARAM1; |
|
| 1522 |
} |
|
| 1523 |
|
|
| 1524 |
void OPPROTO op_movl_npc_T0(void) |
|
| 1525 |
{
|
|
| 1526 |
env->npc = T0; |
|
| 1527 |
} |
|
| 1528 |
|
|
| 1529 | 1187 |
void OPPROTO op_mov_pc_npc(void) |
| 1530 | 1188 |
{
|
| 1531 | 1189 |
env->pc = env->npc; |
| ... | ... | |
| 1556 | 1214 |
FORCE_RET(); |
| 1557 | 1215 |
} |
| 1558 | 1216 |
|
| 1559 |
void OPPROTO op_flush_T0(void) |
|
| 1560 |
{
|
|
| 1561 |
helper_flush(T0); |
|
| 1562 |
} |
|
| 1563 |
|
|
| 1564 | 1217 |
void OPPROTO op_clear_ieee_excp_and_FTT(void) |
| 1565 | 1218 |
{
|
| 1566 | 1219 |
env->fsr &= ~(FSR_FTT_MASK | FSR_CEXC_MASK);; |
| ... | ... | |
| 1993 | 1646 |
env->otherwin--; |
| 1994 | 1647 |
FORCE_RET(); |
| 1995 | 1648 |
} |
| 1996 |
|
|
| 1997 |
void OPPROTO op_popc(void) |
|
| 1998 |
{
|
|
| 1999 |
do_popc(); |
|
| 2000 |
} |
|
| 2001 |
|
|
| 2002 |
void OPPROTO op_done(void) |
|
| 2003 |
{
|
|
| 2004 |
do_done(); |
|
| 2005 |
} |
|
| 2006 |
|
|
| 2007 |
void OPPROTO op_retry(void) |
|
| 2008 |
{
|
|
| 2009 |
do_retry(); |
|
| 2010 |
} |
|
| 2011 |
|
|
| 2012 |
void OPPROTO op_sir(void) |
|
| 2013 |
{
|
|
| 2014 |
T0 = 0; // XXX |
|
| 2015 |
} |
|
| 2016 |
|
|
| 2017 |
void OPPROTO op_ld_asi_reg() |
|
| 2018 |
{
|
|
| 2019 |
T0 += PARAM1; |
|
| 2020 |
helper_ld_asi(env->asi, PARAM2, PARAM3); |
|
| 2021 |
} |
|
| 2022 |
|
|
| 2023 |
void OPPROTO op_st_asi_reg() |
|
| 2024 |
{
|
|
| 2025 |
T0 += PARAM1; |
|
| 2026 |
helper_st_asi(env->asi, PARAM2); |
|
| 2027 |
} |
|
| 2028 |
|
|
| 2029 |
void OPPROTO op_ldf_asi_reg() |
|
| 2030 |
{
|
|
| 2031 |
T0 += PARAM1; |
|
| 2032 |
helper_ldf_asi(env->asi, PARAM2, PARAM3); |
|
| 2033 |
} |
|
| 2034 |
|
|
| 2035 |
void OPPROTO op_stf_asi_reg() |
|
| 2036 |
{
|
|
| 2037 |
T0 += PARAM1; |
|
| 2038 |
helper_stf_asi(env->asi, PARAM2, PARAM3); |
|
| 2039 |
} |
|
| 2040 |
|
|
| 2041 |
void OPPROTO op_ldf_asi() |
|
| 2042 |
{
|
|
| 2043 |
helper_ldf_asi(PARAM1, PARAM2, PARAM3); |
|
| 2044 |
} |
|
| 2045 |
|
|
| 2046 |
void OPPROTO op_stf_asi() |
|
| 2047 |
{
|
|
| 2048 |
helper_stf_asi(PARAM1, PARAM2, PARAM3); |
|
| 2049 |
} |
|
| 2050 |
|
|
| 2051 |
void OPPROTO op_ldstub_asi_reg() /* XXX: should be atomically */ |
|
| 2052 |
{
|
|
| 2053 |
target_ulong tmp; |
|
| 2054 |
|
|
| 2055 |
T0 += PARAM1; |
|
| 2056 |
helper_ld_asi(env->asi, 1, 0); |
|
| 2057 |
tmp = T1; |
|
| 2058 |
T1 = 0xff; |
|
| 2059 |
helper_st_asi(env->asi, 1); |
|
| 2060 |
T1 = tmp; |
|
| 2061 |
} |
|
| 2062 |
|
|
| 2063 |
void OPPROTO op_swap_asi_reg() /* XXX: should be atomically */ |
|
| 2064 |
{
|
|
| 2065 |
target_ulong tmp1, tmp2; |
|
| 2066 |
|
|
| 2067 |
T0 += PARAM1; |
|
| 2068 |
tmp1 = T1; |
|
| 2069 |
helper_ld_asi(env->asi, 4, 0); |
|
| 2070 |
tmp2 = T1; |
|
| 2071 |
T1 = tmp1; |
|
| 2072 |
helper_st_asi(env->asi, 4); |
|
| 2073 |
T1 = tmp2; |
|
| 2074 |
} |
|
| 2075 |
|
|
| 2076 |
void OPPROTO op_ldda_asi() |
|
| 2077 |
{
|
|
| 2078 |
helper_ld_asi(PARAM1, 8, 0); |
|
| 2079 |
T0 = T1 & 0xffffffffUL; |
|
| 2080 |
T1 >>= 32; |
|
| 2081 |
} |
|
| 2082 |
|
|
| 2083 |
void OPPROTO op_ldda_asi_reg() |
|
| 2084 |
{
|
|
| 2085 |
T0 += PARAM1; |
|
| 2086 |
helper_ld_asi(env->asi, 8, 0); |
|
| 2087 |
T0 = T1 & 0xffffffffUL; |
|
| 2088 |
T1 >>= 32; |
|
| 2089 |
} |
|
| 2090 |
|
|
| 2091 |
void OPPROTO op_stda_asi() |
|
| 2092 |
{
|
|
| 2093 |
T1 <<= 32; |
|
| 2094 |
T1 += T2 & 0xffffffffUL; |
|
| 2095 |
helper_st_asi(PARAM1, 8); |
|
| 2096 |
} |
|
| 2097 |
|
|
| 2098 |
void OPPROTO op_stda_asi_reg() |
|
| 2099 |
{
|
|
| 2100 |
T0 += PARAM1; |
|
| 2101 |
T1 <<= 32; |
|
| 2102 |
T1 += T2 & 0xffffffffUL; |
|
| 2103 |
helper_st_asi(env->asi, 8); |
|
| 2104 |
} |
|
| 2105 |
|
|
| 2106 |
void OPPROTO op_cas_asi() /* XXX: should be atomically */ |
|
| 2107 |
{
|
|
| 2108 |
target_ulong tmp; |
|
| 2109 |
|
|
| 2110 |
tmp = T1 & 0xffffffffUL; |
|
| 2111 |
helper_ld_asi(PARAM1, 4, 0); |
|
| 2112 |
if (tmp == T1) {
|
|
| 2113 |
tmp = T1; |
|
| 2114 |
T1 = T2 & 0xffffffffUL; |
|
| 2115 |
helper_st_asi(PARAM1, 4); |
|
| 2116 |
T1 = tmp; |
|
| 2117 |
} |
|
| 2118 |
T1 &= 0xffffffffUL; |
|
| 2119 |
} |
|
| 2120 |
|
|
| 2121 |
void OPPROTO op_cas_asi_reg() /* XXX: should be atomically */ |
|
| 2122 |
{
|
|
| 2123 |
target_ulong tmp; |
|
| 2124 |
|
|
| 2125 |
T0 += PARAM1; |
|
| 2126 |
tmp = T1 & 0xffffffffUL; |
|
| 2127 |
helper_ld_asi(env->asi, 4, 0); |
|
| 2128 |
if (tmp == T1) {
|
|
| 2129 |
tmp = T1; |
|
| 2130 |
T1 = T2 & 0xffffffffUL; |
|
| 2131 |
helper_st_asi(env->asi, 4); |
|
| 2132 |
T1 = tmp; |
|
| 2133 |
} |
|
| 2134 |
T1 &= 0xffffffffUL; |
|
| 2135 |
} |
|
| 2136 |
|
|
| 2137 |
void OPPROTO op_casx_asi() /* XXX: should be atomically */ |
|
| 2138 |
{
|
|
| 2139 |
target_ulong tmp; |
|
| 2140 |
|
|
| 2141 |
tmp = T1; |
|
| 2142 |
helper_ld_asi(PARAM1, 8, 0); |
|
| 2143 |
if (tmp == T1) {
|
|
| 2144 |
tmp = T1; |
|
| 2145 |
T1 = T2; |
|
| 2146 |
helper_st_asi(PARAM1, 8); |
|
| 2147 |
T1 = tmp; |
|
| 2148 |
} |
|
| 2149 |
} |
|
| 2150 |
|
|
| 2151 |
void OPPROTO op_casx_asi_reg() /* XXX: should be atomically */ |
|
| 2152 |
{
|
|
| 2153 |
target_ulong tmp; |
|
| 2154 |
|
|
| 2155 |
T0 += PARAM1; |
|
| 2156 |
tmp = T1; |
|
| 2157 |
helper_ld_asi(env->asi, 8, 0); |
|
| 2158 |
if (tmp == T1) {
|
|
| 2159 |
tmp = T1; |
|
| 2160 |
T1 = T2; |
|
| 2161 |
helper_st_asi(env->asi, 8); |
|
| 2162 |
T1 = tmp; |
|
| 2163 |
} |
|
| 2164 |
} |
|
| 2165 |
#endif |
|
| 2166 |
|
|
| 2167 |
#if !defined(CONFIG_USER_ONLY) || defined(TARGET_SPARC64) |
|
| 2168 |
void OPPROTO op_ld_asi() |
|
| 2169 |
{
|
|
| 2170 |
helper_ld_asi(PARAM1, PARAM2, PARAM3); |
|
| 2171 |
} |
|
| 2172 |
|
|
| 2173 |
void OPPROTO op_st_asi() |
|
| 2174 |
{
|
|
| 2175 |
helper_st_asi(PARAM1, PARAM2); |
|
| 2176 |
} |
|
| 2177 |
|
|
| 2178 |
void OPPROTO op_ldstub_asi() /* XXX: should be atomically */ |
|
| 2179 |
{
|
|
| 2180 |
target_ulong tmp; |
|
| 2181 |
|
|
| 2182 |
helper_ld_asi(PARAM1, 1, 0); |
|
| 2183 |
tmp = T1; |
|
| 2184 |
T1 = 0xff; |
|
| 2185 |
helper_st_asi(PARAM1, 1); |
|
| 2186 |
T1 = tmp; |
|
| 2187 |
} |
|
| 2188 |
|
|
| 2189 |
void OPPROTO op_swap_asi() /* XXX: should be atomically */ |
|
| 2190 |
{
|
|
| 2191 |
target_ulong tmp1, tmp2; |
|
| 2192 |
|
|
| 2193 |
tmp1 = T1; |
|
| 2194 |
helper_ld_asi(PARAM1, 4, 0); |
|
| 2195 |
tmp2 = T1; |
|
| 2196 |
T1 = tmp1; |
|
| 2197 |
helper_st_asi(PARAM1, 4); |
|
| 2198 |
T1 = tmp2; |
|
| 2199 |
} |
|
| 2200 | 1649 |
#endif |
| 2201 | 1650 |
|
| 2202 | 1651 |
#ifdef TARGET_SPARC64 |
Also available in: Unified diff