Revision 8f6f6026 target-mips/op_mem.c
| b/target-mips/op_mem.c | ||
|---|---|---|
| 22 | 22 |
void glue(op_lb, MEMSUFFIX) (void) |
| 23 | 23 |
{
|
| 24 | 24 |
T0 = glue(ldsb, MEMSUFFIX)(T0); |
| 25 |
RETURN();
|
|
| 25 |
FORCE_RET();
|
|
| 26 | 26 |
} |
| 27 | 27 |
|
| 28 | 28 |
void glue(op_lbu, MEMSUFFIX) (void) |
| 29 | 29 |
{
|
| 30 | 30 |
T0 = glue(ldub, MEMSUFFIX)(T0); |
| 31 |
RETURN();
|
|
| 31 |
FORCE_RET();
|
|
| 32 | 32 |
} |
| 33 | 33 |
|
| 34 | 34 |
void glue(op_sb, MEMSUFFIX) (void) |
| 35 | 35 |
{
|
| 36 | 36 |
glue(stb, MEMSUFFIX)(T0, T1); |
| 37 |
RETURN();
|
|
| 37 |
FORCE_RET();
|
|
| 38 | 38 |
} |
| 39 | 39 |
|
| 40 | 40 |
void glue(op_lh, MEMSUFFIX) (void) |
| 41 | 41 |
{
|
| 42 | 42 |
T0 = glue(ldsw, MEMSUFFIX)(T0); |
| 43 |
RETURN();
|
|
| 43 |
FORCE_RET();
|
|
| 44 | 44 |
} |
| 45 | 45 |
|
| 46 | 46 |
void glue(op_lhu, MEMSUFFIX) (void) |
| 47 | 47 |
{
|
| 48 | 48 |
T0 = glue(lduw, MEMSUFFIX)(T0); |
| 49 |
RETURN();
|
|
| 49 |
FORCE_RET();
|
|
| 50 | 50 |
} |
| 51 | 51 |
|
| 52 | 52 |
void glue(op_sh, MEMSUFFIX) (void) |
| 53 | 53 |
{
|
| 54 | 54 |
glue(stw, MEMSUFFIX)(T0, T1); |
| 55 |
RETURN();
|
|
| 55 |
FORCE_RET();
|
|
| 56 | 56 |
} |
| 57 | 57 |
|
| 58 | 58 |
void glue(op_lw, MEMSUFFIX) (void) |
| 59 | 59 |
{
|
| 60 | 60 |
T0 = glue(ldl, MEMSUFFIX)(T0); |
| 61 |
RETURN();
|
|
| 61 |
FORCE_RET();
|
|
| 62 | 62 |
} |
| 63 | 63 |
|
| 64 | 64 |
void glue(op_lwu, MEMSUFFIX) (void) |
| 65 | 65 |
{
|
| 66 | 66 |
T0 = (uint32_t)glue(ldl, MEMSUFFIX)(T0); |
| 67 |
RETURN();
|
|
| 67 |
FORCE_RET();
|
|
| 68 | 68 |
} |
| 69 | 69 |
|
| 70 | 70 |
void glue(op_sw, MEMSUFFIX) (void) |
| 71 | 71 |
{
|
| 72 | 72 |
glue(stl, MEMSUFFIX)(T0, T1); |
| 73 |
RETURN();
|
|
| 73 |
FORCE_RET();
|
|
| 74 | 74 |
} |
| 75 | 75 |
|
| 76 | 76 |
/* "half" load and stores. We must do the memory access inline, |
| ... | ... | |
| 106 | 106 |
T1 = (T1 & 0xFFFFFF00) | tmp; |
| 107 | 107 |
} |
| 108 | 108 |
T1 = (int32_t)T1; |
| 109 |
RETURN();
|
|
| 109 |
FORCE_RET();
|
|
| 110 | 110 |
} |
| 111 | 111 |
|
| 112 | 112 |
void glue(op_lwr, MEMSUFFIX) (void) |
| ... | ... | |
| 131 | 131 |
T1 = (T1 & 0x00FFFFFF) | (tmp << 24); |
| 132 | 132 |
} |
| 133 | 133 |
T1 = (int32_t)T1; |
| 134 |
RETURN();
|
|
| 134 |
FORCE_RET();
|
|
| 135 | 135 |
} |
| 136 | 136 |
|
| 137 | 137 |
void glue(op_swl, MEMSUFFIX) (void) |
| ... | ... | |
| 147 | 147 |
if (GET_LMASK(T0) == 0) |
| 148 | 148 |
glue(stb, MEMSUFFIX)(GET_OFFSET(T0, 3), (uint8_t)T1); |
| 149 | 149 |
|
| 150 |
RETURN();
|
|
| 150 |
FORCE_RET();
|
|
| 151 | 151 |
} |
| 152 | 152 |
|
| 153 | 153 |
void glue(op_swr, MEMSUFFIX) (void) |
| ... | ... | |
| 163 | 163 |
if (GET_LMASK(T0) == 3) |
| 164 | 164 |
glue(stb, MEMSUFFIX)(GET_OFFSET(T0, -3), (uint8_t)(T1 >> 24)); |
| 165 | 165 |
|
| 166 |
RETURN();
|
|
| 166 |
FORCE_RET();
|
|
| 167 | 167 |
} |
| 168 | 168 |
|
| 169 | 169 |
void glue(op_ll, MEMSUFFIX) (void) |
| ... | ... | |
| 171 | 171 |
T1 = T0; |
| 172 | 172 |
T0 = glue(ldl, MEMSUFFIX)(T0); |
| 173 | 173 |
env->CP0_LLAddr = T1; |
| 174 |
RETURN();
|
|
| 174 |
FORCE_RET();
|
|
| 175 | 175 |
} |
| 176 | 176 |
|
| 177 | 177 |
void glue(op_sc, MEMSUFFIX) (void) |
| ... | ... | |
| 187 | 187 |
} else {
|
| 188 | 188 |
T0 = 0; |
| 189 | 189 |
} |
| 190 |
RETURN();
|
|
| 190 |
FORCE_RET();
|
|
| 191 | 191 |
} |
| 192 | 192 |
|
| 193 | 193 |
#if defined(TARGET_MIPS64) |
| 194 | 194 |
void glue(op_ld, MEMSUFFIX) (void) |
| 195 | 195 |
{
|
| 196 | 196 |
T0 = glue(ldq, MEMSUFFIX)(T0); |
| 197 |
RETURN();
|
|
| 197 |
FORCE_RET();
|
|
| 198 | 198 |
} |
| 199 | 199 |
|
| 200 | 200 |
void glue(op_sd, MEMSUFFIX) (void) |
| 201 | 201 |
{
|
| 202 | 202 |
glue(stq, MEMSUFFIX)(T0, T1); |
| 203 |
RETURN();
|
|
| 203 |
FORCE_RET();
|
|
| 204 | 204 |
} |
| 205 | 205 |
|
| 206 | 206 |
/* "half" load and stores. We must do the memory access inline, |
| ... | ... | |
| 254 | 254 |
T1 = (T1 & 0xFFFFFFFFFFFFFF00ULL) | tmp; |
| 255 | 255 |
} |
| 256 | 256 |
|
| 257 |
RETURN();
|
|
| 257 |
FORCE_RET();
|
|
| 258 | 258 |
} |
| 259 | 259 |
|
| 260 | 260 |
void glue(op_ldr, MEMSUFFIX) (void) |
| ... | ... | |
| 299 | 299 |
T1 = (T1 & 0x00FFFFFFFFFFFFFFULL) | (tmp << 56); |
| 300 | 300 |
} |
| 301 | 301 |
|
| 302 |
RETURN();
|
|
| 302 |
FORCE_RET();
|
|
| 303 | 303 |
} |
| 304 | 304 |
|
| 305 | 305 |
void glue(op_sdl, MEMSUFFIX) (void) |
| ... | ... | |
| 327 | 327 |
if (GET_LMASK64(T0) <= 0) |
| 328 | 328 |
glue(stb, MEMSUFFIX)(GET_OFFSET(T0, 7), (uint8_t)T1); |
| 329 | 329 |
|
| 330 |
RETURN();
|
|
| 330 |
FORCE_RET();
|
|
| 331 | 331 |
} |
| 332 | 332 |
|
| 333 | 333 |
void glue(op_sdr, MEMSUFFIX) (void) |
| ... | ... | |
| 355 | 355 |
if (GET_LMASK64(T0) == 7) |
| 356 | 356 |
glue(stb, MEMSUFFIX)(GET_OFFSET(T0, -7), (uint8_t)(T1 >> 56)); |
| 357 | 357 |
|
| 358 |
RETURN();
|
|
| 358 |
FORCE_RET();
|
|
| 359 | 359 |
} |
| 360 | 360 |
|
| 361 | 361 |
void glue(op_lld, MEMSUFFIX) (void) |
| ... | ... | |
| 363 | 363 |
T1 = T0; |
| 364 | 364 |
T0 = glue(ldq, MEMSUFFIX)(T0); |
| 365 | 365 |
env->CP0_LLAddr = T1; |
| 366 |
RETURN();
|
|
| 366 |
FORCE_RET();
|
|
| 367 | 367 |
} |
| 368 | 368 |
|
| 369 | 369 |
void glue(op_scd, MEMSUFFIX) (void) |
| ... | ... | |
| 379 | 379 |
} else {
|
| 380 | 380 |
T0 = 0; |
| 381 | 381 |
} |
| 382 |
RETURN();
|
|
| 382 |
FORCE_RET();
|
|
| 383 | 383 |
} |
| 384 | 384 |
#endif /* TARGET_MIPS64 */ |
| 385 | 385 |
|
| 386 | 386 |
void glue(op_lwc1, MEMSUFFIX) (void) |
| 387 | 387 |
{
|
| 388 | 388 |
WT0 = glue(ldl, MEMSUFFIX)(T0); |
| 389 |
RETURN();
|
|
| 389 |
FORCE_RET();
|
|
| 390 | 390 |
} |
| 391 | 391 |
void glue(op_swc1, MEMSUFFIX) (void) |
| 392 | 392 |
{
|
| 393 | 393 |
glue(stl, MEMSUFFIX)(T0, WT0); |
| 394 |
RETURN();
|
|
| 394 |
FORCE_RET();
|
|
| 395 | 395 |
} |
| 396 | 396 |
void glue(op_ldc1, MEMSUFFIX) (void) |
| 397 | 397 |
{
|
| 398 | 398 |
DT0 = glue(ldq, MEMSUFFIX)(T0); |
| 399 |
RETURN();
|
|
| 399 |
FORCE_RET();
|
|
| 400 | 400 |
} |
| 401 | 401 |
void glue(op_sdc1, MEMSUFFIX) (void) |
| 402 | 402 |
{
|
| 403 | 403 |
glue(stq, MEMSUFFIX)(T0, DT0); |
| 404 |
RETURN();
|
|
| 404 |
FORCE_RET();
|
|
| 405 | 405 |
} |
| 406 | 406 |
void glue(op_luxc1, MEMSUFFIX) (void) |
| 407 | 407 |
{
|
| 408 | 408 |
DT0 = glue(ldq, MEMSUFFIX)(T0 & ~0x7); |
| 409 |
RETURN();
|
|
| 409 |
FORCE_RET();
|
|
| 410 | 410 |
} |
| 411 | 411 |
void glue(op_suxc1, MEMSUFFIX) (void) |
| 412 | 412 |
{
|
| 413 | 413 |
glue(stq, MEMSUFFIX)(T0 & ~0x7, DT0); |
| 414 |
RETURN();
|
|
| 414 |
FORCE_RET();
|
|
| 415 | 415 |
} |
Also available in: Unified diff