?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdbstub/linux-user: support debugging over a unix socket
[qemu.git] / tcg / tci.c
blob46fe9ce63f990f3150370dd9fcfde80c6719f2a1
1 /*
2 * Tiny Code Interpreter for QEMU
3 *
4 * Copyright (c) 2009, 2011, 2016 Stefan Weil
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program 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
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "qemu/osdep.h"
21
22 /* Enable TCI assertions only when debugging TCG (and without NDEBUG defined).
23 * Without assertions, the interpreter runs much faster. */
24 #if defined(CONFIG_DEBUG_TCG)
25 # define tci_assert(cond) assert(cond)
26 #else
27 # define tci_assert(cond) ((void)0)
28 #endif
29
30 #include "qemu-common.h"
31 #include "tcg/tcg.h" /* MAX_OPC_PARAM_IARGS */
32 #include "exec/cpu_ldst.h"
33 #include "tcg/tcg-op.h"
34
35 /* Marker for missing code. */
36 #define TODO() \
37 do { \
38 fprintf(stderr, "TODO %s:%u: %s()\n", \
39 __FILE__, __LINE__, __func__); \
40 tcg_abort(); \
41 } while (0)
42
43 #if MAX_OPC_PARAM_IARGS != 6
44 # error Fix needed, number of supported input arguments changed!
45 #endif
46 #if TCG_TARGET_REG_BITS == 32
47 typedef uint64_t (*helper_function)(tcg_target_ulong, tcg_target_ulong,
48 tcg_target_ulong, tcg_target_ulong,
49 tcg_target_ulong, tcg_target_ulong,
50 tcg_target_ulong, tcg_target_ulong,
51 tcg_target_ulong, tcg_target_ulong,
52 tcg_target_ulong, tcg_target_ulong);
53 #else
54 typedef uint64_t (*helper_function)(tcg_target_ulong, tcg_target_ulong,
55 tcg_target_ulong, tcg_target_ulong,
56 tcg_target_ulong, tcg_target_ulong);
57 #endif
58
59 static tcg_target_ulong tci_read_reg(const tcg_target_ulong *regs, TCGReg index)
60 {
61 tci_assert(index < TCG_TARGET_NB_REGS);
62 return regs[index];
63 }
64
65 #if TCG_TARGET_HAS_ext8s_i32 || TCG_TARGET_HAS_ext8s_i64
66 static int8_t tci_read_reg8s(const tcg_target_ulong *regs, TCGReg index)
67 {
68 return (int8_t)tci_read_reg(regs, index);
69 }
70 #endif
71
72 #if TCG_TARGET_HAS_ext16s_i32 || TCG_TARGET_HAS_ext16s_i64
73 static int16_t tci_read_reg16s(const tcg_target_ulong *regs, TCGReg index)
74 {
75 return (int16_t)tci_read_reg(regs, index);
76 }
77 #endif
78
79 #if TCG_TARGET_REG_BITS == 64
80 static int32_t tci_read_reg32s(const tcg_target_ulong *regs, TCGReg index)
81 {
82 return (int32_t)tci_read_reg(regs, index);
83 }
84 #endif
85
86 static uint8_t tci_read_reg8(const tcg_target_ulong *regs, TCGReg index)
87 {
88 return (uint8_t)tci_read_reg(regs, index);
89 }
90
91 static uint16_t tci_read_reg16(const tcg_target_ulong *regs, TCGReg index)
92 {
93 return (uint16_t)tci_read_reg(regs, index);
94 }
95
96 static uint32_t tci_read_reg32(const tcg_target_ulong *regs, TCGReg index)
97 {
98 return (uint32_t)tci_read_reg(regs, index);
99 }
100
101 #if TCG_TARGET_REG_BITS == 64
102 static uint64_t tci_read_reg64(const tcg_target_ulong *regs, TCGReg index)
103 {
104 return tci_read_reg(regs, index);
105 }
106 #endif
107
108 static void
109 tci_write_reg(tcg_target_ulong *regs, TCGReg index, tcg_target_ulong value)
110 {
111 tci_assert(index < TCG_TARGET_NB_REGS);
112 tci_assert(index != TCG_AREG0);
113 tci_assert(index != TCG_REG_CALL_STACK);
114 regs[index] = value;
115 }
116
117 #if TCG_TARGET_REG_BITS == 64
118 static void
119 tci_write_reg32s(tcg_target_ulong *regs, TCGReg index, int32_t value)
120 {
121 tci_write_reg(regs, index, value);
122 }
123 #endif
124
125 static void tci_write_reg8(tcg_target_ulong *regs, TCGReg index, uint8_t value)
126 {
127 tci_write_reg(regs, index, value);
128 }
129
130 static void
131 tci_write_reg16(tcg_target_ulong *regs, TCGReg index, uint16_t value)
132 {
133 tci_write_reg(regs, index, value);
134 }
135
136 static void
137 tci_write_reg32(tcg_target_ulong *regs, TCGReg index, uint32_t value)
138 {
139 tci_write_reg(regs, index, value);
140 }
141
142 #if TCG_TARGET_REG_BITS == 32
143 static void tci_write_reg64(tcg_target_ulong *regs, uint32_t high_index,
144 uint32_t low_index, uint64_t value)
145 {
146 tci_write_reg(regs, low_index, value);
147 tci_write_reg(regs, high_index, value >> 32);
148 }
149 #elif TCG_TARGET_REG_BITS == 64
150 static void
151 tci_write_reg64(tcg_target_ulong *regs, TCGReg index, uint64_t value)
152 {
153 tci_write_reg(regs, index, value);
154 }
155 #endif
156
157 #if TCG_TARGET_REG_BITS == 32
158 /* Create a 64 bit value from two 32 bit values. */
159 static uint64_t tci_uint64(uint32_t high, uint32_t low)
160 {
161 return ((uint64_t)high << 32) + low;
162 }
163 #endif
164
165 /* Read constant (native size) from bytecode. */
166 static tcg_target_ulong tci_read_i(uint8_t **tb_ptr)
167 {
168 tcg_target_ulong value = *(tcg_target_ulong *)(*tb_ptr);
169 *tb_ptr += sizeof(value);
170 return value;
171 }
172
173 /* Read unsigned constant (32 bit) from bytecode. */
174 static uint32_t tci_read_i32(uint8_t **tb_ptr)
175 {
176 uint32_t value = *(uint32_t *)(*tb_ptr);
177 *tb_ptr += sizeof(value);
178 return value;
179 }
180
181 /* Read signed constant (32 bit) from bytecode. */
182 static int32_t tci_read_s32(uint8_t **tb_ptr)
183 {
184 int32_t value = *(int32_t *)(*tb_ptr);
185 *tb_ptr += sizeof(value);
186 return value;
187 }
188
189 #if TCG_TARGET_REG_BITS == 64
190 /* Read constant (64 bit) from bytecode. */
191 static uint64_t tci_read_i64(uint8_t **tb_ptr)
192 {
193 uint64_t value = *(uint64_t *)(*tb_ptr);
194 *tb_ptr += sizeof(value);
195 return value;
196 }
197 #endif
198
199 /* Read indexed register (native size) from bytecode. */
200 static tcg_target_ulong
201 tci_read_r(const tcg_target_ulong *regs, uint8_t **tb_ptr)
202 {
203 tcg_target_ulong value = tci_read_reg(regs, **tb_ptr);
204 *tb_ptr += 1;
205 return value;
206 }
207
208 /* Read indexed register (8 bit) from bytecode. */
209 static uint8_t tci_read_r8(const tcg_target_ulong *regs, uint8_t **tb_ptr)
210 {
211 uint8_t value = tci_read_reg8(regs, **tb_ptr);
212 *tb_ptr += 1;
213 return value;
214 }
215
216 #if TCG_TARGET_HAS_ext8s_i32 || TCG_TARGET_HAS_ext8s_i64
217 /* Read indexed register (8 bit signed) from bytecode. */
218 static int8_t tci_read_r8s(const tcg_target_ulong *regs, uint8_t **tb_ptr)
219 {
220 int8_t value = tci_read_reg8s(regs, **tb_ptr);
221 *tb_ptr += 1;
222 return value;
223 }
224 #endif
225
226 /* Read indexed register (16 bit) from bytecode. */
227 static uint16_t tci_read_r16(const tcg_target_ulong *regs, uint8_t **tb_ptr)
228 {
229 uint16_t value = tci_read_reg16(regs, **tb_ptr);
230 *tb_ptr += 1;
231 return value;
232 }
233
234 #if TCG_TARGET_HAS_ext16s_i32 || TCG_TARGET_HAS_ext16s_i64
235 /* Read indexed register (16 bit signed) from bytecode. */
236 static int16_t tci_read_r16s(const tcg_target_ulong *regs, uint8_t **tb_ptr)
237 {
238 int16_t value = tci_read_reg16s(regs, **tb_ptr);
239 *tb_ptr += 1;
240 return value;
241 }
242 #endif
243
244 /* Read indexed register (32 bit) from bytecode. */
245 static uint32_t tci_read_r32(const tcg_target_ulong *regs, uint8_t **tb_ptr)
246 {
247 uint32_t value = tci_read_reg32(regs, **tb_ptr);
248 *tb_ptr += 1;
249 return value;
250 }
251
252 #if TCG_TARGET_REG_BITS == 32
253 /* Read two indexed registers (2 * 32 bit) from bytecode. */
254 static uint64_t tci_read_r64(const tcg_target_ulong *regs, uint8_t **tb_ptr)
255 {
256 uint32_t low = tci_read_r32(regs, tb_ptr);
257 return tci_uint64(tci_read_r32(regs, tb_ptr), low);
258 }
259 #elif TCG_TARGET_REG_BITS == 64
260 /* Read indexed register (32 bit signed) from bytecode. */
261 static int32_t tci_read_r32s(const tcg_target_ulong *regs, uint8_t **tb_ptr)
262 {
263 int32_t value = tci_read_reg32s(regs, **tb_ptr);
264 *tb_ptr += 1;
265 return value;
266 }
267
268 /* Read indexed register (64 bit) from bytecode. */
269 static uint64_t tci_read_r64(const tcg_target_ulong *regs, uint8_t **tb_ptr)
270 {
271 uint64_t value = tci_read_reg64(regs, **tb_ptr);
272 *tb_ptr += 1;
273 return value;
274 }
275 #endif
276
277 /* Read indexed register(s) with target address from bytecode. */
278 static target_ulong
279 tci_read_ulong(const tcg_target_ulong *regs, uint8_t **tb_ptr)
280 {
281 target_ulong taddr = tci_read_r(regs, tb_ptr);
282 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
283 taddr += (uint64_t)tci_read_r(regs, tb_ptr) << 32;
284 #endif
285 return taddr;
286 }
287
288 /* Read indexed register or constant (native size) from bytecode. */
289 static tcg_target_ulong
290 tci_read_ri(const tcg_target_ulong *regs, uint8_t **tb_ptr)
291 {
292 tcg_target_ulong value;
293 TCGReg r = **tb_ptr;
294 *tb_ptr += 1;
295 if (r == TCG_CONST) {
296 value = tci_read_i(tb_ptr);
297 } else {
298 value = tci_read_reg(regs, r);
299 }
300 return value;
301 }
302
303 /* Read indexed register or constant (32 bit) from bytecode. */
304 static uint32_t tci_read_ri32(const tcg_target_ulong *regs, uint8_t **tb_ptr)
305 {
306 uint32_t value;
307 TCGReg r = **tb_ptr;
308 *tb_ptr += 1;
309 if (r == TCG_CONST) {
310 value = tci_read_i32(tb_ptr);
311 } else {
312 value = tci_read_reg32(regs, r);
313 }
314 return value;
315 }
316
317 #if TCG_TARGET_REG_BITS == 32
318 /* Read two indexed registers or constants (2 * 32 bit) from bytecode. */
319 static uint64_t tci_read_ri64(const tcg_target_ulong *regs, uint8_t **tb_ptr)
320 {
321 uint32_t low = tci_read_ri32(regs, tb_ptr);
322 return tci_uint64(tci_read_ri32(regs, tb_ptr), low);
323 }
324 #elif TCG_TARGET_REG_BITS == 64
325 /* Read indexed register or constant (64 bit) from bytecode. */
326 static uint64_t tci_read_ri64(const tcg_target_ulong *regs, uint8_t **tb_ptr)
327 {
328 uint64_t value;
329 TCGReg r = **tb_ptr;
330 *tb_ptr += 1;
331 if (r == TCG_CONST) {
332 value = tci_read_i64(tb_ptr);
333 } else {
334 value = tci_read_reg64(regs, r);
335 }
336 return value;
337 }
338 #endif
339
340 static tcg_target_ulong tci_read_label(uint8_t **tb_ptr)
341 {
342 tcg_target_ulong label = tci_read_i(tb_ptr);
343 tci_assert(label != 0);
344 return label;
345 }
346
347 static bool tci_compare32(uint32_t u0, uint32_t u1, TCGCond condition)
348 {
349 bool result = false;
350 int32_t i0 = u0;
351 int32_t i1 = u1;
352 switch (condition) {
353 case TCG_COND_EQ:
354 result = (u0 == u1);
355 break;
356 case TCG_COND_NE:
357 result = (u0 != u1);
358 break;
359 case TCG_COND_LT:
360 result = (i0 < i1);
361 break;
362 case TCG_COND_GE:
363 result = (i0 >= i1);
364 break;
365 case TCG_COND_LE:
366 result = (i0 <= i1);
367 break;
368 case TCG_COND_GT:
369 result = (i0 > i1);
370 break;
371 case TCG_COND_LTU:
372 result = (u0 < u1);
373 break;
374 case TCG_COND_GEU:
375 result = (u0 >= u1);
376 break;
377 case TCG_COND_LEU:
378 result = (u0 <= u1);
379 break;
380 case TCG_COND_GTU:
381 result = (u0 > u1);
382 break;
383 default:
384 TODO();
385 }
386 return result;
387 }
388
389 static bool tci_compare64(uint64_t u0, uint64_t u1, TCGCond condition)
390 {
391 bool result = false;
392 int64_t i0 = u0;
393 int64_t i1 = u1;
394 switch (condition) {
395 case TCG_COND_EQ:
396 result = (u0 == u1);
397 break;
398 case TCG_COND_NE:
399 result = (u0 != u1);
400 break;
401 case TCG_COND_LT:
402 result = (i0 < i1);
403 break;
404 case TCG_COND_GE:
405 result = (i0 >= i1);
406 break;
407 case TCG_COND_LE:
408 result = (i0 <= i1);
409 break;
410 case TCG_COND_GT:
411 result = (i0 > i1);
412 break;
413 case TCG_COND_LTU:
414 result = (u0 < u1);
415 break;
416 case TCG_COND_GEU:
417 result = (u0 >= u1);
418 break;
419 case TCG_COND_LEU:
420 result = (u0 <= u1);
421 break;
422 case TCG_COND_GTU:
423 result = (u0 > u1);
424 break;
425 default:
426 TODO();
427 }
428 return result;
429 }
430
431 #ifdef CONFIG_SOFTMMU
432 # define qemu_ld_ub \
433 helper_ret_ldub_mmu(env, taddr, oi, (uintptr_t)tb_ptr)
434 # define qemu_ld_leuw \
435 helper_le_lduw_mmu(env, taddr, oi, (uintptr_t)tb_ptr)
436 # define qemu_ld_leul \
437 helper_le_ldul_mmu(env, taddr, oi, (uintptr_t)tb_ptr)
438 # define qemu_ld_leq \
439 helper_le_ldq_mmu(env, taddr, oi, (uintptr_t)tb_ptr)
440 # define qemu_ld_beuw \
441 helper_be_lduw_mmu(env, taddr, oi, (uintptr_t)tb_ptr)
442 # define qemu_ld_beul \
443 helper_be_ldul_mmu(env, taddr, oi, (uintptr_t)tb_ptr)
444 # define qemu_ld_beq \
445 helper_be_ldq_mmu(env, taddr, oi, (uintptr_t)tb_ptr)
446 # define qemu_st_b(X) \
447 helper_ret_stb_mmu(env, taddr, X, oi, (uintptr_t)tb_ptr)
448 # define qemu_st_lew(X) \
449 helper_le_stw_mmu(env, taddr, X, oi, (uintptr_t)tb_ptr)
450 # define qemu_st_lel(X) \
451 helper_le_stl_mmu(env, taddr, X, oi, (uintptr_t)tb_ptr)
452 # define qemu_st_leq(X) \
453 helper_le_stq_mmu(env, taddr, X, oi, (uintptr_t)tb_ptr)
454 # define qemu_st_bew(X) \
455 helper_be_stw_mmu(env, taddr, X, oi, (uintptr_t)tb_ptr)
456 # define qemu_st_bel(X) \
457 helper_be_stl_mmu(env, taddr, X, oi, (uintptr_t)tb_ptr)
458 # define qemu_st_beq(X) \
459 helper_be_stq_mmu(env, taddr, X, oi, (uintptr_t)tb_ptr)
460 #else
461 # define qemu_ld_ub ldub_p(g2h(taddr))
462 # define qemu_ld_leuw lduw_le_p(g2h(taddr))
463 # define qemu_ld_leul (uint32_t)ldl_le_p(g2h(taddr))
464 # define qemu_ld_leq ldq_le_p(g2h(taddr))
465 # define qemu_ld_beuw lduw_be_p(g2h(taddr))
466 # define qemu_ld_beul (uint32_t)ldl_be_p(g2h(taddr))
467 # define qemu_ld_beq ldq_be_p(g2h(taddr))
468 # define qemu_st_b(X) stb_p(g2h(taddr), X)
469 # define qemu_st_lew(X) stw_le_p(g2h(taddr), X)
470 # define qemu_st_lel(X) stl_le_p(g2h(taddr), X)
471 # define qemu_st_leq(X) stq_le_p(g2h(taddr), X)
472 # define qemu_st_bew(X) stw_be_p(g2h(taddr), X)
473 # define qemu_st_bel(X) stl_be_p(g2h(taddr), X)
474 # define qemu_st_beq(X) stq_be_p(g2h(taddr), X)
475 #endif
476
477 /* Interpret pseudo code in tb. */
478 uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr)
479 {
480 tcg_target_ulong regs[TCG_TARGET_NB_REGS];
481 long tcg_temps[CPU_TEMP_BUF_NLONGS];
482 uintptr_t sp_value = (uintptr_t)(tcg_temps + CPU_TEMP_BUF_NLONGS);
483 uintptr_t ret = 0;
484
485 regs[TCG_AREG0] = (tcg_target_ulong)env;
486 regs[TCG_REG_CALL_STACK] = sp_value;
487 tci_assert(tb_ptr);
488
489 for (;;) {
490 TCGOpcode opc = tb_ptr[0];
491 #if defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG)
492 uint8_t op_size = tb_ptr[1];
493 uint8_t *old_code_ptr = tb_ptr;
494 #endif
495 tcg_target_ulong t0;
496 tcg_target_ulong t1;
497 tcg_target_ulong t2;
498 tcg_target_ulong label;
499 TCGCond condition;
500 target_ulong taddr;
501 uint8_t tmp8;
502 uint16_t tmp16;
503 uint32_t tmp32;
504 uint64_t tmp64;
505 #if TCG_TARGET_REG_BITS == 32
506 uint64_t v64;
507 #endif
508 TCGMemOpIdx oi;
509
510 #if defined(GETPC)
511 tci_tb_ptr = (uintptr_t)tb_ptr;
512 #endif
513
514 /* Skip opcode and size entry. */
515 tb_ptr += 2;
516
517 switch (opc) {
518 case INDEX_op_call:
519 t0 = tci_read_ri(regs, &tb_ptr);
520 #if TCG_TARGET_REG_BITS == 32
521 tmp64 = ((helper_function)t0)(tci_read_reg(regs, TCG_REG_R0),
522 tci_read_reg(regs, TCG_REG_R1),
523 tci_read_reg(regs, TCG_REG_R2),
524 tci_read_reg(regs, TCG_REG_R3),
525 tci_read_reg(regs, TCG_REG_R5),
526 tci_read_reg(regs, TCG_REG_R6),
527 tci_read_reg(regs, TCG_REG_R7),
528 tci_read_reg(regs, TCG_REG_R8),
529 tci_read_reg(regs, TCG_REG_R9),
530 tci_read_reg(regs, TCG_REG_R10),
531 tci_read_reg(regs, TCG_REG_R11),
532 tci_read_reg(regs, TCG_REG_R12));
533 tci_write_reg(regs, TCG_REG_R0, tmp64);
534 tci_write_reg(regs, TCG_REG_R1, tmp64 >> 32);
535 #else
536 tmp64 = ((helper_function)t0)(tci_read_reg(regs, TCG_REG_R0),
537 tci_read_reg(regs, TCG_REG_R1),
538 tci_read_reg(regs, TCG_REG_R2),
539 tci_read_reg(regs, TCG_REG_R3),
540 tci_read_reg(regs, TCG_REG_R5),
541 tci_read_reg(regs, TCG_REG_R6));
542 tci_write_reg(regs, TCG_REG_R0, tmp64);
543 #endif
544 break;
545 case INDEX_op_br:
546 label = tci_read_label(&tb_ptr);
547 tci_assert(tb_ptr == old_code_ptr + op_size);
548 tb_ptr = (uint8_t *)label;
549 continue;
550 case INDEX_op_setcond_i32:
551 t0 = *tb_ptr++;
552 t1 = tci_read_r32(regs, &tb_ptr);
553 t2 = tci_read_ri32(regs, &tb_ptr);
554 condition = *tb_ptr++;
555 tci_write_reg32(regs, t0, tci_compare32(t1, t2, condition));
556 break;
557 #if TCG_TARGET_REG_BITS == 32
558 case INDEX_op_setcond2_i32:
559 t0 = *tb_ptr++;
560 tmp64 = tci_read_r64(regs, &tb_ptr);
561 v64 = tci_read_ri64(regs, &tb_ptr);
562 condition = *tb_ptr++;
563 tci_write_reg32(regs, t0, tci_compare64(tmp64, v64, condition));
564 break;
565 #elif TCG_TARGET_REG_BITS == 64
566 case INDEX_op_setcond_i64:
567 t0 = *tb_ptr++;
568 t1 = tci_read_r64(regs, &tb_ptr);
569 t2 = tci_read_ri64(regs, &tb_ptr);
570 condition = *tb_ptr++;
571 tci_write_reg64(regs, t0, tci_compare64(t1, t2, condition));
572 break;
573 #endif
574 case INDEX_op_mov_i32:
575 t0 = *tb_ptr++;
576 t1 = tci_read_r32(regs, &tb_ptr);
577 tci_write_reg32(regs, t0, t1);
578 break;
579 case INDEX_op_movi_i32:
580 t0 = *tb_ptr++;
581 t1 = tci_read_i32(&tb_ptr);
582 tci_write_reg32(regs, t0, t1);
583 break;
584
585 /* Load/store operations (32 bit). */
586
587 case INDEX_op_ld8u_i32:
588 t0 = *tb_ptr++;
589 t1 = tci_read_r(regs, &tb_ptr);
590 t2 = tci_read_s32(&tb_ptr);
591 tci_write_reg8(regs, t0, *(uint8_t *)(t1 + t2));
592 break;
593 case INDEX_op_ld8s_i32:
594 TODO();
595 break;
596 case INDEX_op_ld16u_i32:
597 TODO();
598 break;
599 case INDEX_op_ld16s_i32:
600 TODO();
601 break;
602 case INDEX_op_ld_i32:
603 t0 = *tb_ptr++;
604 t1 = tci_read_r(regs, &tb_ptr);
605 t2 = tci_read_s32(&tb_ptr);
606 tci_write_reg32(regs, t0, *(uint32_t *)(t1 + t2));
607 break;
608 case INDEX_op_st8_i32:
609 t0 = tci_read_r8(regs, &tb_ptr);
610 t1 = tci_read_r(regs, &tb_ptr);
611 t2 = tci_read_s32(&tb_ptr);
612 *(uint8_t *)(t1 + t2) = t0;
613 break;
614 case INDEX_op_st16_i32:
615 t0 = tci_read_r16(regs, &tb_ptr);
616 t1 = tci_read_r(regs, &tb_ptr);
617 t2 = tci_read_s32(&tb_ptr);
618 *(uint16_t *)(t1 + t2) = t0;
619 break;
620 case INDEX_op_st_i32:
621 t0 = tci_read_r32(regs, &tb_ptr);
622 t1 = tci_read_r(regs, &tb_ptr);
623 t2 = tci_read_s32(&tb_ptr);
624 tci_assert(t1 != sp_value || (int32_t)t2 < 0);
625 *(uint32_t *)(t1 + t2) = t0;
626 break;
627
628 /* Arithmetic operations (32 bit). */
629
630 case INDEX_op_add_i32:
631 t0 = *tb_ptr++;
632 t1 = tci_read_ri32(regs, &tb_ptr);
633 t2 = tci_read_ri32(regs, &tb_ptr);
634 tci_write_reg32(regs, t0, t1 + t2);
635 break;
636 case INDEX_op_sub_i32:
637 t0 = *tb_ptr++;
638 t1 = tci_read_ri32(regs, &tb_ptr);
639 t2 = tci_read_ri32(regs, &tb_ptr);
640 tci_write_reg32(regs, t0, t1 - t2);
641 break;
642 case INDEX_op_mul_i32:
643 t0 = *tb_ptr++;
644 t1 = tci_read_ri32(regs, &tb_ptr);
645 t2 = tci_read_ri32(regs, &tb_ptr);
646 tci_write_reg32(regs, t0, t1 * t2);
647 break;
648 #if TCG_TARGET_HAS_div_i32
649 case INDEX_op_div_i32:
650 t0 = *tb_ptr++;
651 t1 = tci_read_ri32(regs, &tb_ptr);
652 t2 = tci_read_ri32(regs, &tb_ptr);
653 tci_write_reg32(regs, t0, (int32_t)t1 / (int32_t)t2);
654 break;
655 case INDEX_op_divu_i32:
656 t0 = *tb_ptr++;
657 t1 = tci_read_ri32(regs, &tb_ptr);
658 t2 = tci_read_ri32(regs, &tb_ptr);
659 tci_write_reg32(regs, t0, t1 / t2);
660 break;
661 case INDEX_op_rem_i32:
662 t0 = *tb_ptr++;
663 t1 = tci_read_ri32(regs, &tb_ptr);
664 t2 = tci_read_ri32(regs, &tb_ptr);
665 tci_write_reg32(regs, t0, (int32_t)t1 % (int32_t)t2);
666 break;
667 case INDEX_op_remu_i32:
668 t0 = *tb_ptr++;
669 t1 = tci_read_ri32(regs, &tb_ptr);
670 t2 = tci_read_ri32(regs, &tb_ptr);
671 tci_write_reg32(regs, t0, t1 % t2);
672 break;
673 #elif TCG_TARGET_HAS_div2_i32
674 case INDEX_op_div2_i32:
675 case INDEX_op_divu2_i32:
676 TODO();
677 break;
678 #endif
679 case INDEX_op_and_i32:
680 t0 = *tb_ptr++;
681 t1 = tci_read_ri32(regs, &tb_ptr);
682 t2 = tci_read_ri32(regs, &tb_ptr);
683 tci_write_reg32(regs, t0, t1 & t2);
684 break;
685 case INDEX_op_or_i32:
686 t0 = *tb_ptr++;
687 t1 = tci_read_ri32(regs, &tb_ptr);
688 t2 = tci_read_ri32(regs, &tb_ptr);
689 tci_write_reg32(regs, t0, t1 | t2);
690 break;
691 case INDEX_op_xor_i32:
692 t0 = *tb_ptr++;
693 t1 = tci_read_ri32(regs, &tb_ptr);
694 t2 = tci_read_ri32(regs, &tb_ptr);
695 tci_write_reg32(regs, t0, t1 ^ t2);
696 break;
697
698 /* Shift/rotate operations (32 bit). */
699
700 case INDEX_op_shl_i32:
701 t0 = *tb_ptr++;
702 t1 = tci_read_ri32(regs, &tb_ptr);
703 t2 = tci_read_ri32(regs, &tb_ptr);
704 tci_write_reg32(regs, t0, t1 << (t2 & 31));
705 break;
706 case INDEX_op_shr_i32:
707 t0 = *tb_ptr++;
708 t1 = tci_read_ri32(regs, &tb_ptr);
709 t2 = tci_read_ri32(regs, &tb_ptr);
710 tci_write_reg32(regs, t0, t1 >> (t2 & 31));
711 break;
712 case INDEX_op_sar_i32:
713 t0 = *tb_ptr++;
714 t1 = tci_read_ri32(regs, &tb_ptr);
715 t2 = tci_read_ri32(regs, &tb_ptr);
716 tci_write_reg32(regs, t0, ((int32_t)t1 >> (t2 & 31)));
717 break;
718 #if TCG_TARGET_HAS_rot_i32
719 case INDEX_op_rotl_i32:
720 t0 = *tb_ptr++;
721 t1 = tci_read_ri32(regs, &tb_ptr);
722 t2 = tci_read_ri32(regs, &tb_ptr);
723 tci_write_reg32(regs, t0, rol32(t1, t2 & 31));
724 break;
725 case INDEX_op_rotr_i32:
726 t0 = *tb_ptr++;
727 t1 = tci_read_ri32(regs, &tb_ptr);
728 t2 = tci_read_ri32(regs, &tb_ptr);
729 tci_write_reg32(regs, t0, ror32(t1, t2 & 31));
730 break;
731 #endif
732 #if TCG_TARGET_HAS_deposit_i32
733 case INDEX_op_deposit_i32:
734 t0 = *tb_ptr++;
735 t1 = tci_read_r32(regs, &tb_ptr);
736 t2 = tci_read_r32(regs, &tb_ptr);
737 tmp16 = *tb_ptr++;
738 tmp8 = *tb_ptr++;
739 tmp32 = (((1 << tmp8) - 1) << tmp16);
740 tci_write_reg32(regs, t0, (t1 & ~tmp32) | ((t2 << tmp16) & tmp32));
741 break;
742 #endif
743 case INDEX_op_brcond_i32:
744 t0 = tci_read_r32(regs, &tb_ptr);
745 t1 = tci_read_ri32(regs, &tb_ptr);
746 condition = *tb_ptr++;
747 label = tci_read_label(&tb_ptr);
748 if (tci_compare32(t0, t1, condition)) {
749 tci_assert(tb_ptr == old_code_ptr + op_size);
750 tb_ptr = (uint8_t *)label;
751 continue;
752 }
753 break;
754 #if TCG_TARGET_REG_BITS == 32
755 case INDEX_op_add2_i32:
756 t0 = *tb_ptr++;
757 t1 = *tb_ptr++;
758 tmp64 = tci_read_r64(regs, &tb_ptr);
759 tmp64 += tci_read_r64(regs, &tb_ptr);
760 tci_write_reg64(regs, t1, t0, tmp64);
761 break;
762 case INDEX_op_sub2_i32:
763 t0 = *tb_ptr++;
764 t1 = *tb_ptr++;
765 tmp64 = tci_read_r64(regs, &tb_ptr);
766 tmp64 -= tci_read_r64(regs, &tb_ptr);
767 tci_write_reg64(regs, t1, t0, tmp64);
768 break;
769 case INDEX_op_brcond2_i32:
770 tmp64 = tci_read_r64(regs, &tb_ptr);
771 v64 = tci_read_ri64(regs, &tb_ptr);
772 condition = *tb_ptr++;
773 label = tci_read_label(&tb_ptr);
774 if (tci_compare64(tmp64, v64, condition)) {
775 tci_assert(tb_ptr == old_code_ptr + op_size);
776 tb_ptr = (uint8_t *)label;
777 continue;
778 }
779 break;
780 case INDEX_op_mulu2_i32:
781 t0 = *tb_ptr++;
782 t1 = *tb_ptr++;
783 t2 = tci_read_r32(regs, &tb_ptr);
784 tmp64 = tci_read_r32(regs, &tb_ptr);
785 tci_write_reg64(regs, t1, t0, t2 * tmp64);
786 break;
787 #endif /* TCG_TARGET_REG_BITS == 32 */
788 #if TCG_TARGET_HAS_ext8s_i32
789 case INDEX_op_ext8s_i32:
790 t0 = *tb_ptr++;
791 t1 = tci_read_r8s(regs, &tb_ptr);
792 tci_write_reg32(regs, t0, t1);
793 break;
794 #endif
795 #if TCG_TARGET_HAS_ext16s_i32
796 case INDEX_op_ext16s_i32:
797 t0 = *tb_ptr++;
798 t1 = tci_read_r16s(regs, &tb_ptr);
799 tci_write_reg32(regs, t0, t1);
800 break;
801 #endif
802 #if TCG_TARGET_HAS_ext8u_i32
803 case INDEX_op_ext8u_i32:
804 t0 = *tb_ptr++;
805 t1 = tci_read_r8(regs, &tb_ptr);
806 tci_write_reg32(regs, t0, t1);
807 break;
808 #endif
809 #if TCG_TARGET_HAS_ext16u_i32
810 case INDEX_op_ext16u_i32:
811 t0 = *tb_ptr++;
812 t1 = tci_read_r16(regs, &tb_ptr);
813 tci_write_reg32(regs, t0, t1);
814 break;
815 #endif
816 #if TCG_TARGET_HAS_bswap16_i32
817 case INDEX_op_bswap16_i32:
818 t0 = *tb_ptr++;
819 t1 = tci_read_r16(regs, &tb_ptr);
820 tci_write_reg32(regs, t0, bswap16(t1));
821 break;
822 #endif
823 #if TCG_TARGET_HAS_bswap32_i32
824 case INDEX_op_bswap32_i32:
825 t0 = *tb_ptr++;
826 t1 = tci_read_r32(regs, &tb_ptr);
827 tci_write_reg32(regs, t0, bswap32(t1));
828 break;
829 #endif
830 #if TCG_TARGET_HAS_not_i32
831 case INDEX_op_not_i32:
832 t0 = *tb_ptr++;
833 t1 = tci_read_r32(regs, &tb_ptr);
834 tci_write_reg32(regs, t0, ~t1);
835 break;
836 #endif
837 #if TCG_TARGET_HAS_neg_i32
838 case INDEX_op_neg_i32:
839 t0 = *tb_ptr++;
840 t1 = tci_read_r32(regs, &tb_ptr);
841 tci_write_reg32(regs, t0, -t1);
842 break;
843 #endif
844 #if TCG_TARGET_REG_BITS == 64
845 case INDEX_op_mov_i64:
846 t0 = *tb_ptr++;
847 t1 = tci_read_r64(regs, &tb_ptr);
848 tci_write_reg64(regs, t0, t1);
849 break;
850 case INDEX_op_movi_i64:
851 t0 = *tb_ptr++;
852 t1 = tci_read_i64(&tb_ptr);
853 tci_write_reg64(regs, t0, t1);
854 break;
855
856 /* Load/store operations (64 bit). */
857
858 case INDEX_op_ld8u_i64:
859 t0 = *tb_ptr++;
860 t1 = tci_read_r(regs, &tb_ptr);
861 t2 = tci_read_s32(&tb_ptr);
862 tci_write_reg8(regs, t0, *(uint8_t *)(t1 + t2));
863 break;
864 case INDEX_op_ld8s_i64:
865 TODO();
866 break;
867 case INDEX_op_ld16u_i64:
868 t0 = *tb_ptr++;
869 t1 = tci_read_r(regs, &tb_ptr);
870 t2 = tci_read_s32(&tb_ptr);
871 tci_write_reg16(regs, t0, *(uint16_t *)(t1 + t2));
872 break;
873 case INDEX_op_ld16s_i64:
874 TODO();
875 break;
876 case INDEX_op_ld32u_i64:
877 t0 = *tb_ptr++;
878 t1 = tci_read_r(regs, &tb_ptr);
879 t2 = tci_read_s32(&tb_ptr);
880 tci_write_reg32(regs, t0, *(uint32_t *)(t1 + t2));
881 break;
882 case INDEX_op_ld32s_i64:
883 t0 = *tb_ptr++;
884 t1 = tci_read_r(regs, &tb_ptr);
885 t2 = tci_read_s32(&tb_ptr);
886 tci_write_reg32s(regs, t0, *(int32_t *)(t1 + t2));
887 break;
888 case INDEX_op_ld_i64:
889 t0 = *tb_ptr++;
890 t1 = tci_read_r(regs, &tb_ptr);
891 t2 = tci_read_s32(&tb_ptr);
892 tci_write_reg64(regs, t0, *(uint64_t *)(t1 + t2));
893 break;
894 case INDEX_op_st8_i64:
895 t0 = tci_read_r8(regs, &tb_ptr);
896 t1 = tci_read_r(regs, &tb_ptr);
897 t2 = tci_read_s32(&tb_ptr);
898 *(uint8_t *)(t1 + t2) = t0;
899 break;
900 case INDEX_op_st16_i64:
901 t0 = tci_read_r16(regs, &tb_ptr);
902 t1 = tci_read_r(regs, &tb_ptr);
903 t2 = tci_read_s32(&tb_ptr);
904 *(uint16_t *)(t1 + t2) = t0;
905 break;
906 case INDEX_op_st32_i64:
907 t0 = tci_read_r32(regs, &tb_ptr);
908 t1 = tci_read_r(regs, &tb_ptr);
909 t2 = tci_read_s32(&tb_ptr);
910 *(uint32_t *)(t1 + t2) = t0;
911 break;
912 case INDEX_op_st_i64:
913 t0 = tci_read_r64(regs, &tb_ptr);
914 t1 = tci_read_r(regs, &tb_ptr);
915 t2 = tci_read_s32(&tb_ptr);
916 tci_assert(t1 != sp_value || (int32_t)t2 < 0);
917 *(uint64_t *)(t1 + t2) = t0;
918 break;
919
920 /* Arithmetic operations (64 bit). */
921
922 case INDEX_op_add_i64:
923 t0 = *tb_ptr++;
924 t1 = tci_read_ri64(regs, &tb_ptr);
925 t2 = tci_read_ri64(regs, &tb_ptr);
926 tci_write_reg64(regs, t0, t1 + t2);
927 break;
928 case INDEX_op_sub_i64:
929 t0 = *tb_ptr++;
930 t1 = tci_read_ri64(regs, &tb_ptr);
931 t2 = tci_read_ri64(regs, &tb_ptr);
932 tci_write_reg64(regs, t0, t1 - t2);
933 break;
934 case INDEX_op_mul_i64:
935 t0 = *tb_ptr++;
936 t1 = tci_read_ri64(regs, &tb_ptr);
937 t2 = tci_read_ri64(regs, &tb_ptr);
938 tci_write_reg64(regs, t0, t1 * t2);
939 break;
940 #if TCG_TARGET_HAS_div_i64
941 case INDEX_op_div_i64:
942 case INDEX_op_divu_i64:
943 case INDEX_op_rem_i64:
944 case INDEX_op_remu_i64:
945 TODO();
946 break;
947 #elif TCG_TARGET_HAS_div2_i64
948 case INDEX_op_div2_i64:
949 case INDEX_op_divu2_i64:
950 TODO();
951 break;
952 #endif
953 case INDEX_op_and_i64:
954 t0 = *tb_ptr++;
955 t1 = tci_read_ri64(regs, &tb_ptr);
956 t2 = tci_read_ri64(regs, &tb_ptr);
957 tci_write_reg64(regs, t0, t1 & t2);
958 break;
959 case INDEX_op_or_i64:
960 t0 = *tb_ptr++;
961 t1 = tci_read_ri64(regs, &tb_ptr);
962 t2 = tci_read_ri64(regs, &tb_ptr);
963 tci_write_reg64(regs, t0, t1 | t2);
964 break;
965 case INDEX_op_xor_i64:
966 t0 = *tb_ptr++;
967 t1 = tci_read_ri64(regs, &tb_ptr);
968 t2 = tci_read_ri64(regs, &tb_ptr);
969 tci_write_reg64(regs, t0, t1 ^ t2);
970 break;
971
972 /* Shift/rotate operations (64 bit). */
973
974 case INDEX_op_shl_i64:
975 t0 = *tb_ptr++;
976 t1 = tci_read_ri64(regs, &tb_ptr);
977 t2 = tci_read_ri64(regs, &tb_ptr);
978 tci_write_reg64(regs, t0, t1 << (t2 & 63));
979 break;
980 case INDEX_op_shr_i64:
981 t0 = *tb_ptr++;
982 t1 = tci_read_ri64(regs, &tb_ptr);
983 t2 = tci_read_ri64(regs, &tb_ptr);
984 tci_write_reg64(regs, t0, t1 >> (t2 & 63));
985 break;
986 case INDEX_op_sar_i64:
987 t0 = *tb_ptr++;
988 t1 = tci_read_ri64(regs, &tb_ptr);
989 t2 = tci_read_ri64(regs, &tb_ptr);
990 tci_write_reg64(regs, t0, ((int64_t)t1 >> (t2 & 63)));
991 break;
992 #if TCG_TARGET_HAS_rot_i64
993 case INDEX_op_rotl_i64:
994 t0 = *tb_ptr++;
995 t1 = tci_read_ri64(regs, &tb_ptr);
996 t2 = tci_read_ri64(regs, &tb_ptr);
997 tci_write_reg64(regs, t0, rol64(t1, t2 & 63));
998 break;
999 case INDEX_op_rotr_i64:
1000 t0 = *tb_ptr++;
1001 t1 = tci_read_ri64(regs, &tb_ptr);
1002 t2 = tci_read_ri64(regs, &tb_ptr);
1003 tci_write_reg64(regs, t0, ror64(t1, t2 & 63));
1004 break;
1005 #endif
1006 #if TCG_TARGET_HAS_deposit_i64
1007 case INDEX_op_deposit_i64:
1008 t0 = *tb_ptr++;
1009 t1 = tci_read_r64(regs, &tb_ptr);
1010 t2 = tci_read_r64(regs, &tb_ptr);
1011 tmp16 = *tb_ptr++;
1012 tmp8 = *tb_ptr++;
1013 tmp64 = (((1ULL << tmp8) - 1) << tmp16);
1014 tci_write_reg64(regs, t0, (t1 & ~tmp64) | ((t2 << tmp16) & tmp64));
1015 break;
1016 #endif
1017 case INDEX_op_brcond_i64:
1018 t0 = tci_read_r64(regs, &tb_ptr);
1019 t1 = tci_read_ri64(regs, &tb_ptr);
1020 condition = *tb_ptr++;
1021 label = tci_read_label(&tb_ptr);
1022 if (tci_compare64(t0, t1, condition)) {
1023 tci_assert(tb_ptr == old_code_ptr + op_size);
1024 tb_ptr = (uint8_t *)label;
1025 continue;
1026 }
1027 break;
1028 #if TCG_TARGET_HAS_ext8u_i64
1029 case INDEX_op_ext8u_i64:
1030 t0 = *tb_ptr++;
1031 t1 = tci_read_r8(regs, &tb_ptr);
1032 tci_write_reg64(regs, t0, t1);
1033 break;
1034 #endif
1035 #if TCG_TARGET_HAS_ext8s_i64
1036 case INDEX_op_ext8s_i64:
1037 t0 = *tb_ptr++;
1038 t1 = tci_read_r8s(regs, &tb_ptr);
1039 tci_write_reg64(regs, t0, t1);
1040 break;
1041 #endif
1042 #if TCG_TARGET_HAS_ext16s_i64
1043 case INDEX_op_ext16s_i64:
1044 t0 = *tb_ptr++;
1045 t1 = tci_read_r16s(regs, &tb_ptr);
1046 tci_write_reg64(regs, t0, t1);
1047 break;
1048 #endif
1049 #if TCG_TARGET_HAS_ext16u_i64
1050 case INDEX_op_ext16u_i64:
1051 t0 = *tb_ptr++;
1052 t1 = tci_read_r16(regs, &tb_ptr);
1053 tci_write_reg64(regs, t0, t1);
1054 break;
1055 #endif
1056 #if TCG_TARGET_HAS_ext32s_i64
1057 case INDEX_op_ext32s_i64:
1058 #endif
1059 case INDEX_op_ext_i32_i64:
1060 t0 = *tb_ptr++;
1061 t1 = tci_read_r32s(regs, &tb_ptr);
1062 tci_write_reg64(regs, t0, t1);
1063 break;
1064 #if TCG_TARGET_HAS_ext32u_i64
1065 case INDEX_op_ext32u_i64:
1066 #endif
1067 case INDEX_op_extu_i32_i64:
1068 t0 = *tb_ptr++;
1069 t1 = tci_read_r32(regs, &tb_ptr);
1070 tci_write_reg64(regs, t0, t1);
1071 break;
1072 #if TCG_TARGET_HAS_bswap16_i64
1073 case INDEX_op_bswap16_i64:
1074 t0 = *tb_ptr++;
1075 t1 = tci_read_r16(regs, &tb_ptr);
1076 tci_write_reg64(regs, t0, bswap16(t1));
1077 break;
1078 #endif
1079 #if TCG_TARGET_HAS_bswap32_i64
1080 case INDEX_op_bswap32_i64:
1081 t0 = *tb_ptr++;
1082 t1 = tci_read_r32(regs, &tb_ptr);
1083 tci_write_reg64(regs, t0, bswap32(t1));
1084 break;
1085 #endif
1086 #if TCG_TARGET_HAS_bswap64_i64
1087 case INDEX_op_bswap64_i64:
1088 t0 = *tb_ptr++;
1089 t1 = tci_read_r64(regs, &tb_ptr);
1090 tci_write_reg64(regs, t0, bswap64(t1));
1091 break;
1092 #endif
1093 #if TCG_TARGET_HAS_not_i64
1094 case INDEX_op_not_i64:
1095 t0 = *tb_ptr++;
1096 t1 = tci_read_r64(regs, &tb_ptr);
1097 tci_write_reg64(regs, t0, ~t1);
1098 break;
1099 #endif
1100 #if TCG_TARGET_HAS_neg_i64
1101 case INDEX_op_neg_i64:
1102 t0 = *tb_ptr++;
1103 t1 = tci_read_r64(regs, &tb_ptr);
1104 tci_write_reg64(regs, t0, -t1);
1105 break;
1106 #endif
1107 #endif /* TCG_TARGET_REG_BITS == 64 */
1108
1109 /* QEMU specific operations. */
1110
1111 case INDEX_op_exit_tb:
1112 ret = *(uint64_t *)tb_ptr;
1113 goto exit;
1114 break;
1115 case INDEX_op_goto_tb:
1116 /* Jump address is aligned */
1117 tb_ptr = QEMU_ALIGN_PTR_UP(tb_ptr, 4);
1118 t0 = atomic_read((int32_t *)tb_ptr);
1119 tb_ptr += sizeof(int32_t);
1120 tci_assert(tb_ptr == old_code_ptr + op_size);
1121 tb_ptr += (int32_t)t0;
1122 continue;
1123 case INDEX_op_qemu_ld_i32:
1124 t0 = *tb_ptr++;
1125 taddr = tci_read_ulong(regs, &tb_ptr);
1126 oi = tci_read_i(&tb_ptr);
1127 switch (get_memop(oi) & (MO_BSWAP | MO_SSIZE)) {
1128 case MO_UB:
1129 tmp32 = qemu_ld_ub;
1130 break;
1131 case MO_SB:
1132 tmp32 = (int8_t)qemu_ld_ub;
1133 break;
1134 case MO_LEUW:
1135 tmp32 = qemu_ld_leuw;
1136 break;
1137 case MO_LESW:
1138 tmp32 = (int16_t)qemu_ld_leuw;
1139 break;
1140 case MO_LEUL:
1141 tmp32 = qemu_ld_leul;
1142 break;
1143 case MO_BEUW:
1144 tmp32 = qemu_ld_beuw;
1145 break;
1146 case MO_BESW:
1147 tmp32 = (int16_t)qemu_ld_beuw;
1148 break;
1149 case MO_BEUL:
1150 tmp32 = qemu_ld_beul;
1151 break;
1152 default:
1153 tcg_abort();
1154 }
1155 tci_write_reg(regs, t0, tmp32);
1156 break;
1157 case INDEX_op_qemu_ld_i64:
1158 t0 = *tb_ptr++;
1159 if (TCG_TARGET_REG_BITS == 32) {
1160 t1 = *tb_ptr++;
1161 }
1162 taddr = tci_read_ulong(regs, &tb_ptr);
1163 oi = tci_read_i(&tb_ptr);
1164 switch (get_memop(oi) & (MO_BSWAP | MO_SSIZE)) {
1165 case MO_UB:
1166 tmp64 = qemu_ld_ub;
1167 break;
1168 case MO_SB:
1169 tmp64 = (int8_t)qemu_ld_ub;
1170 break;
1171 case MO_LEUW:
1172 tmp64 = qemu_ld_leuw;
1173 break;
1174 case MO_LESW:
1175 tmp64 = (int16_t)qemu_ld_leuw;
1176 break;
1177 case MO_LEUL:
1178 tmp64 = qemu_ld_leul;
1179 break;
1180 case MO_LESL:
1181 tmp64 = (int32_t)qemu_ld_leul;
1182 break;
1183 case MO_LEQ:
1184 tmp64 = qemu_ld_leq;
1185 break;
1186 case MO_BEUW:
1187 tmp64 = qemu_ld_beuw;
1188 break;
1189 case MO_BESW:
1190 tmp64 = (int16_t)qemu_ld_beuw;
1191 break;
1192 case MO_BEUL:
1193 tmp64 = qemu_ld_beul;
1194 break;
1195 case MO_BESL:
1196 tmp64 = (int32_t)qemu_ld_beul;
1197 break;
1198 case MO_BEQ:
1199 tmp64 = qemu_ld_beq;
1200 break;
1201 default:
1202 tcg_abort();
1203 }
1204 tci_write_reg(regs, t0, tmp64);
1205 if (TCG_TARGET_REG_BITS == 32) {
1206 tci_write_reg(regs, t1, tmp64 >> 32);
1207 }
1208 break;
1209 case INDEX_op_qemu_st_i32:
1210 t0 = tci_read_r(regs, &tb_ptr);
1211 taddr = tci_read_ulong(regs, &tb_ptr);
1212 oi = tci_read_i(&tb_ptr);
1213 switch (get_memop(oi) & (MO_BSWAP | MO_SIZE)) {
1214 case MO_UB:
1215 qemu_st_b(t0);
1216 break;
1217 case MO_LEUW:
1218 qemu_st_lew(t0);
1219 break;
1220 case MO_LEUL:
1221 qemu_st_lel(t0);
1222 break;
1223 case MO_BEUW:
1224 qemu_st_bew(t0);
1225 break;
1226 case MO_BEUL:
1227 qemu_st_bel(t0);
1228 break;
1229 default:
1230 tcg_abort();
1231 }
1232 break;
1233 case INDEX_op_qemu_st_i64:
1234 tmp64 = tci_read_r64(regs, &tb_ptr);
1235 taddr = tci_read_ulong(regs, &tb_ptr);
1236 oi = tci_read_i(&tb_ptr);
1237 switch (get_memop(oi) & (MO_BSWAP | MO_SIZE)) {
1238 case MO_UB:
1239 qemu_st_b(tmp64);
1240 break;
1241 case MO_LEUW:
1242 qemu_st_lew(tmp64);
1243 break;
1244 case MO_LEUL:
1245 qemu_st_lel(tmp64);
1246 break;
1247 case MO_LEQ:
1248 qemu_st_leq(tmp64);
1249 break;
1250 case MO_BEUW:
1251 qemu_st_bew(tmp64);
1252 break;
1253 case MO_BEUL:
1254 qemu_st_bel(tmp64);
1255 break;
1256 case MO_BEQ:
1257 qemu_st_beq(tmp64);
1258 break;
1259 default:
1260 tcg_abort();
1261 }
1262 break;
1263 case INDEX_op_mb:
1264 /* Ensure ordering for all kinds */
1265 smp_mb();
1266 break;
1267 default:
1268 TODO();
1269 break;
1270 }
1271 tci_assert(tb_ptr == old_code_ptr + op_size);
1272 }
1273 exit:
1274 return ret;
1275 }
QEmu