?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
aspeed: Introduce a create_pca9552() helper
[qemu/rayw.git] / target / xtensa / translate.c
blobb1491ed625e5122b7a49ac14751541c7682e6179
1 /*
2 * Xtensa ISA:
3 * http://www.tensilica.com/products/literature-docs/documentation/xtensa-isa-databook.htm
4 *
5 * Copyright (c) 2011, Max Filippov, Open Source and Linux Lab.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * * Neither the name of the Open Source and Linux Lab nor the
16 * names of its contributors may be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
23 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include "qemu/osdep.h"
32
33 #include "cpu.h"
34 #include "exec/exec-all.h"
35 #include "disas/disas.h"
36 #include "tcg/tcg-op.h"
37 #include "qemu/log.h"
38 #include "qemu/qemu-print.h"
39 #include "exec/cpu_ldst.h"
40 #include "semihosting/semihost.h"
41 #include "exec/translator.h"
42
43 #include "exec/helper-proto.h"
44 #include "exec/helper-gen.h"
45
46 #include "exec/log.h"
47
48
49 struct DisasContext {
50 DisasContextBase base;
51 const XtensaConfig *config;
52 uint32_t pc;
53 int cring;
54 int ring;
55 uint32_t lbeg_off;
56 uint32_t lend;
57
58 bool sar_5bit;
59 bool sar_m32_5bit;
60 bool sar_m32_allocated;
61 TCGv_i32 sar_m32;
62
63 unsigned window;
64 unsigned callinc;
65 bool cwoe;
66
67 bool debug;
68 bool icount;
69 TCGv_i32 next_icount;
70
71 unsigned cpenable;
72
73 uint32_t op_flags;
74 xtensa_insnbuf_word insnbuf[MAX_INSNBUF_LENGTH];
75 xtensa_insnbuf_word slotbuf[MAX_INSNBUF_LENGTH];
76 };
77
78 static TCGv_i32 cpu_pc;
79 static TCGv_i32 cpu_R[16];
80 static TCGv_i32 cpu_FR[16];
81 static TCGv_i64 cpu_FRD[16];
82 static TCGv_i32 cpu_MR[4];
83 static TCGv_i32 cpu_BR[16];
84 static TCGv_i32 cpu_BR4[4];
85 static TCGv_i32 cpu_BR8[2];
86 static TCGv_i32 cpu_SR[256];
87 static TCGv_i32 cpu_UR[256];
88 static TCGv_i32 cpu_windowbase_next;
89 static TCGv_i32 cpu_exclusive_addr;
90 static TCGv_i32 cpu_exclusive_val;
91
92 static GHashTable *xtensa_regfile_table;
93
94 #include "exec/gen-icount.h"
95
96 static char *sr_name[256];
97 static char *ur_name[256];
98
99 void xtensa_collect_sr_names(const XtensaConfig *config)
100 {
101 xtensa_isa isa = config->isa;
102 int n = xtensa_isa_num_sysregs(isa);
103 int i;
104
105 for (i = 0; i < n; ++i) {
106 int sr = xtensa_sysreg_number(isa, i);
107
108 if (sr >= 0 && sr < 256) {
109 const char *name = xtensa_sysreg_name(isa, i);
110 char **pname =
111 (xtensa_sysreg_is_user(isa, i) ? ur_name : sr_name) + sr;
112
113 if (*pname) {
114 if (strstr(*pname, name) == NULL) {
115 char *new_name =
116 malloc(strlen(*pname) + strlen(name) + 2);
117
118 strcpy(new_name, *pname);
119 strcat(new_name, "/");
120 strcat(new_name, name);
121 free(*pname);
122 *pname = new_name;
123 }
124 } else {
125 *pname = strdup(name);
126 }
127 }
128 }
129 }
130
131 void xtensa_translate_init(void)
132 {
133 static const char * const regnames[] = {
134 "ar0", "ar1", "ar2", "ar3",
135 "ar4", "ar5", "ar6", "ar7",
136 "ar8", "ar9", "ar10", "ar11",
137 "ar12", "ar13", "ar14", "ar15",
138 };
139 static const char * const fregnames[] = {
140 "f0", "f1", "f2", "f3",
141 "f4", "f5", "f6", "f7",
142 "f8", "f9", "f10", "f11",
143 "f12", "f13", "f14", "f15",
144 };
145 static const char * const mregnames[] = {
146 "m0", "m1", "m2", "m3",
147 };
148 static const char * const bregnames[] = {
149 "b0", "b1", "b2", "b3",
150 "b4", "b5", "b6", "b7",
151 "b8", "b9", "b10", "b11",
152 "b12", "b13", "b14", "b15",
153 };
154 int i;
155
156 cpu_pc = tcg_global_mem_new_i32(cpu_env,
157 offsetof(CPUXtensaState, pc), "pc");
158
159 for (i = 0; i < 16; i++) {
160 cpu_R[i] = tcg_global_mem_new_i32(cpu_env,
161 offsetof(CPUXtensaState, regs[i]),
162 regnames[i]);
163 }
164
165 for (i = 0; i < 16; i++) {
166 cpu_FR[i] = tcg_global_mem_new_i32(cpu_env,
167 offsetof(CPUXtensaState,
168 fregs[i].f32[FP_F32_LOW]),
169 fregnames[i]);
170 }
171
172 for (i = 0; i < 16; i++) {
173 cpu_FRD[i] = tcg_global_mem_new_i64(cpu_env,
174 offsetof(CPUXtensaState,
175 fregs[i].f64),
176 fregnames[i]);
177 }
178
179 for (i = 0; i < 4; i++) {
180 cpu_MR[i] = tcg_global_mem_new_i32(cpu_env,
181 offsetof(CPUXtensaState,
182 sregs[MR + i]),
183 mregnames[i]);
184 }
185
186 for (i = 0; i < 16; i++) {
187 cpu_BR[i] = tcg_global_mem_new_i32(cpu_env,
188 offsetof(CPUXtensaState,
189 sregs[BR]),
190 bregnames[i]);
191 if (i % 4 == 0) {
192 cpu_BR4[i / 4] = tcg_global_mem_new_i32(cpu_env,
193 offsetof(CPUXtensaState,
194 sregs[BR]),
195 bregnames[i]);
196 }
197 if (i % 8 == 0) {
198 cpu_BR8[i / 8] = tcg_global_mem_new_i32(cpu_env,
199 offsetof(CPUXtensaState,
200 sregs[BR]),
201 bregnames[i]);
202 }
203 }
204
205 for (i = 0; i < 256; ++i) {
206 if (sr_name[i]) {
207 cpu_SR[i] = tcg_global_mem_new_i32(cpu_env,
208 offsetof(CPUXtensaState,
209 sregs[i]),
210 sr_name[i]);
211 }
212 }
213
214 for (i = 0; i < 256; ++i) {
215 if (ur_name[i]) {
216 cpu_UR[i] = tcg_global_mem_new_i32(cpu_env,
217 offsetof(CPUXtensaState,
218 uregs[i]),
219 ur_name[i]);
220 }
221 }
222
223 cpu_windowbase_next =
224 tcg_global_mem_new_i32(cpu_env,
225 offsetof(CPUXtensaState, windowbase_next),
226 "windowbase_next");
227 cpu_exclusive_addr =
228 tcg_global_mem_new_i32(cpu_env,
229 offsetof(CPUXtensaState, exclusive_addr),
230 "exclusive_addr");
231 cpu_exclusive_val =
232 tcg_global_mem_new_i32(cpu_env,
233 offsetof(CPUXtensaState, exclusive_val),
234 "exclusive_val");
235 }
236
237 void **xtensa_get_regfile_by_name(const char *name, int entries, int bits)
238 {
239 char *geometry_name;
240 void **res;
241
242 if (xtensa_regfile_table == NULL) {
243 xtensa_regfile_table = g_hash_table_new(g_str_hash, g_str_equal);
244 /*
245 * AR is special. Xtensa translator uses it as a current register
246 * window, but configuration overlays represent it as a complete
247 * physical register file.
248 */
249 g_hash_table_insert(xtensa_regfile_table,
250 (void *)"AR 16x32", (void *)cpu_R);
251 g_hash_table_insert(xtensa_regfile_table,
252 (void *)"AR 32x32", (void *)cpu_R);
253 g_hash_table_insert(xtensa_regfile_table,
254 (void *)"AR 64x32", (void *)cpu_R);
255
256 g_hash_table_insert(xtensa_regfile_table,
257 (void *)"MR 4x32", (void *)cpu_MR);
258
259 g_hash_table_insert(xtensa_regfile_table,
260 (void *)"FR 16x32", (void *)cpu_FR);
261 g_hash_table_insert(xtensa_regfile_table,
262 (void *)"FR 16x64", (void *)cpu_FRD);
263
264 g_hash_table_insert(xtensa_regfile_table,
265 (void *)"BR 16x1", (void *)cpu_BR);
266 g_hash_table_insert(xtensa_regfile_table,
267 (void *)"BR4 4x4", (void *)cpu_BR4);
268 g_hash_table_insert(xtensa_regfile_table,
269 (void *)"BR8 2x8", (void *)cpu_BR8);
270 }
271
272 geometry_name = g_strdup_printf("%s %dx%d", name, entries, bits);
273 res = (void **)g_hash_table_lookup(xtensa_regfile_table, geometry_name);
274 g_free(geometry_name);
275 return res;
276 }
277
278 static inline bool option_enabled(DisasContext *dc, int opt)
279 {
280 return xtensa_option_enabled(dc->config, opt);
281 }
282
283 static void init_sar_tracker(DisasContext *dc)
284 {
285 dc->sar_5bit = false;
286 dc->sar_m32_5bit = false;
287 dc->sar_m32_allocated = false;
288 }
289
290 static void reset_sar_tracker(DisasContext *dc)
291 {
292 if (dc->sar_m32_allocated) {
293 tcg_temp_free(dc->sar_m32);
294 }
295 }
296
297 static void gen_right_shift_sar(DisasContext *dc, TCGv_i32 sa)
298 {
299 tcg_gen_andi_i32(cpu_SR[SAR], sa, 0x1f);
300 if (dc->sar_m32_5bit) {
301 tcg_gen_discard_i32(dc->sar_m32);
302 }
303 dc->sar_5bit = true;
304 dc->sar_m32_5bit = false;
305 }
306
307 static void gen_left_shift_sar(DisasContext *dc, TCGv_i32 sa)
308 {
309 TCGv_i32 tmp = tcg_const_i32(32);
310 if (!dc->sar_m32_allocated) {
311 dc->sar_m32 = tcg_temp_local_new_i32();
312 dc->sar_m32_allocated = true;
313 }
314 tcg_gen_andi_i32(dc->sar_m32, sa, 0x1f);
315 tcg_gen_sub_i32(cpu_SR[SAR], tmp, dc->sar_m32);
316 dc->sar_5bit = false;
317 dc->sar_m32_5bit = true;
318 tcg_temp_free(tmp);
319 }
320
321 static void gen_exception(DisasContext *dc, int excp)
322 {
323 TCGv_i32 tmp = tcg_const_i32(excp);
324 gen_helper_exception(cpu_env, tmp);
325 tcg_temp_free(tmp);
326 }
327
328 static void gen_exception_cause(DisasContext *dc, uint32_t cause)
329 {
330 TCGv_i32 tpc = tcg_const_i32(dc->pc);
331 TCGv_i32 tcause = tcg_const_i32(cause);
332 gen_helper_exception_cause(cpu_env, tpc, tcause);
333 tcg_temp_free(tpc);
334 tcg_temp_free(tcause);
335 if (cause == ILLEGAL_INSTRUCTION_CAUSE ||
336 cause == SYSCALL_CAUSE) {
337 dc->base.is_jmp = DISAS_NORETURN;
338 }
339 }
340
341 static void gen_debug_exception(DisasContext *dc, uint32_t cause)
342 {
343 TCGv_i32 tpc = tcg_const_i32(dc->pc);
344 TCGv_i32 tcause = tcg_const_i32(cause);
345 gen_helper_debug_exception(cpu_env, tpc, tcause);
346 tcg_temp_free(tpc);
347 tcg_temp_free(tcause);
348 if (cause & (DEBUGCAUSE_IB | DEBUGCAUSE_BI | DEBUGCAUSE_BN)) {
349 dc->base.is_jmp = DISAS_NORETURN;
350 }
351 }
352
353 static bool gen_check_privilege(DisasContext *dc)
354 {
355 #ifndef CONFIG_USER_ONLY
356 if (!dc->cring) {
357 return true;
358 }
359 #endif
360 gen_exception_cause(dc, PRIVILEGED_CAUSE);
361 dc->base.is_jmp = DISAS_NORETURN;
362 return false;
363 }
364
365 static bool gen_check_cpenable(DisasContext *dc, uint32_t cp_mask)
366 {
367 cp_mask &= ~dc->cpenable;
368
369 if (option_enabled(dc, XTENSA_OPTION_COPROCESSOR) && cp_mask) {
370 gen_exception_cause(dc, COPROCESSOR0_DISABLED + ctz32(cp_mask));
371 dc->base.is_jmp = DISAS_NORETURN;
372 return false;
373 }
374 return true;
375 }
376
377 static int gen_postprocess(DisasContext *dc, int slot);
378
379 static void gen_jump_slot(DisasContext *dc, TCGv dest, int slot)
380 {
381 tcg_gen_mov_i32(cpu_pc, dest);
382 if (dc->icount) {
383 tcg_gen_mov_i32(cpu_SR[ICOUNT], dc->next_icount);
384 }
385 if (dc->op_flags & XTENSA_OP_POSTPROCESS) {
386 slot = gen_postprocess(dc, slot);
387 }
388 if (slot >= 0) {
389 tcg_gen_goto_tb(slot);
390 tcg_gen_exit_tb(dc->base.tb, slot);
391 } else {
392 tcg_gen_exit_tb(NULL, 0);
393 }
394 dc->base.is_jmp = DISAS_NORETURN;
395 }
396
397 static void gen_jump(DisasContext *dc, TCGv dest)
398 {
399 gen_jump_slot(dc, dest, -1);
400 }
401
402 static int adjust_jump_slot(DisasContext *dc, uint32_t dest, int slot)
403 {
404 return translator_use_goto_tb(&dc->base, dest) ? slot : -1;
405 }
406
407 static void gen_jumpi(DisasContext *dc, uint32_t dest, int slot)
408 {
409 TCGv_i32 tmp = tcg_const_i32(dest);
410 gen_jump_slot(dc, tmp, adjust_jump_slot(dc, dest, slot));
411 tcg_temp_free(tmp);
412 }
413
414 static void gen_callw_slot(DisasContext *dc, int callinc, TCGv_i32 dest,
415 int slot)
416 {
417 TCGv_i32 tcallinc = tcg_const_i32(callinc);
418
419 tcg_gen_deposit_i32(cpu_SR[PS], cpu_SR[PS],
420 tcallinc, PS_CALLINC_SHIFT, PS_CALLINC_LEN);
421 tcg_temp_free(tcallinc);
422 tcg_gen_movi_i32(cpu_R[callinc << 2],
423 (callinc << 30) | (dc->base.pc_next & 0x3fffffff));
424 gen_jump_slot(dc, dest, slot);
425 }
426
427 static bool gen_check_loop_end(DisasContext *dc, int slot)
428 {
429 if (dc->base.pc_next == dc->lend) {
430 TCGLabel *label = gen_new_label();
431
432 tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_SR[LCOUNT], 0, label);
433 tcg_gen_subi_i32(cpu_SR[LCOUNT], cpu_SR[LCOUNT], 1);
434 if (dc->lbeg_off) {
435 gen_jumpi(dc, dc->base.pc_next - dc->lbeg_off, slot);
436 } else {
437 gen_jump(dc, cpu_SR[LBEG]);
438 }
439 gen_set_label(label);
440 gen_jumpi(dc, dc->base.pc_next, -1);
441 return true;
442 }
443 return false;
444 }
445
446 static void gen_jumpi_check_loop_end(DisasContext *dc, int slot)
447 {
448 if (!gen_check_loop_end(dc, slot)) {
449 gen_jumpi(dc, dc->base.pc_next, slot);
450 }
451 }
452
453 static void gen_brcond(DisasContext *dc, TCGCond cond,
454 TCGv_i32 t0, TCGv_i32 t1, uint32_t addr)
455 {
456 TCGLabel *label = gen_new_label();
457
458 tcg_gen_brcond_i32(cond, t0, t1, label);
459 gen_jumpi_check_loop_end(dc, 0);
460 gen_set_label(label);
461 gen_jumpi(dc, addr, 1);
462 }
463
464 static void gen_brcondi(DisasContext *dc, TCGCond cond,
465 TCGv_i32 t0, uint32_t t1, uint32_t addr)
466 {
467 TCGv_i32 tmp = tcg_const_i32(t1);
468 gen_brcond(dc, cond, t0, tmp, addr);
469 tcg_temp_free(tmp);
470 }
471
472 static uint32_t test_exceptions_sr(DisasContext *dc, const OpcodeArg arg[],
473 const uint32_t par[])
474 {
475 return xtensa_option_enabled(dc->config, par[1]) ? 0 : XTENSA_OP_ILL;
476 }
477
478 static uint32_t test_exceptions_ccompare(DisasContext *dc,
479 const OpcodeArg arg[],
480 const uint32_t par[])
481 {
482 unsigned n = par[0] - CCOMPARE;
483
484 if (n >= dc->config->nccompare) {
485 return XTENSA_OP_ILL;
486 }
487 return test_exceptions_sr(dc, arg, par);
488 }
489
490 static uint32_t test_exceptions_dbreak(DisasContext *dc, const OpcodeArg arg[],
491 const uint32_t par[])
492 {
493 unsigned n = MAX_NDBREAK;
494
495 if (par[0] >= DBREAKA && par[0] < DBREAKA + MAX_NDBREAK) {
496 n = par[0] - DBREAKA;
497 }
498 if (par[0] >= DBREAKC && par[0] < DBREAKC + MAX_NDBREAK) {
499 n = par[0] - DBREAKC;
500 }
501 if (n >= dc->config->ndbreak) {
502 return XTENSA_OP_ILL;
503 }
504 return test_exceptions_sr(dc, arg, par);
505 }
506
507 static uint32_t test_exceptions_ibreak(DisasContext *dc, const OpcodeArg arg[],
508 const uint32_t par[])
509 {
510 unsigned n = par[0] - IBREAKA;
511
512 if (n >= dc->config->nibreak) {
513 return XTENSA_OP_ILL;
514 }
515 return test_exceptions_sr(dc, arg, par);
516 }
517
518 static uint32_t test_exceptions_hpi(DisasContext *dc, const OpcodeArg arg[],
519 const uint32_t par[])
520 {
521 unsigned n = MAX_NLEVEL + 1;
522
523 if (par[0] >= EXCSAVE1 && par[0] < EXCSAVE1 + MAX_NLEVEL) {
524 n = par[0] - EXCSAVE1 + 1;
525 }
526 if (par[0] >= EPC1 && par[0] < EPC1 + MAX_NLEVEL) {
527 n = par[0] - EPC1 + 1;
528 }
529 if (par[0] >= EPS2 && par[0] < EPS2 + MAX_NLEVEL - 1) {
530 n = par[0] - EPS2 + 2;
531 }
532 if (n > dc->config->nlevel) {
533 return XTENSA_OP_ILL;
534 }
535 return test_exceptions_sr(dc, arg, par);
536 }
537
538 static MemOp gen_load_store_alignment(DisasContext *dc, MemOp mop,
539 TCGv_i32 addr)
540 {
541 if ((mop & MO_SIZE) == MO_8) {
542 return mop;
543 }
544 if ((mop & MO_AMASK) == MO_UNALN &&
545 !option_enabled(dc, XTENSA_OPTION_HW_ALIGNMENT)) {
546 mop |= MO_ALIGN;
547 }
548 if (!option_enabled(dc, XTENSA_OPTION_UNALIGNED_EXCEPTION)) {
549 tcg_gen_andi_i32(addr, addr, ~0 << get_alignment_bits(mop));
550 }
551 return mop;
552 }
553
554 #ifndef CONFIG_USER_ONLY
555 static void gen_waiti(DisasContext *dc, uint32_t imm4)
556 {
557 TCGv_i32 pc = tcg_const_i32(dc->base.pc_next);
558 TCGv_i32 intlevel = tcg_const_i32(imm4);
559
560 if (tb_cflags(dc->base.tb) & CF_USE_ICOUNT) {
561 gen_io_start();
562 }
563 gen_helper_waiti(cpu_env, pc, intlevel);
564 tcg_temp_free(pc);
565 tcg_temp_free(intlevel);
566 }
567 #endif
568
569 static bool gen_window_check(DisasContext *dc, uint32_t mask)
570 {
571 unsigned r = 31 - clz32(mask);
572
573 if (r / 4 > dc->window) {
574 TCGv_i32 pc = tcg_const_i32(dc->pc);
575 TCGv_i32 w = tcg_const_i32(r / 4);
576
577 gen_helper_window_check(cpu_env, pc, w);
578 dc->base.is_jmp = DISAS_NORETURN;
579 return false;
580 }
581 return true;
582 }
583
584 static TCGv_i32 gen_mac16_m(TCGv_i32 v, bool hi, bool is_unsigned)
585 {
586 TCGv_i32 m = tcg_temp_new_i32();
587
588 if (hi) {
589 (is_unsigned ? tcg_gen_shri_i32 : tcg_gen_sari_i32)(m, v, 16);
590 } else {
591 (is_unsigned ? tcg_gen_ext16u_i32 : tcg_gen_ext16s_i32)(m, v);
592 }
593 return m;
594 }
595
596 static void gen_zero_check(DisasContext *dc, const OpcodeArg arg[])
597 {
598 TCGLabel *label = gen_new_label();
599
600 tcg_gen_brcondi_i32(TCG_COND_NE, arg[2].in, 0, label);
601 gen_exception_cause(dc, INTEGER_DIVIDE_BY_ZERO_CAUSE);
602 gen_set_label(label);
603 }
604
605 static inline unsigned xtensa_op0_insn_len(DisasContext *dc, uint8_t op0)
606 {
607 return xtensa_isa_length_from_chars(dc->config->isa, &op0);
608 }
609
610 static int gen_postprocess(DisasContext *dc, int slot)
611 {
612 uint32_t op_flags = dc->op_flags;
613
614 #ifndef CONFIG_USER_ONLY
615 if (op_flags & XTENSA_OP_CHECK_INTERRUPTS) {
616 if (tb_cflags(dc->base.tb) & CF_USE_ICOUNT) {
617 gen_io_start();
618 }
619 gen_helper_check_interrupts(cpu_env);
620 }
621 #endif
622 if (op_flags & XTENSA_OP_SYNC_REGISTER_WINDOW) {
623 gen_helper_sync_windowbase(cpu_env);
624 }
625 if (op_flags & XTENSA_OP_EXIT_TB_M1) {
626 slot = -1;
627 }
628 return slot;
629 }
630
631 struct opcode_arg_copy {
632 uint32_t resource;
633 void *temp;
634 OpcodeArg *arg;
635 };
636
637 struct opcode_arg_info {
638 uint32_t resource;
639 int index;
640 };
641
642 struct slot_prop {
643 XtensaOpcodeOps *ops;
644 OpcodeArg arg[MAX_OPCODE_ARGS];
645 struct opcode_arg_info in[MAX_OPCODE_ARGS];
646 struct opcode_arg_info out[MAX_OPCODE_ARGS];
647 unsigned n_in;
648 unsigned n_out;
649 uint32_t op_flags;
650 };
651
652 enum resource_type {
653 RES_REGFILE,
654 RES_STATE,
655 RES_MAX,
656 };
657
658 static uint32_t encode_resource(enum resource_type r, unsigned g, unsigned n)
659 {
660 assert(r < RES_MAX && g < 256 && n < 65536);
661 return (r << 24) | (g << 16) | n;
662 }
663
664 static enum resource_type get_resource_type(uint32_t resource)
665 {
666 return resource >> 24;
667 }
668
669 /*
670 * a depends on b if b must be executed before a,
671 * because a's side effects will destroy b's inputs.
672 */
673 static bool op_depends_on(const struct slot_prop *a,
674 const struct slot_prop *b)
675 {
676 unsigned i = 0;
677 unsigned j = 0;
678
679 if (a->op_flags & XTENSA_OP_CONTROL_FLOW) {
680 return true;
681 }
682 if ((a->op_flags & XTENSA_OP_LOAD_STORE) <
683 (b->op_flags & XTENSA_OP_LOAD_STORE)) {
684 return true;
685 }
686 while (i < a->n_out && j < b->n_in) {
687 if (a->out[i].resource < b->in[j].resource) {
688 ++i;
689 } else if (a->out[i].resource > b->in[j].resource) {
690 ++j;
691 } else {
692 return true;
693 }
694 }
695 return false;
696 }
697
698 /*
699 * Try to break a dependency on b, append temporary register copy records
700 * to the end of copy and update n_copy in case of success.
701 * This is not always possible: e.g. control flow must always be the last,
702 * load/store must be first and state dependencies are not supported yet.
703 */
704 static bool break_dependency(struct slot_prop *a,
705 struct slot_prop *b,
706 struct opcode_arg_copy *copy,
707 unsigned *n_copy)
708 {
709 unsigned i = 0;
710 unsigned j = 0;
711 unsigned n = *n_copy;
712 bool rv = false;
713
714 if (a->op_flags & XTENSA_OP_CONTROL_FLOW) {
715 return false;
716 }
717 if ((a->op_flags & XTENSA_OP_LOAD_STORE) <
718 (b->op_flags & XTENSA_OP_LOAD_STORE)) {
719 return false;
720 }
721 while (i < a->n_out && j < b->n_in) {
722 if (a->out[i].resource < b->in[j].resource) {
723 ++i;
724 } else if (a->out[i].resource > b->in[j].resource) {
725 ++j;
726 } else {
727 int index = b->in[j].index;
728
729 if (get_resource_type(a->out[i].resource) != RES_REGFILE ||
730 index < 0) {
731 return false;
732 }
733 copy[n].resource = b->in[j].resource;
734 copy[n].arg = b->arg + index;
735 ++n;
736 ++j;
737 rv = true;
738 }
739 }
740 *n_copy = n;
741 return rv;
742 }
743
744 /*
745 * Calculate evaluation order for slot opcodes.
746 * Build opcode order graph and output its nodes in topological sort order.
747 * An edge a -> b in the graph means that opcode a must be followed by
748 * opcode b.
749 */
750 static bool tsort(struct slot_prop *slot,
751 struct slot_prop *sorted[],
752 unsigned n,
753 struct opcode_arg_copy *copy,
754 unsigned *n_copy)
755 {
756 struct tsnode {
757 unsigned n_in_edge;
758 unsigned n_out_edge;
759 unsigned out_edge[MAX_INSN_SLOTS];
760 } node[MAX_INSN_SLOTS];
761
762 unsigned in[MAX_INSN_SLOTS];
763 unsigned i, j;
764 unsigned n_in = 0;
765 unsigned n_out = 0;
766 unsigned n_edge = 0;
767 unsigned in_idx = 0;
768 unsigned node_idx = 0;
769
770 for (i = 0; i < n; ++i) {
771 node[i].n_in_edge = 0;
772 node[i].n_out_edge = 0;
773 }
774
775 for (i = 0; i < n; ++i) {
776 unsigned n_out_edge = 0;
777
778 for (j = 0; j < n; ++j) {
779 if (i != j && op_depends_on(slot + j, slot + i)) {
780 node[i].out_edge[n_out_edge] = j;
781 ++node[j].n_in_edge;
782 ++n_out_edge;
783 ++n_edge;
784 }
785 }
786 node[i].n_out_edge = n_out_edge;
787 }
788
789 for (i = 0; i < n; ++i) {
790 if (!node[i].n_in_edge) {
791 in[n_in] = i;
792 ++n_in;
793 }
794 }
795
796 again:
797 for (; in_idx < n_in; ++in_idx) {
798 i = in[in_idx];
799 sorted[n_out] = slot + i;
800 ++n_out;
801 for (j = 0; j < node[i].n_out_edge; ++j) {
802 --n_edge;
803 if (--node[node[i].out_edge[j]].n_in_edge == 0) {
804 in[n_in] = node[i].out_edge[j];
805 ++n_in;
806 }
807 }
808 }
809 if (n_edge) {
810 for (; node_idx < n; ++node_idx) {
811 struct tsnode *cnode = node + node_idx;
812
813 if (cnode->n_in_edge) {
814 for (j = 0; j < cnode->n_out_edge; ++j) {
815 unsigned k = cnode->out_edge[j];
816
817 if (break_dependency(slot + k, slot + node_idx,
818 copy, n_copy) &&
819 --node[k].n_in_edge == 0) {
820 in[n_in] = k;
821 ++n_in;
822 --n_edge;
823 cnode->out_edge[j] =
824 cnode->out_edge[cnode->n_out_edge - 1];
825 --cnode->n_out_edge;
826 goto again;
827 }
828 }
829 }
830 }
831 }
832 return n_edge == 0;
833 }
834
835 static void opcode_add_resource(struct slot_prop *op,
836 uint32_t resource, char direction,
837 int index)
838 {
839 switch (direction) {
840 case 'm':
841 case 'i':
842 assert(op->n_in < ARRAY_SIZE(op->in));
843 op->in[op->n_in].resource = resource;
844 op->in[op->n_in].index = index;
845 ++op->n_in;
846 /* fall through */
847 case 'o':
848 if (direction == 'm' || direction == 'o') {
849 assert(op->n_out < ARRAY_SIZE(op->out));
850 op->out[op->n_out].resource = resource;
851 op->out[op->n_out].index = index;
852 ++op->n_out;
853 }
854 break;
855 default:
856 g_assert_not_reached();
857 }
858 }
859
860 static int resource_compare(const void *a, const void *b)
861 {
862 const struct opcode_arg_info *pa = a;
863 const struct opcode_arg_info *pb = b;
864
865 return pa->resource < pb->resource ?
866 -1 : (pa->resource > pb->resource ? 1 : 0);
867 }
868
869 static int arg_copy_compare(const void *a, const void *b)
870 {
871 const struct opcode_arg_copy *pa = a;
872 const struct opcode_arg_copy *pb = b;
873
874 return pa->resource < pb->resource ?
875 -1 : (pa->resource > pb->resource ? 1 : 0);
876 }
877
878 static void disas_xtensa_insn(CPUXtensaState *env, DisasContext *dc)
879 {
880 xtensa_isa isa = dc->config->isa;
881 unsigned char b[MAX_INSN_LENGTH] = {translator_ldub(env, &dc->base,
882 dc->pc)};
883 unsigned len = xtensa_op0_insn_len(dc, b[0]);
884 xtensa_format fmt;
885 int slot, slots;
886 unsigned i;
887 uint32_t op_flags = 0;
888 struct slot_prop slot_prop[MAX_INSN_SLOTS];
889 struct slot_prop *ordered[MAX_INSN_SLOTS];
890 struct opcode_arg_copy arg_copy[MAX_INSN_SLOTS * MAX_OPCODE_ARGS];
891 unsigned n_arg_copy = 0;
892 uint32_t debug_cause = 0;
893 uint32_t windowed_register = 0;
894 uint32_t coprocessor = 0;
895
896 if (len == XTENSA_UNDEFINED) {
897 qemu_log_mask(LOG_GUEST_ERROR,
898 "unknown instruction length (pc = %08x)\n",
899 dc->pc);
900 gen_exception_cause(dc, ILLEGAL_INSTRUCTION_CAUSE);
901 dc->base.pc_next = dc->pc + 1;
902 return;
903 }
904
905 dc->base.pc_next = dc->pc + len;
906 for (i = 1; i < len; ++i) {
907 b[i] = translator_ldub(env, &dc->base, dc->pc + i);
908 }
909 xtensa_insnbuf_from_chars(isa, dc->insnbuf, b, len);
910 fmt = xtensa_format_decode(isa, dc->insnbuf);
911 if (fmt == XTENSA_UNDEFINED) {
912 qemu_log_mask(LOG_GUEST_ERROR,
913 "unrecognized instruction format (pc = %08x)\n",
914 dc->pc);
915 gen_exception_cause(dc, ILLEGAL_INSTRUCTION_CAUSE);
916 return;
917 }
918 slots = xtensa_format_num_slots(isa, fmt);
919 for (slot = 0; slot < slots; ++slot) {
920 xtensa_opcode opc;
921 int opnd, vopnd, opnds;
922 OpcodeArg *arg = slot_prop[slot].arg;
923 XtensaOpcodeOps *ops;
924
925 xtensa_format_get_slot(isa, fmt, slot, dc->insnbuf, dc->slotbuf);
926 opc = xtensa_opcode_decode(isa, fmt, slot, dc->slotbuf);
927 if (opc == XTENSA_UNDEFINED) {
928 qemu_log_mask(LOG_GUEST_ERROR,
929 "unrecognized opcode in slot %d (pc = %08x)\n",
930 slot, dc->pc);
931 gen_exception_cause(dc, ILLEGAL_INSTRUCTION_CAUSE);
932 return;
933 }
934 opnds = xtensa_opcode_num_operands(isa, opc);
935
936 for (opnd = vopnd = 0; opnd < opnds; ++opnd) {
937 void **register_file = NULL;
938 xtensa_regfile rf;
939
940 if (xtensa_operand_is_register(isa, opc, opnd)) {
941 rf = xtensa_operand_regfile(isa, opc, opnd);
942 register_file = dc->config->regfile[rf];
943
944 if (rf == dc->config->a_regfile) {
945 uint32_t v;
946
947 xtensa_operand_get_field(isa, opc, opnd, fmt, slot,
948 dc->slotbuf, &v);
949 xtensa_operand_decode(isa, opc, opnd, &v);
950 windowed_register |= 1u << v;
951 }
952 }
953 if (xtensa_operand_is_visible(isa, opc, opnd)) {
954 uint32_t v;
955
956 xtensa_operand_get_field(isa, opc, opnd, fmt, slot,
957 dc->slotbuf, &v);
958 xtensa_operand_decode(isa, opc, opnd, &v);
959 arg[vopnd].raw_imm = v;
960 if (xtensa_operand_is_PCrelative(isa, opc, opnd)) {
961 xtensa_operand_undo_reloc(isa, opc, opnd, &v, dc->pc);
962 }
963 arg[vopnd].imm = v;
964 if (register_file) {
965 arg[vopnd].in = register_file[v];
966 arg[vopnd].out = register_file[v];
967 arg[vopnd].num_bits = xtensa_regfile_num_bits(isa, rf);
968 } else {
969 arg[vopnd].num_bits = 32;
970 }
971 ++vopnd;
972 }
973 }
974 ops = dc->config->opcode_ops[opc];
975 slot_prop[slot].ops = ops;
976
977 if (ops) {
978 op_flags |= ops->op_flags;
979 if (ops->test_exceptions) {
980 op_flags |= ops->test_exceptions(dc, arg, ops->par);
981 }
982 } else {
983 qemu_log_mask(LOG_UNIMP,
984 "unimplemented opcode '%s' in slot %d (pc = %08x)\n",
985 xtensa_opcode_name(isa, opc), slot, dc->pc);
986 op_flags |= XTENSA_OP_ILL;
987 }
988 if (op_flags & XTENSA_OP_ILL) {
989 gen_exception_cause(dc, ILLEGAL_INSTRUCTION_CAUSE);
990 return;
991 }
992 if (op_flags & XTENSA_OP_DEBUG_BREAK) {
993 debug_cause |= ops->par[0];
994 }
995 if (ops->test_overflow) {
996 windowed_register |= ops->test_overflow(dc, arg, ops->par);
997 }
998 coprocessor |= ops->coprocessor;
999
1000 if (slots > 1) {
1001 slot_prop[slot].n_in = 0;
1002 slot_prop[slot].n_out = 0;
1003 slot_prop[slot].op_flags = ops->op_flags & XTENSA_OP_LOAD_STORE;
1004
1005 opnds = xtensa_opcode_num_operands(isa, opc);
1006
1007 for (opnd = vopnd = 0; opnd < opnds; ++opnd) {
1008 bool visible = xtensa_operand_is_visible(isa, opc, opnd);
1009
1010 if (xtensa_operand_is_register(isa, opc, opnd)) {
1011 xtensa_regfile rf = xtensa_operand_regfile(isa, opc, opnd);
1012 uint32_t v = 0;
1013
1014 xtensa_operand_get_field(isa, opc, opnd, fmt, slot,
1015 dc->slotbuf, &v);
1016 xtensa_operand_decode(isa, opc, opnd, &v);
1017 opcode_add_resource(slot_prop + slot,
1018 encode_resource(RES_REGFILE, rf, v),
1019 xtensa_operand_inout(isa, opc, opnd),
1020 visible ? vopnd : -1);
1021 }
1022 if (visible) {
1023 ++vopnd;
1024 }
1025 }
1026
1027 opnds = xtensa_opcode_num_stateOperands(isa, opc);
1028
1029 for (opnd = 0; opnd < opnds; ++opnd) {
1030 xtensa_state state = xtensa_stateOperand_state(isa, opc, opnd);
1031
1032 opcode_add_resource(slot_prop + slot,
1033 encode_resource(RES_STATE, 0, state),
1034 xtensa_stateOperand_inout(isa, opc, opnd),
1035 -1);
1036 }
1037 if (xtensa_opcode_is_branch(isa, opc) ||
1038 xtensa_opcode_is_jump(isa, opc) ||
1039 xtensa_opcode_is_loop(isa, opc) ||
1040 xtensa_opcode_is_call(isa, opc)) {
1041 slot_prop[slot].op_flags |= XTENSA_OP_CONTROL_FLOW;
1042 }
1043
1044 qsort(slot_prop[slot].in, slot_prop[slot].n_in,
1045 sizeof(slot_prop[slot].in[0]), resource_compare);
1046 qsort(slot_prop[slot].out, slot_prop[slot].n_out,
1047 sizeof(slot_prop[slot].out[0]), resource_compare);
1048 }
1049 }
1050
1051 if (slots > 1) {
1052 if (!tsort(slot_prop, ordered, slots, arg_copy, &n_arg_copy)) {
1053 qemu_log_mask(LOG_UNIMP,
1054 "Circular resource dependencies (pc = %08x)\n",
1055 dc->pc);
1056 gen_exception_cause(dc, ILLEGAL_INSTRUCTION_CAUSE);
1057 return;
1058 }
1059 } else {
1060 ordered[0] = slot_prop + 0;
1061 }
1062
1063 if ((op_flags & XTENSA_OP_PRIVILEGED) &&
1064 !gen_check_privilege(dc)) {
1065 return;
1066 }
1067
1068 if (op_flags & XTENSA_OP_SYSCALL) {
1069 gen_exception_cause(dc, SYSCALL_CAUSE);
1070 return;
1071 }
1072
1073 if ((op_flags & XTENSA_OP_DEBUG_BREAK) && dc->debug) {
1074 gen_debug_exception(dc, debug_cause);
1075 return;
1076 }
1077
1078 if (windowed_register && !gen_window_check(dc, windowed_register)) {
1079 return;
1080 }
1081
1082 if (op_flags & XTENSA_OP_UNDERFLOW) {
1083 TCGv_i32 tmp = tcg_const_i32(dc->pc);
1084
1085 gen_helper_test_underflow_retw(cpu_env, tmp);
1086 tcg_temp_free(tmp);
1087 }
1088
1089 if (op_flags & XTENSA_OP_ALLOCA) {
1090 TCGv_i32 tmp = tcg_const_i32(dc->pc);
1091
1092 gen_helper_movsp(cpu_env, tmp);
1093 tcg_temp_free(tmp);
1094 }
1095
1096 if (coprocessor && !gen_check_cpenable(dc, coprocessor)) {
1097 return;
1098 }
1099
1100 if (n_arg_copy) {
1101 uint32_t resource;
1102 void *temp;
1103 unsigned j;
1104
1105 qsort(arg_copy, n_arg_copy, sizeof(*arg_copy), arg_copy_compare);
1106 for (i = j = 0; i < n_arg_copy; ++i) {
1107 if (i == 0 || arg_copy[i].resource != resource) {
1108 resource = arg_copy[i].resource;
1109 if (arg_copy[i].arg->num_bits <= 32) {
1110 temp = tcg_temp_local_new_i32();
1111 tcg_gen_mov_i32(temp, arg_copy[i].arg->in);
1112 } else if (arg_copy[i].arg->num_bits <= 64) {
1113 temp = tcg_temp_local_new_i64();
1114 tcg_gen_mov_i64(temp, arg_copy[i].arg->in);
1115 } else {
1116 g_assert_not_reached();
1117 }
1118 arg_copy[i].temp = temp;
1119
1120 if (i != j) {
1121 arg_copy[j] = arg_copy[i];
1122 }
1123 ++j;
1124 }
1125 arg_copy[i].arg->in = temp;
1126 }
1127 n_arg_copy = j;
1128 }
1129
1130 if (op_flags & XTENSA_OP_DIVIDE_BY_ZERO) {
1131 for (slot = 0; slot < slots; ++slot) {
1132 if (slot_prop[slot].ops->op_flags & XTENSA_OP_DIVIDE_BY_ZERO) {
1133 gen_zero_check(dc, slot_prop[slot].arg);
1134 }
1135 }
1136 }
1137
1138 dc->op_flags = op_flags;
1139
1140 for (slot = 0; slot < slots; ++slot) {
1141 struct slot_prop *pslot = ordered[slot];
1142 XtensaOpcodeOps *ops = pslot->ops;
1143
1144 ops->translate(dc, pslot->arg, ops->par);
1145 }
1146
1147 for (i = 0; i < n_arg_copy; ++i) {
1148 if (arg_copy[i].arg->num_bits <= 32) {
1149 tcg_temp_free_i32(arg_copy[i].temp);
1150 } else if (arg_copy[i].arg->num_bits <= 64) {
1151 tcg_temp_free_i64(arg_copy[i].temp);
1152 } else {
1153 g_assert_not_reached();
1154 }
1155 }
1156
1157 if (dc->base.is_jmp == DISAS_NEXT) {
1158 gen_postprocess(dc, 0);
1159 dc->op_flags = 0;
1160 if (op_flags & XTENSA_OP_EXIT_TB_M1) {
1161 /* Change in mmu index, memory mapping or tb->flags; exit tb */
1162 gen_jumpi_check_loop_end(dc, -1);
1163 } else if (op_flags & XTENSA_OP_EXIT_TB_0) {
1164 gen_jumpi_check_loop_end(dc, 0);
1165 } else {
1166 gen_check_loop_end(dc, 0);
1167 }
1168 }
1169 dc->pc = dc->base.pc_next;
1170 }
1171
1172 static inline unsigned xtensa_insn_len(CPUXtensaState *env, DisasContext *dc)
1173 {
1174 uint8_t b0 = cpu_ldub_code(env, dc->pc);
1175 return xtensa_op0_insn_len(dc, b0);
1176 }
1177
1178 static void gen_ibreak_check(CPUXtensaState *env, DisasContext *dc)
1179 {
1180 unsigned i;
1181
1182 for (i = 0; i < dc->config->nibreak; ++i) {
1183 if ((env->sregs[IBREAKENABLE] & (1 << i)) &&
1184 env->sregs[IBREAKA + i] == dc->pc) {
1185 gen_debug_exception(dc, DEBUGCAUSE_IB);
1186 break;
1187 }
1188 }
1189 }
1190
1191 static void xtensa_tr_init_disas_context(DisasContextBase *dcbase,
1192 CPUState *cpu)
1193 {
1194 DisasContext *dc = container_of(dcbase, DisasContext, base);
1195 CPUXtensaState *env = cpu->env_ptr;
1196 uint32_t tb_flags = dc->base.tb->flags;
1197
1198 dc->config = env->config;
1199 dc->pc = dc->base.pc_first;
1200 dc->ring = tb_flags & XTENSA_TBFLAG_RING_MASK;
1201 dc->cring = (tb_flags & XTENSA_TBFLAG_EXCM) ? 0 : dc->ring;
1202 dc->lbeg_off = (dc->base.tb->cs_base & XTENSA_CSBASE_LBEG_OFF_MASK) >>
1203 XTENSA_CSBASE_LBEG_OFF_SHIFT;
1204 dc->lend = (dc->base.tb->cs_base & XTENSA_CSBASE_LEND_MASK) +
1205 (dc->base.pc_first & TARGET_PAGE_MASK);
1206 dc->debug = tb_flags & XTENSA_TBFLAG_DEBUG;
1207 dc->icount = tb_flags & XTENSA_TBFLAG_ICOUNT;
1208 dc->cpenable = (tb_flags & XTENSA_TBFLAG_CPENABLE_MASK) >>
1209 XTENSA_TBFLAG_CPENABLE_SHIFT;
1210 dc->window = ((tb_flags & XTENSA_TBFLAG_WINDOW_MASK) >>
1211 XTENSA_TBFLAG_WINDOW_SHIFT);
1212 dc->cwoe = tb_flags & XTENSA_TBFLAG_CWOE;
1213 dc->callinc = ((tb_flags & XTENSA_TBFLAG_CALLINC_MASK) >>
1214 XTENSA_TBFLAG_CALLINC_SHIFT);
1215 init_sar_tracker(dc);
1216 }
1217
1218 static void xtensa_tr_tb_start(DisasContextBase *dcbase, CPUState *cpu)
1219 {
1220 DisasContext *dc = container_of(dcbase, DisasContext, base);
1221
1222 if (dc->icount) {
1223 dc->next_icount = tcg_temp_local_new_i32();
1224 }
1225 }
1226
1227 static void xtensa_tr_insn_start(DisasContextBase *dcbase, CPUState *cpu)
1228 {
1229 tcg_gen_insn_start(dcbase->pc_next);
1230 }
1231
1232 static void xtensa_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
1233 {
1234 DisasContext *dc = container_of(dcbase, DisasContext, base);
1235 CPUXtensaState *env = cpu->env_ptr;
1236 target_ulong page_start;
1237
1238 /* These two conditions only apply to the first insn in the TB,
1239 but this is the first TranslateOps hook that allows exiting. */
1240 if ((tb_cflags(dc->base.tb) & CF_USE_ICOUNT)
1241 && (dc->base.tb->flags & XTENSA_TBFLAG_YIELD)) {
1242 gen_exception(dc, EXCP_YIELD);
1243 dc->base.pc_next = dc->pc + 1;
1244 dc->base.is_jmp = DISAS_NORETURN;
1245 return;
1246 }
1247
1248 if (dc->icount) {
1249 TCGLabel *label = gen_new_label();
1250
1251 tcg_gen_addi_i32(dc->next_icount, cpu_SR[ICOUNT], 1);
1252 tcg_gen_brcondi_i32(TCG_COND_NE, dc->next_icount, 0, label);
1253 tcg_gen_mov_i32(dc->next_icount, cpu_SR[ICOUNT]);
1254 if (dc->debug) {
1255 gen_debug_exception(dc, DEBUGCAUSE_IC);
1256 }
1257 gen_set_label(label);
1258 }
1259
1260 if (dc->debug) {
1261 gen_ibreak_check(env, dc);
1262 }
1263
1264 disas_xtensa_insn(env, dc);
1265
1266 if (dc->icount) {
1267 tcg_gen_mov_i32(cpu_SR[ICOUNT], dc->next_icount);
1268 }
1269
1270 /* End the TB if the next insn will cross into the next page. */
1271 page_start = dc->base.pc_first & TARGET_PAGE_MASK;
1272 if (dc->base.is_jmp == DISAS_NEXT &&
1273 (dc->pc - page_start >= TARGET_PAGE_SIZE ||
1274 dc->pc - page_start + xtensa_insn_len(env, dc) > TARGET_PAGE_SIZE)) {
1275 dc->base.is_jmp = DISAS_TOO_MANY;
1276 }
1277 }
1278
1279 static void xtensa_tr_tb_stop(DisasContextBase *dcbase, CPUState *cpu)
1280 {
1281 DisasContext *dc = container_of(dcbase, DisasContext, base);
1282
1283 reset_sar_tracker(dc);
1284 if (dc->icount) {
1285 tcg_temp_free(dc->next_icount);
1286 }
1287
1288 switch (dc->base.is_jmp) {
1289 case DISAS_NORETURN:
1290 break;
1291 case DISAS_TOO_MANY:
1292 gen_jumpi(dc, dc->pc, 0);
1293 break;
1294 default:
1295 g_assert_not_reached();
1296 }
1297 }
1298
1299 static void xtensa_tr_disas_log(const DisasContextBase *dcbase, CPUState *cpu)
1300 {
1301 qemu_log("IN: %s\n", lookup_symbol(dcbase->pc_first));
1302 log_target_disas(cpu, dcbase->pc_first, dcbase->tb->size);
1303 }
1304
1305 static const TranslatorOps xtensa_translator_ops = {
1306 .init_disas_context = xtensa_tr_init_disas_context,
1307 .tb_start = xtensa_tr_tb_start,
1308 .insn_start = xtensa_tr_insn_start,
1309 .translate_insn = xtensa_tr_translate_insn,
1310 .tb_stop = xtensa_tr_tb_stop,
1311 .disas_log = xtensa_tr_disas_log,
1312 };
1313
1314 void gen_intermediate_code(CPUState *cpu, TranslationBlock *tb, int max_insns)
1315 {
1316 DisasContext dc = {};
1317 translator_loop(&xtensa_translator_ops, &dc.base, cpu, tb, max_insns);
1318 }
1319
1320 void xtensa_cpu_dump_state(CPUState *cs, FILE *f, int flags)
1321 {
1322 XtensaCPU *cpu = XTENSA_CPU(cs);
1323 CPUXtensaState *env = &cpu->env;
1324 xtensa_isa isa = env->config->isa;
1325 int i, j;
1326
1327 qemu_fprintf(f, "PC=%08x\n\n", env->pc);
1328
1329 for (i = j = 0; i < xtensa_isa_num_sysregs(isa); ++i) {
1330 const uint32_t *reg =
1331 xtensa_sysreg_is_user(isa, i) ? env->uregs : env->sregs;
1332 int regno = xtensa_sysreg_number(isa, i);
1333
1334 if (regno >= 0) {
1335 qemu_fprintf(f, "%12s=%08x%c",
1336 xtensa_sysreg_name(isa, i),
1337 reg[regno],
1338 (j++ % 4) == 3 ? '\n' : ' ');
1339 }
1340 }
1341
1342 qemu_fprintf(f, (j % 4) == 0 ? "\n" : "\n\n");
1343
1344 for (i = 0; i < 16; ++i) {
1345 qemu_fprintf(f, " A%02d=%08x%c",
1346 i, env->regs[i], (i % 4) == 3 ? '\n' : ' ');
1347 }
1348
1349 xtensa_sync_phys_from_window(env);
1350 qemu_fprintf(f, "\n");
1351
1352 for (i = 0; i < env->config->nareg; ++i) {
1353 qemu_fprintf(f, "AR%02d=%08x ", i, env->phys_regs[i]);
1354 if (i % 4 == 3) {
1355 bool ws = (env->sregs[WINDOW_START] & (1 << (i / 4))) != 0;
1356 bool cw = env->sregs[WINDOW_BASE] == i / 4;
1357
1358 qemu_fprintf(f, "%c%c\n", ws ? '<' : ' ', cw ? '=' : ' ');
1359 }
1360 }
1361
1362 if ((flags & CPU_DUMP_FPU) &&
1363 xtensa_option_enabled(env->config, XTENSA_OPTION_FP_COPROCESSOR)) {
1364 qemu_fprintf(f, "\n");
1365
1366 for (i = 0; i < 16; ++i) {
1367 qemu_fprintf(f, "F%02d=%08x (%-+15.8e)%c", i,
1368 float32_val(env->fregs[i].f32[FP_F32_LOW]),
1369 *(float *)(env->fregs[i].f32 + FP_F32_LOW),
1370 (i % 2) == 1 ? '\n' : ' ');
1371 }
1372 }
1373
1374 if ((flags & CPU_DUMP_FPU) &&
1375 xtensa_option_enabled(env->config, XTENSA_OPTION_DFP_COPROCESSOR) &&
1376 !xtensa_option_enabled(env->config, XTENSA_OPTION_DFPU_SINGLE_ONLY)) {
1377 qemu_fprintf(f, "\n");
1378
1379 for (i = 0; i < 16; ++i) {
1380 qemu_fprintf(f, "F%02d=%016"PRIx64" (%-+24.16le)%c", i,
1381 float64_val(env->fregs[i].f64),
1382 *(double *)(&env->fregs[i].f64),
1383 (i % 2) == 1 ? '\n' : ' ');
1384 }
1385 }
1386 }
1387
1388 void restore_state_to_opc(CPUXtensaState *env, TranslationBlock *tb,
1389 target_ulong *data)
1390 {
1391 env->pc = data[0];
1392 }
1393
1394 static void translate_abs(DisasContext *dc, const OpcodeArg arg[],
1395 const uint32_t par[])
1396 {
1397 tcg_gen_abs_i32(arg[0].out, arg[1].in);
1398 }
1399
1400 static void translate_add(DisasContext *dc, const OpcodeArg arg[],
1401 const uint32_t par[])
1402 {
1403 tcg_gen_add_i32(arg[0].out, arg[1].in, arg[2].in);
1404 }
1405
1406 static void translate_addi(DisasContext *dc, const OpcodeArg arg[],
1407 const uint32_t par[])
1408 {
1409 tcg_gen_addi_i32(arg[0].out, arg[1].in, arg[2].imm);
1410 }
1411
1412 static void translate_addx(DisasContext *dc, const OpcodeArg arg[],
1413 const uint32_t par[])
1414 {
1415 TCGv_i32 tmp = tcg_temp_new_i32();
1416 tcg_gen_shli_i32(tmp, arg[1].in, par[0]);
1417 tcg_gen_add_i32(arg[0].out, tmp, arg[2].in);
1418 tcg_temp_free(tmp);
1419 }
1420
1421 static void translate_all(DisasContext *dc, const OpcodeArg arg[],
1422 const uint32_t par[])
1423 {
1424 uint32_t shift = par[1];
1425 TCGv_i32 mask = tcg_const_i32(((1 << shift) - 1) << arg[1].imm);
1426 TCGv_i32 tmp = tcg_temp_new_i32();
1427
1428 tcg_gen_and_i32(tmp, arg[1].in, mask);
1429 if (par[0]) {
1430 tcg_gen_addi_i32(tmp, tmp, 1 << arg[1].imm);
1431 } else {
1432 tcg_gen_add_i32(tmp, tmp, mask);
1433 }
1434 tcg_gen_shri_i32(tmp, tmp, arg[1].imm + shift);
1435 tcg_gen_deposit_i32(arg[0].out, arg[0].out,
1436 tmp, arg[0].imm, 1);
1437 tcg_temp_free(mask);
1438 tcg_temp_free(tmp);
1439 }
1440
1441 static void translate_and(DisasContext *dc, const OpcodeArg arg[],
1442 const uint32_t par[])
1443 {
1444 tcg_gen_and_i32(arg[0].out, arg[1].in, arg[2].in);
1445 }
1446
1447 static void translate_ball(DisasContext *dc, const OpcodeArg arg[],
1448 const uint32_t par[])
1449 {
1450 TCGv_i32 tmp = tcg_temp_new_i32();
1451 tcg_gen_and_i32(tmp, arg[0].in, arg[1].in);
1452 gen_brcond(dc, par[0], tmp, arg[1].in, arg[2].imm);
1453 tcg_temp_free(tmp);
1454 }
1455
1456 static void translate_bany(DisasContext *dc, const OpcodeArg arg[],
1457 const uint32_t par[])
1458 {
1459 TCGv_i32 tmp = tcg_temp_new_i32();
1460 tcg_gen_and_i32(tmp, arg[0].in, arg[1].in);
1461 gen_brcondi(dc, par[0], tmp, 0, arg[2].imm);
1462 tcg_temp_free(tmp);
1463 }
1464
1465 static void translate_b(DisasContext *dc, const OpcodeArg arg[],
1466 const uint32_t par[])
1467 {
1468 gen_brcond(dc, par[0], arg[0].in, arg[1].in, arg[2].imm);
1469 }
1470
1471 static void translate_bb(DisasContext *dc, const OpcodeArg arg[],
1472 const uint32_t par[])
1473 {
1474 #ifdef TARGET_WORDS_BIGENDIAN
1475 TCGv_i32 bit = tcg_const_i32(0x80000000u);
1476 #else
1477 TCGv_i32 bit = tcg_const_i32(0x00000001u);
1478 #endif
1479 TCGv_i32 tmp = tcg_temp_new_i32();
1480 tcg_gen_andi_i32(tmp, arg[1].in, 0x1f);
1481 #ifdef TARGET_WORDS_BIGENDIAN
1482 tcg_gen_shr_i32(bit, bit, tmp);
1483 #else
1484 tcg_gen_shl_i32(bit, bit, tmp);
1485 #endif
1486 tcg_gen_and_i32(tmp, arg[0].in, bit);
1487 gen_brcondi(dc, par[0], tmp, 0, arg[2].imm);
1488 tcg_temp_free(tmp);
1489 tcg_temp_free(bit);
1490 }
1491
1492 static void translate_bbi(DisasContext *dc, const OpcodeArg arg[],
1493 const uint32_t par[])
1494 {
1495 TCGv_i32 tmp = tcg_temp_new_i32();
1496 #ifdef TARGET_WORDS_BIGENDIAN
1497 tcg_gen_andi_i32(tmp, arg[0].in, 0x80000000u >> arg[1].imm);
1498 #else
1499 tcg_gen_andi_i32(tmp, arg[0].in, 0x00000001u << arg[1].imm);
1500 #endif
1501 gen_brcondi(dc, par[0], tmp, 0, arg[2].imm);
1502 tcg_temp_free(tmp);
1503 }
1504
1505 static void translate_bi(DisasContext *dc, const OpcodeArg arg[],
1506 const uint32_t par[])
1507 {
1508 gen_brcondi(dc, par[0], arg[0].in, arg[1].imm, arg[2].imm);
1509 }
1510
1511 static void translate_bz(DisasContext *dc, const OpcodeArg arg[],
1512 const uint32_t par[])
1513 {
1514 gen_brcondi(dc, par[0], arg[0].in, 0, arg[1].imm);
1515 }
1516
1517 enum {
1518 BOOLEAN_AND,
1519 BOOLEAN_ANDC,
1520 BOOLEAN_OR,
1521 BOOLEAN_ORC,
1522 BOOLEAN_XOR,
1523 };
1524
1525 static void translate_boolean(DisasContext *dc, const OpcodeArg arg[],
1526 const uint32_t par[])
1527 {
1528 static void (* const op[])(TCGv_i32, TCGv_i32, TCGv_i32) = {
1529 [BOOLEAN_AND] = tcg_gen_and_i32,
1530 [BOOLEAN_ANDC] = tcg_gen_andc_i32,
1531 [BOOLEAN_OR] = tcg_gen_or_i32,
1532 [BOOLEAN_ORC] = tcg_gen_orc_i32,
1533 [BOOLEAN_XOR] = tcg_gen_xor_i32,
1534 };
1535
1536 TCGv_i32 tmp1 = tcg_temp_new_i32();
1537 TCGv_i32 tmp2 = tcg_temp_new_i32();
1538
1539 tcg_gen_shri_i32(tmp1, arg[1].in, arg[1].imm);
1540 tcg_gen_shri_i32(tmp2, arg[2].in, arg[2].imm);
1541 op[par[0]](tmp1, tmp1, tmp2);
1542 tcg_gen_deposit_i32(arg[0].out, arg[0].out, tmp1, arg[0].imm, 1);
1543 tcg_temp_free(tmp1);
1544 tcg_temp_free(tmp2);
1545 }
1546
1547 static void translate_bp(DisasContext *dc, const OpcodeArg arg[],
1548 const uint32_t par[])
1549 {
1550 TCGv_i32 tmp = tcg_temp_new_i32();
1551
1552 tcg_gen_andi_i32(tmp, arg[0].in, 1 << arg[0].imm);
1553 gen_brcondi(dc, par[0], tmp, 0, arg[1].imm);
1554 tcg_temp_free(tmp);
1555 }
1556
1557 static void translate_call0(DisasContext *dc, const OpcodeArg arg[],
1558 const uint32_t par[])
1559 {
1560 tcg_gen_movi_i32(cpu_R[0], dc->base.pc_next);
1561 gen_jumpi(dc, arg[0].imm, 0);
1562 }
1563
1564 static void translate_callw(DisasContext *dc, const OpcodeArg arg[],
1565 const uint32_t par[])
1566 {
1567 TCGv_i32 tmp = tcg_const_i32(arg[0].imm);
1568 gen_callw_slot(dc, par[0], tmp, adjust_jump_slot(dc, arg[0].imm, 0));
1569 tcg_temp_free(tmp);
1570 }
1571
1572 static void translate_callx0(DisasContext *dc, const OpcodeArg arg[],
1573 const uint32_t par[])
1574 {
1575 TCGv_i32 tmp = tcg_temp_new_i32();
1576 tcg_gen_mov_i32(tmp, arg[0].in);
1577 tcg_gen_movi_i32(cpu_R[0], dc->base.pc_next);
1578 gen_jump(dc, tmp);
1579 tcg_temp_free(tmp);
1580 }
1581
1582 static void translate_callxw(DisasContext *dc, const OpcodeArg arg[],
1583 const uint32_t par[])
1584 {
1585 TCGv_i32 tmp = tcg_temp_new_i32();
1586
1587 tcg_gen_mov_i32(tmp, arg[0].in);
1588 gen_callw_slot(dc, par[0], tmp, -1);
1589 tcg_temp_free(tmp);
1590 }
1591
1592 static void translate_clamps(DisasContext *dc, const OpcodeArg arg[],
1593 const uint32_t par[])
1594 {
1595 TCGv_i32 tmp1 = tcg_const_i32(-1u << arg[2].imm);
1596 TCGv_i32 tmp2 = tcg_const_i32((1 << arg[2].imm) - 1);
1597
1598 tcg_gen_smax_i32(tmp1, tmp1, arg[1].in);
1599 tcg_gen_smin_i32(arg[0].out, tmp1, tmp2);
1600 tcg_temp_free(tmp1);
1601 tcg_temp_free(tmp2);
1602 }
1603
1604 static void translate_clrb_expstate(DisasContext *dc, const OpcodeArg arg[],
1605 const uint32_t par[])
1606 {
1607 /* TODO: GPIO32 may be a part of coprocessor */
1608 tcg_gen_andi_i32(cpu_UR[EXPSTATE], cpu_UR[EXPSTATE], ~(1u << arg[0].imm));
1609 }
1610
1611 static void translate_clrex(DisasContext *dc, const OpcodeArg arg[],
1612 const uint32_t par[])
1613 {
1614 tcg_gen_movi_i32(cpu_exclusive_addr, -1);
1615 }
1616
1617 static void translate_const16(DisasContext *dc, const OpcodeArg arg[],
1618 const uint32_t par[])
1619 {
1620 TCGv_i32 c = tcg_const_i32(arg[1].imm);
1621
1622 tcg_gen_deposit_i32(arg[0].out, c, arg[0].in, 16, 16);
1623 tcg_temp_free(c);
1624 }
1625
1626 static void translate_dcache(DisasContext *dc, const OpcodeArg arg[],
1627 const uint32_t par[])
1628 {
1629 TCGv_i32 addr = tcg_temp_new_i32();
1630 TCGv_i32 res = tcg_temp_new_i32();
1631
1632 tcg_gen_addi_i32(addr, arg[0].in, arg[1].imm);
1633 tcg_gen_qemu_ld8u(res, addr, dc->cring);
1634 tcg_temp_free(addr);
1635 tcg_temp_free(res);
1636 }
1637
1638 static void translate_depbits(DisasContext *dc, const OpcodeArg arg[],
1639 const uint32_t par[])
1640 {
1641 tcg_gen_deposit_i32(arg[1].out, arg[1].in, arg[0].in,
1642 arg[2].imm, arg[3].imm);
1643 }
1644
1645 static void translate_diwbuip(DisasContext *dc, const OpcodeArg arg[],
1646 const uint32_t par[])
1647 {
1648 tcg_gen_addi_i32(arg[0].out, arg[0].in, dc->config->dcache_line_bytes);
1649 }
1650
1651 static uint32_t test_exceptions_entry(DisasContext *dc, const OpcodeArg arg[],
1652 const uint32_t par[])
1653 {
1654 if (arg[0].imm > 3 || !dc->cwoe) {
1655 qemu_log_mask(LOG_GUEST_ERROR,
1656 "Illegal entry instruction(pc = %08x)\n", dc->pc);
1657 return XTENSA_OP_ILL;
1658 } else {
1659 return 0;
1660 }
1661 }
1662
1663 static uint32_t test_overflow_entry(DisasContext *dc, const OpcodeArg arg[],
1664 const uint32_t par[])
1665 {
1666 return 1 << (dc->callinc * 4);
1667 }
1668
1669 static void translate_entry(DisasContext *dc, const OpcodeArg arg[],
1670 const uint32_t par[])
1671 {
1672 TCGv_i32 pc = tcg_const_i32(dc->pc);
1673 TCGv_i32 s = tcg_const_i32(arg[0].imm);
1674 TCGv_i32 imm = tcg_const_i32(arg[1].imm);
1675 gen_helper_entry(cpu_env, pc, s, imm);
1676 tcg_temp_free(imm);
1677 tcg_temp_free(s);
1678 tcg_temp_free(pc);
1679 }
1680
1681 static void translate_extui(DisasContext *dc, const OpcodeArg arg[],
1682 const uint32_t par[])
1683 {
1684 int maskimm = (1 << arg[3].imm) - 1;
1685
1686 TCGv_i32 tmp = tcg_temp_new_i32();
1687 tcg_gen_shri_i32(tmp, arg[1].in, arg[2].imm);
1688 tcg_gen_andi_i32(arg[0].out, tmp, maskimm);
1689 tcg_temp_free(tmp);
1690 }
1691
1692 static void translate_getex(DisasContext *dc, const OpcodeArg arg[],
1693 const uint32_t par[])
1694 {
1695 TCGv_i32 tmp = tcg_temp_new_i32();
1696
1697 tcg_gen_extract_i32(tmp, cpu_SR[ATOMCTL], 8, 1);
1698 tcg_gen_deposit_i32(cpu_SR[ATOMCTL], cpu_SR[ATOMCTL], arg[0].in, 8, 1);
1699 tcg_gen_mov_i32(arg[0].out, tmp);
1700 tcg_temp_free(tmp);
1701 }
1702
1703 static void translate_icache(DisasContext *dc, const OpcodeArg arg[],
1704 const uint32_t par[])
1705 {
1706 #ifndef CONFIG_USER_ONLY
1707 TCGv_i32 addr = tcg_temp_new_i32();
1708
1709 tcg_gen_movi_i32(cpu_pc, dc->pc);
1710 tcg_gen_addi_i32(addr, arg[0].in, arg[1].imm);
1711 gen_helper_itlb_hit_test(cpu_env, addr);
1712 tcg_temp_free(addr);
1713 #endif
1714 }
1715
1716 static void translate_itlb(DisasContext *dc, const OpcodeArg arg[],
1717 const uint32_t par[])
1718 {
1719 #ifndef CONFIG_USER_ONLY
1720 TCGv_i32 dtlb = tcg_const_i32(par[0]);
1721
1722 gen_helper_itlb(cpu_env, arg[0].in, dtlb);
1723 tcg_temp_free(dtlb);
1724 #endif
1725 }
1726
1727 static void translate_j(DisasContext *dc, const OpcodeArg arg[],
1728 const uint32_t par[])
1729 {
1730 gen_jumpi(dc, arg[0].imm, 0);
1731 }
1732
1733 static void translate_jx(DisasContext *dc, const OpcodeArg arg[],
1734 const uint32_t par[])
1735 {
1736 gen_jump(dc, arg[0].in);
1737 }
1738
1739 static void translate_l32e(DisasContext *dc, const OpcodeArg arg[],
1740 const uint32_t par[])
1741 {
1742 TCGv_i32 addr = tcg_temp_new_i32();
1743 MemOp mop;
1744
1745 tcg_gen_addi_i32(addr, arg[1].in, arg[2].imm);
1746 mop = gen_load_store_alignment(dc, MO_TEUL, addr);
1747 tcg_gen_qemu_ld_tl(arg[0].out, addr, dc->ring, mop);
1748 tcg_temp_free(addr);
1749 }
1750
1751 #ifdef CONFIG_USER_ONLY
1752 static void gen_check_exclusive(DisasContext *dc, TCGv_i32 addr, bool is_write)
1753 {
1754 }
1755 #else
1756 static void gen_check_exclusive(DisasContext *dc, TCGv_i32 addr, bool is_write)
1757 {
1758 if (!option_enabled(dc, XTENSA_OPTION_MPU)) {
1759 TCGv_i32 tpc = tcg_const_i32(dc->pc);
1760 TCGv_i32 write = tcg_const_i32(is_write);
1761
1762 gen_helper_check_exclusive(cpu_env, tpc, addr, write);
1763 tcg_temp_free(tpc);
1764 tcg_temp_free(write);
1765 }
1766 }
1767 #endif
1768
1769 static void translate_l32ex(DisasContext *dc, const OpcodeArg arg[],
1770 const uint32_t par[])
1771 {
1772 TCGv_i32 addr = tcg_temp_new_i32();
1773 MemOp mop;
1774
1775 tcg_gen_mov_i32(addr, arg[1].in);
1776 mop = gen_load_store_alignment(dc, MO_TEUL | MO_ALIGN, addr);
1777 gen_check_exclusive(dc, addr, false);
1778 tcg_gen_qemu_ld_i32(arg[0].out, addr, dc->cring, mop);
1779 tcg_gen_mov_i32(cpu_exclusive_addr, addr);
1780 tcg_gen_mov_i32(cpu_exclusive_val, arg[0].out);
1781 tcg_temp_free(addr);
1782 }
1783
1784 static void translate_ldst(DisasContext *dc, const OpcodeArg arg[],
1785 const uint32_t par[])
1786 {
1787 TCGv_i32 addr = tcg_temp_new_i32();
1788 MemOp mop;
1789
1790 tcg_gen_addi_i32(addr, arg[1].in, arg[2].imm);
1791 mop = gen_load_store_alignment(dc, par[0], addr);
1792
1793 if (par[2]) {
1794 if (par[1]) {
1795 tcg_gen_mb(TCG_BAR_STRL | TCG_MO_ALL);
1796 }
1797 tcg_gen_qemu_st_tl(arg[0].in, addr, dc->cring, mop);
1798 } else {
1799 tcg_gen_qemu_ld_tl(arg[0].out, addr, dc->cring, mop);
1800 if (par[1]) {
1801 tcg_gen_mb(TCG_BAR_LDAQ | TCG_MO_ALL);
1802 }
1803 }
1804 tcg_temp_free(addr);
1805 }
1806
1807 static void translate_l32r(DisasContext *dc, const OpcodeArg arg[],
1808 const uint32_t par[])
1809 {
1810 TCGv_i32 tmp;
1811
1812 if (dc->base.tb->flags & XTENSA_TBFLAG_LITBASE) {
1813 tmp = tcg_const_i32(arg[1].raw_imm - 1);
1814 tcg_gen_add_i32(tmp, cpu_SR[LITBASE], tmp);
1815 } else {
1816 tmp = tcg_const_i32(arg[1].imm);
1817 }
1818 tcg_gen_qemu_ld32u(arg[0].out, tmp, dc->cring);
1819 tcg_temp_free(tmp);
1820 }
1821
1822 static void translate_loop(DisasContext *dc, const OpcodeArg arg[],
1823 const uint32_t par[])
1824 {
1825 uint32_t lend = arg[1].imm;
1826
1827 tcg_gen_subi_i32(cpu_SR[LCOUNT], arg[0].in, 1);
1828 tcg_gen_movi_i32(cpu_SR[LBEG], dc->base.pc_next);
1829 tcg_gen_movi_i32(cpu_SR[LEND], lend);
1830
1831 if (par[0] != TCG_COND_NEVER) {
1832 TCGLabel *label = gen_new_label();
1833 tcg_gen_brcondi_i32(par[0], arg[0].in, 0, label);
1834 gen_jumpi(dc, lend, 1);
1835 gen_set_label(label);
1836 }
1837
1838 gen_jumpi(dc, dc->base.pc_next, 0);
1839 }
1840
1841 enum {
1842 MAC16_UMUL,
1843 MAC16_MUL,
1844 MAC16_MULA,
1845 MAC16_MULS,
1846 MAC16_NONE,
1847 };
1848
1849 enum {
1850 MAC16_LL,
1851 MAC16_HL,
1852 MAC16_LH,
1853 MAC16_HH,
1854
1855 MAC16_HX = 0x1,
1856 MAC16_XH = 0x2,
1857 };
1858
1859 static void translate_mac16(DisasContext *dc, const OpcodeArg arg[],
1860 const uint32_t par[])
1861 {
1862 int op = par[0];
1863 unsigned half = par[1];
1864 uint32_t ld_offset = par[2];
1865 unsigned off = ld_offset ? 2 : 0;
1866 TCGv_i32 vaddr = tcg_temp_new_i32();
1867 TCGv_i32 mem32 = tcg_temp_new_i32();
1868
1869 if (ld_offset) {
1870 MemOp mop;
1871
1872 tcg_gen_addi_i32(vaddr, arg[1].in, ld_offset);
1873 mop = gen_load_store_alignment(dc, MO_TEUL, vaddr);
1874 tcg_gen_qemu_ld_tl(mem32, vaddr, dc->cring, mop);
1875 }
1876 if (op != MAC16_NONE) {
1877 TCGv_i32 m1 = gen_mac16_m(arg[off].in,
1878 half & MAC16_HX, op == MAC16_UMUL);
1879 TCGv_i32 m2 = gen_mac16_m(arg[off + 1].in,
1880 half & MAC16_XH, op == MAC16_UMUL);
1881
1882 if (op == MAC16_MUL || op == MAC16_UMUL) {
1883 tcg_gen_mul_i32(cpu_SR[ACCLO], m1, m2);
1884 if (op == MAC16_UMUL) {
1885 tcg_gen_movi_i32(cpu_SR[ACCHI], 0);
1886 } else {
1887 tcg_gen_sari_i32(cpu_SR[ACCHI], cpu_SR[ACCLO], 31);
1888 }
1889 } else {
1890 TCGv_i32 lo = tcg_temp_new_i32();
1891 TCGv_i32 hi = tcg_temp_new_i32();
1892
1893 tcg_gen_mul_i32(lo, m1, m2);
1894 tcg_gen_sari_i32(hi, lo, 31);
1895 if (op == MAC16_MULA) {
1896 tcg_gen_add2_i32(cpu_SR[ACCLO], cpu_SR[ACCHI],
1897 cpu_SR[ACCLO], cpu_SR[ACCHI],
1898 lo, hi);
1899 } else {
1900 tcg_gen_sub2_i32(cpu_SR[ACCLO], cpu_SR[ACCHI],
1901 cpu_SR[ACCLO], cpu_SR[ACCHI],
1902 lo, hi);
1903 }
1904 tcg_gen_ext8s_i32(cpu_SR[ACCHI], cpu_SR[ACCHI]);
1905
1906 tcg_temp_free_i32(lo);
1907 tcg_temp_free_i32(hi);
1908 }
1909 tcg_temp_free(m1);
1910 tcg_temp_free(m2);
1911 }
1912 if (ld_offset) {
1913 tcg_gen_mov_i32(arg[1].out, vaddr);
1914 tcg_gen_mov_i32(cpu_SR[MR + arg[0].imm], mem32);
1915 }
1916 tcg_temp_free(vaddr);
1917 tcg_temp_free(mem32);
1918 }
1919
1920 static void translate_memw(DisasContext *dc, const OpcodeArg arg[],
1921 const uint32_t par[])
1922 {
1923 tcg_gen_mb(TCG_BAR_SC | TCG_MO_ALL);
1924 }
1925
1926 static void translate_smin(DisasContext *dc, const OpcodeArg arg[],
1927 const uint32_t par[])
1928 {
1929 tcg_gen_smin_i32(arg[0].out, arg[1].in, arg[2].in);
1930 }
1931
1932 static void translate_umin(DisasContext *dc, const OpcodeArg arg[],
1933 const uint32_t par[])
1934 {
1935 tcg_gen_umin_i32(arg[0].out, arg[1].in, arg[2].in);
1936 }
1937
1938 static void translate_smax(DisasContext *dc, const OpcodeArg arg[],
1939 const uint32_t par[])
1940 {
1941 tcg_gen_smax_i32(arg[0].out, arg[1].in, arg[2].in);
1942 }
1943
1944 static void translate_umax(DisasContext *dc, const OpcodeArg arg[],
1945 const uint32_t par[])
1946 {
1947 tcg_gen_umax_i32(arg[0].out, arg[1].in, arg[2].in);
1948 }
1949
1950 static void translate_mov(DisasContext *dc, const OpcodeArg arg[],
1951 const uint32_t par[])
1952 {
1953 tcg_gen_mov_i32(arg[0].out, arg[1].in);
1954 }
1955
1956 static void translate_movcond(DisasContext *dc, const OpcodeArg arg[],
1957 const uint32_t par[])
1958 {
1959 TCGv_i32 zero = tcg_const_i32(0);
1960
1961 tcg_gen_movcond_i32(par[0], arg[0].out,
1962 arg[2].in, zero, arg[1].in, arg[0].in);
1963 tcg_temp_free(zero);
1964 }
1965
1966 static void translate_movi(DisasContext *dc, const OpcodeArg arg[],
1967 const uint32_t par[])
1968 {
1969 tcg_gen_movi_i32(arg[0].out, arg[1].imm);
1970 }
1971
1972 static void translate_movp(DisasContext *dc, const OpcodeArg arg[],
1973 const uint32_t par[])
1974 {
1975 TCGv_i32 zero = tcg_const_i32(0);
1976 TCGv_i32 tmp = tcg_temp_new_i32();
1977
1978 tcg_gen_andi_i32(tmp, arg[2].in, 1 << arg[2].imm);
1979 tcg_gen_movcond_i32(par[0],
1980 arg[0].out, tmp, zero,
1981 arg[1].in, arg[0].in);
1982 tcg_temp_free(tmp);
1983 tcg_temp_free(zero);
1984 }
1985
1986 static void translate_movsp(DisasContext *dc, const OpcodeArg arg[],
1987 const uint32_t par[])
1988 {
1989 tcg_gen_mov_i32(arg[0].out, arg[1].in);
1990 }
1991
1992 static void translate_mul16(DisasContext *dc, const OpcodeArg arg[],
1993 const uint32_t par[])
1994 {
1995 TCGv_i32 v1 = tcg_temp_new_i32();
1996 TCGv_i32 v2 = tcg_temp_new_i32();
1997
1998 if (par[0]) {
1999 tcg_gen_ext16s_i32(v1, arg[1].in);
2000 tcg_gen_ext16s_i32(v2, arg[2].in);
2001 } else {
2002 tcg_gen_ext16u_i32(v1, arg[1].in);
2003 tcg_gen_ext16u_i32(v2, arg[2].in);
2004 }
2005 tcg_gen_mul_i32(arg[0].out, v1, v2);
2006 tcg_temp_free(v2);
2007 tcg_temp_free(v1);
2008 }
2009
2010 static void translate_mull(DisasContext *dc, const OpcodeArg arg[],
2011 const uint32_t par[])
2012 {
2013 tcg_gen_mul_i32(arg[0].out, arg[1].in, arg[2].in);
2014 }
2015
2016 static void translate_mulh(DisasContext *dc, const OpcodeArg arg[],
2017 const uint32_t par[])
2018 {
2019 TCGv_i32 lo = tcg_temp_new();
2020
2021 if (par[0]) {
2022 tcg_gen_muls2_i32(lo, arg[0].out, arg[1].in, arg[2].in);
2023 } else {
2024 tcg_gen_mulu2_i32(lo, arg[0].out, arg[1].in, arg[2].in);
2025 }
2026 tcg_temp_free(lo);
2027 }
2028
2029 static void translate_neg(DisasContext *dc, const OpcodeArg arg[],
2030 const uint32_t par[])
2031 {
2032 tcg_gen_neg_i32(arg[0].out, arg[1].in);
2033 }
2034
2035 static void translate_nop(DisasContext *dc, const OpcodeArg arg[],
2036 const uint32_t par[])
2037 {
2038 }
2039
2040 static void translate_nsa(DisasContext *dc, const OpcodeArg arg[],
2041 const uint32_t par[])
2042 {
2043 tcg_gen_clrsb_i32(arg[0].out, arg[1].in);
2044 }
2045
2046 static void translate_nsau(DisasContext *dc, const OpcodeArg arg[],
2047 const uint32_t par[])
2048 {
2049 tcg_gen_clzi_i32(arg[0].out, arg[1].in, 32);
2050 }
2051
2052 static void translate_or(DisasContext *dc, const OpcodeArg arg[],
2053 const uint32_t par[])
2054 {
2055 tcg_gen_or_i32(arg[0].out, arg[1].in, arg[2].in);
2056 }
2057
2058 static void translate_ptlb(DisasContext *dc, const OpcodeArg arg[],
2059 const uint32_t par[])
2060 {
2061 #ifndef CONFIG_USER_ONLY
2062 TCGv_i32 dtlb = tcg_const_i32(par[0]);
2063
2064 tcg_gen_movi_i32(cpu_pc, dc->pc);
2065 gen_helper_ptlb(arg[0].out, cpu_env, arg[1].in, dtlb);
2066 tcg_temp_free(dtlb);
2067 #endif
2068 }
2069
2070 static void translate_pptlb(DisasContext *dc, const OpcodeArg arg[],
2071 const uint32_t par[])
2072 {
2073 #ifndef CONFIG_USER_ONLY
2074 tcg_gen_movi_i32(cpu_pc, dc->pc);
2075 gen_helper_pptlb(arg[0].out, cpu_env, arg[1].in);
2076 #endif
2077 }
2078
2079 static void translate_quos(DisasContext *dc, const OpcodeArg arg[],
2080 const uint32_t par[])
2081 {
2082 TCGLabel *label1 = gen_new_label();
2083 TCGLabel *label2 = gen_new_label();
2084
2085 tcg_gen_brcondi_i32(TCG_COND_NE, arg[1].in, 0x80000000,
2086 label1);
2087 tcg_gen_brcondi_i32(TCG_COND_NE, arg[2].in, 0xffffffff,
2088 label1);
2089 tcg_gen_movi_i32(arg[0].out,
2090 par[0] ? 0x80000000 : 0);
2091 tcg_gen_br(label2);
2092 gen_set_label(label1);
2093 if (par[0]) {
2094 tcg_gen_div_i32(arg[0].out,
2095 arg[1].in, arg[2].in);
2096 } else {
2097 tcg_gen_rem_i32(arg[0].out,
2098 arg[1].in, arg[2].in);
2099 }
2100 gen_set_label(label2);
2101 }
2102
2103 static void translate_quou(DisasContext *dc, const OpcodeArg arg[],
2104 const uint32_t par[])
2105 {
2106 tcg_gen_divu_i32(arg[0].out,
2107 arg[1].in, arg[2].in);
2108 }
2109
2110 static void translate_read_impwire(DisasContext *dc, const OpcodeArg arg[],
2111 const uint32_t par[])
2112 {
2113 /* TODO: GPIO32 may be a part of coprocessor */
2114 tcg_gen_movi_i32(arg[0].out, 0);
2115 }
2116
2117 static void translate_remu(DisasContext *dc, const OpcodeArg arg[],
2118 const uint32_t par[])
2119 {
2120 tcg_gen_remu_i32(arg[0].out,
2121 arg[1].in, arg[2].in);
2122 }
2123
2124 static void translate_rer(DisasContext *dc, const OpcodeArg arg[],
2125 const uint32_t par[])
2126 {
2127 gen_helper_rer(arg[0].out, cpu_env, arg[1].in);
2128 }
2129
2130 static void translate_ret(DisasContext *dc, const OpcodeArg arg[],
2131 const uint32_t par[])
2132 {
2133 gen_jump(dc, cpu_R[0]);
2134 }
2135
2136 static uint32_t test_exceptions_retw(DisasContext *dc, const OpcodeArg arg[],
2137 const uint32_t par[])
2138 {
2139 if (!dc->cwoe) {
2140 qemu_log_mask(LOG_GUEST_ERROR,
2141 "Illegal retw instruction(pc = %08x)\n", dc->pc);
2142 return XTENSA_OP_ILL;
2143 } else {
2144 TCGv_i32 tmp = tcg_const_i32(dc->pc);
2145
2146 gen_helper_test_ill_retw(cpu_env, tmp);
2147 tcg_temp_free(tmp);
2148 return 0;
2149 }
2150 }
2151
2152 static void translate_retw(DisasContext *dc, const OpcodeArg arg[],
2153 const uint32_t par[])
2154 {
2155 TCGv_i32 tmp = tcg_const_i32(1);
2156 tcg_gen_shl_i32(tmp, tmp, cpu_SR[WINDOW_BASE]);
2157 tcg_gen_andc_i32(cpu_SR[WINDOW_START],
2158 cpu_SR[WINDOW_START], tmp);
2159 tcg_gen_movi_i32(tmp, dc->pc);
2160 tcg_gen_deposit_i32(tmp, tmp, cpu_R[0], 0, 30);
2161 gen_helper_retw(cpu_env, cpu_R[0]);
2162 gen_jump(dc, tmp);
2163 tcg_temp_free(tmp);
2164 }
2165
2166 static void translate_rfde(DisasContext *dc, const OpcodeArg arg[],
2167 const uint32_t par[])
2168 {
2169 gen_jump(dc, cpu_SR[dc->config->ndepc ? DEPC : EPC1]);
2170 }
2171
2172 static void translate_rfe(DisasContext *dc, const OpcodeArg arg[],
2173 const uint32_t par[])
2174 {
2175 tcg_gen_andi_i32(cpu_SR[PS], cpu_SR[PS], ~PS_EXCM);
2176 gen_jump(dc, cpu_SR[EPC1]);
2177 }
2178
2179 static void translate_rfi(DisasContext *dc, const OpcodeArg arg[],
2180 const uint32_t par[])
2181 {
2182 tcg_gen_mov_i32(cpu_SR[PS], cpu_SR[EPS2 + arg[0].imm - 2]);
2183 gen_jump(dc, cpu_SR[EPC1 + arg[0].imm - 1]);
2184 }
2185
2186 static void translate_rfw(DisasContext *dc, const OpcodeArg arg[],
2187 const uint32_t par[])
2188 {
2189 TCGv_i32 tmp = tcg_const_i32(1);
2190
2191 tcg_gen_andi_i32(cpu_SR[PS], cpu_SR[PS], ~PS_EXCM);
2192 tcg_gen_shl_i32(tmp, tmp, cpu_SR[WINDOW_BASE]);
2193
2194 if (par[0]) {
2195 tcg_gen_andc_i32(cpu_SR[WINDOW_START],
2196 cpu_SR[WINDOW_START], tmp);
2197 } else {
2198 tcg_gen_or_i32(cpu_SR[WINDOW_START],
2199 cpu_SR[WINDOW_START], tmp);
2200 }
2201
2202 tcg_temp_free(tmp);
2203 gen_helper_restore_owb(cpu_env);
2204 gen_jump(dc, cpu_SR[EPC1]);
2205 }
2206
2207 static void translate_rotw(DisasContext *dc, const OpcodeArg arg[],
2208 const uint32_t par[])
2209 {
2210 tcg_gen_addi_i32(cpu_windowbase_next, cpu_SR[WINDOW_BASE], arg[0].imm);
2211 }
2212
2213 static void translate_rsil(DisasContext *dc, const OpcodeArg arg[],
2214 const uint32_t par[])
2215 {
2216 tcg_gen_mov_i32(arg[0].out, cpu_SR[PS]);
2217 tcg_gen_andi_i32(cpu_SR[PS], cpu_SR[PS], ~PS_INTLEVEL);
2218 tcg_gen_ori_i32(cpu_SR[PS], cpu_SR[PS], arg[1].imm);
2219 }
2220
2221 static void translate_rsr(DisasContext *dc, const OpcodeArg arg[],
2222 const uint32_t par[])
2223 {
2224 if (sr_name[par[0]]) {
2225 tcg_gen_mov_i32(arg[0].out, cpu_SR[par[0]]);
2226 } else {
2227 tcg_gen_movi_i32(arg[0].out, 0);
2228 }
2229 }
2230
2231 static void translate_rsr_ccount(DisasContext *dc, const OpcodeArg arg[],
2232 const uint32_t par[])
2233 {
2234 #ifndef CONFIG_USER_ONLY
2235 if (tb_cflags(dc->base.tb) & CF_USE_ICOUNT) {
2236 gen_io_start();
2237 }
2238 gen_helper_update_ccount(cpu_env);
2239 tcg_gen_mov_i32(arg[0].out, cpu_SR[par[0]]);
2240 #endif
2241 }
2242
2243 static void translate_rsr_ptevaddr(DisasContext *dc, const OpcodeArg arg[],
2244 const uint32_t par[])
2245 {
2246 #ifndef CONFIG_USER_ONLY
2247 TCGv_i32 tmp = tcg_temp_new_i32();
2248
2249 tcg_gen_shri_i32(tmp, cpu_SR[EXCVADDR], 10);
2250 tcg_gen_or_i32(tmp, tmp, cpu_SR[PTEVADDR]);
2251 tcg_gen_andi_i32(arg[0].out, tmp, 0xfffffffc);
2252 tcg_temp_free(tmp);
2253 #endif
2254 }
2255
2256 static void translate_rtlb(DisasContext *dc, const OpcodeArg arg[],
2257 const uint32_t par[])
2258 {
2259 #ifndef CONFIG_USER_ONLY
2260 static void (* const helper[])(TCGv_i32 r, TCGv_env env, TCGv_i32 a1,
2261 TCGv_i32 a2) = {
2262 gen_helper_rtlb0,
2263 gen_helper_rtlb1,
2264 };
2265 TCGv_i32 dtlb = tcg_const_i32(par[0]);
2266
2267 helper[par[1]](arg[0].out, cpu_env, arg[1].in, dtlb);
2268 tcg_temp_free(dtlb);
2269 #endif
2270 }
2271
2272 static void translate_rptlb0(DisasContext *dc, const OpcodeArg arg[],
2273 const uint32_t par[])
2274 {
2275 #ifndef CONFIG_USER_ONLY
2276 gen_helper_rptlb0(arg[0].out, cpu_env, arg[1].in);
2277 #endif
2278 }
2279
2280 static void translate_rptlb1(DisasContext *dc, const OpcodeArg arg[],
2281 const uint32_t par[])
2282 {
2283 #ifndef CONFIG_USER_ONLY
2284 gen_helper_rptlb1(arg[0].out, cpu_env, arg[1].in);
2285 #endif
2286 }
2287
2288 static void translate_rur(DisasContext *dc, const OpcodeArg arg[],
2289 const uint32_t par[])
2290 {
2291 tcg_gen_mov_i32(arg[0].out, cpu_UR[par[0]]);
2292 }
2293
2294 static void translate_setb_expstate(DisasContext *dc, const OpcodeArg arg[],
2295 const uint32_t par[])
2296 {
2297 /* TODO: GPIO32 may be a part of coprocessor */
2298 tcg_gen_ori_i32(cpu_UR[EXPSTATE], cpu_UR[EXPSTATE], 1u << arg[0].imm);
2299 }
2300
2301 #ifdef CONFIG_USER_ONLY
2302 static void gen_check_atomctl(DisasContext *dc, TCGv_i32 addr)
2303 {
2304 }
2305 #else
2306 static void gen_check_atomctl(DisasContext *dc, TCGv_i32 addr)
2307 {
2308 TCGv_i32 tpc = tcg_const_i32(dc->pc);
2309
2310 gen_helper_check_atomctl(cpu_env, tpc, addr);
2311 tcg_temp_free(tpc);
2312 }
2313 #endif
2314
2315 static void translate_s32c1i(DisasContext *dc, const OpcodeArg arg[],
2316 const uint32_t par[])
2317 {
2318 TCGv_i32 tmp = tcg_temp_local_new_i32();
2319 TCGv_i32 addr = tcg_temp_local_new_i32();
2320 MemOp mop;
2321
2322 tcg_gen_mov_i32(tmp, arg[0].in);
2323 tcg_gen_addi_i32(addr, arg[1].in, arg[2].imm);
2324 mop = gen_load_store_alignment(dc, MO_TEUL | MO_ALIGN, addr);
2325 gen_check_atomctl(dc, addr);
2326 tcg_gen_atomic_cmpxchg_i32(arg[0].out, addr, cpu_SR[SCOMPARE1],
2327 tmp, dc->cring, mop);
2328 tcg_temp_free(addr);
2329 tcg_temp_free(tmp);
2330 }
2331
2332 static void translate_s32e(DisasContext *dc, const OpcodeArg arg[],
2333 const uint32_t par[])
2334 {
2335 TCGv_i32 addr = tcg_temp_new_i32();
2336 MemOp mop;
2337
2338 tcg_gen_addi_i32(addr, arg[1].in, arg[2].imm);
2339 mop = gen_load_store_alignment(dc, MO_TEUL, addr);
2340 tcg_gen_qemu_st_tl(arg[0].in, addr, dc->ring, mop);
2341 tcg_temp_free(addr);
2342 }
2343
2344 static void translate_s32ex(DisasContext *dc, const OpcodeArg arg[],
2345 const uint32_t par[])
2346 {
2347 TCGv_i32 prev = tcg_temp_new_i32();
2348 TCGv_i32 addr = tcg_temp_local_new_i32();
2349 TCGv_i32 res = tcg_temp_local_new_i32();
2350 TCGLabel *label = gen_new_label();
2351 MemOp mop;
2352
2353 tcg_gen_movi_i32(res, 0);
2354 tcg_gen_mov_i32(addr, arg[1].in);
2355 mop = gen_load_store_alignment(dc, MO_TEUL | MO_ALIGN, addr);
2356 tcg_gen_brcond_i32(TCG_COND_NE, addr, cpu_exclusive_addr, label);
2357 gen_check_exclusive(dc, addr, true);
2358 tcg_gen_atomic_cmpxchg_i32(prev, cpu_exclusive_addr, cpu_exclusive_val,
2359 arg[0].in, dc->cring, mop);
2360 tcg_gen_setcond_i32(TCG_COND_EQ, res, prev, cpu_exclusive_val);
2361 tcg_gen_movcond_i32(TCG_COND_EQ, cpu_exclusive_val,
2362 prev, cpu_exclusive_val, prev, cpu_exclusive_val);
2363 tcg_gen_movi_i32(cpu_exclusive_addr, -1);
2364 gen_set_label(label);
2365 tcg_gen_extract_i32(arg[0].out, cpu_SR[ATOMCTL], 8, 1);
2366 tcg_gen_deposit_i32(cpu_SR[ATOMCTL], cpu_SR[ATOMCTL], res, 8, 1);
2367 tcg_temp_free(prev);
2368 tcg_temp_free(addr);
2369 tcg_temp_free(res);
2370 }
2371
2372 static void translate_salt(DisasContext *dc, const OpcodeArg arg[],
2373 const uint32_t par[])
2374 {
2375 tcg_gen_setcond_i32(par[0],
2376 arg[0].out,
2377 arg[1].in, arg[2].in);
2378 }
2379
2380 static void translate_sext(DisasContext *dc, const OpcodeArg arg[],
2381 const uint32_t par[])
2382 {
2383 int shift = 31 - arg[2].imm;
2384
2385 if (shift == 24) {
2386 tcg_gen_ext8s_i32(arg[0].out, arg[1].in);
2387 } else if (shift == 16) {
2388 tcg_gen_ext16s_i32(arg[0].out, arg[1].in);
2389 } else {
2390 TCGv_i32 tmp = tcg_temp_new_i32();
2391 tcg_gen_shli_i32(tmp, arg[1].in, shift);
2392 tcg_gen_sari_i32(arg[0].out, tmp, shift);
2393 tcg_temp_free(tmp);
2394 }
2395 }
2396
2397 static uint32_t test_exceptions_simcall(DisasContext *dc,
2398 const OpcodeArg arg[],
2399 const uint32_t par[])
2400 {
2401 #ifdef CONFIG_USER_ONLY
2402 bool ill = true;
2403 #else
2404 /* Between RE.2 and RE.3 simcall opcode's become nop for the hardware. */
2405 bool ill = dc->config->hw_version <= 250002 && !semihosting_enabled();
2406 #endif
2407 if (ill || !semihosting_enabled()) {
2408 qemu_log_mask(LOG_GUEST_ERROR, "SIMCALL but semihosting is disabled\n");
2409 }
2410 return ill ? XTENSA_OP_ILL : 0;
2411 }
2412
2413 static void translate_simcall(DisasContext *dc, const OpcodeArg arg[],
2414 const uint32_t par[])
2415 {
2416 #ifndef CONFIG_USER_ONLY
2417 if (semihosting_enabled()) {
2418 gen_helper_simcall(cpu_env);
2419 }
2420 #endif
2421 }
2422
2423 /*
2424 * Note: 64 bit ops are used here solely because SAR values
2425 * have range 0..63
2426 */
2427 #define gen_shift_reg(cmd, reg) do { \
2428 TCGv_i64 tmp = tcg_temp_new_i64(); \
2429 tcg_gen_extu_i32_i64(tmp, reg); \
2430 tcg_gen_##cmd##_i64(v, v, tmp); \
2431 tcg_gen_extrl_i64_i32(arg[0].out, v); \
2432 tcg_temp_free_i64(v); \
2433 tcg_temp_free_i64(tmp); \
2434 } while (0)
2435
2436 #define gen_shift(cmd) gen_shift_reg(cmd, cpu_SR[SAR])
2437
2438 static void translate_sll(DisasContext *dc, const OpcodeArg arg[],
2439 const uint32_t par[])
2440 {
2441 if (dc->sar_m32_5bit) {
2442 tcg_gen_shl_i32(arg[0].out, arg[1].in, dc->sar_m32);
2443 } else {
2444 TCGv_i64 v = tcg_temp_new_i64();
2445 TCGv_i32 s = tcg_const_i32(32);
2446 tcg_gen_sub_i32(s, s, cpu_SR[SAR]);
2447 tcg_gen_andi_i32(s, s, 0x3f);
2448 tcg_gen_extu_i32_i64(v, arg[1].in);
2449 gen_shift_reg(shl, s);
2450 tcg_temp_free(s);
2451 }
2452 }
2453
2454 static void translate_slli(DisasContext *dc, const OpcodeArg arg[],
2455 const uint32_t par[])
2456 {
2457 if (arg[2].imm == 32) {
2458 qemu_log_mask(LOG_GUEST_ERROR, "slli a%d, a%d, 32 is undefined\n",
2459 arg[0].imm, arg[1].imm);
2460 }
2461 tcg_gen_shli_i32(arg[0].out, arg[1].in, arg[2].imm & 0x1f);
2462 }
2463
2464 static void translate_sra(DisasContext *dc, const OpcodeArg arg[],
2465 const uint32_t par[])
2466 {
2467 if (dc->sar_m32_5bit) {
2468 tcg_gen_sar_i32(arg[0].out, arg[1].in, cpu_SR[SAR]);
2469 } else {
2470 TCGv_i64 v = tcg_temp_new_i64();
2471 tcg_gen_ext_i32_i64(v, arg[1].in);
2472 gen_shift(sar);
2473 }
2474 }
2475
2476 static void translate_srai(DisasContext *dc, const OpcodeArg arg[],
2477 const uint32_t par[])
2478 {
2479 tcg_gen_sari_i32(arg[0].out, arg[1].in, arg[2].imm);
2480 }
2481
2482 static void translate_src(DisasContext *dc, const OpcodeArg arg[],
2483 const uint32_t par[])
2484 {
2485 TCGv_i64 v = tcg_temp_new_i64();
2486 tcg_gen_concat_i32_i64(v, arg[2].in, arg[1].in);
2487 gen_shift(shr);
2488 }
2489
2490 static void translate_srl(DisasContext *dc, const OpcodeArg arg[],
2491 const uint32_t par[])
2492 {
2493 if (dc->sar_m32_5bit) {
2494 tcg_gen_shr_i32(arg[0].out, arg[1].in, cpu_SR[SAR]);
2495 } else {
2496 TCGv_i64 v = tcg_temp_new_i64();
2497 tcg_gen_extu_i32_i64(v, arg[1].in);
2498 gen_shift(shr);
2499 }
2500 }
2501
2502 #undef gen_shift
2503 #undef gen_shift_reg
2504
2505 static void translate_srli(DisasContext *dc, const OpcodeArg arg[],
2506 const uint32_t par[])
2507 {
2508 tcg_gen_shri_i32(arg[0].out, arg[1].in, arg[2].imm);
2509 }
2510
2511 static void translate_ssa8b(DisasContext *dc, const OpcodeArg arg[],
2512 const uint32_t par[])
2513 {
2514 TCGv_i32 tmp = tcg_temp_new_i32();
2515 tcg_gen_shli_i32(tmp, arg[0].in, 3);
2516 gen_left_shift_sar(dc, tmp);
2517 tcg_temp_free(tmp);
2518 }
2519
2520 static void translate_ssa8l(DisasContext *dc, const OpcodeArg arg[],
2521 const uint32_t par[])
2522 {
2523 TCGv_i32 tmp = tcg_temp_new_i32();
2524 tcg_gen_shli_i32(tmp, arg[0].in, 3);
2525 gen_right_shift_sar(dc, tmp);
2526 tcg_temp_free(tmp);
2527 }
2528
2529 static void translate_ssai(DisasContext *dc, const OpcodeArg arg[],
2530 const uint32_t par[])
2531 {
2532 TCGv_i32 tmp = tcg_const_i32(arg[0].imm);
2533 gen_right_shift_sar(dc, tmp);
2534 tcg_temp_free(tmp);
2535 }
2536
2537 static void translate_ssl(DisasContext *dc, const OpcodeArg arg[],
2538 const uint32_t par[])
2539 {
2540 gen_left_shift_sar(dc, arg[0].in);
2541 }
2542
2543 static void translate_ssr(DisasContext *dc, const OpcodeArg arg[],
2544 const uint32_t par[])
2545 {
2546 gen_right_shift_sar(dc, arg[0].in);
2547 }
2548
2549 static void translate_sub(DisasContext *dc, const OpcodeArg arg[],
2550 const uint32_t par[])
2551 {
2552 tcg_gen_sub_i32(arg[0].out, arg[1].in, arg[2].in);
2553 }
2554
2555 static void translate_subx(DisasContext *dc, const OpcodeArg arg[],
2556 const uint32_t par[])
2557 {
2558 TCGv_i32 tmp = tcg_temp_new_i32();
2559 tcg_gen_shli_i32(tmp, arg[1].in, par[0]);
2560 tcg_gen_sub_i32(arg[0].out, tmp, arg[2].in);
2561 tcg_temp_free(tmp);
2562 }
2563
2564 static void translate_waiti(DisasContext *dc, const OpcodeArg arg[],
2565 const uint32_t par[])
2566 {
2567 #ifndef CONFIG_USER_ONLY
2568 gen_waiti(dc, arg[0].imm);
2569 #endif
2570 }
2571
2572 static void translate_wtlb(DisasContext *dc, const OpcodeArg arg[],
2573 const uint32_t par[])
2574 {
2575 #ifndef CONFIG_USER_ONLY
2576 TCGv_i32 dtlb = tcg_const_i32(par[0]);
2577
2578 gen_helper_wtlb(cpu_env, arg[0].in, arg[1].in, dtlb);
2579 tcg_temp_free(dtlb);
2580 #endif
2581 }
2582
2583 static void translate_wptlb(DisasContext *dc, const OpcodeArg arg[],
2584 const uint32_t par[])
2585 {
2586 #ifndef CONFIG_USER_ONLY
2587 gen_helper_wptlb(cpu_env, arg[0].in, arg[1].in);
2588 #endif
2589 }
2590
2591 static void translate_wer(DisasContext *dc, const OpcodeArg arg[],
2592 const uint32_t par[])
2593 {
2594 gen_helper_wer(cpu_env, arg[0].in, arg[1].in);
2595 }
2596
2597 static void translate_wrmsk_expstate(DisasContext *dc, const OpcodeArg arg[],
2598 const uint32_t par[])
2599 {
2600 /* TODO: GPIO32 may be a part of coprocessor */
2601 tcg_gen_and_i32(cpu_UR[EXPSTATE], arg[0].in, arg[1].in);
2602 }
2603
2604 static void translate_wsr(DisasContext *dc, const OpcodeArg arg[],
2605 const uint32_t par[])
2606 {
2607 if (sr_name[par[0]]) {
2608 tcg_gen_mov_i32(cpu_SR[par[0]], arg[0].in);
2609 }
2610 }
2611
2612 static void translate_wsr_mask(DisasContext *dc, const OpcodeArg arg[],
2613 const uint32_t par[])
2614 {
2615 if (sr_name[par[0]]) {
2616 tcg_gen_andi_i32(cpu_SR[par[0]], arg[0].in, par[2]);
2617 }
2618 }
2619
2620 static void translate_wsr_acchi(DisasContext *dc, const OpcodeArg arg[],
2621 const uint32_t par[])
2622 {
2623 tcg_gen_ext8s_i32(cpu_SR[par[0]], arg[0].in);
2624 }
2625
2626 static void translate_wsr_ccompare(DisasContext *dc, const OpcodeArg arg[],
2627 const uint32_t par[])
2628 {
2629 #ifndef CONFIG_USER_ONLY
2630 uint32_t id = par[0] - CCOMPARE;
2631 TCGv_i32 tmp = tcg_const_i32(id);
2632
2633 assert(id < dc->config->nccompare);
2634 if (tb_cflags(dc->base.tb) & CF_USE_ICOUNT) {
2635 gen_io_start();
2636 }
2637 tcg_gen_mov_i32(cpu_SR[par[0]], arg[0].in);
2638 gen_helper_update_ccompare(cpu_env, tmp);
2639 tcg_temp_free(tmp);
2640 #endif
2641 }
2642
2643 static void translate_wsr_ccount(DisasContext *dc, const OpcodeArg arg[],
2644 const uint32_t par[])
2645 {
2646 #ifndef CONFIG_USER_ONLY
2647 if (tb_cflags(dc->base.tb) & CF_USE_ICOUNT) {
2648 gen_io_start();
2649 }
2650 gen_helper_wsr_ccount(cpu_env, arg[0].in);
2651 #endif
2652 }
2653
2654 static void translate_wsr_dbreaka(DisasContext *dc, const OpcodeArg arg[],
2655 const uint32_t par[])
2656 {
2657 #ifndef CONFIG_USER_ONLY
2658 unsigned id = par[0] - DBREAKA;
2659 TCGv_i32 tmp = tcg_const_i32(id);
2660
2661 assert(id < dc->config->ndbreak);
2662 gen_helper_wsr_dbreaka(cpu_env, tmp, arg[0].in);
2663 tcg_temp_free(tmp);
2664 #endif
2665 }
2666
2667 static void translate_wsr_dbreakc(DisasContext *dc, const OpcodeArg arg[],
2668 const uint32_t par[])
2669 {
2670 #ifndef CONFIG_USER_ONLY
2671 unsigned id = par[0] - DBREAKC;
2672 TCGv_i32 tmp = tcg_const_i32(id);
2673
2674 assert(id < dc->config->ndbreak);
2675 gen_helper_wsr_dbreakc(cpu_env, tmp, arg[0].in);
2676 tcg_temp_free(tmp);
2677 #endif
2678 }
2679
2680 static void translate_wsr_ibreaka(DisasContext *dc, const OpcodeArg arg[],
2681 const uint32_t par[])
2682 {
2683 #ifndef CONFIG_USER_ONLY
2684 unsigned id = par[0] - IBREAKA;
2685 TCGv_i32 tmp = tcg_const_i32(id);
2686
2687 assert(id < dc->config->nibreak);
2688 gen_helper_wsr_ibreaka(cpu_env, tmp, arg[0].in);
2689 tcg_temp_free(tmp);
2690 #endif
2691 }
2692
2693 static void translate_wsr_ibreakenable(DisasContext *dc, const OpcodeArg arg[],
2694 const uint32_t par[])
2695 {
2696 #ifndef CONFIG_USER_ONLY
2697 gen_helper_wsr_ibreakenable(cpu_env, arg[0].in);
2698 #endif
2699 }
2700
2701 static void translate_wsr_icount(DisasContext *dc, const OpcodeArg arg[],
2702 const uint32_t par[])
2703 {
2704 #ifndef CONFIG_USER_ONLY
2705 if (dc->icount) {
2706 tcg_gen_mov_i32(dc->next_icount, arg[0].in);
2707 } else {
2708 tcg_gen_mov_i32(cpu_SR[par[0]], arg[0].in);
2709 }
2710 #endif
2711 }
2712
2713 static void translate_wsr_intclear(DisasContext *dc, const OpcodeArg arg[],
2714 const uint32_t par[])
2715 {
2716 #ifndef CONFIG_USER_ONLY
2717 gen_helper_intclear(cpu_env, arg[0].in);
2718 #endif
2719 }
2720
2721 static void translate_wsr_intset(DisasContext *dc, const OpcodeArg arg[],
2722 const uint32_t par[])
2723 {
2724 #ifndef CONFIG_USER_ONLY
2725 gen_helper_intset(cpu_env, arg[0].in);
2726 #endif
2727 }
2728
2729 static void translate_wsr_memctl(DisasContext *dc, const OpcodeArg arg[],
2730 const uint32_t par[])
2731 {
2732 #ifndef CONFIG_USER_ONLY
2733 gen_helper_wsr_memctl(cpu_env, arg[0].in);
2734 #endif
2735 }
2736
2737 static void translate_wsr_mpuenb(DisasContext *dc, const OpcodeArg arg[],
2738 const uint32_t par[])
2739 {
2740 #ifndef CONFIG_USER_ONLY
2741 gen_helper_wsr_mpuenb(cpu_env, arg[0].in);
2742 #endif
2743 }
2744
2745 static void translate_wsr_ps(DisasContext *dc, const OpcodeArg arg[],
2746 const uint32_t par[])
2747 {
2748 #ifndef CONFIG_USER_ONLY
2749 uint32_t mask = PS_WOE | PS_CALLINC | PS_OWB |
2750 PS_UM | PS_EXCM | PS_INTLEVEL;
2751
2752 if (option_enabled(dc, XTENSA_OPTION_MMU) ||
2753 option_enabled(dc, XTENSA_OPTION_MPU)) {
2754 mask |= PS_RING;
2755 }
2756 tcg_gen_andi_i32(cpu_SR[par[0]], arg[0].in, mask);
2757 #endif
2758 }
2759
2760 static void translate_wsr_rasid(DisasContext *dc, const OpcodeArg arg[],
2761 const uint32_t par[])
2762 {
2763 #ifndef CONFIG_USER_ONLY
2764 gen_helper_wsr_rasid(cpu_env, arg[0].in);
2765 #endif
2766 }
2767
2768 static void translate_wsr_sar(DisasContext *dc, const OpcodeArg arg[],
2769 const uint32_t par[])
2770 {
2771 tcg_gen_andi_i32(cpu_SR[par[0]], arg[0].in, 0x3f);
2772 if (dc->sar_m32_5bit) {
2773 tcg_gen_discard_i32(dc->sar_m32);
2774 }
2775 dc->sar_5bit = false;
2776 dc->sar_m32_5bit = false;
2777 }
2778
2779 static void translate_wsr_windowbase(DisasContext *dc, const OpcodeArg arg[],
2780 const uint32_t par[])
2781 {
2782 #ifndef CONFIG_USER_ONLY
2783 tcg_gen_mov_i32(cpu_windowbase_next, arg[0].in);
2784 #endif
2785 }
2786
2787 static void translate_wsr_windowstart(DisasContext *dc, const OpcodeArg arg[],
2788 const uint32_t par[])
2789 {
2790 #ifndef CONFIG_USER_ONLY
2791 tcg_gen_andi_i32(cpu_SR[par[0]], arg[0].in,
2792 (1 << dc->config->nareg / 4) - 1);
2793 #endif
2794 }
2795
2796 static void translate_wur(DisasContext *dc, const OpcodeArg arg[],
2797 const uint32_t par[])
2798 {
2799 tcg_gen_mov_i32(cpu_UR[par[0]], arg[0].in);
2800 }
2801
2802 static void translate_xor(DisasContext *dc, const OpcodeArg arg[],
2803 const uint32_t par[])
2804 {
2805 tcg_gen_xor_i32(arg[0].out, arg[1].in, arg[2].in);
2806 }
2807
2808 static void translate_xsr(DisasContext *dc, const OpcodeArg arg[],
2809 const uint32_t par[])
2810 {
2811 if (sr_name[par[0]]) {
2812 TCGv_i32 tmp = tcg_temp_new_i32();
2813
2814 tcg_gen_mov_i32(tmp, arg[0].in);
2815 tcg_gen_mov_i32(arg[0].out, cpu_SR[par[0]]);
2816 tcg_gen_mov_i32(cpu_SR[par[0]], tmp);
2817 tcg_temp_free(tmp);
2818 } else {
2819 tcg_gen_movi_i32(arg[0].out, 0);
2820 }
2821 }
2822
2823 static void translate_xsr_mask(DisasContext *dc, const OpcodeArg arg[],
2824 const uint32_t par[])
2825 {
2826 if (sr_name[par[0]]) {
2827 TCGv_i32 tmp = tcg_temp_new_i32();
2828
2829 tcg_gen_mov_i32(tmp, arg[0].in);
2830 tcg_gen_mov_i32(arg[0].out, cpu_SR[par[0]]);
2831 tcg_gen_andi_i32(cpu_SR[par[0]], tmp, par[2]);
2832 tcg_temp_free(tmp);
2833 } else {
2834 tcg_gen_movi_i32(arg[0].out, 0);
2835 }
2836 }
2837
2838 static void translate_xsr_ccount(DisasContext *dc, const OpcodeArg arg[],
2839 const uint32_t par[])
2840 {
2841 #ifndef CONFIG_USER_ONLY
2842 TCGv_i32 tmp = tcg_temp_new_i32();
2843
2844 if (tb_cflags(dc->base.tb) & CF_USE_ICOUNT) {
2845 gen_io_start();
2846 }
2847
2848 gen_helper_update_ccount(cpu_env);
2849 tcg_gen_mov_i32(tmp, cpu_SR[par[0]]);
2850 gen_helper_wsr_ccount(cpu_env, arg[0].in);
2851 tcg_gen_mov_i32(arg[0].out, tmp);
2852 tcg_temp_free(tmp);
2853
2854 #endif
2855 }
2856
2857 #define gen_translate_xsr(name) \
2858 static void translate_xsr_##name(DisasContext *dc, const OpcodeArg arg[], \
2859 const uint32_t par[]) \
2860 { \
2861 TCGv_i32 tmp = tcg_temp_new_i32(); \
2862 \
2863 if (sr_name[par[0]]) { \
2864 tcg_gen_mov_i32(tmp, cpu_SR[par[0]]); \
2865 } else { \
2866 tcg_gen_movi_i32(tmp, 0); \
2867 } \
2868 translate_wsr_##name(dc, arg, par); \
2869 tcg_gen_mov_i32(arg[0].out, tmp); \
2870 tcg_temp_free(tmp); \
2871 }
2872
2873 gen_translate_xsr(acchi)
2874 gen_translate_xsr(ccompare)
2875 gen_translate_xsr(dbreaka)
2876 gen_translate_xsr(dbreakc)
2877 gen_translate_xsr(ibreaka)
2878 gen_translate_xsr(ibreakenable)
2879 gen_translate_xsr(icount)
2880 gen_translate_xsr(memctl)
2881 gen_translate_xsr(mpuenb)
2882 gen_translate_xsr(ps)
2883 gen_translate_xsr(rasid)
2884 gen_translate_xsr(sar)
2885 gen_translate_xsr(windowbase)
2886 gen_translate_xsr(windowstart)
2887
2888 #undef gen_translate_xsr
2889
2890 static const XtensaOpcodeOps core_ops[] = {
2891 {
2892 .name = "abs",
2893 .translate = translate_abs,
2894 }, {
2895 .name = (const char * const[]) {
2896 "add", "add.n", NULL,
2897 },
2898 .translate = translate_add,
2899 .op_flags = XTENSA_OP_NAME_ARRAY,
2900 }, {
2901 .name = (const char * const[]) {
2902 "addi", "addi.n", NULL,
2903 },
2904 .translate = translate_addi,
2905 .op_flags = XTENSA_OP_NAME_ARRAY,
2906 }, {
2907 .name = "addmi",
2908 .translate = translate_addi,
2909 }, {
2910 .name = "addx2",
2911 .translate = translate_addx,
2912 .par = (const uint32_t[]){1},
2913 }, {
2914 .name = "addx4",
2915 .translate = translate_addx,
2916 .par = (const uint32_t[]){2},
2917 }, {
2918 .name = "addx8",
2919 .translate = translate_addx,
2920 .par = (const uint32_t[]){3},
2921 }, {
2922 .name = "all4",
2923 .translate = translate_all,
2924 .par = (const uint32_t[]){true, 4},
2925 }, {
2926 .name = "all8",
2927 .translate = translate_all,
2928 .par = (const uint32_t[]){true, 8},
2929 }, {
2930 .name = "and",
2931 .translate = translate_and,
2932 }, {
2933 .name = "andb",
2934 .translate = translate_boolean,
2935 .par = (const uint32_t[]){BOOLEAN_AND},
2936 }, {
2937 .name = "andbc",
2938 .translate = translate_boolean,
2939 .par = (const uint32_t[]){BOOLEAN_ANDC},
2940 }, {
2941 .name = "any4",
2942 .translate = translate_all,
2943 .par = (const uint32_t[]){false, 4},
2944 }, {
2945 .name = "any8",
2946 .translate = translate_all,
2947 .par = (const uint32_t[]){false, 8},
2948 }, {
2949 .name = (const char * const[]) {
2950 "ball", "ball.w15", "ball.w18", NULL,
2951 },
2952 .translate = translate_ball,
2953 .par = (const uint32_t[]){TCG_COND_EQ},
2954 .op_flags = XTENSA_OP_NAME_ARRAY,
2955 }, {
2956 .name = (const char * const[]) {
2957 "bany", "bany.w15", "bany.w18", NULL,
2958 },
2959 .translate = translate_bany,
2960 .par = (const uint32_t[]){TCG_COND_NE},
2961 .op_flags = XTENSA_OP_NAME_ARRAY,
2962 }, {
2963 .name = (const char * const[]) {
2964 "bbc", "bbc.w15", "bbc.w18", NULL,
2965 },
2966 .translate = translate_bb,
2967 .par = (const uint32_t[]){TCG_COND_EQ},
2968 .op_flags = XTENSA_OP_NAME_ARRAY,
2969 }, {
2970 .name = (const char * const[]) {
2971 "bbci", "bbci.w15", "bbci.w18", NULL,
2972 },
2973 .translate = translate_bbi,
2974 .par = (const uint32_t[]){TCG_COND_EQ},
2975 .op_flags = XTENSA_OP_NAME_ARRAY,
2976 }, {
2977 .name = (const char * const[]) {
2978 "bbs", "bbs.w15", "bbs.w18", NULL,
2979 },
2980 .translate = translate_bb,
2981 .par = (const uint32_t[]){TCG_COND_NE},
2982 .op_flags = XTENSA_OP_NAME_ARRAY,
2983 }, {
2984 .name = (const char * const[]) {
2985 "bbsi", "bbsi.w15", "bbsi.w18", NULL,
2986 },
2987 .translate = translate_bbi,
2988 .par = (const uint32_t[]){TCG_COND_NE},
2989 .op_flags = XTENSA_OP_NAME_ARRAY,
2990 }, {
2991 .name = (const char * const[]) {
2992 "beq", "beq.w15", "beq.w18", NULL,
2993 },
2994 .translate = translate_b,
2995 .par = (const uint32_t[]){TCG_COND_EQ},
2996 .op_flags = XTENSA_OP_NAME_ARRAY,
2997 }, {
2998 .name = (const char * const[]) {
2999 "beqi", "beqi.w15", "beqi.w18", NULL,
3000 },
3001 .translate = translate_bi,
3002 .par = (const uint32_t[]){TCG_COND_EQ},
3003 .op_flags = XTENSA_OP_NAME_ARRAY,
3004 }, {
3005 .name = (const char * const[]) {
3006 "beqz", "beqz.n", "beqz.w15", "beqz.w18", NULL,
3007 },
3008 .translate = translate_bz,
3009 .par = (const uint32_t[]){TCG_COND_EQ},
3010 .op_flags = XTENSA_OP_NAME_ARRAY,
3011 }, {
3012 .name = "bf",
3013 .translate = translate_bp,
3014 .par = (const uint32_t[]){TCG_COND_EQ},
3015 }, {
3016 .name = (const char * const[]) {
3017 "bge", "bge.w15", "bge.w18", NULL,
3018 },
3019 .translate = translate_b,
3020 .par = (const uint32_t[]){TCG_COND_GE},
3021 .op_flags = XTENSA_OP_NAME_ARRAY,
3022 }, {
3023 .name = (const char * const[]) {
3024 "bgei", "bgei.w15", "bgei.w18", NULL,
3025 },
3026 .translate = translate_bi,
3027 .par = (const uint32_t[]){TCG_COND_GE},
3028 .op_flags = XTENSA_OP_NAME_ARRAY,
3029 }, {
3030 .name = (const char * const[]) {
3031 "bgeu", "bgeu.w15", "bgeu.w18", NULL,
3032 },
3033 .translate = translate_b,
3034 .par = (const uint32_t[]){TCG_COND_GEU},
3035 .op_flags = XTENSA_OP_NAME_ARRAY,
3036 }, {
3037 .name = (const char * const[]) {
3038 "bgeui", "bgeui.w15", "bgeui.w18", NULL,
3039 },
3040 .translate = translate_bi,
3041 .par = (const uint32_t[]){TCG_COND_GEU},
3042 .op_flags = XTENSA_OP_NAME_ARRAY,
3043 }, {
3044 .name = (const char * const[]) {
3045 "bgez", "bgez.w15", "bgez.w18", NULL,
3046 },
3047 .translate = translate_bz,
3048 .par = (const uint32_t[]){TCG_COND_GE},
3049 .op_flags = XTENSA_OP_NAME_ARRAY,
3050 }, {
3051 .name = (const char * const[]) {
3052 "blt", "blt.w15", "blt.w18", NULL,
3053 },
3054 .translate = translate_b,
3055 .par = (const uint32_t[]){TCG_COND_LT},
3056 .op_flags = XTENSA_OP_NAME_ARRAY,
3057 }, {
3058 .name = (const char * const[]) {
3059 "blti", "blti.w15", "blti.w18", NULL,
3060 },
3061 .translate = translate_bi,
3062 .par = (const uint32_t[]){TCG_COND_LT},
3063 .op_flags = XTENSA_OP_NAME_ARRAY,
3064 }, {
3065 .name = (const char * const[]) {
3066 "bltu", "bltu.w15", "bltu.w18", NULL,
3067 },
3068 .translate = translate_b,
3069 .par = (const uint32_t[]){TCG_COND_LTU},
3070 .op_flags = XTENSA_OP_NAME_ARRAY,
3071 }, {
3072 .name = (const char * const[]) {
3073 "bltui", "bltui.w15", "bltui.w18", NULL,
3074 },
3075 .translate = translate_bi,
3076 .par = (const uint32_t[]){TCG_COND_LTU},
3077 .op_flags = XTENSA_OP_NAME_ARRAY,
3078 }, {
3079 .name = (const char * const[]) {
3080 "bltz", "bltz.w15", "bltz.w18", NULL,
3081 },
3082 .translate = translate_bz,
3083 .par = (const uint32_t[]){TCG_COND_LT},
3084 .op_flags = XTENSA_OP_NAME_ARRAY,
3085 }, {
3086 .name = (const char * const[]) {
3087 "bnall", "bnall.w15", "bnall.w18", NULL,
3088 },
3089 .translate = translate_ball,
3090 .par = (const uint32_t[]){TCG_COND_NE},
3091 .op_flags = XTENSA_OP_NAME_ARRAY,
3092 }, {
3093 .name = (const char * const[]) {
3094 "bne", "bne.w15", "bne.w18", NULL,
3095 },
3096 .translate = translate_b,
3097 .par = (const uint32_t[]){TCG_COND_NE},
3098 .op_flags = XTENSA_OP_NAME_ARRAY,
3099 }, {
3100 .name = (const char * const[]) {
3101 "bnei", "bnei.w15", "bnei.w18", NULL,
3102 },
3103 .translate = translate_bi,
3104 .par = (const uint32_t[]){TCG_COND_NE},
3105 .op_flags = XTENSA_OP_NAME_ARRAY,
3106 }, {
3107 .name = (const char * const[]) {
3108 "bnez", "bnez.n", "bnez.w15", "bnez.w18", NULL,
3109 },
3110 .translate = translate_bz,
3111 .par = (const uint32_t[]){TCG_COND_NE},
3112 .op_flags = XTENSA_OP_NAME_ARRAY,
3113 }, {
3114 .name = (const char * const[]) {
3115 "bnone", "bnone.w15", "bnone.w18", NULL,
3116 },
3117 .translate = translate_bany,
3118 .par = (const uint32_t[]){TCG_COND_EQ},
3119 .op_flags = XTENSA_OP_NAME_ARRAY,
3120 }, {
3121 .name = "break",
3122 .translate = translate_nop,
3123 .par = (const uint32_t[]){DEBUGCAUSE_BI},
3124 .op_flags = XTENSA_OP_DEBUG_BREAK,
3125 }, {
3126 .name = "break.n",
3127 .translate = translate_nop,
3128 .par = (const uint32_t[]){DEBUGCAUSE_BN},
3129 .op_flags = XTENSA_OP_DEBUG_BREAK,
3130 }, {
3131 .name = "bt",
3132 .translate = translate_bp,
3133 .par = (const uint32_t[]){TCG_COND_NE},
3134 }, {
3135 .name = "call0",
3136 .translate = translate_call0,
3137 }, {
3138 .name = "call12",
3139 .translate = translate_callw,
3140 .par = (const uint32_t[]){3},
3141 }, {
3142 .name = "call4",
3143 .translate = translate_callw,
3144 .par = (const uint32_t[]){1},
3145 }, {
3146 .name = "call8",
3147 .translate = translate_callw,
3148 .par = (const uint32_t[]){2},
3149 }, {
3150 .name = "callx0",
3151 .translate = translate_callx0,
3152 }, {
3153 .name = "callx12",
3154 .translate = translate_callxw,
3155 .par = (const uint32_t[]){3},
3156 }, {
3157 .name = "callx4",
3158 .translate = translate_callxw,
3159 .par = (const uint32_t[]){1},
3160 }, {
3161 .name = "callx8",
3162 .translate = translate_callxw,
3163 .par = (const uint32_t[]){2},
3164 }, {
3165 .name = "clamps",
3166 .translate = translate_clamps,
3167 }, {
3168 .name = "clrb_expstate",
3169 .translate = translate_clrb_expstate,
3170 }, {
3171 .name = "clrex",
3172 .translate = translate_clrex,
3173 }, {
3174 .name = "const16",
3175 .translate = translate_const16,
3176 }, {
3177 .name = "depbits",
3178 .translate = translate_depbits,
3179 }, {
3180 .name = "dhi",
3181 .translate = translate_dcache,
3182 .op_flags = XTENSA_OP_PRIVILEGED,
3183 }, {
3184 .name = "dhi.b",
3185 .translate = translate_nop,
3186 }, {
3187 .name = "dhu",
3188 .translate = translate_dcache,
3189 .op_flags = XTENSA_OP_PRIVILEGED,
3190 }, {
3191 .name = "dhwb",
3192 .translate = translate_dcache,
3193 }, {
3194 .name = "dhwb.b",
3195 .translate = translate_nop,
3196 }, {
3197 .name = "dhwbi",
3198 .translate = translate_dcache,
3199 }, {
3200 .name = "dhwbi.b",
3201 .translate = translate_nop,
3202 }, {
3203 .name = "dii",
3204 .translate = translate_nop,
3205 .op_flags = XTENSA_OP_PRIVILEGED,
3206 }, {
3207 .name = "diu",
3208 .translate = translate_nop,
3209 .op_flags = XTENSA_OP_PRIVILEGED,
3210 }, {
3211 .name = "diwb",
3212 .translate = translate_nop,
3213 .op_flags = XTENSA_OP_PRIVILEGED,
3214 }, {
3215 .name = "diwbi",
3216 .translate = translate_nop,
3217 .op_flags = XTENSA_OP_PRIVILEGED,
3218 }, {
3219 .name = "diwbui.p",
3220 .translate = translate_diwbuip,
3221 .op_flags = XTENSA_OP_PRIVILEGED,
3222 }, {
3223 .name = "dpfl",
3224 .translate = translate_dcache,
3225 .op_flags = XTENSA_OP_PRIVILEGED,
3226 }, {
3227 .name = "dpfm.b",
3228 .translate = translate_nop,
3229 }, {
3230 .name = "dpfm.bf",
3231 .translate = translate_nop,
3232 }, {
3233 .name = "dpfr",
3234 .translate = translate_nop,
3235 }, {
3236 .name = "dpfr.b",
3237 .translate = translate_nop,
3238 }, {
3239 .name = "dpfr.bf",
3240 .translate = translate_nop,
3241 }, {
3242 .name = "dpfro",
3243 .translate = translate_nop,
3244 }, {
3245 .name = "dpfw",
3246 .translate = translate_nop,
3247 }, {
3248 .name = "dpfw.b",
3249 .translate = translate_nop,
3250 }, {
3251 .name = "dpfw.bf",
3252 .translate = translate_nop,
3253 }, {
3254 .name = "dpfwo",
3255 .translate = translate_nop,
3256 }, {
3257 .name = "dsync",
3258 .translate = translate_nop,
3259 }, {
3260 .name = "entry",
3261 .translate = translate_entry,
3262 .test_exceptions = test_exceptions_entry,
3263 .test_overflow = test_overflow_entry,
3264 .op_flags = XTENSA_OP_EXIT_TB_M1 |
3265 XTENSA_OP_SYNC_REGISTER_WINDOW,
3266 }, {
3267 .name = "esync",
3268 .translate = translate_nop,
3269 }, {
3270 .name = "excw",
3271 .translate = translate_nop,
3272 }, {
3273 .name = "extui",
3274 .translate = translate_extui,
3275 }, {
3276 .name = "extw",
3277 .translate = translate_memw,
3278 }, {
3279 .name = "getex",
3280 .translate = translate_getex,
3281 }, {
3282 .name = "hwwdtlba",
3283 .op_flags = XTENSA_OP_ILL,
3284 }, {
3285 .name = "hwwitlba",
3286 .op_flags = XTENSA_OP_ILL,
3287 }, {
3288 .name = "idtlb",
3289 .translate = translate_itlb,
3290 .par = (const uint32_t[]){true},
3291 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
3292 }, {
3293 .name = "ihi",
3294 .translate = translate_icache,
3295 }, {
3296 .name = "ihu",
3297 .translate = translate_icache,
3298 .op_flags = XTENSA_OP_PRIVILEGED,
3299 }, {
3300 .name = "iii",
3301 .translate = translate_nop,
3302 .op_flags = XTENSA_OP_PRIVILEGED,
3303 }, {
3304 .name = "iitlb",
3305 .translate = translate_itlb,
3306 .par = (const uint32_t[]){false},
3307 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
3308 }, {
3309 .name = "iiu",
3310 .translate = translate_nop,
3311 .op_flags = XTENSA_OP_PRIVILEGED,
3312 }, {
3313 .name = (const char * const[]) {
3314 "ill", "ill.n", NULL,
3315 },
3316 .op_flags = XTENSA_OP_ILL | XTENSA_OP_NAME_ARRAY,
3317 }, {
3318 .name = "ipf",
3319 .translate = translate_nop,
3320 }, {
3321 .name = "ipfl",
3322 .translate = translate_icache,
3323 .op_flags = XTENSA_OP_PRIVILEGED,
3324 }, {
3325 .name = "isync",
3326 .translate = translate_nop,
3327 }, {
3328 .name = "j",
3329 .translate = translate_j,
3330 }, {
3331 .name = "jx",
3332 .translate = translate_jx,
3333 }, {
3334 .name = "l16si",
3335 .translate = translate_ldst,
3336 .par = (const uint32_t[]){MO_TESW, false, false},
3337 .op_flags = XTENSA_OP_LOAD,
3338 }, {
3339 .name = "l16ui",
3340 .translate = translate_ldst,
3341 .par = (const uint32_t[]){MO_TEUW, false, false},
3342 .op_flags = XTENSA_OP_LOAD,
3343 }, {
3344 .name = "l32ai",
3345 .translate = translate_ldst,
3346 .par = (const uint32_t[]){MO_TEUL | MO_ALIGN, true, false},
3347 .op_flags = XTENSA_OP_LOAD,
3348 }, {
3349 .name = "l32e",
3350 .translate = translate_l32e,
3351 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_LOAD,
3352 }, {
3353 .name = "l32ex",
3354 .translate = translate_l32ex,
3355 .op_flags = XTENSA_OP_LOAD,
3356 }, {
3357 .name = (const char * const[]) {
3358 "l32i", "l32i.n", NULL,
3359 },
3360 .translate = translate_ldst,
3361 .par = (const uint32_t[]){MO_TEUL, false, false},
3362 .op_flags = XTENSA_OP_NAME_ARRAY | XTENSA_OP_LOAD,
3363 }, {
3364 .name = "l32r",
3365 .translate = translate_l32r,
3366 .op_flags = XTENSA_OP_LOAD,
3367 }, {
3368 .name = "l8ui",
3369 .translate = translate_ldst,
3370 .par = (const uint32_t[]){MO_UB, false, false},
3371 .op_flags = XTENSA_OP_LOAD,
3372 }, {
3373 .name = "lddec",
3374 .translate = translate_mac16,
3375 .par = (const uint32_t[]){MAC16_NONE, 0, -4},
3376 .op_flags = XTENSA_OP_LOAD,
3377 }, {
3378 .name = "ldinc",
3379 .translate = translate_mac16,
3380 .par = (const uint32_t[]){MAC16_NONE, 0, 4},
3381 .op_flags = XTENSA_OP_LOAD,
3382 }, {
3383 .name = "ldpte",
3384 .op_flags = XTENSA_OP_ILL,
3385 }, {
3386 .name = (const char * const[]) {
3387 "loop", "loop.w15", NULL,
3388 },
3389 .translate = translate_loop,
3390 .par = (const uint32_t[]){TCG_COND_NEVER},
3391 .op_flags = XTENSA_OP_NAME_ARRAY,
3392 }, {
3393 .name = (const char * const[]) {
3394 "loopgtz", "loopgtz.w15", NULL,
3395 },
3396 .translate = translate_loop,
3397 .par = (const uint32_t[]){TCG_COND_GT},
3398 .op_flags = XTENSA_OP_NAME_ARRAY,
3399 }, {
3400 .name = (const char * const[]) {
3401 "loopnez", "loopnez.w15", NULL,
3402 },
3403 .translate = translate_loop,
3404 .par = (const uint32_t[]){TCG_COND_NE},
3405 .op_flags = XTENSA_OP_NAME_ARRAY,
3406 }, {
3407 .name = "max",
3408 .translate = translate_smax,
3409 }, {
3410 .name = "maxu",
3411 .translate = translate_umax,
3412 }, {
3413 .name = "memw",
3414 .translate = translate_memw,
3415 }, {
3416 .name = "min",
3417 .translate = translate_smin,
3418 }, {
3419 .name = "minu",
3420 .translate = translate_umin,
3421 }, {
3422 .name = (const char * const[]) {
3423 "mov", "mov.n", NULL,
3424 },
3425 .translate = translate_mov,
3426 .op_flags = XTENSA_OP_NAME_ARRAY,
3427 }, {
3428 .name = "moveqz",
3429 .translate = translate_movcond,
3430 .par = (const uint32_t[]){TCG_COND_EQ},
3431 }, {
3432 .name = "movf",
3433 .translate = translate_movp,
3434 .par = (const uint32_t[]){TCG_COND_EQ},
3435 }, {
3436 .name = "movgez",
3437 .translate = translate_movcond,
3438 .par = (const uint32_t[]){TCG_COND_GE},
3439 }, {
3440 .name = "movi",
3441 .translate = translate_movi,
3442 }, {
3443 .name = "movi.n",
3444 .translate = translate_movi,
3445 }, {
3446 .name = "movltz",
3447 .translate = translate_movcond,
3448 .par = (const uint32_t[]){TCG_COND_LT},
3449 }, {
3450 .name = "movnez",
3451 .translate = translate_movcond,
3452 .par = (const uint32_t[]){TCG_COND_NE},
3453 }, {
3454 .name = "movsp",
3455 .translate = translate_movsp,
3456 .op_flags = XTENSA_OP_ALLOCA,
3457 }, {
3458 .name = "movt",
3459 .translate = translate_movp,
3460 .par = (const uint32_t[]){TCG_COND_NE},
3461 }, {
3462 .name = "mul.aa.hh",
3463 .translate = translate_mac16,
3464 .par = (const uint32_t[]){MAC16_MUL, MAC16_HH, 0},
3465 }, {
3466 .name = "mul.aa.hl",
3467 .translate = translate_mac16,
3468 .par = (const uint32_t[]){MAC16_MUL, MAC16_HL, 0},
3469 }, {
3470 .name = "mul.aa.lh",
3471 .translate = translate_mac16,
3472 .par = (const uint32_t[]){MAC16_MUL, MAC16_LH, 0},
3473 }, {
3474 .name = "mul.aa.ll",
3475 .translate = translate_mac16,
3476 .par = (const uint32_t[]){MAC16_MUL, MAC16_LL, 0},
3477 }, {
3478 .name = "mul.ad.hh",
3479 .translate = translate_mac16,
3480 .par = (const uint32_t[]){MAC16_MUL, MAC16_HH, 0},
3481 }, {
3482 .name = "mul.ad.hl",
3483 .translate = translate_mac16,
3484 .par = (const uint32_t[]){MAC16_MUL, MAC16_HL, 0},
3485 }, {
3486 .name = "mul.ad.lh",
3487 .translate = translate_mac16,
3488 .par = (const uint32_t[]){MAC16_MUL, MAC16_LH, 0},
3489 }, {
3490 .name = "mul.ad.ll",
3491 .translate = translate_mac16,
3492 .par = (const uint32_t[]){MAC16_MUL, MAC16_LL, 0},
3493 }, {
3494 .name = "mul.da.hh",
3495 .translate = translate_mac16,
3496 .par = (const uint32_t[]){MAC16_MUL, MAC16_HH, 0},
3497 }, {
3498 .name = "mul.da.hl",
3499 .translate = translate_mac16,
3500 .par = (const uint32_t[]){MAC16_MUL, MAC16_HL, 0},
3501 }, {
3502 .name = "mul.da.lh",
3503 .translate = translate_mac16,
3504 .par = (const uint32_t[]){MAC16_MUL, MAC16_LH, 0},
3505 }, {
3506 .name = "mul.da.ll",
3507 .translate = translate_mac16,
3508 .par = (const uint32_t[]){MAC16_MUL, MAC16_LL, 0},
3509 }, {
3510 .name = "mul.dd.hh",
3511 .translate = translate_mac16,
3512 .par = (const uint32_t[]){MAC16_MUL, MAC16_HH, 0},
3513 }, {
3514 .name = "mul.dd.hl",
3515 .translate = translate_mac16,
3516 .par = (const uint32_t[]){MAC16_MUL, MAC16_HL, 0},
3517 }, {
3518 .name = "mul.dd.lh",
3519 .translate = translate_mac16,
3520 .par = (const uint32_t[]){MAC16_MUL, MAC16_LH, 0},
3521 }, {
3522 .name = "mul.dd.ll",
3523 .translate = translate_mac16,
3524 .par = (const uint32_t[]){MAC16_MUL, MAC16_LL, 0},
3525 }, {
3526 .name = "mul16s",
3527 .translate = translate_mul16,
3528 .par = (const uint32_t[]){true},
3529 }, {
3530 .name = "mul16u",
3531 .translate = translate_mul16,
3532 .par = (const uint32_t[]){false},
3533 }, {
3534 .name = "mula.aa.hh",
3535 .translate = translate_mac16,
3536 .par = (const uint32_t[]){MAC16_MULA, MAC16_HH, 0},
3537 }, {
3538 .name = "mula.aa.hl",
3539 .translate = translate_mac16,
3540 .par = (const uint32_t[]){MAC16_MULA, MAC16_HL, 0},
3541 }, {
3542 .name = "mula.aa.lh",
3543 .translate = translate_mac16,
3544 .par = (const uint32_t[]){MAC16_MULA, MAC16_LH, 0},
3545 }, {
3546 .name = "mula.aa.ll",
3547 .translate = translate_mac16,
3548 .par = (const uint32_t[]){MAC16_MULA, MAC16_LL, 0},
3549 }, {
3550 .name = "mula.ad.hh",
3551 .translate = translate_mac16,
3552 .par = (const uint32_t[]){MAC16_MULA, MAC16_HH, 0},
3553 }, {
3554 .name = "mula.ad.hl",
3555 .translate = translate_mac16,
3556 .par = (const uint32_t[]){MAC16_MULA, MAC16_HL, 0},
3557 }, {
3558 .name = "mula.ad.lh",
3559 .translate = translate_mac16,
3560 .par = (const uint32_t[]){MAC16_MULA, MAC16_LH, 0},
3561 }, {
3562 .name = "mula.ad.ll",
3563 .translate = translate_mac16,
3564 .par = (const uint32_t[]){MAC16_MULA, MAC16_LL, 0},
3565 }, {
3566 .name = "mula.da.hh",
3567 .translate = translate_mac16,
3568 .par = (const uint32_t[]){MAC16_MULA, MAC16_HH, 0},
3569 }, {
3570 .name = "mula.da.hh.lddec",
3571 .translate = translate_mac16,
3572 .par = (const uint32_t[]){MAC16_MULA, MAC16_HH, -4},
3573 }, {
3574 .name = "mula.da.hh.ldinc",
3575 .translate = translate_mac16,
3576 .par = (const uint32_t[]){MAC16_MULA, MAC16_HH, 4},
3577 }, {
3578 .name = "mula.da.hl",
3579 .translate = translate_mac16,
3580 .par = (const uint32_t[]){MAC16_MULA, MAC16_HL, 0},
3581 }, {
3582 .name = "mula.da.hl.lddec",
3583 .translate = translate_mac16,
3584 .par = (const uint32_t[]){MAC16_MULA, MAC16_HL, -4},
3585 }, {
3586 .name = "mula.da.hl.ldinc",
3587 .translate = translate_mac16,
3588 .par = (const uint32_t[]){MAC16_MULA, MAC16_HL, 4},
3589 }, {
3590 .name = "mula.da.lh",
3591 .translate = translate_mac16,
3592 .par = (const uint32_t[]){MAC16_MULA, MAC16_LH, 0},
3593 }, {
3594 .name = "mula.da.lh.lddec",
3595 .translate = translate_mac16,
3596 .par = (const uint32_t[]){MAC16_MULA, MAC16_LH, -4},
3597 }, {
3598 .name = "mula.da.lh.ldinc",
3599 .translate = translate_mac16,
3600 .par = (const uint32_t[]){MAC16_MULA, MAC16_LH, 4},
3601 }, {
3602 .name = "mula.da.ll",
3603 .translate = translate_mac16,
3604 .par = (const uint32_t[]){MAC16_MULA, MAC16_LL, 0},
3605 }, {
3606 .name = "mula.da.ll.lddec",
3607 .translate = translate_mac16,
3608 .par = (const uint32_t[]){MAC16_MULA, MAC16_LL, -4},
3609 }, {
3610 .name = "mula.da.ll.ldinc",
3611 .translate = translate_mac16,
3612 .par = (const uint32_t[]){MAC16_MULA, MAC16_LL, 4},
3613 }, {
3614 .name = "mula.dd.hh",
3615 .translate = translate_mac16,
3616 .par = (const uint32_t[]){MAC16_MULA, MAC16_HH, 0},
3617 }, {
3618 .name = "mula.dd.hh.lddec",
3619 .translate = translate_mac16,
3620 .par = (const uint32_t[]){MAC16_MULA, MAC16_HH, -4},
3621 }, {
3622 .name = "mula.dd.hh.ldinc",
3623 .translate = translate_mac16,
3624 .par = (const uint32_t[]){MAC16_MULA, MAC16_HH, 4},
3625 }, {
3626 .name = "mula.dd.hl",
3627 .translate = translate_mac16,
3628 .par = (const uint32_t[]){MAC16_MULA, MAC16_HL, 0},
3629 }, {
3630 .name = "mula.dd.hl.lddec",
3631 .translate = translate_mac16,
3632 .par = (const uint32_t[]){MAC16_MULA, MAC16_HL, -4},
3633 }, {
3634 .name = "mula.dd.hl.ldinc",
3635 .translate = translate_mac16,
3636 .par = (const uint32_t[]){MAC16_MULA, MAC16_HL, 4},
3637 }, {
3638 .name = "mula.dd.lh",
3639 .translate = translate_mac16,
3640 .par = (const uint32_t[]){MAC16_MULA, MAC16_LH, 0},
3641 }, {
3642 .name = "mula.dd.lh.lddec",
3643 .translate = translate_mac16,
3644 .par = (const uint32_t[]){MAC16_MULA, MAC16_LH, -4},
3645 }, {
3646 .name = "mula.dd.lh.ldinc",
3647 .translate = translate_mac16,
3648 .par = (const uint32_t[]){MAC16_MULA, MAC16_LH, 4},
3649 }, {
3650 .name = "mula.dd.ll",
3651 .translate = translate_mac16,
3652 .par = (const uint32_t[]){MAC16_MULA, MAC16_LL, 0},
3653 }, {
3654 .name = "mula.dd.ll.lddec",
3655 .translate = translate_mac16,
3656 .par = (const uint32_t[]){MAC16_MULA, MAC16_LL, -4},
3657 }, {
3658 .name = "mula.dd.ll.ldinc",
3659 .translate = translate_mac16,
3660 .par = (const uint32_t[]){MAC16_MULA, MAC16_LL, 4},
3661 }, {
3662 .name = "mull",
3663 .translate = translate_mull,
3664 }, {
3665 .name = "muls.aa.hh",
3666 .translate = translate_mac16,
3667 .par = (const uint32_t[]){MAC16_MULS, MAC16_HH, 0},
3668 }, {
3669 .name = "muls.aa.hl",
3670 .translate = translate_mac16,
3671 .par = (const uint32_t[]){MAC16_MULS, MAC16_HL, 0},
3672 }, {
3673 .name = "muls.aa.lh",
3674 .translate = translate_mac16,
3675 .par = (const uint32_t[]){MAC16_MULS, MAC16_LH, 0},
3676 }, {
3677 .name = "muls.aa.ll",
3678 .translate = translate_mac16,
3679 .par = (const uint32_t[]){MAC16_MULS, MAC16_LL, 0},
3680 }, {
3681 .name = "muls.ad.hh",
3682 .translate = translate_mac16,
3683 .par = (const uint32_t[]){MAC16_MULS, MAC16_HH, 0},
3684 }, {
3685 .name = "muls.ad.hl",
3686 .translate = translate_mac16,
3687 .par = (const uint32_t[]){MAC16_MULS, MAC16_HL, 0},
3688 }, {
3689 .name = "muls.ad.lh",
3690 .translate = translate_mac16,
3691 .par = (const uint32_t[]){MAC16_MULS, MAC16_LH, 0},
3692 }, {
3693 .name = "muls.ad.ll",
3694 .translate = translate_mac16,
3695 .par = (const uint32_t[]){MAC16_MULS, MAC16_LL, 0},
3696 }, {
3697 .name = "muls.da.hh",
3698 .translate = translate_mac16,
3699 .par = (const uint32_t[]){MAC16_MULS, MAC16_HH, 0},
3700 }, {
3701 .name = "muls.da.hl",
3702 .translate = translate_mac16,
3703 .par = (const uint32_t[]){MAC16_MULS, MAC16_HL, 0},
3704 }, {
3705 .name = "muls.da.lh",
3706 .translate = translate_mac16,
3707 .par = (const uint32_t[]){MAC16_MULS, MAC16_LH, 0},
3708 }, {
3709 .name = "muls.da.ll",
3710 .translate = translate_mac16,
3711 .par = (const uint32_t[]){MAC16_MULS, MAC16_LL, 0},
3712 }, {
3713 .name = "muls.dd.hh",
3714 .translate = translate_mac16,
3715 .par = (const uint32_t[]){MAC16_MULS, MAC16_HH, 0},
3716 }, {
3717 .name = "muls.dd.hl",
3718 .translate = translate_mac16,
3719 .par = (const uint32_t[]){MAC16_MULS, MAC16_HL, 0},
3720 }, {
3721 .name = "muls.dd.lh",
3722 .translate = translate_mac16,
3723 .par = (const uint32_t[]){MAC16_MULS, MAC16_LH, 0},
3724 }, {
3725 .name = "muls.dd.ll",
3726 .translate = translate_mac16,
3727 .par = (const uint32_t[]){MAC16_MULS, MAC16_LL, 0},
3728 }, {
3729 .name = "mulsh",
3730 .translate = translate_mulh,
3731 .par = (const uint32_t[]){true},
3732 }, {
3733 .name = "muluh",
3734 .translate = translate_mulh,
3735 .par = (const uint32_t[]){false},
3736 }, {
3737 .name = "neg",
3738 .translate = translate_neg,
3739 }, {
3740 .name = (const char * const[]) {
3741 "nop", "nop.n", NULL,
3742 },
3743 .translate = translate_nop,
3744 .op_flags = XTENSA_OP_NAME_ARRAY,
3745 }, {
3746 .name = "nsa",
3747 .translate = translate_nsa,
3748 }, {
3749 .name = "nsau",
3750 .translate = translate_nsau,
3751 }, {
3752 .name = "or",
3753 .translate = translate_or,
3754 }, {
3755 .name = "orb",
3756 .translate = translate_boolean,
3757 .par = (const uint32_t[]){BOOLEAN_OR},
3758 }, {
3759 .name = "orbc",
3760 .translate = translate_boolean,
3761 .par = (const uint32_t[]){BOOLEAN_ORC},
3762 }, {
3763 .name = "pdtlb",
3764 .translate = translate_ptlb,
3765 .par = (const uint32_t[]){true},
3766 .op_flags = XTENSA_OP_PRIVILEGED,
3767 }, {
3768 .name = "pfend.a",
3769 .translate = translate_nop,
3770 }, {
3771 .name = "pfend.o",
3772 .translate = translate_nop,
3773 }, {
3774 .name = "pfnxt.f",
3775 .translate = translate_nop,
3776 }, {
3777 .name = "pfwait.a",
3778 .translate = translate_nop,
3779 }, {
3780 .name = "pfwait.r",
3781 .translate = translate_nop,
3782 }, {
3783 .name = "pitlb",
3784 .translate = translate_ptlb,
3785 .par = (const uint32_t[]){false},
3786 .op_flags = XTENSA_OP_PRIVILEGED,
3787 }, {
3788 .name = "pptlb",
3789 .translate = translate_pptlb,
3790 .op_flags = XTENSA_OP_PRIVILEGED,
3791 }, {
3792 .name = "quos",
3793 .translate = translate_quos,
3794 .par = (const uint32_t[]){true},
3795 .op_flags = XTENSA_OP_DIVIDE_BY_ZERO,
3796 }, {
3797 .name = "quou",
3798 .translate = translate_quou,
3799 .op_flags = XTENSA_OP_DIVIDE_BY_ZERO,
3800 }, {
3801 .name = "rdtlb0",
3802 .translate = translate_rtlb,
3803 .par = (const uint32_t[]){true, 0},
3804 .op_flags = XTENSA_OP_PRIVILEGED,
3805 }, {
3806 .name = "rdtlb1",
3807 .translate = translate_rtlb,
3808 .par = (const uint32_t[]){true, 1},
3809 .op_flags = XTENSA_OP_PRIVILEGED,
3810 }, {
3811 .name = "read_impwire",
3812 .translate = translate_read_impwire,
3813 }, {
3814 .name = "rems",
3815 .translate = translate_quos,
3816 .par = (const uint32_t[]){false},
3817 .op_flags = XTENSA_OP_DIVIDE_BY_ZERO,
3818 }, {
3819 .name = "remu",
3820 .translate = translate_remu,
3821 .op_flags = XTENSA_OP_DIVIDE_BY_ZERO,
3822 }, {
3823 .name = "rer",
3824 .translate = translate_rer,
3825 .op_flags = XTENSA_OP_PRIVILEGED,
3826 }, {
3827 .name = (const char * const[]) {
3828 "ret", "ret.n", NULL,
3829 },
3830 .translate = translate_ret,
3831 .op_flags = XTENSA_OP_NAME_ARRAY,
3832 }, {
3833 .name = (const char * const[]) {
3834 "retw", "retw.n", NULL,
3835 },
3836 .translate = translate_retw,
3837 .test_exceptions = test_exceptions_retw,
3838 .op_flags = XTENSA_OP_UNDERFLOW | XTENSA_OP_NAME_ARRAY,
3839 }, {
3840 .name = "rfdd",
3841 .op_flags = XTENSA_OP_ILL,
3842 }, {
3843 .name = "rfde",
3844 .translate = translate_rfde,
3845 .op_flags = XTENSA_OP_PRIVILEGED,
3846 }, {
3847 .name = "rfdo",
3848 .op_flags = XTENSA_OP_ILL,
3849 }, {
3850 .name = "rfe",
3851 .translate = translate_rfe,
3852 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_CHECK_INTERRUPTS,
3853 }, {
3854 .name = "rfi",
3855 .translate = translate_rfi,
3856 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_CHECK_INTERRUPTS,
3857 }, {
3858 .name = "rfwo",
3859 .translate = translate_rfw,
3860 .par = (const uint32_t[]){true},
3861 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_CHECK_INTERRUPTS,
3862 }, {
3863 .name = "rfwu",
3864 .translate = translate_rfw,
3865 .par = (const uint32_t[]){false},
3866 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_CHECK_INTERRUPTS,
3867 }, {
3868 .name = "ritlb0",
3869 .translate = translate_rtlb,
3870 .par = (const uint32_t[]){false, 0},
3871 .op_flags = XTENSA_OP_PRIVILEGED,
3872 }, {
3873 .name = "ritlb1",
3874 .translate = translate_rtlb,
3875 .par = (const uint32_t[]){false, 1},
3876 .op_flags = XTENSA_OP_PRIVILEGED,
3877 }, {
3878 .name = "rptlb0",
3879 .translate = translate_rptlb0,
3880 .op_flags = XTENSA_OP_PRIVILEGED,
3881 }, {
3882 .name = "rptlb1",
3883 .translate = translate_rptlb1,
3884 .op_flags = XTENSA_OP_PRIVILEGED,
3885 }, {
3886 .name = "rotw",
3887 .translate = translate_rotw,
3888 .op_flags = XTENSA_OP_PRIVILEGED |
3889 XTENSA_OP_EXIT_TB_M1 |
3890 XTENSA_OP_SYNC_REGISTER_WINDOW,
3891 }, {
3892 .name = "rsil",
3893 .translate = translate_rsil,
3894 .op_flags =
3895 XTENSA_OP_PRIVILEGED |
3896 XTENSA_OP_EXIT_TB_0 |
3897 XTENSA_OP_CHECK_INTERRUPTS,
3898 }, {
3899 .name = "rsr.176",
3900 .translate = translate_rsr,
3901 .par = (const uint32_t[]){176},
3902 .op_flags = XTENSA_OP_PRIVILEGED,
3903 }, {
3904 .name = "rsr.208",
3905 .translate = translate_rsr,
3906 .par = (const uint32_t[]){208},
3907 .op_flags = XTENSA_OP_PRIVILEGED,
3908 }, {
3909 .name = "rsr.acchi",
3910 .translate = translate_rsr,
3911 .test_exceptions = test_exceptions_sr,
3912 .par = (const uint32_t[]){
3913 ACCHI,
3914 XTENSA_OPTION_MAC16,
3915 },
3916 }, {
3917 .name = "rsr.acclo",
3918 .translate = translate_rsr,
3919 .test_exceptions = test_exceptions_sr,
3920 .par = (const uint32_t[]){
3921 ACCLO,
3922 XTENSA_OPTION_MAC16,
3923 },
3924 }, {
3925 .name = "rsr.atomctl",
3926 .translate = translate_rsr,
3927 .test_exceptions = test_exceptions_sr,
3928 .par = (const uint32_t[]){
3929 ATOMCTL,
3930 XTENSA_OPTION_ATOMCTL,
3931 },
3932 .op_flags = XTENSA_OP_PRIVILEGED,
3933 }, {
3934 .name = "rsr.br",
3935 .translate = translate_rsr,
3936 .test_exceptions = test_exceptions_sr,
3937 .par = (const uint32_t[]){
3938 BR,
3939 XTENSA_OPTION_BOOLEAN,
3940 },
3941 }, {
3942 .name = "rsr.cacheadrdis",
3943 .translate = translate_rsr,
3944 .test_exceptions = test_exceptions_sr,
3945 .par = (const uint32_t[]){
3946 CACHEADRDIS,
3947 XTENSA_OPTION_MPU,
3948 },
3949 .op_flags = XTENSA_OP_PRIVILEGED,
3950 }, {
3951 .name = "rsr.cacheattr",
3952 .translate = translate_rsr,
3953 .test_exceptions = test_exceptions_sr,
3954 .par = (const uint32_t[]){
3955 CACHEATTR,
3956 XTENSA_OPTION_CACHEATTR,
3957 },
3958 .op_flags = XTENSA_OP_PRIVILEGED,
3959 }, {
3960 .name = "rsr.ccompare0",
3961 .translate = translate_rsr,
3962 .test_exceptions = test_exceptions_ccompare,
3963 .par = (const uint32_t[]){
3964 CCOMPARE,
3965 XTENSA_OPTION_TIMER_INTERRUPT,
3966 },
3967 .op_flags = XTENSA_OP_PRIVILEGED,
3968 }, {
3969 .name = "rsr.ccompare1",
3970 .translate = translate_rsr,
3971 .test_exceptions = test_exceptions_ccompare,
3972 .par = (const uint32_t[]){
3973 CCOMPARE + 1,
3974 XTENSA_OPTION_TIMER_INTERRUPT,
3975 },
3976 .op_flags = XTENSA_OP_PRIVILEGED,
3977 }, {
3978 .name = "rsr.ccompare2",
3979 .translate = translate_rsr,
3980 .test_exceptions = test_exceptions_ccompare,
3981 .par = (const uint32_t[]){
3982 CCOMPARE + 2,
3983 XTENSA_OPTION_TIMER_INTERRUPT,
3984 },
3985 .op_flags = XTENSA_OP_PRIVILEGED,
3986 }, {
3987 .name = "rsr.ccount",
3988 .translate = translate_rsr_ccount,
3989 .test_exceptions = test_exceptions_sr,
3990 .par = (const uint32_t[]){
3991 CCOUNT,
3992 XTENSA_OPTION_TIMER_INTERRUPT,
3993 },
3994 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
3995 }, {
3996 .name = "rsr.configid0",
3997 .translate = translate_rsr,
3998 .par = (const uint32_t[]){CONFIGID0},
3999 .op_flags = XTENSA_OP_PRIVILEGED,
4000 }, {
4001 .name = "rsr.configid1",
4002 .translate = translate_rsr,
4003 .par = (const uint32_t[]){CONFIGID1},
4004 .op_flags = XTENSA_OP_PRIVILEGED,
4005 }, {
4006 .name = "rsr.cpenable",
4007 .translate = translate_rsr,
4008 .test_exceptions = test_exceptions_sr,
4009 .par = (const uint32_t[]){
4010 CPENABLE,
4011 XTENSA_OPTION_COPROCESSOR,
4012 },
4013 .op_flags = XTENSA_OP_PRIVILEGED,
4014 }, {
4015 .name = "rsr.dbreaka0",
4016 .translate = translate_rsr,
4017 .test_exceptions = test_exceptions_dbreak,
4018 .par = (const uint32_t[]){
4019 DBREAKA,
4020 XTENSA_OPTION_DEBUG,
4021 },
4022 .op_flags = XTENSA_OP_PRIVILEGED,
4023 }, {
4024 .name = "rsr.dbreaka1",
4025 .translate = translate_rsr,
4026 .test_exceptions = test_exceptions_dbreak,
4027 .par = (const uint32_t[]){
4028 DBREAKA + 1,
4029 XTENSA_OPTION_DEBUG,
4030 },
4031 .op_flags = XTENSA_OP_PRIVILEGED,
4032 }, {
4033 .name = "rsr.dbreakc0",
4034 .translate = translate_rsr,
4035 .test_exceptions = test_exceptions_dbreak,
4036 .par = (const uint32_t[]){
4037 DBREAKC,
4038 XTENSA_OPTION_DEBUG,
4039 },
4040 .op_flags = XTENSA_OP_PRIVILEGED,
4041 }, {
4042 .name = "rsr.dbreakc1",
4043 .translate = translate_rsr,
4044 .test_exceptions = test_exceptions_dbreak,
4045 .par = (const uint32_t[]){
4046 DBREAKC + 1,
4047 XTENSA_OPTION_DEBUG,
4048 },
4049 .op_flags = XTENSA_OP_PRIVILEGED,
4050 }, {
4051 .name = "rsr.ddr",
4052 .translate = translate_rsr,
4053 .test_exceptions = test_exceptions_sr,
4054 .par = (const uint32_t[]){
4055 DDR,
4056 XTENSA_OPTION_DEBUG,
4057 },
4058 .op_flags = XTENSA_OP_PRIVILEGED,
4059 }, {
4060 .name = "rsr.debugcause",
4061 .translate = translate_rsr,
4062 .test_exceptions = test_exceptions_sr,
4063 .par = (const uint32_t[]){
4064 DEBUGCAUSE,
4065 XTENSA_OPTION_DEBUG,
4066 },
4067 .op_flags = XTENSA_OP_PRIVILEGED,
4068 }, {
4069 .name = "rsr.depc",
4070 .translate = translate_rsr,
4071 .test_exceptions = test_exceptions_sr,
4072 .par = (const uint32_t[]){
4073 DEPC,
4074 XTENSA_OPTION_EXCEPTION,
4075 },
4076 .op_flags = XTENSA_OP_PRIVILEGED,
4077 }, {
4078 .name = "rsr.dtlbcfg",
4079 .translate = translate_rsr,
4080 .test_exceptions = test_exceptions_sr,
4081 .par = (const uint32_t[]){
4082 DTLBCFG,
4083 XTENSA_OPTION_MMU,
4084 },
4085 .op_flags = XTENSA_OP_PRIVILEGED,
4086 }, {
4087 .name = "rsr.epc1",
4088 .translate = translate_rsr,
4089 .test_exceptions = test_exceptions_sr,
4090 .par = (const uint32_t[]){
4091 EPC1,
4092 XTENSA_OPTION_EXCEPTION,
4093 },
4094 .op_flags = XTENSA_OP_PRIVILEGED,
4095 }, {
4096 .name = "rsr.epc2",
4097 .translate = translate_rsr,
4098 .test_exceptions = test_exceptions_hpi,
4099 .par = (const uint32_t[]){
4100 EPC1 + 1,
4101 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4102 },
4103 .op_flags = XTENSA_OP_PRIVILEGED,
4104 }, {
4105 .name = "rsr.epc3",
4106 .translate = translate_rsr,
4107 .test_exceptions = test_exceptions_hpi,
4108 .par = (const uint32_t[]){
4109 EPC1 + 2,
4110 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4111 },
4112 .op_flags = XTENSA_OP_PRIVILEGED,
4113 }, {
4114 .name = "rsr.epc4",
4115 .translate = translate_rsr,
4116 .test_exceptions = test_exceptions_hpi,
4117 .par = (const uint32_t[]){
4118 EPC1 + 3,
4119 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4120 },
4121 .op_flags = XTENSA_OP_PRIVILEGED,
4122 }, {
4123 .name = "rsr.epc5",
4124 .translate = translate_rsr,
4125 .test_exceptions = test_exceptions_hpi,
4126 .par = (const uint32_t[]){
4127 EPC1 + 4,
4128 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4129 },
4130 .op_flags = XTENSA_OP_PRIVILEGED,
4131 }, {
4132 .name = "rsr.epc6",
4133 .translate = translate_rsr,
4134 .test_exceptions = test_exceptions_hpi,
4135 .par = (const uint32_t[]){
4136 EPC1 + 5,
4137 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4138 },
4139 .op_flags = XTENSA_OP_PRIVILEGED,
4140 }, {
4141 .name = "rsr.epc7",
4142 .translate = translate_rsr,
4143 .test_exceptions = test_exceptions_hpi,
4144 .par = (const uint32_t[]){
4145 EPC1 + 6,
4146 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4147 },
4148 .op_flags = XTENSA_OP_PRIVILEGED,
4149 }, {
4150 .name = "rsr.eps2",
4151 .translate = translate_rsr,
4152 .test_exceptions = test_exceptions_hpi,
4153 .par = (const uint32_t[]){
4154 EPS2,
4155 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4156 },
4157 .op_flags = XTENSA_OP_PRIVILEGED,
4158 }, {
4159 .name = "rsr.eps3",
4160 .translate = translate_rsr,
4161 .test_exceptions = test_exceptions_hpi,
4162 .par = (const uint32_t[]){
4163 EPS2 + 1,
4164 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4165 },
4166 .op_flags = XTENSA_OP_PRIVILEGED,
4167 }, {
4168 .name = "rsr.eps4",
4169 .translate = translate_rsr,
4170 .test_exceptions = test_exceptions_hpi,
4171 .par = (const uint32_t[]){
4172 EPS2 + 2,
4173 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4174 },
4175 .op_flags = XTENSA_OP_PRIVILEGED,
4176 }, {
4177 .name = "rsr.eps5",
4178 .translate = translate_rsr,
4179 .test_exceptions = test_exceptions_hpi,
4180 .par = (const uint32_t[]){
4181 EPS2 + 3,
4182 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4183 },
4184 .op_flags = XTENSA_OP_PRIVILEGED,
4185 }, {
4186 .name = "rsr.eps6",
4187 .translate = translate_rsr,
4188 .test_exceptions = test_exceptions_hpi,
4189 .par = (const uint32_t[]){
4190 EPS2 + 4,
4191 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4192 },
4193 .op_flags = XTENSA_OP_PRIVILEGED,
4194 }, {
4195 .name = "rsr.eps7",
4196 .translate = translate_rsr,
4197 .test_exceptions = test_exceptions_hpi,
4198 .par = (const uint32_t[]){
4199 EPS2 + 5,
4200 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4201 },
4202 .op_flags = XTENSA_OP_PRIVILEGED,
4203 }, {
4204 .name = "rsr.eraccess",
4205 .translate = translate_rsr,
4206 .par = (const uint32_t[]){ERACCESS},
4207 .op_flags = XTENSA_OP_PRIVILEGED,
4208 }, {
4209 .name = "rsr.exccause",
4210 .translate = translate_rsr,
4211 .test_exceptions = test_exceptions_sr,
4212 .par = (const uint32_t[]){
4213 EXCCAUSE,
4214 XTENSA_OPTION_EXCEPTION,
4215 },
4216 .op_flags = XTENSA_OP_PRIVILEGED,
4217 }, {
4218 .name = "rsr.excsave1",
4219 .translate = translate_rsr,
4220 .test_exceptions = test_exceptions_sr,
4221 .par = (const uint32_t[]){
4222 EXCSAVE1,
4223 XTENSA_OPTION_EXCEPTION,
4224 },
4225 .op_flags = XTENSA_OP_PRIVILEGED,
4226 }, {
4227 .name = "rsr.excsave2",
4228 .translate = translate_rsr,
4229 .test_exceptions = test_exceptions_hpi,
4230 .par = (const uint32_t[]){
4231 EXCSAVE1 + 1,
4232 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4233 },
4234 .op_flags = XTENSA_OP_PRIVILEGED,
4235 }, {
4236 .name = "rsr.excsave3",
4237 .translate = translate_rsr,
4238 .test_exceptions = test_exceptions_hpi,
4239 .par = (const uint32_t[]){
4240 EXCSAVE1 + 2,
4241 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4242 },
4243 .op_flags = XTENSA_OP_PRIVILEGED,
4244 }, {
4245 .name = "rsr.excsave4",
4246 .translate = translate_rsr,
4247 .test_exceptions = test_exceptions_hpi,
4248 .par = (const uint32_t[]){
4249 EXCSAVE1 + 3,
4250 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4251 },
4252 .op_flags = XTENSA_OP_PRIVILEGED,
4253 }, {
4254 .name = "rsr.excsave5",
4255 .translate = translate_rsr,
4256 .test_exceptions = test_exceptions_hpi,
4257 .par = (const uint32_t[]){
4258 EXCSAVE1 + 4,
4259 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4260 },
4261 .op_flags = XTENSA_OP_PRIVILEGED,
4262 }, {
4263 .name = "rsr.excsave6",
4264 .translate = translate_rsr,
4265 .test_exceptions = test_exceptions_hpi,
4266 .par = (const uint32_t[]){
4267 EXCSAVE1 + 5,
4268 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4269 },
4270 .op_flags = XTENSA_OP_PRIVILEGED,
4271 }, {
4272 .name = "rsr.excsave7",
4273 .translate = translate_rsr,
4274 .test_exceptions = test_exceptions_hpi,
4275 .par = (const uint32_t[]){
4276 EXCSAVE1 + 6,
4277 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4278 },
4279 .op_flags = XTENSA_OP_PRIVILEGED,
4280 }, {
4281 .name = "rsr.excvaddr",
4282 .translate = translate_rsr,
4283 .test_exceptions = test_exceptions_sr,
4284 .par = (const uint32_t[]){
4285 EXCVADDR,
4286 XTENSA_OPTION_EXCEPTION,
4287 },
4288 .op_flags = XTENSA_OP_PRIVILEGED,
4289 }, {
4290 .name = "rsr.ibreaka0",
4291 .translate = translate_rsr,
4292 .test_exceptions = test_exceptions_ibreak,
4293 .par = (const uint32_t[]){
4294 IBREAKA,
4295 XTENSA_OPTION_DEBUG,
4296 },
4297 .op_flags = XTENSA_OP_PRIVILEGED,
4298 }, {
4299 .name = "rsr.ibreaka1",
4300 .translate = translate_rsr,
4301 .test_exceptions = test_exceptions_ibreak,
4302 .par = (const uint32_t[]){
4303 IBREAKA + 1,
4304 XTENSA_OPTION_DEBUG,
4305 },
4306 .op_flags = XTENSA_OP_PRIVILEGED,
4307 }, {
4308 .name = "rsr.ibreakenable",
4309 .translate = translate_rsr,
4310 .test_exceptions = test_exceptions_sr,
4311 .par = (const uint32_t[]){
4312 IBREAKENABLE,
4313 XTENSA_OPTION_DEBUG,
4314 },
4315 .op_flags = XTENSA_OP_PRIVILEGED,
4316 }, {
4317 .name = "rsr.icount",
4318 .translate = translate_rsr,
4319 .test_exceptions = test_exceptions_sr,
4320 .par = (const uint32_t[]){
4321 ICOUNT,
4322 XTENSA_OPTION_DEBUG,
4323 },
4324 .op_flags = XTENSA_OP_PRIVILEGED,
4325 }, {
4326 .name = "rsr.icountlevel",
4327 .translate = translate_rsr,
4328 .test_exceptions = test_exceptions_sr,
4329 .par = (const uint32_t[]){
4330 ICOUNTLEVEL,
4331 XTENSA_OPTION_DEBUG,
4332 },
4333 .op_flags = XTENSA_OP_PRIVILEGED,
4334 }, {
4335 .name = "rsr.intclear",
4336 .translate = translate_rsr,
4337 .test_exceptions = test_exceptions_sr,
4338 .par = (const uint32_t[]){
4339 INTCLEAR,
4340 XTENSA_OPTION_INTERRUPT,
4341 },
4342 .op_flags = XTENSA_OP_PRIVILEGED,
4343 }, {
4344 .name = "rsr.intenable",
4345 .translate = translate_rsr,
4346 .test_exceptions = test_exceptions_sr,
4347 .par = (const uint32_t[]){
4348 INTENABLE,
4349 XTENSA_OPTION_INTERRUPT,
4350 },
4351 .op_flags = XTENSA_OP_PRIVILEGED,
4352 }, {
4353 .name = "rsr.interrupt",
4354 .translate = translate_rsr_ccount,
4355 .test_exceptions = test_exceptions_sr,
4356 .par = (const uint32_t[]){
4357 INTSET,
4358 XTENSA_OPTION_INTERRUPT,
4359 },
4360 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
4361 }, {
4362 .name = "rsr.intset",
4363 .translate = translate_rsr_ccount,
4364 .test_exceptions = test_exceptions_sr,
4365 .par = (const uint32_t[]){
4366 INTSET,
4367 XTENSA_OPTION_INTERRUPT,
4368 },
4369 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
4370 }, {
4371 .name = "rsr.itlbcfg",
4372 .translate = translate_rsr,
4373 .test_exceptions = test_exceptions_sr,
4374 .par = (const uint32_t[]){
4375 ITLBCFG,
4376 XTENSA_OPTION_MMU,
4377 },
4378 .op_flags = XTENSA_OP_PRIVILEGED,
4379 }, {
4380 .name = "rsr.lbeg",
4381 .translate = translate_rsr,
4382 .test_exceptions = test_exceptions_sr,
4383 .par = (const uint32_t[]){
4384 LBEG,
4385 XTENSA_OPTION_LOOP,
4386 },
4387 }, {
4388 .name = "rsr.lcount",
4389 .translate = translate_rsr,
4390 .test_exceptions = test_exceptions_sr,
4391 .par = (const uint32_t[]){
4392 LCOUNT,
4393 XTENSA_OPTION_LOOP,
4394 },
4395 }, {
4396 .name = "rsr.lend",
4397 .translate = translate_rsr,
4398 .test_exceptions = test_exceptions_sr,
4399 .par = (const uint32_t[]){
4400 LEND,
4401 XTENSA_OPTION_LOOP,
4402 },
4403 }, {
4404 .name = "rsr.litbase",
4405 .translate = translate_rsr,
4406 .test_exceptions = test_exceptions_sr,
4407 .par = (const uint32_t[]){
4408 LITBASE,
4409 XTENSA_OPTION_EXTENDED_L32R,
4410 },
4411 }, {
4412 .name = "rsr.m0",
4413 .translate = translate_rsr,
4414 .test_exceptions = test_exceptions_sr,
4415 .par = (const uint32_t[]){
4416 MR,
4417 XTENSA_OPTION_MAC16,
4418 },
4419 }, {
4420 .name = "rsr.m1",
4421 .translate = translate_rsr,
4422 .test_exceptions = test_exceptions_sr,
4423 .par = (const uint32_t[]){
4424 MR + 1,
4425 XTENSA_OPTION_MAC16,
4426 },
4427 }, {
4428 .name = "rsr.m2",
4429 .translate = translate_rsr,
4430 .test_exceptions = test_exceptions_sr,
4431 .par = (const uint32_t[]){
4432 MR + 2,
4433 XTENSA_OPTION_MAC16,
4434 },
4435 }, {
4436 .name = "rsr.m3",
4437 .translate = translate_rsr,
4438 .test_exceptions = test_exceptions_sr,
4439 .par = (const uint32_t[]){
4440 MR + 3,
4441 XTENSA_OPTION_MAC16,
4442 },
4443 }, {
4444 .name = "rsr.memctl",
4445 .translate = translate_rsr,
4446 .par = (const uint32_t[]){MEMCTL},
4447 .op_flags = XTENSA_OP_PRIVILEGED,
4448 }, {
4449 .name = "rsr.mecr",
4450 .translate = translate_rsr,
4451 .test_exceptions = test_exceptions_sr,
4452 .par = (const uint32_t[]){
4453 MECR,
4454 XTENSA_OPTION_MEMORY_ECC_PARITY,
4455 },
4456 .op_flags = XTENSA_OP_PRIVILEGED,
4457 }, {
4458 .name = "rsr.mepc",
4459 .translate = translate_rsr,
4460 .test_exceptions = test_exceptions_sr,
4461 .par = (const uint32_t[]){
4462 MEPC,
4463 XTENSA_OPTION_MEMORY_ECC_PARITY,
4464 },
4465 .op_flags = XTENSA_OP_PRIVILEGED,
4466 }, {
4467 .name = "rsr.meps",
4468 .translate = translate_rsr,
4469 .test_exceptions = test_exceptions_sr,
4470 .par = (const uint32_t[]){
4471 MEPS,
4472 XTENSA_OPTION_MEMORY_ECC_PARITY,
4473 },
4474 .op_flags = XTENSA_OP_PRIVILEGED,
4475 }, {
4476 .name = "rsr.mesave",
4477 .translate = translate_rsr,
4478 .test_exceptions = test_exceptions_sr,
4479 .par = (const uint32_t[]){
4480 MESAVE,
4481 XTENSA_OPTION_MEMORY_ECC_PARITY,
4482 },
4483 .op_flags = XTENSA_OP_PRIVILEGED,
4484 }, {
4485 .name = "rsr.mesr",
4486 .translate = translate_rsr,
4487 .test_exceptions = test_exceptions_sr,
4488 .par = (const uint32_t[]){
4489 MESR,
4490 XTENSA_OPTION_MEMORY_ECC_PARITY,
4491 },
4492 .op_flags = XTENSA_OP_PRIVILEGED,
4493 }, {
4494 .name = "rsr.mevaddr",
4495 .translate = translate_rsr,
4496 .test_exceptions = test_exceptions_sr,
4497 .par = (const uint32_t[]){
4498 MESR,
4499 XTENSA_OPTION_MEMORY_ECC_PARITY,
4500 },
4501 .op_flags = XTENSA_OP_PRIVILEGED,
4502 }, {
4503 .name = "rsr.misc0",
4504 .translate = translate_rsr,
4505 .test_exceptions = test_exceptions_sr,
4506 .par = (const uint32_t[]){
4507 MISC,
4508 XTENSA_OPTION_MISC_SR,
4509 },
4510 .op_flags = XTENSA_OP_PRIVILEGED,
4511 }, {
4512 .name = "rsr.misc1",
4513 .translate = translate_rsr,
4514 .test_exceptions = test_exceptions_sr,
4515 .par = (const uint32_t[]){
4516 MISC + 1,
4517 XTENSA_OPTION_MISC_SR,
4518 },
4519 .op_flags = XTENSA_OP_PRIVILEGED,
4520 }, {
4521 .name = "rsr.misc2",
4522 .translate = translate_rsr,
4523 .test_exceptions = test_exceptions_sr,
4524 .par = (const uint32_t[]){
4525 MISC + 2,
4526 XTENSA_OPTION_MISC_SR,
4527 },
4528 .op_flags = XTENSA_OP_PRIVILEGED,
4529 }, {
4530 .name = "rsr.misc3",
4531 .translate = translate_rsr,
4532 .test_exceptions = test_exceptions_sr,
4533 .par = (const uint32_t[]){
4534 MISC + 3,
4535 XTENSA_OPTION_MISC_SR,
4536 },
4537 .op_flags = XTENSA_OP_PRIVILEGED,
4538 }, {
4539 .name = "rsr.mpucfg",
4540 .translate = translate_rsr,
4541 .test_exceptions = test_exceptions_sr,
4542 .par = (const uint32_t[]){
4543 MPUCFG,
4544 XTENSA_OPTION_MPU,
4545 },
4546 .op_flags = XTENSA_OP_PRIVILEGED,
4547 }, {
4548 .name = "rsr.mpuenb",
4549 .translate = translate_rsr,
4550 .test_exceptions = test_exceptions_sr,
4551 .par = (const uint32_t[]){
4552 MPUENB,
4553 XTENSA_OPTION_MPU,
4554 },
4555 .op_flags = XTENSA_OP_PRIVILEGED,
4556 }, {
4557 .name = "rsr.prefctl",
4558 .translate = translate_rsr,
4559 .par = (const uint32_t[]){PREFCTL},
4560 }, {
4561 .name = "rsr.prid",
4562 .translate = translate_rsr,
4563 .test_exceptions = test_exceptions_sr,
4564 .par = (const uint32_t[]){
4565 PRID,
4566 XTENSA_OPTION_PROCESSOR_ID,
4567 },
4568 .op_flags = XTENSA_OP_PRIVILEGED,
4569 }, {
4570 .name = "rsr.ps",
4571 .translate = translate_rsr,
4572 .test_exceptions = test_exceptions_sr,
4573 .par = (const uint32_t[]){
4574 PS,
4575 XTENSA_OPTION_EXCEPTION,
4576 },
4577 .op_flags = XTENSA_OP_PRIVILEGED,
4578 }, {
4579 .name = "rsr.ptevaddr",
4580 .translate = translate_rsr_ptevaddr,
4581 .test_exceptions = test_exceptions_sr,
4582 .par = (const uint32_t[]){
4583 PTEVADDR,
4584 XTENSA_OPTION_MMU,
4585 },
4586 .op_flags = XTENSA_OP_PRIVILEGED,
4587 }, {
4588 .name = "rsr.rasid",
4589 .translate = translate_rsr,
4590 .test_exceptions = test_exceptions_sr,
4591 .par = (const uint32_t[]){
4592 RASID,
4593 XTENSA_OPTION_MMU,
4594 },
4595 .op_flags = XTENSA_OP_PRIVILEGED,
4596 }, {
4597 .name = "rsr.sar",
4598 .translate = translate_rsr,
4599 .par = (const uint32_t[]){SAR},
4600 }, {
4601 .name = "rsr.scompare1",
4602 .translate = translate_rsr,
4603 .test_exceptions = test_exceptions_sr,
4604 .par = (const uint32_t[]){
4605 SCOMPARE1,
4606 XTENSA_OPTION_CONDITIONAL_STORE,
4607 },
4608 }, {
4609 .name = "rsr.vecbase",
4610 .translate = translate_rsr,
4611 .test_exceptions = test_exceptions_sr,
4612 .par = (const uint32_t[]){
4613 VECBASE,
4614 XTENSA_OPTION_RELOCATABLE_VECTOR,
4615 },
4616 .op_flags = XTENSA_OP_PRIVILEGED,
4617 }, {
4618 .name = "rsr.windowbase",
4619 .translate = translate_rsr,
4620 .test_exceptions = test_exceptions_sr,
4621 .par = (const uint32_t[]){
4622 WINDOW_BASE,
4623 XTENSA_OPTION_WINDOWED_REGISTER,
4624 },
4625 .op_flags = XTENSA_OP_PRIVILEGED,
4626 }, {
4627 .name = "rsr.windowstart",
4628 .translate = translate_rsr,
4629 .test_exceptions = test_exceptions_sr,
4630 .par = (const uint32_t[]){
4631 WINDOW_START,
4632 XTENSA_OPTION_WINDOWED_REGISTER,
4633 },
4634 .op_flags = XTENSA_OP_PRIVILEGED,
4635 }, {
4636 .name = "rsync",
4637 .translate = translate_nop,
4638 }, {
4639 .name = "rur.expstate",
4640 .translate = translate_rur,
4641 .par = (const uint32_t[]){EXPSTATE},
4642 }, {
4643 .name = "rur.threadptr",
4644 .translate = translate_rur,
4645 .par = (const uint32_t[]){THREADPTR},
4646 }, {
4647 .name = "s16i",
4648 .translate = translate_ldst,
4649 .par = (const uint32_t[]){MO_TEUW, false, true},
4650 .op_flags = XTENSA_OP_STORE,
4651 }, {
4652 .name = "s32c1i",
4653 .translate = translate_s32c1i,
4654 .op_flags = XTENSA_OP_LOAD | XTENSA_OP_STORE,
4655 }, {
4656 .name = "s32e",
4657 .translate = translate_s32e,
4658 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_STORE,
4659 }, {
4660 .name = "s32ex",
4661 .translate = translate_s32ex,
4662 .op_flags = XTENSA_OP_LOAD | XTENSA_OP_STORE,
4663 }, {
4664 .name = (const char * const[]) {
4665 "s32i", "s32i.n", "s32nb", NULL,
4666 },
4667 .translate = translate_ldst,
4668 .par = (const uint32_t[]){MO_TEUL, false, true},
4669 .op_flags = XTENSA_OP_NAME_ARRAY | XTENSA_OP_STORE,
4670 }, {
4671 .name = "s32ri",
4672 .translate = translate_ldst,
4673 .par = (const uint32_t[]){MO_TEUL | MO_ALIGN, true, true},
4674 .op_flags = XTENSA_OP_STORE,
4675 }, {
4676 .name = "s8i",
4677 .translate = translate_ldst,
4678 .par = (const uint32_t[]){MO_UB, false, true},
4679 .op_flags = XTENSA_OP_STORE,
4680 }, {
4681 .name = "salt",
4682 .translate = translate_salt,
4683 .par = (const uint32_t[]){TCG_COND_LT},
4684 }, {
4685 .name = "saltu",
4686 .translate = translate_salt,
4687 .par = (const uint32_t[]){TCG_COND_LTU},
4688 }, {
4689 .name = "setb_expstate",
4690 .translate = translate_setb_expstate,
4691 }, {
4692 .name = "sext",
4693 .translate = translate_sext,
4694 }, {
4695 .name = "simcall",
4696 .translate = translate_simcall,
4697 .test_exceptions = test_exceptions_simcall,
4698 .op_flags = XTENSA_OP_PRIVILEGED,
4699 }, {
4700 .name = "sll",
4701 .translate = translate_sll,
4702 }, {
4703 .name = "slli",
4704 .translate = translate_slli,
4705 }, {
4706 .name = "sra",
4707 .translate = translate_sra,
4708 }, {
4709 .name = "srai",
4710 .translate = translate_srai,
4711 }, {
4712 .name = "src",
4713 .translate = translate_src,
4714 }, {
4715 .name = "srl",
4716 .translate = translate_srl,
4717 }, {
4718 .name = "srli",
4719 .translate = translate_srli,
4720 }, {
4721 .name = "ssa8b",
4722 .translate = translate_ssa8b,
4723 }, {
4724 .name = "ssa8l",
4725 .translate = translate_ssa8l,
4726 }, {
4727 .name = "ssai",
4728 .translate = translate_ssai,
4729 }, {
4730 .name = "ssl",
4731 .translate = translate_ssl,
4732 }, {
4733 .name = "ssr",
4734 .translate = translate_ssr,
4735 }, {
4736 .name = "sub",
4737 .translate = translate_sub,
4738 }, {
4739 .name = "subx2",
4740 .translate = translate_subx,
4741 .par = (const uint32_t[]){1},
4742 }, {
4743 .name = "subx4",
4744 .translate = translate_subx,
4745 .par = (const uint32_t[]){2},
4746 }, {
4747 .name = "subx8",
4748 .translate = translate_subx,
4749 .par = (const uint32_t[]){3},
4750 }, {
4751 .name = "syscall",
4752 .op_flags = XTENSA_OP_SYSCALL,
4753 }, {
4754 .name = "umul.aa.hh",
4755 .translate = translate_mac16,
4756 .par = (const uint32_t[]){MAC16_UMUL, MAC16_HH, 0},
4757 }, {
4758 .name = "umul.aa.hl",
4759 .translate = translate_mac16,
4760 .par = (const uint32_t[]){MAC16_UMUL, MAC16_HL, 0},
4761 }, {
4762 .name = "umul.aa.lh",
4763 .translate = translate_mac16,
4764 .par = (const uint32_t[]){MAC16_UMUL, MAC16_LH, 0},
4765 }, {
4766 .name = "umul.aa.ll",
4767 .translate = translate_mac16,
4768 .par = (const uint32_t[]){MAC16_UMUL, MAC16_LL, 0},
4769 }, {
4770 .name = "waiti",
4771 .translate = translate_waiti,
4772 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
4773 }, {
4774 .name = "wdtlb",
4775 .translate = translate_wtlb,
4776 .par = (const uint32_t[]){true},
4777 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
4778 }, {
4779 .name = "wer",
4780 .translate = translate_wer,
4781 .op_flags = XTENSA_OP_PRIVILEGED,
4782 }, {
4783 .name = "witlb",
4784 .translate = translate_wtlb,
4785 .par = (const uint32_t[]){false},
4786 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
4787 }, {
4788 .name = "wptlb",
4789 .translate = translate_wptlb,
4790 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
4791 }, {
4792 .name = "wrmsk_expstate",
4793 .translate = translate_wrmsk_expstate,
4794 }, {
4795 .name = "wsr.176",
4796 .op_flags = XTENSA_OP_ILL,
4797 }, {
4798 .name = "wsr.208",
4799 .op_flags = XTENSA_OP_ILL,
4800 }, {
4801 .name = "wsr.acchi",
4802 .translate = translate_wsr_acchi,
4803 .test_exceptions = test_exceptions_sr,
4804 .par = (const uint32_t[]){
4805 ACCHI,
4806 XTENSA_OPTION_MAC16,
4807 },
4808 }, {
4809 .name = "wsr.acclo",
4810 .translate = translate_wsr,
4811 .test_exceptions = test_exceptions_sr,
4812 .par = (const uint32_t[]){
4813 ACCLO,
4814 XTENSA_OPTION_MAC16,
4815 },
4816 }, {
4817 .name = "wsr.atomctl",
4818 .translate = translate_wsr_mask,
4819 .test_exceptions = test_exceptions_sr,
4820 .par = (const uint32_t[]){
4821 ATOMCTL,
4822 XTENSA_OPTION_ATOMCTL,
4823 0x3f,
4824 },
4825 .op_flags = XTENSA_OP_PRIVILEGED,
4826 }, {
4827 .name = "wsr.br",
4828 .translate = translate_wsr_mask,
4829 .test_exceptions = test_exceptions_sr,
4830 .par = (const uint32_t[]){
4831 BR,
4832 XTENSA_OPTION_BOOLEAN,
4833 0xffff,
4834 },
4835 }, {
4836 .name = "wsr.cacheadrdis",
4837 .translate = translate_wsr_mask,
4838 .test_exceptions = test_exceptions_sr,
4839 .par = (const uint32_t[]){
4840 CACHEADRDIS,
4841 XTENSA_OPTION_MPU,
4842 0xff,
4843 },
4844 .op_flags = XTENSA_OP_PRIVILEGED,
4845 }, {
4846 .name = "wsr.cacheattr",
4847 .translate = translate_wsr,
4848 .test_exceptions = test_exceptions_sr,
4849 .par = (const uint32_t[]){
4850 CACHEATTR,
4851 XTENSA_OPTION_CACHEATTR,
4852 },
4853 .op_flags = XTENSA_OP_PRIVILEGED,
4854 }, {
4855 .name = "wsr.ccompare0",
4856 .translate = translate_wsr_ccompare,
4857 .test_exceptions = test_exceptions_ccompare,
4858 .par = (const uint32_t[]){
4859 CCOMPARE,
4860 XTENSA_OPTION_TIMER_INTERRUPT,
4861 },
4862 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
4863 }, {
4864 .name = "wsr.ccompare1",
4865 .translate = translate_wsr_ccompare,
4866 .test_exceptions = test_exceptions_ccompare,
4867 .par = (const uint32_t[]){
4868 CCOMPARE + 1,
4869 XTENSA_OPTION_TIMER_INTERRUPT,
4870 },
4871 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
4872 }, {
4873 .name = "wsr.ccompare2",
4874 .translate = translate_wsr_ccompare,
4875 .test_exceptions = test_exceptions_ccompare,
4876 .par = (const uint32_t[]){
4877 CCOMPARE + 2,
4878 XTENSA_OPTION_TIMER_INTERRUPT,
4879 },
4880 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
4881 }, {
4882 .name = "wsr.ccount",
4883 .translate = translate_wsr_ccount,
4884 .test_exceptions = test_exceptions_sr,
4885 .par = (const uint32_t[]){
4886 CCOUNT,
4887 XTENSA_OPTION_TIMER_INTERRUPT,
4888 },
4889 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
4890 }, {
4891 .name = "wsr.configid0",
4892 .op_flags = XTENSA_OP_ILL,
4893 }, {
4894 .name = "wsr.configid1",
4895 .op_flags = XTENSA_OP_ILL,
4896 }, {
4897 .name = "wsr.cpenable",
4898 .translate = translate_wsr_mask,
4899 .test_exceptions = test_exceptions_sr,
4900 .par = (const uint32_t[]){
4901 CPENABLE,
4902 XTENSA_OPTION_COPROCESSOR,
4903 0xff,
4904 },
4905 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
4906 }, {
4907 .name = "wsr.dbreaka0",
4908 .translate = translate_wsr_dbreaka,
4909 .test_exceptions = test_exceptions_dbreak,
4910 .par = (const uint32_t[]){
4911 DBREAKA,
4912 XTENSA_OPTION_DEBUG,
4913 },
4914 .op_flags = XTENSA_OP_PRIVILEGED,
4915 }, {
4916 .name = "wsr.dbreaka1",
4917 .translate = translate_wsr_dbreaka,
4918 .test_exceptions = test_exceptions_dbreak,
4919 .par = (const uint32_t[]){
4920 DBREAKA + 1,
4921 XTENSA_OPTION_DEBUG,
4922 },
4923 .op_flags = XTENSA_OP_PRIVILEGED,
4924 }, {
4925 .name = "wsr.dbreakc0",
4926 .translate = translate_wsr_dbreakc,
4927 .test_exceptions = test_exceptions_dbreak,
4928 .par = (const uint32_t[]){
4929 DBREAKC,
4930 XTENSA_OPTION_DEBUG,
4931 },
4932 .op_flags = XTENSA_OP_PRIVILEGED,
4933 }, {
4934 .name = "wsr.dbreakc1",
4935 .translate = translate_wsr_dbreakc,
4936 .test_exceptions = test_exceptions_dbreak,
4937 .par = (const uint32_t[]){
4938 DBREAKC + 1,
4939 XTENSA_OPTION_DEBUG,
4940 },
4941 .op_flags = XTENSA_OP_PRIVILEGED,
4942 }, {
4943 .name = "wsr.ddr",
4944 .translate = translate_wsr,
4945 .test_exceptions = test_exceptions_sr,
4946 .par = (const uint32_t[]){
4947 DDR,
4948 XTENSA_OPTION_DEBUG,
4949 },
4950 .op_flags = XTENSA_OP_PRIVILEGED,
4951 }, {
4952 .name = "wsr.debugcause",
4953 .op_flags = XTENSA_OP_ILL,
4954 }, {
4955 .name = "wsr.depc",
4956 .translate = translate_wsr,
4957 .test_exceptions = test_exceptions_sr,
4958 .par = (const uint32_t[]){
4959 DEPC,
4960 XTENSA_OPTION_EXCEPTION,
4961 },
4962 .op_flags = XTENSA_OP_PRIVILEGED,
4963 }, {
4964 .name = "wsr.dtlbcfg",
4965 .translate = translate_wsr_mask,
4966 .test_exceptions = test_exceptions_sr,
4967 .par = (const uint32_t[]){
4968 DTLBCFG,
4969 XTENSA_OPTION_MMU,
4970 0x01130000,
4971 },
4972 .op_flags = XTENSA_OP_PRIVILEGED,
4973 }, {
4974 .name = "wsr.epc1",
4975 .translate = translate_wsr,
4976 .test_exceptions = test_exceptions_sr,
4977 .par = (const uint32_t[]){
4978 EPC1,
4979 XTENSA_OPTION_EXCEPTION,
4980 },
4981 .op_flags = XTENSA_OP_PRIVILEGED,
4982 }, {
4983 .name = "wsr.epc2",
4984 .translate = translate_wsr,
4985 .test_exceptions = test_exceptions_hpi,
4986 .par = (const uint32_t[]){
4987 EPC1 + 1,
4988 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4989 },
4990 .op_flags = XTENSA_OP_PRIVILEGED,
4991 }, {
4992 .name = "wsr.epc3",
4993 .translate = translate_wsr,
4994 .test_exceptions = test_exceptions_hpi,
4995 .par = (const uint32_t[]){
4996 EPC1 + 2,
4997 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
4998 },
4999 .op_flags = XTENSA_OP_PRIVILEGED,
5000 }, {
5001 .name = "wsr.epc4",
5002 .translate = translate_wsr,
5003 .test_exceptions = test_exceptions_hpi,
5004 .par = (const uint32_t[]){
5005 EPC1 + 3,
5006 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5007 },
5008 .op_flags = XTENSA_OP_PRIVILEGED,
5009 }, {
5010 .name = "wsr.epc5",
5011 .translate = translate_wsr,
5012 .test_exceptions = test_exceptions_hpi,
5013 .par = (const uint32_t[]){
5014 EPC1 + 4,
5015 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5016 },
5017 .op_flags = XTENSA_OP_PRIVILEGED,
5018 }, {
5019 .name = "wsr.epc6",
5020 .translate = translate_wsr,
5021 .test_exceptions = test_exceptions_hpi,
5022 .par = (const uint32_t[]){
5023 EPC1 + 5,
5024 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5025 },
5026 .op_flags = XTENSA_OP_PRIVILEGED,
5027 }, {
5028 .name = "wsr.epc7",
5029 .translate = translate_wsr,
5030 .test_exceptions = test_exceptions_hpi,
5031 .par = (const uint32_t[]){
5032 EPC1 + 6,
5033 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5034 },
5035 .op_flags = XTENSA_OP_PRIVILEGED,
5036 }, {
5037 .name = "wsr.eps2",
5038 .translate = translate_wsr,
5039 .test_exceptions = test_exceptions_hpi,
5040 .par = (const uint32_t[]){
5041 EPS2,
5042 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5043 },
5044 .op_flags = XTENSA_OP_PRIVILEGED,
5045 }, {
5046 .name = "wsr.eps3",
5047 .translate = translate_wsr,
5048 .test_exceptions = test_exceptions_hpi,
5049 .par = (const uint32_t[]){
5050 EPS2 + 1,
5051 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5052 },
5053 .op_flags = XTENSA_OP_PRIVILEGED,
5054 }, {
5055 .name = "wsr.eps4",
5056 .translate = translate_wsr,
5057 .test_exceptions = test_exceptions_hpi,
5058 .par = (const uint32_t[]){
5059 EPS2 + 2,
5060 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5061 },
5062 .op_flags = XTENSA_OP_PRIVILEGED,
5063 }, {
5064 .name = "wsr.eps5",
5065 .translate = translate_wsr,
5066 .test_exceptions = test_exceptions_hpi,
5067 .par = (const uint32_t[]){
5068 EPS2 + 3,
5069 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5070 },
5071 .op_flags = XTENSA_OP_PRIVILEGED,
5072 }, {
5073 .name = "wsr.eps6",
5074 .translate = translate_wsr,
5075 .test_exceptions = test_exceptions_hpi,
5076 .par = (const uint32_t[]){
5077 EPS2 + 4,
5078 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5079 },
5080 .op_flags = XTENSA_OP_PRIVILEGED,
5081 }, {
5082 .name = "wsr.eps7",
5083 .translate = translate_wsr,
5084 .test_exceptions = test_exceptions_hpi,
5085 .par = (const uint32_t[]){
5086 EPS2 + 5,
5087 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5088 },
5089 .op_flags = XTENSA_OP_PRIVILEGED,
5090 }, {
5091 .name = "wsr.eraccess",
5092 .translate = translate_wsr_mask,
5093 .par = (const uint32_t[]){
5094 ERACCESS,
5095 0,
5096 0xffff,
5097 },
5098 .op_flags = XTENSA_OP_PRIVILEGED,
5099 }, {
5100 .name = "wsr.exccause",
5101 .translate = translate_wsr,
5102 .test_exceptions = test_exceptions_sr,
5103 .par = (const uint32_t[]){
5104 EXCCAUSE,
5105 XTENSA_OPTION_EXCEPTION,
5106 },
5107 .op_flags = XTENSA_OP_PRIVILEGED,
5108 }, {
5109 .name = "wsr.excsave1",
5110 .translate = translate_wsr,
5111 .test_exceptions = test_exceptions_sr,
5112 .par = (const uint32_t[]){
5113 EXCSAVE1,
5114 XTENSA_OPTION_EXCEPTION,
5115 },
5116 .op_flags = XTENSA_OP_PRIVILEGED,
5117 }, {
5118 .name = "wsr.excsave2",
5119 .translate = translate_wsr,
5120 .test_exceptions = test_exceptions_hpi,
5121 .par = (const uint32_t[]){
5122 EXCSAVE1 + 1,
5123 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5124 },
5125 .op_flags = XTENSA_OP_PRIVILEGED,
5126 }, {
5127 .name = "wsr.excsave3",
5128 .translate = translate_wsr,
5129 .test_exceptions = test_exceptions_hpi,
5130 .par = (const uint32_t[]){
5131 EXCSAVE1 + 2,
5132 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5133 },
5134 .op_flags = XTENSA_OP_PRIVILEGED,
5135 }, {
5136 .name = "wsr.excsave4",
5137 .translate = translate_wsr,
5138 .test_exceptions = test_exceptions_hpi,
5139 .par = (const uint32_t[]){
5140 EXCSAVE1 + 3,
5141 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5142 },
5143 .op_flags = XTENSA_OP_PRIVILEGED,
5144 }, {
5145 .name = "wsr.excsave5",
5146 .translate = translate_wsr,
5147 .test_exceptions = test_exceptions_hpi,
5148 .par = (const uint32_t[]){
5149 EXCSAVE1 + 4,
5150 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5151 },
5152 .op_flags = XTENSA_OP_PRIVILEGED,
5153 }, {
5154 .name = "wsr.excsave6",
5155 .translate = translate_wsr,
5156 .test_exceptions = test_exceptions_hpi,
5157 .par = (const uint32_t[]){
5158 EXCSAVE1 + 5,
5159 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5160 },
5161 .op_flags = XTENSA_OP_PRIVILEGED,
5162 }, {
5163 .name = "wsr.excsave7",
5164 .translate = translate_wsr,
5165 .test_exceptions = test_exceptions_hpi,
5166 .par = (const uint32_t[]){
5167 EXCSAVE1 + 6,
5168 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5169 },
5170 .op_flags = XTENSA_OP_PRIVILEGED,
5171 }, {
5172 .name = "wsr.excvaddr",
5173 .translate = translate_wsr,
5174 .test_exceptions = test_exceptions_sr,
5175 .par = (const uint32_t[]){
5176 EXCVADDR,
5177 XTENSA_OPTION_EXCEPTION,
5178 },
5179 .op_flags = XTENSA_OP_PRIVILEGED,
5180 }, {
5181 .name = "wsr.ibreaka0",
5182 .translate = translate_wsr_ibreaka,
5183 .test_exceptions = test_exceptions_ibreak,
5184 .par = (const uint32_t[]){
5185 IBREAKA,
5186 XTENSA_OPTION_DEBUG,
5187 },
5188 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5189 }, {
5190 .name = "wsr.ibreaka1",
5191 .translate = translate_wsr_ibreaka,
5192 .test_exceptions = test_exceptions_ibreak,
5193 .par = (const uint32_t[]){
5194 IBREAKA + 1,
5195 XTENSA_OPTION_DEBUG,
5196 },
5197 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5198 }, {
5199 .name = "wsr.ibreakenable",
5200 .translate = translate_wsr_ibreakenable,
5201 .test_exceptions = test_exceptions_sr,
5202 .par = (const uint32_t[]){
5203 IBREAKENABLE,
5204 XTENSA_OPTION_DEBUG,
5205 },
5206 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5207 }, {
5208 .name = "wsr.icount",
5209 .translate = translate_wsr_icount,
5210 .test_exceptions = test_exceptions_sr,
5211 .par = (const uint32_t[]){
5212 ICOUNT,
5213 XTENSA_OPTION_DEBUG,
5214 },
5215 .op_flags = XTENSA_OP_PRIVILEGED,
5216 }, {
5217 .name = "wsr.icountlevel",
5218 .translate = translate_wsr_mask,
5219 .test_exceptions = test_exceptions_sr,
5220 .par = (const uint32_t[]){
5221 ICOUNTLEVEL,
5222 XTENSA_OPTION_DEBUG,
5223 0xf,
5224 },
5225 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
5226 }, {
5227 .name = "wsr.intclear",
5228 .translate = translate_wsr_intclear,
5229 .test_exceptions = test_exceptions_sr,
5230 .par = (const uint32_t[]){
5231 INTCLEAR,
5232 XTENSA_OPTION_INTERRUPT,
5233 },
5234 .op_flags =
5235 XTENSA_OP_PRIVILEGED |
5236 XTENSA_OP_EXIT_TB_0 |
5237 XTENSA_OP_CHECK_INTERRUPTS,
5238 }, {
5239 .name = "wsr.intenable",
5240 .translate = translate_wsr,
5241 .test_exceptions = test_exceptions_sr,
5242 .par = (const uint32_t[]){
5243 INTENABLE,
5244 XTENSA_OPTION_INTERRUPT,
5245 },
5246 .op_flags =
5247 XTENSA_OP_PRIVILEGED |
5248 XTENSA_OP_EXIT_TB_0 |
5249 XTENSA_OP_CHECK_INTERRUPTS,
5250 }, {
5251 .name = "wsr.interrupt",
5252 .translate = translate_wsr,
5253 .test_exceptions = test_exceptions_sr,
5254 .par = (const uint32_t[]){
5255 INTSET,
5256 XTENSA_OPTION_INTERRUPT,
5257 },
5258 .op_flags =
5259 XTENSA_OP_PRIVILEGED |
5260 XTENSA_OP_EXIT_TB_0 |
5261 XTENSA_OP_CHECK_INTERRUPTS,
5262 }, {
5263 .name = "wsr.intset",
5264 .translate = translate_wsr_intset,
5265 .test_exceptions = test_exceptions_sr,
5266 .par = (const uint32_t[]){
5267 INTSET,
5268 XTENSA_OPTION_INTERRUPT,
5269 },
5270 .op_flags =
5271 XTENSA_OP_PRIVILEGED |
5272 XTENSA_OP_EXIT_TB_0 |
5273 XTENSA_OP_CHECK_INTERRUPTS,
5274 }, {
5275 .name = "wsr.itlbcfg",
5276 .translate = translate_wsr_mask,
5277 .test_exceptions = test_exceptions_sr,
5278 .par = (const uint32_t[]){
5279 ITLBCFG,
5280 XTENSA_OPTION_MMU,
5281 0x01130000,
5282 },
5283 .op_flags = XTENSA_OP_PRIVILEGED,
5284 }, {
5285 .name = "wsr.lbeg",
5286 .translate = translate_wsr,
5287 .test_exceptions = test_exceptions_sr,
5288 .par = (const uint32_t[]){
5289 LBEG,
5290 XTENSA_OPTION_LOOP,
5291 },
5292 .op_flags = XTENSA_OP_EXIT_TB_M1,
5293 }, {
5294 .name = "wsr.lcount",
5295 .translate = translate_wsr,
5296 .test_exceptions = test_exceptions_sr,
5297 .par = (const uint32_t[]){
5298 LCOUNT,
5299 XTENSA_OPTION_LOOP,
5300 },
5301 }, {
5302 .name = "wsr.lend",
5303 .translate = translate_wsr,
5304 .test_exceptions = test_exceptions_sr,
5305 .par = (const uint32_t[]){
5306 LEND,
5307 XTENSA_OPTION_LOOP,
5308 },
5309 .op_flags = XTENSA_OP_EXIT_TB_M1,
5310 }, {
5311 .name = "wsr.litbase",
5312 .translate = translate_wsr_mask,
5313 .test_exceptions = test_exceptions_sr,
5314 .par = (const uint32_t[]){
5315 LITBASE,
5316 XTENSA_OPTION_EXTENDED_L32R,
5317 0xfffff001,
5318 },
5319 .op_flags = XTENSA_OP_EXIT_TB_M1,
5320 }, {
5321 .name = "wsr.m0",
5322 .translate = translate_wsr,
5323 .test_exceptions = test_exceptions_sr,
5324 .par = (const uint32_t[]){
5325 MR,
5326 XTENSA_OPTION_MAC16,
5327 },
5328 }, {
5329 .name = "wsr.m1",
5330 .translate = translate_wsr,
5331 .test_exceptions = test_exceptions_sr,
5332 .par = (const uint32_t[]){
5333 MR + 1,
5334 XTENSA_OPTION_MAC16,
5335 },
5336 }, {
5337 .name = "wsr.m2",
5338 .translate = translate_wsr,
5339 .test_exceptions = test_exceptions_sr,
5340 .par = (const uint32_t[]){
5341 MR + 2,
5342 XTENSA_OPTION_MAC16,
5343 },
5344 }, {
5345 .name = "wsr.m3",
5346 .translate = translate_wsr,
5347 .test_exceptions = test_exceptions_sr,
5348 .par = (const uint32_t[]){
5349 MR + 3,
5350 XTENSA_OPTION_MAC16,
5351 },
5352 }, {
5353 .name = "wsr.memctl",
5354 .translate = translate_wsr_memctl,
5355 .par = (const uint32_t[]){MEMCTL},
5356 .op_flags = XTENSA_OP_PRIVILEGED,
5357 }, {
5358 .name = "wsr.mecr",
5359 .translate = translate_wsr,
5360 .test_exceptions = test_exceptions_sr,
5361 .par = (const uint32_t[]){
5362 MECR,
5363 XTENSA_OPTION_MEMORY_ECC_PARITY,
5364 },
5365 .op_flags = XTENSA_OP_PRIVILEGED,
5366 }, {
5367 .name = "wsr.mepc",
5368 .translate = translate_wsr,
5369 .test_exceptions = test_exceptions_sr,
5370 .par = (const uint32_t[]){
5371 MEPC,
5372 XTENSA_OPTION_MEMORY_ECC_PARITY,
5373 },
5374 .op_flags = XTENSA_OP_PRIVILEGED,
5375 }, {
5376 .name = "wsr.meps",
5377 .translate = translate_wsr,
5378 .test_exceptions = test_exceptions_sr,
5379 .par = (const uint32_t[]){
5380 MEPS,
5381 XTENSA_OPTION_MEMORY_ECC_PARITY,
5382 },
5383 .op_flags = XTENSA_OP_PRIVILEGED,
5384 }, {
5385 .name = "wsr.mesave",
5386 .translate = translate_wsr,
5387 .test_exceptions = test_exceptions_sr,
5388 .par = (const uint32_t[]){
5389 MESAVE,
5390 XTENSA_OPTION_MEMORY_ECC_PARITY,
5391 },
5392 .op_flags = XTENSA_OP_PRIVILEGED,
5393 }, {
5394 .name = "wsr.mesr",
5395 .translate = translate_wsr,
5396 .test_exceptions = test_exceptions_sr,
5397 .par = (const uint32_t[]){
5398 MESR,
5399 XTENSA_OPTION_MEMORY_ECC_PARITY,
5400 },
5401 .op_flags = XTENSA_OP_PRIVILEGED,
5402 }, {
5403 .name = "wsr.mevaddr",
5404 .translate = translate_wsr,
5405 .test_exceptions = test_exceptions_sr,
5406 .par = (const uint32_t[]){
5407 MESR,
5408 XTENSA_OPTION_MEMORY_ECC_PARITY,
5409 },
5410 .op_flags = XTENSA_OP_PRIVILEGED,
5411 }, {
5412 .name = "wsr.misc0",
5413 .translate = translate_wsr,
5414 .test_exceptions = test_exceptions_sr,
5415 .par = (const uint32_t[]){
5416 MISC,
5417 XTENSA_OPTION_MISC_SR,
5418 },
5419 .op_flags = XTENSA_OP_PRIVILEGED,
5420 }, {
5421 .name = "wsr.misc1",
5422 .translate = translate_wsr,
5423 .test_exceptions = test_exceptions_sr,
5424 .par = (const uint32_t[]){
5425 MISC + 1,
5426 XTENSA_OPTION_MISC_SR,
5427 },
5428 .op_flags = XTENSA_OP_PRIVILEGED,
5429 }, {
5430 .name = "wsr.misc2",
5431 .translate = translate_wsr,
5432 .test_exceptions = test_exceptions_sr,
5433 .par = (const uint32_t[]){
5434 MISC + 2,
5435 XTENSA_OPTION_MISC_SR,
5436 },
5437 .op_flags = XTENSA_OP_PRIVILEGED,
5438 }, {
5439 .name = "wsr.misc3",
5440 .translate = translate_wsr,
5441 .test_exceptions = test_exceptions_sr,
5442 .par = (const uint32_t[]){
5443 MISC + 3,
5444 XTENSA_OPTION_MISC_SR,
5445 },
5446 .op_flags = XTENSA_OP_PRIVILEGED,
5447 }, {
5448 .name = "wsr.mmid",
5449 .translate = translate_wsr,
5450 .test_exceptions = test_exceptions_sr,
5451 .par = (const uint32_t[]){
5452 MMID,
5453 XTENSA_OPTION_TRACE_PORT,
5454 },
5455 .op_flags = XTENSA_OP_PRIVILEGED,
5456 }, {
5457 .name = "wsr.mpuenb",
5458 .translate = translate_wsr_mpuenb,
5459 .test_exceptions = test_exceptions_sr,
5460 .par = (const uint32_t[]){
5461 MPUENB,
5462 XTENSA_OPTION_MPU,
5463 },
5464 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
5465 }, {
5466 .name = "wsr.prefctl",
5467 .translate = translate_wsr,
5468 .par = (const uint32_t[]){PREFCTL},
5469 }, {
5470 .name = "wsr.prid",
5471 .op_flags = XTENSA_OP_ILL,
5472 }, {
5473 .name = "wsr.ps",
5474 .translate = translate_wsr_ps,
5475 .test_exceptions = test_exceptions_sr,
5476 .par = (const uint32_t[]){
5477 PS,
5478 XTENSA_OPTION_EXCEPTION,
5479 },
5480 .op_flags =
5481 XTENSA_OP_PRIVILEGED |
5482 XTENSA_OP_EXIT_TB_M1 |
5483 XTENSA_OP_CHECK_INTERRUPTS,
5484 }, {
5485 .name = "wsr.ptevaddr",
5486 .translate = translate_wsr_mask,
5487 .test_exceptions = test_exceptions_sr,
5488 .par = (const uint32_t[]){
5489 PTEVADDR,
5490 XTENSA_OPTION_MMU,
5491 0xffc00000,
5492 },
5493 .op_flags = XTENSA_OP_PRIVILEGED,
5494 }, {
5495 .name = "wsr.rasid",
5496 .translate = translate_wsr_rasid,
5497 .test_exceptions = test_exceptions_sr,
5498 .par = (const uint32_t[]){
5499 RASID,
5500 XTENSA_OPTION_MMU,
5501 },
5502 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
5503 }, {
5504 .name = "wsr.sar",
5505 .translate = translate_wsr_sar,
5506 .par = (const uint32_t[]){SAR},
5507 }, {
5508 .name = "wsr.scompare1",
5509 .translate = translate_wsr,
5510 .test_exceptions = test_exceptions_sr,
5511 .par = (const uint32_t[]){
5512 SCOMPARE1,
5513 XTENSA_OPTION_CONDITIONAL_STORE,
5514 },
5515 }, {
5516 .name = "wsr.vecbase",
5517 .translate = translate_wsr,
5518 .test_exceptions = test_exceptions_sr,
5519 .par = (const uint32_t[]){
5520 VECBASE,
5521 XTENSA_OPTION_RELOCATABLE_VECTOR,
5522 },
5523 .op_flags = XTENSA_OP_PRIVILEGED,
5524 }, {
5525 .name = "wsr.windowbase",
5526 .translate = translate_wsr_windowbase,
5527 .test_exceptions = test_exceptions_sr,
5528 .par = (const uint32_t[]){
5529 WINDOW_BASE,
5530 XTENSA_OPTION_WINDOWED_REGISTER,
5531 },
5532 .op_flags = XTENSA_OP_PRIVILEGED |
5533 XTENSA_OP_EXIT_TB_M1 |
5534 XTENSA_OP_SYNC_REGISTER_WINDOW,
5535 }, {
5536 .name = "wsr.windowstart",
5537 .translate = translate_wsr_windowstart,
5538 .test_exceptions = test_exceptions_sr,
5539 .par = (const uint32_t[]){
5540 WINDOW_START,
5541 XTENSA_OPTION_WINDOWED_REGISTER,
5542 },
5543 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
5544 }, {
5545 .name = "wur.expstate",
5546 .translate = translate_wur,
5547 .par = (const uint32_t[]){EXPSTATE},
5548 }, {
5549 .name = "wur.threadptr",
5550 .translate = translate_wur,
5551 .par = (const uint32_t[]){THREADPTR},
5552 }, {
5553 .name = "xor",
5554 .translate = translate_xor,
5555 }, {
5556 .name = "xorb",
5557 .translate = translate_boolean,
5558 .par = (const uint32_t[]){BOOLEAN_XOR},
5559 }, {
5560 .name = "xsr.176",
5561 .op_flags = XTENSA_OP_ILL,
5562 }, {
5563 .name = "xsr.208",
5564 .op_flags = XTENSA_OP_ILL,
5565 }, {
5566 .name = "xsr.acchi",
5567 .translate = translate_xsr_acchi,
5568 .test_exceptions = test_exceptions_sr,
5569 .par = (const uint32_t[]){
5570 ACCHI,
5571 XTENSA_OPTION_MAC16,
5572 },
5573 }, {
5574 .name = "xsr.acclo",
5575 .translate = translate_xsr,
5576 .test_exceptions = test_exceptions_sr,
5577 .par = (const uint32_t[]){
5578 ACCLO,
5579 XTENSA_OPTION_MAC16,
5580 },
5581 }, {
5582 .name = "xsr.atomctl",
5583 .translate = translate_xsr_mask,
5584 .test_exceptions = test_exceptions_sr,
5585 .par = (const uint32_t[]){
5586 ATOMCTL,
5587 XTENSA_OPTION_ATOMCTL,
5588 0x3f,
5589 },
5590 .op_flags = XTENSA_OP_PRIVILEGED,
5591 }, {
5592 .name = "xsr.br",
5593 .translate = translate_xsr_mask,
5594 .test_exceptions = test_exceptions_sr,
5595 .par = (const uint32_t[]){
5596 BR,
5597 XTENSA_OPTION_BOOLEAN,
5598 0xffff,
5599 },
5600 }, {
5601 .name = "xsr.cacheadrdis",
5602 .translate = translate_xsr_mask,
5603 .test_exceptions = test_exceptions_sr,
5604 .par = (const uint32_t[]){
5605 CACHEADRDIS,
5606 XTENSA_OPTION_MPU,
5607 0xff,
5608 },
5609 .op_flags = XTENSA_OP_PRIVILEGED,
5610 }, {
5611 .name = "xsr.cacheattr",
5612 .translate = translate_xsr,
5613 .test_exceptions = test_exceptions_sr,
5614 .par = (const uint32_t[]){
5615 CACHEATTR,
5616 XTENSA_OPTION_CACHEATTR,
5617 },
5618 .op_flags = XTENSA_OP_PRIVILEGED,
5619 }, {
5620 .name = "xsr.ccompare0",
5621 .translate = translate_xsr_ccompare,
5622 .test_exceptions = test_exceptions_ccompare,
5623 .par = (const uint32_t[]){
5624 CCOMPARE,
5625 XTENSA_OPTION_TIMER_INTERRUPT,
5626 },
5627 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5628 }, {
5629 .name = "xsr.ccompare1",
5630 .translate = translate_xsr_ccompare,
5631 .test_exceptions = test_exceptions_ccompare,
5632 .par = (const uint32_t[]){
5633 CCOMPARE + 1,
5634 XTENSA_OPTION_TIMER_INTERRUPT,
5635 },
5636 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5637 }, {
5638 .name = "xsr.ccompare2",
5639 .translate = translate_xsr_ccompare,
5640 .test_exceptions = test_exceptions_ccompare,
5641 .par = (const uint32_t[]){
5642 CCOMPARE + 2,
5643 XTENSA_OPTION_TIMER_INTERRUPT,
5644 },
5645 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5646 }, {
5647 .name = "xsr.ccount",
5648 .translate = translate_xsr_ccount,
5649 .test_exceptions = test_exceptions_sr,
5650 .par = (const uint32_t[]){
5651 CCOUNT,
5652 XTENSA_OPTION_TIMER_INTERRUPT,
5653 },
5654 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5655 }, {
5656 .name = "xsr.configid0",
5657 .op_flags = XTENSA_OP_ILL,
5658 }, {
5659 .name = "xsr.configid1",
5660 .op_flags = XTENSA_OP_ILL,
5661 }, {
5662 .name = "xsr.cpenable",
5663 .translate = translate_xsr_mask,
5664 .test_exceptions = test_exceptions_sr,
5665 .par = (const uint32_t[]){
5666 CPENABLE,
5667 XTENSA_OPTION_COPROCESSOR,
5668 0xff,
5669 },
5670 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
5671 }, {
5672 .name = "xsr.dbreaka0",
5673 .translate = translate_xsr_dbreaka,
5674 .test_exceptions = test_exceptions_dbreak,
5675 .par = (const uint32_t[]){
5676 DBREAKA,
5677 XTENSA_OPTION_DEBUG,
5678 },
5679 .op_flags = XTENSA_OP_PRIVILEGED,
5680 }, {
5681 .name = "xsr.dbreaka1",
5682 .translate = translate_xsr_dbreaka,
5683 .test_exceptions = test_exceptions_dbreak,
5684 .par = (const uint32_t[]){
5685 DBREAKA + 1,
5686 XTENSA_OPTION_DEBUG,
5687 },
5688 .op_flags = XTENSA_OP_PRIVILEGED,
5689 }, {
5690 .name = "xsr.dbreakc0",
5691 .translate = translate_xsr_dbreakc,
5692 .test_exceptions = test_exceptions_dbreak,
5693 .par = (const uint32_t[]){
5694 DBREAKC,
5695 XTENSA_OPTION_DEBUG,
5696 },
5697 .op_flags = XTENSA_OP_PRIVILEGED,
5698 }, {
5699 .name = "xsr.dbreakc1",
5700 .translate = translate_xsr_dbreakc,
5701 .test_exceptions = test_exceptions_dbreak,
5702 .par = (const uint32_t[]){
5703 DBREAKC + 1,
5704 XTENSA_OPTION_DEBUG,
5705 },
5706 .op_flags = XTENSA_OP_PRIVILEGED,
5707 }, {
5708 .name = "xsr.ddr",
5709 .translate = translate_xsr,
5710 .test_exceptions = test_exceptions_sr,
5711 .par = (const uint32_t[]){
5712 DDR,
5713 XTENSA_OPTION_DEBUG,
5714 },
5715 .op_flags = XTENSA_OP_PRIVILEGED,
5716 }, {
5717 .name = "xsr.debugcause",
5718 .op_flags = XTENSA_OP_ILL,
5719 }, {
5720 .name = "xsr.depc",
5721 .translate = translate_xsr,
5722 .test_exceptions = test_exceptions_sr,
5723 .par = (const uint32_t[]){
5724 DEPC,
5725 XTENSA_OPTION_EXCEPTION,
5726 },
5727 .op_flags = XTENSA_OP_PRIVILEGED,
5728 }, {
5729 .name = "xsr.dtlbcfg",
5730 .translate = translate_xsr_mask,
5731 .test_exceptions = test_exceptions_sr,
5732 .par = (const uint32_t[]){
5733 DTLBCFG,
5734 XTENSA_OPTION_MMU,
5735 0x01130000,
5736 },
5737 .op_flags = XTENSA_OP_PRIVILEGED,
5738 }, {
5739 .name = "xsr.epc1",
5740 .translate = translate_xsr,
5741 .test_exceptions = test_exceptions_sr,
5742 .par = (const uint32_t[]){
5743 EPC1,
5744 XTENSA_OPTION_EXCEPTION,
5745 },
5746 .op_flags = XTENSA_OP_PRIVILEGED,
5747 }, {
5748 .name = "xsr.epc2",
5749 .translate = translate_xsr,
5750 .test_exceptions = test_exceptions_hpi,
5751 .par = (const uint32_t[]){
5752 EPC1 + 1,
5753 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5754 },
5755 .op_flags = XTENSA_OP_PRIVILEGED,
5756 }, {
5757 .name = "xsr.epc3",
5758 .translate = translate_xsr,
5759 .test_exceptions = test_exceptions_hpi,
5760 .par = (const uint32_t[]){
5761 EPC1 + 2,
5762 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5763 },
5764 .op_flags = XTENSA_OP_PRIVILEGED,
5765 }, {
5766 .name = "xsr.epc4",
5767 .translate = translate_xsr,
5768 .test_exceptions = test_exceptions_hpi,
5769 .par = (const uint32_t[]){
5770 EPC1 + 3,
5771 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5772 },
5773 .op_flags = XTENSA_OP_PRIVILEGED,
5774 }, {
5775 .name = "xsr.epc5",
5776 .translate = translate_xsr,
5777 .test_exceptions = test_exceptions_hpi,
5778 .par = (const uint32_t[]){
5779 EPC1 + 4,
5780 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5781 },
5782 .op_flags = XTENSA_OP_PRIVILEGED,
5783 }, {
5784 .name = "xsr.epc6",
5785 .translate = translate_xsr,
5786 .test_exceptions = test_exceptions_hpi,
5787 .par = (const uint32_t[]){
5788 EPC1 + 5,
5789 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5790 },
5791 .op_flags = XTENSA_OP_PRIVILEGED,
5792 }, {
5793 .name = "xsr.epc7",
5794 .translate = translate_xsr,
5795 .test_exceptions = test_exceptions_hpi,
5796 .par = (const uint32_t[]){
5797 EPC1 + 6,
5798 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5799 },
5800 .op_flags = XTENSA_OP_PRIVILEGED,
5801 }, {
5802 .name = "xsr.eps2",
5803 .translate = translate_xsr,
5804 .test_exceptions = test_exceptions_hpi,
5805 .par = (const uint32_t[]){
5806 EPS2,
5807 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5808 },
5809 .op_flags = XTENSA_OP_PRIVILEGED,
5810 }, {
5811 .name = "xsr.eps3",
5812 .translate = translate_xsr,
5813 .test_exceptions = test_exceptions_hpi,
5814 .par = (const uint32_t[]){
5815 EPS2 + 1,
5816 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5817 },
5818 .op_flags = XTENSA_OP_PRIVILEGED,
5819 }, {
5820 .name = "xsr.eps4",
5821 .translate = translate_xsr,
5822 .test_exceptions = test_exceptions_hpi,
5823 .par = (const uint32_t[]){
5824 EPS2 + 2,
5825 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5826 },
5827 .op_flags = XTENSA_OP_PRIVILEGED,
5828 }, {
5829 .name = "xsr.eps5",
5830 .translate = translate_xsr,
5831 .test_exceptions = test_exceptions_hpi,
5832 .par = (const uint32_t[]){
5833 EPS2 + 3,
5834 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5835 },
5836 .op_flags = XTENSA_OP_PRIVILEGED,
5837 }, {
5838 .name = "xsr.eps6",
5839 .translate = translate_xsr,
5840 .test_exceptions = test_exceptions_hpi,
5841 .par = (const uint32_t[]){
5842 EPS2 + 4,
5843 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5844 },
5845 .op_flags = XTENSA_OP_PRIVILEGED,
5846 }, {
5847 .name = "xsr.eps7",
5848 .translate = translate_xsr,
5849 .test_exceptions = test_exceptions_hpi,
5850 .par = (const uint32_t[]){
5851 EPS2 + 5,
5852 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5853 },
5854 .op_flags = XTENSA_OP_PRIVILEGED,
5855 }, {
5856 .name = "xsr.eraccess",
5857 .translate = translate_xsr_mask,
5858 .par = (const uint32_t[]){
5859 ERACCESS,
5860 0,
5861 0xffff,
5862 },
5863 .op_flags = XTENSA_OP_PRIVILEGED,
5864 }, {
5865 .name = "xsr.exccause",
5866 .translate = translate_xsr,
5867 .test_exceptions = test_exceptions_sr,
5868 .par = (const uint32_t[]){
5869 EXCCAUSE,
5870 XTENSA_OPTION_EXCEPTION,
5871 },
5872 .op_flags = XTENSA_OP_PRIVILEGED,
5873 }, {
5874 .name = "xsr.excsave1",
5875 .translate = translate_xsr,
5876 .test_exceptions = test_exceptions_sr,
5877 .par = (const uint32_t[]){
5878 EXCSAVE1,
5879 XTENSA_OPTION_EXCEPTION,
5880 },
5881 .op_flags = XTENSA_OP_PRIVILEGED,
5882 }, {
5883 .name = "xsr.excsave2",
5884 .translate = translate_xsr,
5885 .test_exceptions = test_exceptions_hpi,
5886 .par = (const uint32_t[]){
5887 EXCSAVE1 + 1,
5888 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5889 },
5890 .op_flags = XTENSA_OP_PRIVILEGED,
5891 }, {
5892 .name = "xsr.excsave3",
5893 .translate = translate_xsr,
5894 .test_exceptions = test_exceptions_hpi,
5895 .par = (const uint32_t[]){
5896 EXCSAVE1 + 2,
5897 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5898 },
5899 .op_flags = XTENSA_OP_PRIVILEGED,
5900 }, {
5901 .name = "xsr.excsave4",
5902 .translate = translate_xsr,
5903 .test_exceptions = test_exceptions_hpi,
5904 .par = (const uint32_t[]){
5905 EXCSAVE1 + 3,
5906 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5907 },
5908 .op_flags = XTENSA_OP_PRIVILEGED,
5909 }, {
5910 .name = "xsr.excsave5",
5911 .translate = translate_xsr,
5912 .test_exceptions = test_exceptions_hpi,
5913 .par = (const uint32_t[]){
5914 EXCSAVE1 + 4,
5915 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5916 },
5917 .op_flags = XTENSA_OP_PRIVILEGED,
5918 }, {
5919 .name = "xsr.excsave6",
5920 .translate = translate_xsr,
5921 .test_exceptions = test_exceptions_hpi,
5922 .par = (const uint32_t[]){
5923 EXCSAVE1 + 5,
5924 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5925 },
5926 .op_flags = XTENSA_OP_PRIVILEGED,
5927 }, {
5928 .name = "xsr.excsave7",
5929 .translate = translate_xsr,
5930 .test_exceptions = test_exceptions_hpi,
5931 .par = (const uint32_t[]){
5932 EXCSAVE1 + 6,
5933 XTENSA_OPTION_HIGH_PRIORITY_INTERRUPT,
5934 },
5935 .op_flags = XTENSA_OP_PRIVILEGED,
5936 }, {
5937 .name = "xsr.excvaddr",
5938 .translate = translate_xsr,
5939 .test_exceptions = test_exceptions_sr,
5940 .par = (const uint32_t[]){
5941 EXCVADDR,
5942 XTENSA_OPTION_EXCEPTION,
5943 },
5944 .op_flags = XTENSA_OP_PRIVILEGED,
5945 }, {
5946 .name = "xsr.ibreaka0",
5947 .translate = translate_xsr_ibreaka,
5948 .test_exceptions = test_exceptions_ibreak,
5949 .par = (const uint32_t[]){
5950 IBREAKA,
5951 XTENSA_OPTION_DEBUG,
5952 },
5953 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5954 }, {
5955 .name = "xsr.ibreaka1",
5956 .translate = translate_xsr_ibreaka,
5957 .test_exceptions = test_exceptions_ibreak,
5958 .par = (const uint32_t[]){
5959 IBREAKA + 1,
5960 XTENSA_OPTION_DEBUG,
5961 },
5962 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5963 }, {
5964 .name = "xsr.ibreakenable",
5965 .translate = translate_xsr_ibreakenable,
5966 .test_exceptions = test_exceptions_sr,
5967 .par = (const uint32_t[]){
5968 IBREAKENABLE,
5969 XTENSA_OPTION_DEBUG,
5970 },
5971 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_0,
5972 }, {
5973 .name = "xsr.icount",
5974 .translate = translate_xsr_icount,
5975 .test_exceptions = test_exceptions_sr,
5976 .par = (const uint32_t[]){
5977 ICOUNT,
5978 XTENSA_OPTION_DEBUG,
5979 },
5980 .op_flags = XTENSA_OP_PRIVILEGED,
5981 }, {
5982 .name = "xsr.icountlevel",
5983 .translate = translate_xsr_mask,
5984 .test_exceptions = test_exceptions_sr,
5985 .par = (const uint32_t[]){
5986 ICOUNTLEVEL,
5987 XTENSA_OPTION_DEBUG,
5988 0xf,
5989 },
5990 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
5991 }, {
5992 .name = "xsr.intclear",
5993 .op_flags = XTENSA_OP_ILL,
5994 }, {
5995 .name = "xsr.intenable",
5996 .translate = translate_xsr,
5997 .test_exceptions = test_exceptions_sr,
5998 .par = (const uint32_t[]){
5999 INTENABLE,
6000 XTENSA_OPTION_INTERRUPT,
6001 },
6002 .op_flags =
6003 XTENSA_OP_PRIVILEGED |
6004 XTENSA_OP_EXIT_TB_0 |
6005 XTENSA_OP_CHECK_INTERRUPTS,
6006 }, {
6007 .name = "xsr.interrupt",
6008 .op_flags = XTENSA_OP_ILL,
6009 }, {
6010 .name = "xsr.intset",
6011 .op_flags = XTENSA_OP_ILL,
6012 }, {
6013 .name = "xsr.itlbcfg",
6014 .translate = translate_xsr_mask,
6015 .test_exceptions = test_exceptions_sr,
6016 .par = (const uint32_t[]){
6017 ITLBCFG,
6018 XTENSA_OPTION_MMU,
6019 0x01130000,
6020 },
6021 .op_flags = XTENSA_OP_PRIVILEGED,
6022 }, {
6023 .name = "xsr.lbeg",
6024 .translate = translate_xsr,
6025 .test_exceptions = test_exceptions_sr,
6026 .par = (const uint32_t[]){
6027 LBEG,
6028 XTENSA_OPTION_LOOP,
6029 },
6030 .op_flags = XTENSA_OP_EXIT_TB_M1,
6031 }, {
6032 .name = "xsr.lcount",
6033 .translate = translate_xsr,
6034 .test_exceptions = test_exceptions_sr,
6035 .par = (const uint32_t[]){
6036 LCOUNT,
6037 XTENSA_OPTION_LOOP,
6038 },
6039 }, {
6040 .name = "xsr.lend",
6041 .translate = translate_xsr,
6042 .test_exceptions = test_exceptions_sr,
6043 .par = (const uint32_t[]){
6044 LEND,
6045 XTENSA_OPTION_LOOP,
6046 },
6047 .op_flags = XTENSA_OP_EXIT_TB_M1,
6048 }, {
6049 .name = "xsr.litbase",
6050 .translate = translate_xsr_mask,
6051 .test_exceptions = test_exceptions_sr,
6052 .par = (const uint32_t[]){
6053 LITBASE,
6054 XTENSA_OPTION_EXTENDED_L32R,
6055 0xfffff001,
6056 },
6057 .op_flags = XTENSA_OP_EXIT_TB_M1,
6058 }, {
6059 .name = "xsr.m0",
6060 .translate = translate_xsr,
6061 .test_exceptions = test_exceptions_sr,
6062 .par = (const uint32_t[]){
6063 MR,
6064 XTENSA_OPTION_MAC16,
6065 },
6066 }, {
6067 .name = "xsr.m1",
6068 .translate = translate_xsr,
6069 .test_exceptions = test_exceptions_sr,
6070 .par = (const uint32_t[]){
6071 MR + 1,
6072 XTENSA_OPTION_MAC16,
6073 },
6074 }, {
6075 .name = "xsr.m2",
6076 .translate = translate_xsr,
6077 .test_exceptions = test_exceptions_sr,
6078 .par = (const uint32_t[]){
6079 MR + 2,
6080 XTENSA_OPTION_MAC16,
6081 },
6082 }, {
6083 .name = "xsr.m3",
6084 .translate = translate_xsr,
6085 .test_exceptions = test_exceptions_sr,
6086 .par = (const uint32_t[]){
6087 MR + 3,
6088 XTENSA_OPTION_MAC16,
6089 },
6090 }, {
6091 .name = "xsr.memctl",
6092 .translate = translate_xsr_memctl,
6093 .par = (const uint32_t[]){MEMCTL},
6094 .op_flags = XTENSA_OP_PRIVILEGED,
6095 }, {
6096 .name = "xsr.mecr",
6097 .translate = translate_xsr,
6098 .test_exceptions = test_exceptions_sr,
6099 .par = (const uint32_t[]){
6100 MECR,
6101 XTENSA_OPTION_MEMORY_ECC_PARITY,
6102 },
6103 .op_flags = XTENSA_OP_PRIVILEGED,
6104 }, {
6105 .name = "xsr.mepc",
6106 .translate = translate_xsr,
6107 .test_exceptions = test_exceptions_sr,
6108 .par = (const uint32_t[]){
6109 MEPC,
6110 XTENSA_OPTION_MEMORY_ECC_PARITY,
6111 },
6112 .op_flags = XTENSA_OP_PRIVILEGED,
6113 }, {
6114 .name = "xsr.meps",
6115 .translate = translate_xsr,
6116 .test_exceptions = test_exceptions_sr,
6117 .par = (const uint32_t[]){
6118 MEPS,
6119 XTENSA_OPTION_MEMORY_ECC_PARITY,
6120 },
6121 .op_flags = XTENSA_OP_PRIVILEGED,
6122 }, {
6123 .name = "xsr.mesave",
6124 .translate = translate_xsr,
6125 .test_exceptions = test_exceptions_sr,
6126 .par = (const uint32_t[]){
6127 MESAVE,
6128 XTENSA_OPTION_MEMORY_ECC_PARITY,
6129 },
6130 .op_flags = XTENSA_OP_PRIVILEGED,
6131 }, {
6132 .name = "xsr.mesr",
6133 .translate = translate_xsr,
6134 .test_exceptions = test_exceptions_sr,
6135 .par = (const uint32_t[]){
6136 MESR,
6137 XTENSA_OPTION_MEMORY_ECC_PARITY,
6138 },
6139 .op_flags = XTENSA_OP_PRIVILEGED,
6140 }, {
6141 .name = "xsr.mevaddr",
6142 .translate = translate_xsr,
6143 .test_exceptions = test_exceptions_sr,
6144 .par = (const uint32_t[]){
6145 MESR,
6146 XTENSA_OPTION_MEMORY_ECC_PARITY,
6147 },
6148 .op_flags = XTENSA_OP_PRIVILEGED,
6149 }, {
6150 .name = "xsr.misc0",
6151 .translate = translate_xsr,
6152 .test_exceptions = test_exceptions_sr,
6153 .par = (const uint32_t[]){
6154 MISC,
6155 XTENSA_OPTION_MISC_SR,
6156 },
6157 .op_flags = XTENSA_OP_PRIVILEGED,
6158 }, {
6159 .name = "xsr.misc1",
6160 .translate = translate_xsr,
6161 .test_exceptions = test_exceptions_sr,
6162 .par = (const uint32_t[]){
6163 MISC + 1,
6164 XTENSA_OPTION_MISC_SR,
6165 },
6166 .op_flags = XTENSA_OP_PRIVILEGED,
6167 }, {
6168 .name = "xsr.misc2",
6169 .translate = translate_xsr,
6170 .test_exceptions = test_exceptions_sr,
6171 .par = (const uint32_t[]){
6172 MISC + 2,
6173 XTENSA_OPTION_MISC_SR,
6174 },
6175 .op_flags = XTENSA_OP_PRIVILEGED,
6176 }, {
6177 .name = "xsr.misc3",
6178 .translate = translate_xsr,
6179 .test_exceptions = test_exceptions_sr,
6180 .par = (const uint32_t[]){
6181 MISC + 3,
6182 XTENSA_OPTION_MISC_SR,
6183 },
6184 .op_flags = XTENSA_OP_PRIVILEGED,
6185 }, {
6186 .name = "xsr.mpuenb",
6187 .translate = translate_xsr_mpuenb,
6188 .test_exceptions = test_exceptions_sr,
6189 .par = (const uint32_t[]){
6190 MPUENB,
6191 XTENSA_OPTION_MPU,
6192 },
6193 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
6194 }, {
6195 .name = "xsr.prefctl",
6196 .translate = translate_xsr,
6197 .par = (const uint32_t[]){PREFCTL},
6198 }, {
6199 .name = "xsr.prid",
6200 .op_flags = XTENSA_OP_ILL,
6201 }, {
6202 .name = "xsr.ps",
6203 .translate = translate_xsr_ps,
6204 .test_exceptions = test_exceptions_sr,
6205 .par = (const uint32_t[]){
6206 PS,
6207 XTENSA_OPTION_EXCEPTION,
6208 },
6209 .op_flags =
6210 XTENSA_OP_PRIVILEGED |
6211 XTENSA_OP_EXIT_TB_M1 |
6212 XTENSA_OP_CHECK_INTERRUPTS,
6213 }, {
6214 .name = "xsr.ptevaddr",
6215 .translate = translate_xsr_mask,
6216 .test_exceptions = test_exceptions_sr,
6217 .par = (const uint32_t[]){
6218 PTEVADDR,
6219 XTENSA_OPTION_MMU,
6220 0xffc00000,
6221 },
6222 .op_flags = XTENSA_OP_PRIVILEGED,
6223 }, {
6224 .name = "xsr.rasid",
6225 .translate = translate_xsr_rasid,
6226 .test_exceptions = test_exceptions_sr,
6227 .par = (const uint32_t[]){
6228 RASID,
6229 XTENSA_OPTION_MMU,
6230 },
6231 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
6232 }, {
6233 .name = "xsr.sar",
6234 .translate = translate_xsr_sar,
6235 .par = (const uint32_t[]){SAR},
6236 }, {
6237 .name = "xsr.scompare1",
6238 .translate = translate_xsr,
6239 .test_exceptions = test_exceptions_sr,
6240 .par = (const uint32_t[]){
6241 SCOMPARE1,
6242 XTENSA_OPTION_CONDITIONAL_STORE,
6243 },
6244 }, {
6245 .name = "xsr.vecbase",
6246 .translate = translate_xsr,
6247 .test_exceptions = test_exceptions_sr,
6248 .par = (const uint32_t[]){
6249 VECBASE,
6250 XTENSA_OPTION_RELOCATABLE_VECTOR,
6251 },
6252 .op_flags = XTENSA_OP_PRIVILEGED,
6253 }, {
6254 .name = "xsr.windowbase",
6255 .translate = translate_xsr_windowbase,
6256 .test_exceptions = test_exceptions_sr,
6257 .par = (const uint32_t[]){
6258 WINDOW_BASE,
6259 XTENSA_OPTION_WINDOWED_REGISTER,
6260 },
6261 .op_flags = XTENSA_OP_PRIVILEGED |
6262 XTENSA_OP_EXIT_TB_M1 |
6263 XTENSA_OP_SYNC_REGISTER_WINDOW,
6264 }, {
6265 .name = "xsr.windowstart",
6266 .translate = translate_xsr_windowstart,
6267 .test_exceptions = test_exceptions_sr,
6268 .par = (const uint32_t[]){
6269 WINDOW_START,
6270 XTENSA_OPTION_WINDOWED_REGISTER,
6271 },
6272 .op_flags = XTENSA_OP_PRIVILEGED | XTENSA_OP_EXIT_TB_M1,
6273 },
6274 };
6275
6276 const XtensaOpcodeTranslators xtensa_core_opcodes = {
6277 .num_opcodes = ARRAY_SIZE(core_ops),
6278 .opcode = core_ops,
6279 };
6280
6281
6282 static inline void get_f32_o1_i3(const OpcodeArg *arg, OpcodeArg *arg32,
6283 int o0, int i0, int i1, int i2)
6284 {
6285 if ((i0 >= 0 && arg[i0].num_bits == 64) ||
6286 (o0 >= 0 && arg[o0].num_bits == 64)) {
6287 if (o0 >= 0) {
6288 arg32[o0].out = tcg_temp_new_i32();
6289 }
6290 if (i0 >= 0) {
6291 arg32[i0].in = tcg_temp_new_i32();
6292 tcg_gen_extrl_i64_i32(arg32[i0].in, arg[i0].in);
6293 }
6294 if (i1 >= 0) {
6295 arg32[i1].in = tcg_temp_new_i32();
6296 tcg_gen_extrl_i64_i32(arg32[i1].in, arg[i1].in);
6297 }
6298 if (i2 >= 0) {
6299 arg32[i2].in = tcg_temp_new_i32();
6300 tcg_gen_extrl_i64_i32(arg32[i2].in, arg[i2].in);
6301 }
6302 } else {
6303 if (o0 >= 0) {
6304 arg32[o0].out = arg[o0].out;
6305 }
6306 if (i0 >= 0) {
6307 arg32[i0].in = arg[i0].in;
6308 }
6309 if (i1 >= 0) {
6310 arg32[i1].in = arg[i1].in;
6311 }
6312 if (i2 >= 0) {
6313 arg32[i2].in = arg[i2].in;
6314 }
6315 }
6316 }
6317
6318 static inline void put_f32_o1_i3(const OpcodeArg *arg, const OpcodeArg *arg32,
6319 int o0, int i0, int i1, int i2)
6320 {
6321 if ((i0 >= 0 && arg[i0].num_bits == 64) ||
6322 (o0 >= 0 && arg[o0].num_bits == 64)) {
6323 if (o0 >= 0) {
6324 tcg_gen_extu_i32_i64(arg[o0].out, arg32[o0].out);
6325 tcg_temp_free_i32(arg32[o0].out);
6326 }
6327 if (i0 >= 0) {
6328 tcg_temp_free_i32(arg32[i0].in);
6329 }
6330 if (i1 >= 0) {
6331 tcg_temp_free_i32(arg32[i1].in);
6332 }
6333 if (i2 >= 0) {
6334 tcg_temp_free_i32(arg32[i2].in);
6335 }
6336 }
6337 }
6338
6339 static inline void get_f32_o1_i2(const OpcodeArg *arg, OpcodeArg *arg32,
6340 int o0, int i0, int i1)
6341 {
6342 get_f32_o1_i3(arg, arg32, o0, i0, i1, -1);
6343 }
6344
6345 static inline void put_f32_o1_i2(const OpcodeArg *arg, const OpcodeArg *arg32,
6346 int o0, int i0, int i1)
6347 {
6348 put_f32_o1_i3(arg, arg32, o0, i0, i1, -1);
6349 }
6350
6351 static inline void get_f32_o1_i1(const OpcodeArg *arg, OpcodeArg *arg32,
6352 int o0, int i0)
6353 {
6354 get_f32_o1_i2(arg, arg32, o0, i0, -1);
6355 }
6356
6357 static inline void put_f32_o1_i1(const OpcodeArg *arg, const OpcodeArg *arg32,
6358 int o0, int i0)
6359 {
6360 put_f32_o1_i2(arg, arg32, o0, i0, -1);
6361 }
6362
6363 static inline void get_f32_o1(const OpcodeArg *arg, OpcodeArg *arg32,
6364 int o0)
6365 {
6366 get_f32_o1_i1(arg, arg32, o0, -1);
6367 }
6368
6369 static inline void put_f32_o1(const OpcodeArg *arg, const OpcodeArg *arg32,
6370 int o0)
6371 {
6372 put_f32_o1_i1(arg, arg32, o0, -1);
6373 }
6374
6375 static inline void get_f32_i2(const OpcodeArg *arg, OpcodeArg *arg32,
6376 int i0, int i1)
6377 {
6378 get_f32_o1_i2(arg, arg32, -1, i0, i1);
6379 }
6380
6381 static inline void put_f32_i2(const OpcodeArg *arg, const OpcodeArg *arg32,
6382 int i0, int i1)
6383 {
6384 put_f32_o1_i2(arg, arg32, -1, i0, i1);
6385 }
6386
6387 static inline void get_f32_i1(const OpcodeArg *arg, OpcodeArg *arg32,
6388 int i0)
6389 {
6390 get_f32_i2(arg, arg32, i0, -1);
6391 }
6392
6393 static inline void put_f32_i1(const OpcodeArg *arg, const OpcodeArg *arg32,
6394 int i0)
6395 {
6396 put_f32_i2(arg, arg32, i0, -1);
6397 }
6398
6399
6400 static void translate_abs_d(DisasContext *dc, const OpcodeArg arg[],
6401 const uint32_t par[])
6402 {
6403 gen_helper_abs_d(arg[0].out, arg[1].in);
6404 }
6405
6406 static void translate_abs_s(DisasContext *dc, const OpcodeArg arg[],
6407 const uint32_t par[])
6408 {
6409 OpcodeArg arg32[2];
6410
6411 get_f32_o1_i1(arg, arg32, 0, 1);
6412 gen_helper_abs_s(arg32[0].out, arg32[1].in);
6413 put_f32_o1_i1(arg, arg32, 0, 1);
6414 }
6415
6416 static void translate_fpu2k_add_s(DisasContext *dc, const OpcodeArg arg[],
6417 const uint32_t par[])
6418 {
6419 gen_helper_fpu2k_add_s(arg[0].out, cpu_env,
6420 arg[1].in, arg[2].in);
6421 }
6422
6423 enum {
6424 COMPARE_UN,
6425 COMPARE_OEQ,
6426 COMPARE_UEQ,
6427 COMPARE_OLT,
6428 COMPARE_ULT,
6429 COMPARE_OLE,
6430 COMPARE_ULE,
6431 };
6432
6433 static void translate_compare_d(DisasContext *dc, const OpcodeArg arg[],
6434 const uint32_t par[])
6435 {
6436 static void (* const helper[])(TCGv_i32 res, TCGv_env env,
6437 TCGv_i64 s, TCGv_i64 t) = {
6438 [COMPARE_UN] = gen_helper_un_d,
6439 [COMPARE_OEQ] = gen_helper_oeq_d,
6440 [COMPARE_UEQ] = gen_helper_ueq_d,
6441 [COMPARE_OLT] = gen_helper_olt_d,
6442 [COMPARE_ULT] = gen_helper_ult_d,
6443 [COMPARE_OLE] = gen_helper_ole_d,
6444 [COMPARE_ULE] = gen_helper_ule_d,
6445 };
6446 TCGv_i32 zero = tcg_const_i32(0);
6447 TCGv_i32 res = tcg_temp_new_i32();
6448 TCGv_i32 set_br = tcg_temp_new_i32();
6449 TCGv_i32 clr_br = tcg_temp_new_i32();
6450
6451 tcg_gen_ori_i32(set_br, arg[0].in, 1 << arg[0].imm);
6452 tcg_gen_andi_i32(clr_br, arg[0].in, ~(1 << arg[0].imm));
6453
6454 helper[par[0]](res, cpu_env, arg[1].in, arg[2].in);
6455 tcg_gen_movcond_i32(TCG_COND_NE,
6456 arg[0].out, res, zero,
6457 set_br, clr_br);
6458 tcg_temp_free(zero);
6459 tcg_temp_free(res);
6460 tcg_temp_free(set_br);
6461 tcg_temp_free(clr_br);
6462 }
6463
6464 static void translate_compare_s(DisasContext *dc, const OpcodeArg arg[],
6465 const uint32_t par[])
6466 {
6467 static void (* const helper[])(TCGv_i32 res, TCGv_env env,
6468 TCGv_i32 s, TCGv_i32 t) = {
6469 [COMPARE_UN] = gen_helper_un_s,
6470 [COMPARE_OEQ] = gen_helper_oeq_s,
6471 [COMPARE_UEQ] = gen_helper_ueq_s,
6472 [COMPARE_OLT] = gen_helper_olt_s,
6473 [COMPARE_ULT] = gen_helper_ult_s,
6474 [COMPARE_OLE] = gen_helper_ole_s,
6475 [COMPARE_ULE] = gen_helper_ule_s,
6476 };
6477 OpcodeArg arg32[3];
6478 TCGv_i32 zero = tcg_const_i32(0);
6479 TCGv_i32 res = tcg_temp_new_i32();
6480 TCGv_i32 set_br = tcg_temp_new_i32();
6481 TCGv_i32 clr_br = tcg_temp_new_i32();
6482
6483 tcg_gen_ori_i32(set_br, arg[0].in, 1 << arg[0].imm);
6484 tcg_gen_andi_i32(clr_br, arg[0].in, ~(1 << arg[0].imm));
6485
6486 get_f32_i2(arg, arg32, 1, 2);
6487 helper[par[0]](res, cpu_env, arg32[1].in, arg32[2].in);
6488 tcg_gen_movcond_i32(TCG_COND_NE,
6489 arg[0].out, res, zero,
6490 set_br, clr_br);
6491 put_f32_i2(arg, arg32, 1, 2);
6492 tcg_temp_free(zero);
6493 tcg_temp_free(res);
6494 tcg_temp_free(set_br);
6495 tcg_temp_free(clr_br);
6496 }
6497
6498 static void translate_const_d(DisasContext *dc, const OpcodeArg arg[],
6499 const uint32_t par[])
6500 {
6501 static const uint64_t v[] = {
6502 UINT64_C(0x0000000000000000),
6503 UINT64_C(0x3ff0000000000000),
6504 UINT64_C(0x4000000000000000),
6505 UINT64_C(0x3fe0000000000000),
6506 };
6507
6508 tcg_gen_movi_i64(arg[0].out, v[arg[1].imm % ARRAY_SIZE(v)]);
6509 if (arg[1].imm >= ARRAY_SIZE(v)) {
6510 qemu_log_mask(LOG_GUEST_ERROR,
6511 "const.d f%d, #%d, immediate value is reserved\n",
6512 arg[0].imm, arg[1].imm);
6513 }
6514 }
6515
6516 static void translate_const_s(DisasContext *dc, const OpcodeArg arg[],
6517 const uint32_t par[])
6518 {
6519 static const uint32_t v[] = {
6520 0x00000000,
6521 0x3f800000,
6522 0x40000000,
6523 0x3f000000,
6524 };
6525
6526 if (arg[0].num_bits == 32) {
6527 tcg_gen_movi_i32(arg[0].out, v[arg[1].imm % ARRAY_SIZE(v)]);
6528 } else {
6529 tcg_gen_movi_i64(arg[0].out, v[arg[1].imm % ARRAY_SIZE(v)]);
6530 }
6531 if (arg[1].imm >= ARRAY_SIZE(v)) {
6532 qemu_log_mask(LOG_GUEST_ERROR,
6533 "const.s f%d, #%d, immediate value is reserved\n",
6534 arg[0].imm, arg[1].imm);
6535 }
6536 }
6537
6538 static void translate_float_d(DisasContext *dc, const OpcodeArg arg[],
6539 const uint32_t par[])
6540 {
6541 TCGv_i32 scale = tcg_const_i32(-arg[2].imm);
6542
6543 if (par[0]) {
6544 gen_helper_uitof_d(arg[0].out, cpu_env, arg[1].in, scale);
6545 } else {
6546 gen_helper_itof_d(arg[0].out, cpu_env, arg[1].in, scale);
6547 }
6548 tcg_temp_free(scale);
6549 }
6550
6551 static void translate_float_s(DisasContext *dc, const OpcodeArg arg[],
6552 const uint32_t par[])
6553 {
6554 TCGv_i32 scale = tcg_const_i32(-arg[2].imm);
6555 OpcodeArg arg32[1];
6556
6557 get_f32_o1(arg, arg32, 0);
6558 if (par[0]) {
6559 gen_helper_uitof_s(arg32[0].out, cpu_env, arg[1].in, scale);
6560 } else {
6561 gen_helper_itof_s(arg32[0].out, cpu_env, arg[1].in, scale);
6562 }
6563 put_f32_o1(arg, arg32, 0);
6564 tcg_temp_free(scale);
6565 }
6566
6567 static void translate_ftoi_d(DisasContext *dc, const OpcodeArg arg[],
6568 const uint32_t par[])
6569 {
6570 TCGv_i32 rounding_mode = tcg_const_i32(par[0]);
6571 TCGv_i32 scale = tcg_const_i32(arg[2].imm);
6572
6573 if (par[1]) {
6574 gen_helper_ftoui_d(arg[0].out, cpu_env, arg[1].in,
6575 rounding_mode, scale);
6576 } else {
6577 gen_helper_ftoi_d(arg[0].out, cpu_env, arg[1].in,
6578 rounding_mode, scale);
6579 }
6580 tcg_temp_free(rounding_mode);
6581 tcg_temp_free(scale);
6582 }
6583
6584 static void translate_ftoi_s(DisasContext *dc, const OpcodeArg arg[],
6585 const uint32_t par[])
6586 {
6587 TCGv_i32 rounding_mode = tcg_const_i32(par[0]);
6588 TCGv_i32 scale = tcg_const_i32(arg[2].imm);
6589 OpcodeArg arg32[2];
6590
6591 get_f32_i1(arg, arg32, 1);
6592 if (par[1]) {
6593 gen_helper_ftoui_s(arg[0].out, cpu_env, arg32[1].in,
6594 rounding_mode, scale);
6595 } else {
6596 gen_helper_ftoi_s(arg[0].out, cpu_env, arg32[1].in,
6597 rounding_mode, scale);
6598 }
6599 put_f32_i1(arg, arg32, 1);
6600 tcg_temp_free(rounding_mode);
6601 tcg_temp_free(scale);
6602 }
6603
6604 static void translate_ldsti(DisasContext *dc, const OpcodeArg arg[],
6605 const uint32_t par[])
6606 {
6607 TCGv_i32 addr = tcg_temp_new_i32();
6608 MemOp mop;
6609
6610 tcg_gen_addi_i32(addr, arg[1].in, arg[2].imm);
6611 mop = gen_load_store_alignment(dc, MO_TEUL, addr);
6612 if (par[0]) {
6613 tcg_gen_qemu_st_tl(arg[0].in, addr, dc->cring, mop);
6614 } else {
6615 tcg_gen_qemu_ld_tl(arg[0].out, addr, dc->cring, mop);
6616 }
6617 if (par[1]) {
6618 tcg_gen_mov_i32(arg[1].out, addr);
6619 }
6620 tcg_temp_free(addr);
6621 }
6622
6623 static void translate_ldstx(DisasContext *dc, const OpcodeArg arg[],
6624 const uint32_t par[])
6625 {
6626 TCGv_i32 addr = tcg_temp_new_i32();
6627 MemOp mop;
6628
6629 tcg_gen_add_i32(addr, arg[1].in, arg[2].in);
6630 mop = gen_load_store_alignment(dc, MO_TEUL, addr);
6631 if (par[0]) {
6632 tcg_gen_qemu_st_tl(arg[0].in, addr, dc->cring, mop);
6633 } else {
6634 tcg_gen_qemu_ld_tl(arg[0].out, addr, dc->cring, mop);
6635 }
6636 if (par[1]) {
6637 tcg_gen_mov_i32(arg[1].out, addr);
6638 }
6639 tcg_temp_free(addr);
6640 }
6641
6642 static void translate_fpu2k_madd_s(DisasContext *dc, const OpcodeArg arg[],
6643 const uint32_t par[])
6644 {
6645 gen_helper_fpu2k_madd_s(arg[0].out, cpu_env,
6646 arg[0].in, arg[1].in, arg[2].in);
6647 }
6648
6649 static void translate_mov_d(DisasContext *dc, const OpcodeArg arg[],
6650 const uint32_t par[])
6651 {
6652 tcg_gen_mov_i64(arg[0].out, arg[1].in);
6653 }
6654
6655 static void translate_mov_s(DisasContext *dc, const OpcodeArg arg[],
6656 const uint32_t par[])
6657 {
6658 if (arg[0].num_bits == 32) {
6659 tcg_gen_mov_i32(arg[0].out, arg[1].in);
6660 } else {
6661 tcg_gen_mov_i64(arg[0].out, arg[1].in);
6662 }
6663 }
6664
6665 static void translate_movcond_d(DisasContext *dc, const OpcodeArg arg[],
6666 const uint32_t par[])
6667 {
6668 TCGv_i64 zero = tcg_const_i64(0);
6669 TCGv_i64 arg2 = tcg_temp_new_i64();
6670
6671 tcg_gen_ext_i32_i64(arg2, arg[2].in);
6672 tcg_gen_movcond_i64(par[0], arg[0].out,
6673 arg2, zero,
6674 arg[1].in, arg[0].in);
6675 tcg_temp_free_i64(zero);
6676 tcg_temp_free_i64(arg2);
6677 }
6678
6679 static void translate_movcond_s(DisasContext *dc, const OpcodeArg arg[],
6680 const uint32_t par[])
6681 {
6682 if (arg[0].num_bits == 32) {
6683 TCGv_i32 zero = tcg_const_i32(0);
6684
6685 tcg_gen_movcond_i32(par[0], arg[0].out,
6686 arg[2].in, zero,
6687 arg[1].in, arg[0].in);
6688 tcg_temp_free(zero);
6689 } else {
6690 translate_movcond_d(dc, arg, par);
6691 }
6692 }
6693
6694 static void translate_movp_d(DisasContext *dc, const OpcodeArg arg[],
6695 const uint32_t par[])
6696 {
6697 TCGv_i64 zero = tcg_const_i64(0);
6698 TCGv_i32 tmp1 = tcg_temp_new_i32();
6699 TCGv_i64 tmp2 = tcg_temp_new_i64();
6700
6701 tcg_gen_andi_i32(tmp1, arg[2].in, 1 << arg[2].imm);
6702 tcg_gen_extu_i32_i64(tmp2, tmp1);
6703 tcg_gen_movcond_i64(par[0],
6704 arg[0].out, tmp2, zero,
6705 arg[1].in, arg[0].in);
6706 tcg_temp_free_i64(zero);
6707 tcg_temp_free_i32(tmp1);
6708 tcg_temp_free_i64(tmp2);
6709 }
6710
6711 static void translate_movp_s(DisasContext *dc, const OpcodeArg arg[],
6712 const uint32_t par[])
6713 {
6714 if (arg[0].num_bits == 32) {
6715 TCGv_i32 zero = tcg_const_i32(0);
6716 TCGv_i32 tmp = tcg_temp_new_i32();
6717
6718 tcg_gen_andi_i32(tmp, arg[2].in, 1 << arg[2].imm);
6719 tcg_gen_movcond_i32(par[0],
6720 arg[0].out, tmp, zero,
6721 arg[1].in, arg[0].in);
6722 tcg_temp_free(tmp);
6723 tcg_temp_free(zero);
6724 } else {
6725 translate_movp_d(dc, arg, par);
6726 }
6727 }
6728
6729 static void translate_fpu2k_mul_s(DisasContext *dc, const OpcodeArg arg[],
6730 const uint32_t par[])
6731 {
6732 gen_helper_fpu2k_mul_s(arg[0].out, cpu_env,
6733 arg[1].in, arg[2].in);
6734 }
6735
6736 static void translate_fpu2k_msub_s(DisasContext *dc, const OpcodeArg arg[],
6737 const uint32_t par[])
6738 {
6739 gen_helper_fpu2k_msub_s(arg[0].out, cpu_env,
6740 arg[0].in, arg[1].in, arg[2].in);
6741 }
6742
6743 static void translate_neg_d(DisasContext *dc, const OpcodeArg arg[],
6744 const uint32_t par[])
6745 {
6746 gen_helper_neg_d(arg[0].out, arg[1].in);
6747 }
6748
6749 static void translate_neg_s(DisasContext *dc, const OpcodeArg arg[],
6750 const uint32_t par[])
6751 {
6752 OpcodeArg arg32[2];
6753
6754 get_f32_o1_i1(arg, arg32, 0, 1);
6755 gen_helper_neg_s(arg32[0].out, arg32[1].in);
6756 put_f32_o1_i1(arg, arg32, 0, 1);
6757 }
6758
6759 static void translate_rfr_d(DisasContext *dc, const OpcodeArg arg[],
6760 const uint32_t par[])
6761 {
6762 tcg_gen_extrh_i64_i32(arg[0].out, arg[1].in);
6763 }
6764
6765 static void translate_rfr_s(DisasContext *dc, const OpcodeArg arg[],
6766 const uint32_t par[])
6767 {
6768 if (arg[1].num_bits == 32) {
6769 tcg_gen_mov_i32(arg[0].out, arg[1].in);
6770 } else {
6771 tcg_gen_extrl_i64_i32(arg[0].out, arg[1].in);
6772 }
6773 }
6774
6775 static void translate_fpu2k_sub_s(DisasContext *dc, const OpcodeArg arg[],
6776 const uint32_t par[])
6777 {
6778 gen_helper_fpu2k_sub_s(arg[0].out, cpu_env,
6779 arg[1].in, arg[2].in);
6780 }
6781
6782 static void translate_wfr_d(DisasContext *dc, const OpcodeArg arg[],
6783 const uint32_t par[])
6784 {
6785 tcg_gen_concat_i32_i64(arg[0].out, arg[2].in, arg[1].in);
6786 }
6787
6788 static void translate_wfr_s(DisasContext *dc, const OpcodeArg arg[],
6789 const uint32_t par[])
6790 {
6791 if (arg[0].num_bits == 32) {
6792 tcg_gen_mov_i32(arg[0].out, arg[1].in);
6793 } else {
6794 tcg_gen_ext_i32_i64(arg[0].out, arg[1].in);
6795 }
6796 }
6797
6798 static void translate_wur_fpu2k_fcr(DisasContext *dc, const OpcodeArg arg[],
6799 const uint32_t par[])
6800 {
6801 gen_helper_wur_fpu2k_fcr(cpu_env, arg[0].in);
6802 }
6803
6804 static void translate_wur_fpu2k_fsr(DisasContext *dc, const OpcodeArg arg[],
6805 const uint32_t par[])
6806 {
6807 tcg_gen_andi_i32(cpu_UR[par[0]], arg[0].in, 0xffffff80);
6808 }
6809
6810 static const XtensaOpcodeOps fpu2000_ops[] = {
6811 {
6812 .name = "abs.s",
6813 .translate = translate_abs_s,
6814 .coprocessor = 0x1,
6815 }, {
6816 .name = "add.s",
6817 .translate = translate_fpu2k_add_s,
6818 .coprocessor = 0x1,
6819 }, {
6820 .name = "ceil.s",
6821 .translate = translate_ftoi_s,
6822 .par = (const uint32_t[]){float_round_up, false},
6823 .coprocessor = 0x1,
6824 }, {
6825 .name = "float.s",
6826 .translate = translate_float_s,
6827 .par = (const uint32_t[]){false},
6828 .coprocessor = 0x1,
6829 }, {
6830 .name = "floor.s",
6831 .translate = translate_ftoi_s,
6832 .par = (const uint32_t[]){float_round_down, false},
6833 .coprocessor = 0x1,
6834 }, {
6835 .name = "lsi",
6836 .translate = translate_ldsti,
6837 .par = (const uint32_t[]){false, false},
6838 .op_flags = XTENSA_OP_LOAD,
6839 .coprocessor = 0x1,
6840 }, {
6841 .name = "lsiu",
6842 .translate = translate_ldsti,
6843 .par = (const uint32_t[]){false, true},
6844 .op_flags = XTENSA_OP_LOAD,
6845 .coprocessor = 0x1,
6846 }, {
6847 .name = "lsx",
6848 .translate = translate_ldstx,
6849 .par = (const uint32_t[]){false, false},
6850 .op_flags = XTENSA_OP_LOAD,
6851 .coprocessor = 0x1,
6852 }, {
6853 .name = "lsxu",
6854 .translate = translate_ldstx,
6855 .par = (const uint32_t[]){false, true},
6856 .op_flags = XTENSA_OP_LOAD,
6857 .coprocessor = 0x1,
6858 }, {
6859 .name = "madd.s",
6860 .translate = translate_fpu2k_madd_s,
6861 .coprocessor = 0x1,
6862 }, {
6863 .name = "mov.s",
6864 .translate = translate_mov_s,
6865 .coprocessor = 0x1,
6866 }, {
6867 .name = "moveqz.s",
6868 .translate = translate_movcond_s,
6869 .par = (const uint32_t[]){TCG_COND_EQ},
6870 .coprocessor = 0x1,
6871 }, {
6872 .name = "movf.s",
6873 .translate = translate_movp_s,
6874 .par = (const uint32_t[]){TCG_COND_EQ},
6875 .coprocessor = 0x1,
6876 }, {
6877 .name = "movgez.s",
6878 .translate = translate_movcond_s,
6879 .par = (const uint32_t[]){TCG_COND_GE},
6880 .coprocessor = 0x1,
6881 }, {
6882 .name = "movltz.s",
6883 .translate = translate_movcond_s,
6884 .par = (const uint32_t[]){TCG_COND_LT},
6885 .coprocessor = 0x1,
6886 }, {
6887 .name = "movnez.s",
6888 .translate = translate_movcond_s,
6889 .par = (const uint32_t[]){TCG_COND_NE},
6890 .coprocessor = 0x1,
6891 }, {
6892 .name = "movt.s",
6893 .translate = translate_movp_s,
6894 .par = (const uint32_t[]){TCG_COND_NE},
6895 .coprocessor = 0x1,
6896 }, {
6897 .name = "msub.s",
6898 .translate = translate_fpu2k_msub_s,
6899 .coprocessor = 0x1,
6900 }, {
6901 .name = "mul.s",
6902 .translate = translate_fpu2k_mul_s,
6903 .coprocessor = 0x1,
6904 }, {
6905 .name = "neg.s",
6906 .translate = translate_neg_s,
6907 .coprocessor = 0x1,
6908 }, {
6909 .name = "oeq.s",
6910 .translate = translate_compare_s,
6911 .par = (const uint32_t[]){COMPARE_OEQ},
6912 .coprocessor = 0x1,
6913 }, {
6914 .name = "ole.s",
6915 .translate = translate_compare_s,
6916 .par = (const uint32_t[]){COMPARE_OLE},
6917 .coprocessor = 0x1,
6918 }, {
6919 .name = "olt.s",
6920 .translate = translate_compare_s,
6921 .par = (const uint32_t[]){COMPARE_OLT},
6922 .coprocessor = 0x1,
6923 }, {
6924 .name = "rfr",
6925 .translate = translate_rfr_s,
6926 .coprocessor = 0x1,
6927 }, {
6928 .name = "round.s",
6929 .translate = translate_ftoi_s,
6930 .par = (const uint32_t[]){float_round_nearest_even, false},
6931 .coprocessor = 0x1,
6932 }, {
6933 .name = "rur.fcr",
6934 .translate = translate_rur,
6935 .par = (const uint32_t[]){FCR},
6936 .coprocessor = 0x1,
6937 }, {
6938 .name = "rur.fsr",
6939 .translate = translate_rur,
6940 .par = (const uint32_t[]){FSR},
6941 .coprocessor = 0x1,
6942 }, {
6943 .name = "ssi",
6944 .translate = translate_ldsti,
6945 .par = (const uint32_t[]){true, false},
6946 .op_flags = XTENSA_OP_STORE,
6947 .coprocessor = 0x1,
6948 }, {
6949 .name = "ssiu",
6950 .translate = translate_ldsti,
6951 .par = (const uint32_t[]){true, true},
6952 .op_flags = XTENSA_OP_STORE,
6953 .coprocessor = 0x1,
6954 }, {
6955 .name = "ssx",
6956 .translate = translate_ldstx,
6957 .par = (const uint32_t[]){true, false},
6958 .op_flags = XTENSA_OP_STORE,
6959 .coprocessor = 0x1,
6960 }, {
6961 .name = "ssxu",
6962 .translate = translate_ldstx,
6963 .par = (const uint32_t[]){true, true},
6964 .op_flags = XTENSA_OP_STORE,
6965 .coprocessor = 0x1,
6966 }, {
6967 .name = "sub.s",
6968 .translate = translate_fpu2k_sub_s,
6969 .coprocessor = 0x1,
6970 }, {
6971 .name = "trunc.s",
6972 .translate = translate_ftoi_s,
6973 .par = (const uint32_t[]){float_round_to_zero, false},
6974 .coprocessor = 0x1,
6975 }, {
6976 .name = "ueq.s",
6977 .translate = translate_compare_s,
6978 .par = (const uint32_t[]){COMPARE_UEQ},
6979 .coprocessor = 0x1,
6980 }, {
6981 .name = "ufloat.s",
6982 .translate = translate_float_s,
6983 .par = (const uint32_t[]){true},
6984 .coprocessor = 0x1,
6985 }, {
6986 .name = "ule.s",
6987 .translate = translate_compare_s,
6988 .par = (const uint32_t[]){COMPARE_ULE},
6989 .coprocessor = 0x1,
6990 }, {
6991 .name = "ult.s",
6992 .translate = translate_compare_s,
6993 .par = (const uint32_t[]){COMPARE_ULT},
6994 .coprocessor = 0x1,
6995 }, {
6996 .name = "un.s",
6997 .translate = translate_compare_s,
6998 .par = (const uint32_t[]){COMPARE_UN},
6999 .coprocessor = 0x1,
7000 }, {
7001 .name = "utrunc.s",
7002 .translate = translate_ftoi_s,
7003 .par = (const uint32_t[]){float_round_to_zero, true},
7004 .coprocessor = 0x1,
7005 }, {
7006 .name = "wfr",
7007 .translate = translate_wfr_s,
7008 .coprocessor = 0x1,
7009 }, {
7010 .name = "wur.fcr",
7011 .translate = translate_wur_fpu2k_fcr,
7012 .par = (const uint32_t[]){FCR},
7013 .coprocessor = 0x1,
7014 }, {
7015 .name = "wur.fsr",
7016 .translate = translate_wur_fpu2k_fsr,
7017 .par = (const uint32_t[]){FSR},
7018 .coprocessor = 0x1,
7019 },
7020 };
7021
7022 const XtensaOpcodeTranslators xtensa_fpu2000_opcodes = {
7023 .num_opcodes = ARRAY_SIZE(fpu2000_ops),
7024 .opcode = fpu2000_ops,
7025 };
7026
7027 static void translate_add_d(DisasContext *dc, const OpcodeArg arg[],
7028 const uint32_t par[])
7029 {
7030 gen_helper_add_d(arg[0].out, cpu_env, arg[1].in, arg[2].in);
7031 }
7032
7033 static void translate_add_s(DisasContext *dc, const OpcodeArg arg[],
7034 const uint32_t par[])
7035 {
7036 if (option_enabled(dc, XTENSA_OPTION_DFPU_SINGLE_ONLY)) {
7037 gen_helper_fpu2k_add_s(arg[0].out, cpu_env,
7038 arg[1].in, arg[2].in);
7039 } else {
7040 OpcodeArg arg32[3];
7041
7042 get_f32_o1_i2(arg, arg32, 0, 1, 2);
7043 gen_helper_add_s(arg32[0].out, cpu_env, arg32[1].in, arg32[2].in);
7044 put_f32_o1_i2(arg, arg32, 0, 1, 2);
7045 }
7046 }
7047
7048 static void translate_cvtd_s(DisasContext *dc, const OpcodeArg arg[],
7049 const uint32_t par[])
7050 {
7051 TCGv_i32 v = tcg_temp_new_i32();
7052
7053 tcg_gen_extrl_i64_i32(v, arg[1].in);
7054 gen_helper_cvtd_s(arg[0].out, cpu_env, v);
7055 tcg_temp_free_i32(v);
7056 }
7057
7058 static void translate_cvts_d(DisasContext *dc, const OpcodeArg arg[],
7059 const uint32_t par[])
7060 {
7061 TCGv_i32 v = tcg_temp_new_i32();
7062
7063 gen_helper_cvts_d(v, cpu_env, arg[1].in);
7064 tcg_gen_extu_i32_i64(arg[0].out, v);
7065 tcg_temp_free_i32(v);
7066 }
7067
7068 static void translate_ldsti_d(DisasContext *dc, const OpcodeArg arg[],
7069 const uint32_t par[])
7070 {
7071 TCGv_i32 addr;
7072 MemOp mop;
7073
7074 if (par[1]) {
7075 addr = tcg_temp_new_i32();
7076 tcg_gen_addi_i32(addr, arg[1].in, arg[2].imm);
7077 } else {
7078 addr = arg[1].in;
7079 }
7080 mop = gen_load_store_alignment(dc, MO_TEUQ, addr);
7081 if (par[0]) {
7082 tcg_gen_qemu_st_i64(arg[0].in, addr, dc->cring, mop);
7083 } else {
7084 tcg_gen_qemu_ld_i64(arg[0].out, addr, dc->cring, mop);
7085 }
7086 if (par[2]) {
7087 if (par[1]) {
7088 tcg_gen_mov_i32(arg[1].out, addr);
7089 } else {
7090 tcg_gen_addi_i32(arg[1].out, arg[1].in, arg[2].imm);
7091 }
7092 }
7093 if (par[1]) {
7094 tcg_temp_free(addr);
7095 }
7096 }
7097
7098 static void translate_ldsti_s(DisasContext *dc, const OpcodeArg arg[],
7099 const uint32_t par[])
7100 {
7101 TCGv_i32 addr;
7102 OpcodeArg arg32[1];
7103 MemOp mop;
7104
7105 if (par[1]) {
7106 addr = tcg_temp_new_i32();
7107 tcg_gen_addi_i32(addr, arg[1].in, arg[2].imm);
7108 } else {
7109 addr = arg[1].in;
7110 }
7111 mop = gen_load_store_alignment(dc, MO_TEUL, addr);
7112 if (par[0]) {
7113 get_f32_i1(arg, arg32, 0);
7114 tcg_gen_qemu_st_tl(arg32[0].in, addr, dc->cring, mop);
7115 put_f32_i1(arg, arg32, 0);
7116 } else {
7117 get_f32_o1(arg, arg32, 0);
7118 tcg_gen_qemu_ld_tl(arg32[0].out, addr, dc->cring, mop);
7119 put_f32_o1(arg, arg32, 0);
7120 }
7121 if (par[2]) {
7122 if (par[1]) {
7123 tcg_gen_mov_i32(arg[1].out, addr);
7124 } else {
7125 tcg_gen_addi_i32(arg[1].out, arg[1].in, arg[2].imm);
7126 }
7127 }
7128 if (par[1]) {
7129 tcg_temp_free(addr);
7130 }
7131 }
7132
7133 static void translate_ldstx_d(DisasContext *dc, const OpcodeArg arg[],
7134 const uint32_t par[])
7135 {
7136 TCGv_i32 addr;
7137 MemOp mop;
7138
7139 if (par[1]) {
7140 addr = tcg_temp_new_i32();
7141 tcg_gen_add_i32(addr, arg[1].in, arg[2].in);
7142 } else {
7143 addr = arg[1].in;
7144 }
7145 mop = gen_load_store_alignment(dc, MO_TEUQ, addr);
7146 if (par[0]) {
7147 tcg_gen_qemu_st_i64(arg[0].in, addr, dc->cring, mop);
7148 } else {
7149 tcg_gen_qemu_ld_i64(arg[0].out, addr, dc->cring, mop);
7150 }
7151 if (par[2]) {
7152 if (par[1]) {
7153 tcg_gen_mov_i32(arg[1].out, addr);
7154 } else {
7155 tcg_gen_add_i32(arg[1].out, arg[1].in, arg[2].in);
7156 }
7157 }
7158 if (par[1]) {
7159 tcg_temp_free(addr);
7160 }
7161 }
7162
7163 static void translate_ldstx_s(DisasContext *dc, const OpcodeArg arg[],
7164 const uint32_t par[])
7165 {
7166 TCGv_i32 addr;
7167 OpcodeArg arg32[1];
7168 MemOp mop;
7169
7170 if (par[1]) {
7171 addr = tcg_temp_new_i32();
7172 tcg_gen_add_i32(addr, arg[1].in, arg[2].in);
7173 } else {
7174 addr = arg[1].in;
7175 }
7176 mop = gen_load_store_alignment(dc, MO_TEUL, addr);
7177 if (par[0]) {
7178 get_f32_i1(arg, arg32, 0);
7179 tcg_gen_qemu_st_tl(arg32[0].in, addr, dc->cring, mop);
7180 put_f32_i1(arg, arg32, 0);
7181 } else {
7182 get_f32_o1(arg, arg32, 0);
7183 tcg_gen_qemu_ld_tl(arg32[0].out, addr, dc->cring, mop);
7184 put_f32_o1(arg, arg32, 0);
7185 }
7186 if (par[2]) {
7187 if (par[1]) {
7188 tcg_gen_mov_i32(arg[1].out, addr);
7189 } else {
7190 tcg_gen_add_i32(arg[1].out, arg[1].in, arg[2].in);
7191 }
7192 }
7193 if (par[1]) {
7194 tcg_temp_free(addr);
7195 }
7196 }
7197
7198 static void translate_madd_d(DisasContext *dc, const OpcodeArg arg[],
7199 const uint32_t par[])
7200 {
7201 gen_helper_madd_d(arg[0].out, cpu_env,
7202 arg[0].in, arg[1].in, arg[2].in);
7203 }
7204
7205 static void translate_madd_s(DisasContext *dc, const OpcodeArg arg[],
7206 const uint32_t par[])
7207 {
7208 if (option_enabled(dc, XTENSA_OPTION_DFPU_SINGLE_ONLY)) {
7209 gen_helper_fpu2k_madd_s(arg[0].out, cpu_env,
7210 arg[0].in, arg[1].in, arg[2].in);
7211 } else {
7212 OpcodeArg arg32[3];
7213
7214 get_f32_o1_i3(arg, arg32, 0, 0, 1, 2);
7215 gen_helper_madd_s(arg32[0].out, cpu_env,
7216 arg32[0].in, arg32[1].in, arg32[2].in);
7217 put_f32_o1_i3(arg, arg32, 0, 0, 1, 2);
7218 }
7219 }
7220
7221 static void translate_mul_d(DisasContext *dc, const OpcodeArg arg[],
7222 const uint32_t par[])
7223 {
7224 gen_helper_mul_d(arg[0].out, cpu_env, arg[1].in, arg[2].in);
7225 }
7226
7227 static void translate_mul_s(DisasContext *dc, const OpcodeArg arg[],
7228 const uint32_t par[])
7229 {
7230 if (option_enabled(dc, XTENSA_OPTION_DFPU_SINGLE_ONLY)) {
7231 gen_helper_fpu2k_mul_s(arg[0].out, cpu_env,
7232 arg[1].in, arg[2].in);
7233 } else {
7234 OpcodeArg arg32[3];
7235
7236 get_f32_o1_i2(arg, arg32, 0, 1, 2);
7237 gen_helper_mul_s(arg32[0].out, cpu_env, arg32[1].in, arg32[2].in);
7238 put_f32_o1_i2(arg, arg32, 0, 1, 2);
7239 }
7240 }
7241
7242 static void translate_msub_d(DisasContext *dc, const OpcodeArg arg[],
7243 const uint32_t par[])
7244 {
7245 gen_helper_msub_d(arg[0].out, cpu_env,
7246 arg[0].in, arg[1].in, arg[2].in);
7247 }
7248
7249 static void translate_msub_s(DisasContext *dc, const OpcodeArg arg[],
7250 const uint32_t par[])
7251 {
7252 if (option_enabled(dc, XTENSA_OPTION_DFPU_SINGLE_ONLY)) {
7253 gen_helper_fpu2k_msub_s(arg[0].out, cpu_env,
7254 arg[0].in, arg[1].in, arg[2].in);
7255 } else {
7256 OpcodeArg arg32[3];
7257
7258 get_f32_o1_i3(arg, arg32, 0, 0, 1, 2);
7259 gen_helper_msub_s(arg32[0].out, cpu_env,
7260 arg32[0].in, arg32[1].in, arg32[2].in);
7261 put_f32_o1_i3(arg, arg32, 0, 0, 1, 2);
7262 }
7263 }
7264
7265 static void translate_sub_d(DisasContext *dc, const OpcodeArg arg[],
7266 const uint32_t par[])
7267 {
7268 gen_helper_sub_d(arg[0].out, cpu_env, arg[1].in, arg[2].in);
7269 }
7270
7271 static void translate_sub_s(DisasContext *dc, const OpcodeArg arg[],
7272 const uint32_t par[])
7273 {
7274 if (option_enabled(dc, XTENSA_OPTION_DFPU_SINGLE_ONLY)) {
7275 gen_helper_fpu2k_sub_s(arg[0].out, cpu_env,
7276 arg[1].in, arg[2].in);
7277 } else {
7278 OpcodeArg arg32[3];
7279
7280 get_f32_o1_i2(arg, arg32, 0, 1, 2);
7281 gen_helper_sub_s(arg32[0].out, cpu_env, arg32[1].in, arg32[2].in);
7282 put_f32_o1_i2(arg, arg32, 0, 1, 2);
7283 }
7284 }
7285
7286 static void translate_mkdadj_d(DisasContext *dc, const OpcodeArg arg[],
7287 const uint32_t par[])
7288 {
7289 gen_helper_mkdadj_d(arg[0].out, cpu_env, arg[0].in, arg[1].in);
7290 }
7291
7292 static void translate_mkdadj_s(DisasContext *dc, const OpcodeArg arg[],
7293 const uint32_t par[])
7294 {
7295 OpcodeArg arg32[2];
7296
7297 get_f32_o1_i2(arg, arg32, 0, 0, 1);
7298 gen_helper_mkdadj_s(arg32[0].out, cpu_env, arg32[0].in, arg32[1].in);
7299 put_f32_o1_i2(arg, arg32, 0, 0, 1);
7300 }
7301
7302 static void translate_mksadj_d(DisasContext *dc, const OpcodeArg arg[],
7303 const uint32_t par[])
7304 {
7305 gen_helper_mksadj_d(arg[0].out, cpu_env, arg[1].in);
7306 }
7307
7308 static void translate_mksadj_s(DisasContext *dc, const OpcodeArg arg[],
7309 const uint32_t par[])
7310 {
7311 OpcodeArg arg32[2];
7312
7313 get_f32_o1_i1(arg, arg32, 0, 1);
7314 gen_helper_mksadj_s(arg32[0].out, cpu_env, arg32[1].in);
7315 put_f32_o1_i1(arg, arg32, 0, 1);
7316 }
7317
7318 static void translate_wur_fpu_fcr(DisasContext *dc, const OpcodeArg arg[],
7319 const uint32_t par[])
7320 {
7321 gen_helper_wur_fpu_fcr(cpu_env, arg[0].in);
7322 }
7323
7324 static void translate_rur_fpu_fsr(DisasContext *dc, const OpcodeArg arg[],
7325 const uint32_t par[])
7326 {
7327 gen_helper_rur_fpu_fsr(arg[0].out, cpu_env);
7328 }
7329
7330 static void translate_wur_fpu_fsr(DisasContext *dc, const OpcodeArg arg[],
7331 const uint32_t par[])
7332 {
7333 gen_helper_wur_fpu_fsr(cpu_env, arg[0].in);
7334 }
7335
7336 static const XtensaOpcodeOps fpu_ops[] = {
7337 {
7338 .name = "abs.d",
7339 .translate = translate_abs_d,
7340 .coprocessor = 0x1,
7341 }, {
7342 .name = "abs.s",
7343 .translate = translate_abs_s,
7344 .coprocessor = 0x1,
7345 }, {
7346 .name = "add.d",
7347 .translate = translate_add_d,
7348 .coprocessor = 0x1,
7349 }, {
7350 .name = "add.s",
7351 .translate = translate_add_s,
7352 .coprocessor = 0x1,
7353 }, {
7354 .name = "addexp.d",
7355 .translate = translate_nop,
7356 .coprocessor = 0x1,
7357 }, {
7358 .name = "addexp.s",
7359 .translate = translate_nop,
7360 .coprocessor = 0x1,
7361 }, {
7362 .name = "addexpm.d",
7363 .translate = translate_mov_s,
7364 .coprocessor = 0x1,
7365 }, {
7366 .name = "addexpm.s",
7367 .translate = translate_mov_s,
7368 .coprocessor = 0x1,
7369 }, {
7370 .name = "ceil.d",
7371 .translate = translate_ftoi_d,
7372 .par = (const uint32_t[]){float_round_up, false},
7373 .coprocessor = 0x1,
7374 }, {
7375 .name = "ceil.s",
7376 .translate = translate_ftoi_s,
7377 .par = (const uint32_t[]){float_round_up, false},
7378 .coprocessor = 0x1,
7379 }, {
7380 .name = "const.d",
7381 .translate = translate_const_d,
7382 .coprocessor = 0x1,
7383 }, {
7384 .name = "const.s",
7385 .translate = translate_const_s,
7386 .coprocessor = 0x1,
7387 }, {
7388 .name = "cvtd.s",
7389 .translate = translate_cvtd_s,
7390 .coprocessor = 0x1,
7391 }, {
7392 .name = "cvts.d",
7393 .translate = translate_cvts_d,
7394 .coprocessor = 0x1,
7395 }, {
7396 .name = "div0.d",
7397 .translate = translate_nop,
7398 .coprocessor = 0x1,
7399 }, {
7400 .name = "div0.s",
7401 .translate = translate_nop,
7402 .coprocessor = 0x1,
7403 }, {
7404 .name = "divn.d",
7405 .translate = translate_nop,
7406 .coprocessor = 0x1,
7407 }, {
7408 .name = "divn.s",
7409 .translate = translate_nop,
7410 .coprocessor = 0x1,
7411 }, {
7412 .name = "float.d",
7413 .translate = translate_float_d,
7414 .par = (const uint32_t[]){false},
7415 .coprocessor = 0x1,
7416 }, {
7417 .name = "float.s",
7418 .translate = translate_float_s,
7419 .par = (const uint32_t[]){false},
7420 .coprocessor = 0x1,
7421 }, {
7422 .name = "floor.d",
7423 .translate = translate_ftoi_d,
7424 .par = (const uint32_t[]){float_round_down, false},
7425 .coprocessor = 0x1,
7426 }, {
7427 .name = "floor.s",
7428 .translate = translate_ftoi_s,
7429 .par = (const uint32_t[]){float_round_down, false},
7430 .coprocessor = 0x1,
7431 }, {
7432 .name = "ldi",
7433 .translate = translate_ldsti_d,
7434 .par = (const uint32_t[]){false, true, false},
7435 .op_flags = XTENSA_OP_LOAD,
7436 .coprocessor = 0x1,
7437 }, {
7438 .name = "ldip",
7439 .translate = translate_ldsti_d,
7440 .par = (const uint32_t[]){false, false, true},
7441 .op_flags = XTENSA_OP_LOAD,
7442 .coprocessor = 0x1,
7443 }, {
7444 .name = "ldiu",
7445 .translate = translate_ldsti_d,
7446 .par = (const uint32_t[]){false, true, true},
7447 .op_flags = XTENSA_OP_LOAD,
7448 .coprocessor = 0x1,
7449 }, {
7450 .name = "ldx",
7451 .translate = translate_ldstx_d,
7452 .par = (const uint32_t[]){false, true, false},
7453 .op_flags = XTENSA_OP_LOAD,
7454 .coprocessor = 0x1,
7455 }, {
7456 .name = "ldxp",
7457 .translate = translate_ldstx_d,
7458 .par = (const uint32_t[]){false, false, true},
7459 .op_flags = XTENSA_OP_LOAD,
7460 .coprocessor = 0x1,
7461 }, {
7462 .name = "ldxu",
7463 .translate = translate_ldstx_d,
7464 .par = (const uint32_t[]){false, true, true},
7465 .op_flags = XTENSA_OP_LOAD,
7466 .coprocessor = 0x1,
7467 }, {
7468 .name = "lsi",
7469 .translate = translate_ldsti_s,
7470 .par = (const uint32_t[]){false, true, false},
7471 .op_flags = XTENSA_OP_LOAD,
7472 .coprocessor = 0x1,
7473 }, {
7474 .name = "lsip",
7475 .translate = translate_ldsti_s,
7476 .par = (const uint32_t[]){false, false, true},
7477 .op_flags = XTENSA_OP_LOAD,
7478 .coprocessor = 0x1,
7479 }, {
7480 .name = "lsiu",
7481 .translate = translate_ldsti_s,
7482 .par = (const uint32_t[]){false, true, true},
7483 .op_flags = XTENSA_OP_LOAD,
7484 .coprocessor = 0x1,
7485 }, {
7486 .name = "lsx",
7487 .translate = translate_ldstx_s,
7488 .par = (const uint32_t[]){false, true, false},
7489 .op_flags = XTENSA_OP_LOAD,
7490 .coprocessor = 0x1,
7491 }, {
7492 .name = "lsxp",
7493 .translate = translate_ldstx_s,
7494 .par = (const uint32_t[]){false, false, true},
7495 .op_flags = XTENSA_OP_LOAD,
7496 .coprocessor = 0x1,
7497 }, {
7498 .name = "lsxu",
7499 .translate = translate_ldstx_s,
7500 .par = (const uint32_t[]){false, true, true},
7501 .op_flags = XTENSA_OP_LOAD,
7502 .coprocessor = 0x1,
7503 }, {
7504 .name = "madd.d",
7505 .translate = translate_madd_d,
7506 .coprocessor = 0x1,
7507 }, {
7508 .name = "madd.s",
7509 .translate = translate_madd_s,
7510 .coprocessor = 0x1,
7511 }, {
7512 .name = "maddn.d",
7513 .translate = translate_nop,
7514 .coprocessor = 0x1,
7515 }, {
7516 .name = "maddn.s",
7517 .translate = translate_nop,
7518 .coprocessor = 0x1,
7519 }, {
7520 .name = "mkdadj.d",
7521 .translate = translate_mkdadj_d,
7522 .coprocessor = 0x1,
7523 }, {
7524 .name = "mkdadj.s",
7525 .translate = translate_mkdadj_s,
7526 .coprocessor = 0x1,
7527 }, {
7528 .name = "mksadj.d",
7529 .translate = translate_mksadj_d,
7530 .coprocessor = 0x1,
7531 }, {
7532 .name = "mksadj.s",
7533 .translate = translate_mksadj_s,
7534 .coprocessor = 0x1,
7535 }, {
7536 .name = "mov.d",
7537 .translate = translate_mov_d,
7538 .coprocessor = 0x1,
7539 }, {
7540 .name = "mov.s",
7541 .translate = translate_mov_s,
7542 .coprocessor = 0x1,
7543 }, {
7544 .name = "moveqz.d",
7545 .translate = translate_movcond_d,
7546 .par = (const uint32_t[]){TCG_COND_EQ},
7547 .coprocessor = 0x1,
7548 }, {
7549 .name = "moveqz.s",
7550 .translate = translate_movcond_s,
7551 .par = (const uint32_t[]){TCG_COND_EQ},
7552 .coprocessor = 0x1,
7553 }, {
7554 .name = "movf.d",
7555 .translate = translate_movp_d,
7556 .par = (const uint32_t[]){TCG_COND_EQ},
7557 .coprocessor = 0x1,
7558 }, {
7559 .name = "movf.s",
7560 .translate = translate_movp_s,
7561 .par = (const uint32_t[]){TCG_COND_EQ},
7562 .coprocessor = 0x1,
7563 }, {
7564 .name = "movgez.d",
7565 .translate = translate_movcond_d,
7566 .par = (const uint32_t[]){TCG_COND_GE},
7567 .coprocessor = 0x1,
7568 }, {
7569 .name = "movgez.s",
7570 .translate = translate_movcond_s,
7571 .par = (const uint32_t[]){TCG_COND_GE},
7572 .coprocessor = 0x1,
7573 }, {
7574 .name = "movltz.d",
7575 .translate = translate_movcond_d,
7576 .par = (const uint32_t[]){TCG_COND_LT},
7577 .coprocessor = 0x1,
7578 }, {
7579 .name = "movltz.s",
7580 .translate = translate_movcond_s,
7581 .par = (const uint32_t[]){TCG_COND_LT},
7582 .coprocessor = 0x1,
7583 }, {
7584 .name = "movnez.d",
7585 .translate = translate_movcond_d,
7586 .par = (const uint32_t[]){TCG_COND_NE},
7587 .coprocessor = 0x1,
7588 }, {
7589 .name = "movnez.s",
7590 .translate = translate_movcond_s,
7591 .par = (const uint32_t[]){TCG_COND_NE},
7592 .coprocessor = 0x1,
7593 }, {
7594 .name = "movt.d",
7595 .translate = translate_movp_d,
7596 .par = (const uint32_t[]){TCG_COND_NE},
7597 .coprocessor = 0x1,
7598 }, {
7599 .name = "movt.s",
7600 .translate = translate_movp_s,
7601 .par = (const uint32_t[]){TCG_COND_NE},
7602 .coprocessor = 0x1,
7603 }, {
7604 .name = "msub.d",
7605 .translate = translate_msub_d,
7606 .coprocessor = 0x1,
7607 }, {
7608 .name = "msub.s",
7609 .translate = translate_msub_s,
7610 .coprocessor = 0x1,
7611 }, {
7612 .name = "mul.d",
7613 .translate = translate_mul_d,
7614 .coprocessor = 0x1,
7615 }, {
7616 .name = "mul.s",
7617 .translate = translate_mul_s,
7618 .coprocessor = 0x1,
7619 }, {
7620 .name = "neg.d",
7621 .translate = translate_neg_d,
7622 .coprocessor = 0x1,
7623 }, {
7624 .name = "neg.s",
7625 .translate = translate_neg_s,
7626 .coprocessor = 0x1,
7627 }, {
7628 .name = "nexp01.d",
7629 .translate = translate_nop,
7630 .coprocessor = 0x1,
7631 }, {
7632 .name = "nexp01.s",
7633 .translate = translate_nop,
7634 .coprocessor = 0x1,
7635 }, {
7636 .name = "oeq.d",
7637 .translate = translate_compare_d,
7638 .par = (const uint32_t[]){COMPARE_OEQ},
7639 .coprocessor = 0x1,
7640 }, {
7641 .name = "oeq.s",
7642 .translate = translate_compare_s,
7643 .par = (const uint32_t[]){COMPARE_OEQ},
7644 .coprocessor = 0x1,
7645 }, {
7646 .name = "ole.d",
7647 .translate = translate_compare_d,
7648 .par = (const uint32_t[]){COMPARE_OLE},
7649 .coprocessor = 0x1,
7650 }, {
7651 .name = "ole.s",
7652 .translate = translate_compare_s,
7653 .par = (const uint32_t[]){COMPARE_OLE},
7654 .coprocessor = 0x1,
7655 }, {
7656 .name = "olt.d",
7657 .translate = translate_compare_d,
7658 .par = (const uint32_t[]){COMPARE_OLT},
7659 .coprocessor = 0x1,
7660 }, {
7661 .name = "olt.s",
7662 .translate = translate_compare_s,
7663 .par = (const uint32_t[]){COMPARE_OLT},
7664 .coprocessor = 0x1,
7665 }, {
7666 .name = "rfr",
7667 .translate = translate_rfr_s,
7668 .coprocessor = 0x1,
7669 }, {
7670 .name = "rfrd",
7671 .translate = translate_rfr_d,
7672 .coprocessor = 0x1,
7673 }, {
7674 .name = "round.d",
7675 .translate = translate_ftoi_d,
7676 .par = (const uint32_t[]){float_round_nearest_even, false},
7677 .coprocessor = 0x1,
7678 }, {
7679 .name = "round.s",
7680 .translate = translate_ftoi_s,
7681 .par = (const uint32_t[]){float_round_nearest_even, false},
7682 .coprocessor = 0x1,
7683 }, {
7684 .name = "rur.fcr",
7685 .translate = translate_rur,
7686 .par = (const uint32_t[]){FCR},
7687 .coprocessor = 0x1,
7688 }, {
7689 .name = "rur.fsr",
7690 .translate = translate_rur_fpu_fsr,
7691 .coprocessor = 0x1,
7692 }, {
7693 .name = "sdi",
7694 .translate = translate_ldsti_d,
7695 .par = (const uint32_t[]){true, true, false},
7696 .op_flags = XTENSA_OP_STORE,
7697 .coprocessor = 0x1,
7698 }, {
7699 .name = "sdip",
7700 .translate = translate_ldsti_d,
7701 .par = (const uint32_t[]){true, false, true},
7702 .op_flags = XTENSA_OP_STORE,
7703 .coprocessor = 0x1,
7704 }, {
7705 .name = "sdiu",
7706 .translate = translate_ldsti_d,
7707 .par = (const uint32_t[]){true, true, true},
7708 .op_flags = XTENSA_OP_STORE,
7709 .coprocessor = 0x1,
7710 }, {
7711 .name = "sdx",
7712 .translate = translate_ldstx_d,
7713 .par = (const uint32_t[]){true, true, false},
7714 .op_flags = XTENSA_OP_STORE,
7715 .coprocessor = 0x1,
7716 }, {
7717 .name = "sdxp",
7718 .translate = translate_ldstx_d,
7719 .par = (const uint32_t[]){true, false, true},
7720 .op_flags = XTENSA_OP_STORE,
7721 .coprocessor = 0x1,
7722 }, {
7723 .name = "sdxu",
7724 .translate = translate_ldstx_d,
7725 .par = (const uint32_t[]){true, true, true},
7726 .op_flags = XTENSA_OP_STORE,
7727 .coprocessor = 0x1,
7728 }, {
7729 .name = "sqrt0.d",
7730 .translate = translate_nop,
7731 .coprocessor = 0x1,
7732 }, {
7733 .name = "sqrt0.s",
7734 .translate = translate_nop,
7735 .coprocessor = 0x1,
7736 }, {
7737 .name = "ssi",
7738 .translate = translate_ldsti_s,
7739 .par = (const uint32_t[]){true, true, false},
7740 .op_flags = XTENSA_OP_STORE,
7741 .coprocessor = 0x1,
7742 }, {
7743 .name = "ssip",
7744 .translate = translate_ldsti_s,
7745 .par = (const uint32_t[]){true, false, true},
7746 .op_flags = XTENSA_OP_STORE,
7747 .coprocessor = 0x1,
7748 }, {
7749 .name = "ssiu",
7750 .translate = translate_ldsti_s,
7751 .par = (const uint32_t[]){true, true, true},
7752 .op_flags = XTENSA_OP_STORE,
7753 .coprocessor = 0x1,
7754 }, {
7755 .name = "ssx",
7756 .translate = translate_ldstx_s,
7757 .par = (const uint32_t[]){true, true, false},
7758 .op_flags = XTENSA_OP_STORE,
7759 .coprocessor = 0x1,
7760 }, {
7761 .name = "ssxp",
7762 .translate = translate_ldstx_s,
7763 .par = (const uint32_t[]){true, false, true},
7764 .op_flags = XTENSA_OP_STORE,
7765 .coprocessor = 0x1,
7766 }, {
7767 .name = "ssxu",
7768 .translate = translate_ldstx_s,
7769 .par = (const uint32_t[]){true, true, true},
7770 .op_flags = XTENSA_OP_STORE,
7771 .coprocessor = 0x1,
7772 }, {
7773 .name = "sub.d",
7774 .translate = translate_sub_d,
7775 .coprocessor = 0x1,
7776 }, {
7777 .name = "sub.s",
7778 .translate = translate_sub_s,
7779 .coprocessor = 0x1,
7780 }, {
7781 .name = "trunc.d",
7782 .translate = translate_ftoi_d,
7783 .par = (const uint32_t[]){float_round_to_zero, false},
7784 .coprocessor = 0x1,
7785 }, {
7786 .name = "trunc.s",
7787 .translate = translate_ftoi_s,
7788 .par = (const uint32_t[]){float_round_to_zero, false},
7789 .coprocessor = 0x1,
7790 }, {
7791 .name = "ueq.d",
7792 .translate = translate_compare_d,
7793 .par = (const uint32_t[]){COMPARE_UEQ},
7794 .coprocessor = 0x1,
7795 }, {
7796 .name = "ueq.s",
7797 .translate = translate_compare_s,
7798 .par = (const uint32_t[]){COMPARE_UEQ},
7799 .coprocessor = 0x1,
7800 }, {
7801 .name = "ufloat.d",
7802 .translate = translate_float_d,
7803 .par = (const uint32_t[]){true},
7804 .coprocessor = 0x1,
7805 }, {
7806 .name = "ufloat.s",
7807 .translate = translate_float_s,
7808 .par = (const uint32_t[]){true},
7809 .coprocessor = 0x1,
7810 }, {
7811 .name = "ule.d",
7812 .translate = translate_compare_d,
7813 .par = (const uint32_t[]){COMPARE_ULE},
7814 .coprocessor = 0x1,
7815 }, {
7816 .name = "ule.s",
7817 .translate = translate_compare_s,
7818 .par = (const uint32_t[]){COMPARE_ULE},
7819 .coprocessor = 0x1,
7820 }, {
7821 .name = "ult.d",
7822 .translate = translate_compare_d,
7823 .par = (const uint32_t[]){COMPARE_ULT},
7824 .coprocessor = 0x1,
7825 }, {
7826 .name = "ult.s",
7827 .translate = translate_compare_s,
7828 .par = (const uint32_t[]){COMPARE_ULT},
7829 .coprocessor = 0x1,
7830 }, {
7831 .name = "un.d",
7832 .translate = translate_compare_d,
7833 .par = (const uint32_t[]){COMPARE_UN},
7834 .coprocessor = 0x1,
7835 }, {
7836 .name = "un.s",
7837 .translate = translate_compare_s,
7838 .par = (const uint32_t[]){COMPARE_UN},
7839 .coprocessor = 0x1,
7840 }, {
7841 .name = "utrunc.d",
7842 .translate = translate_ftoi_d,
7843 .par = (const uint32_t[]){float_round_to_zero, true},
7844 .coprocessor = 0x1,
7845 }, {
7846 .name = "utrunc.s",
7847 .translate = translate_ftoi_s,
7848 .par = (const uint32_t[]){float_round_to_zero, true},
7849 .coprocessor = 0x1,
7850 }, {
7851 .name = "wfr",
7852 .translate = translate_wfr_s,
7853 .coprocessor = 0x1,
7854 }, {
7855 .name = "wfrd",
7856 .translate = translate_wfr_d,
7857 .coprocessor = 0x1,
7858 }, {
7859 .name = "wur.fcr",
7860 .translate = translate_wur_fpu_fcr,
7861 .par = (const uint32_t[]){FCR},
7862 .coprocessor = 0x1,
7863 }, {
7864 .name = "wur.fsr",
7865 .translate = translate_wur_fpu_fsr,
7866 .coprocessor = 0x1,
7867 },
7868 };
7869
7870 const XtensaOpcodeTranslators xtensa_fpu_opcodes = {
7871 .num_opcodes = ARRAY_SIZE(fpu_ops),
7872 .opcode = fpu_ops,
7873 };
Ray Wang's QEMU Repository