+
+static void
+_unldi4(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1
+# if __WORDSIZE == 64
+ , jit_bool_t sign
+# endif
+ )
+{
+ jit_int32_t t0, r2;
+ if ((i1 & -4) == i1) {
+# if __WORDSIZE == 64
+ if (sign)
+# endif
+ ldi_i(r0, i1);
+# if __WORDSIZE == 64
+ else
+ ldi_ui(r0, i1);
+# endif
+ }
+ else {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & -2) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_us(r0, i1);
+# if __WORDSIZE == 64
+ if (sign)
+ ldi_s(r2, i1 + 2);
+ else
+# endif
+ ldi_us(r2, i1 + 2);
+ lshi(r2, r2, 16);
+# else
+# if __WORDSIZE == 64
+ if (sign)
+ ldi_s(r0, i1);
+ else
+# endif
+ ldi_us(r0, i1);
+ lshi(r0, r0, 16);
+ ldi_us(r2, i1 + 2);
+# endif
+ }
+ else if ((i1 & 3) == 3) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ ldi_i(r2, i1 + 1);
+ lshi(r2, r2, 8);
+# if __WORDSIZE == 64
+ if (sign)
+ extr_i(r2, r2);
+ else
+ extr_ui(r2, r2);
+# endif
+# else
+# if __WORDSIZE == 64
+ if (sign)
+ ldi_c(r0, i1);
+ else
+# endif
+ ldi_uc(r0, i1);
+ lshi(r0, r0, 24);
+# if __WORDSIZE == 32
+ ldi(r2, i1 + 1);
+# else
+ ldi_ui(r2, i1 + 1);
+# endif
+ rshi_u(r2, r2, 8);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+# if __WORDSIZE == 32
+ ldi(r0, i1 - 1);
+# else
+ ldi_ui(r0, i1 - 1);
+# endif
+ rshi_u(r0, r0, 8);
+# if __WORDSIZE == 64
+ if (sign)
+ ldi_c(r2, i1 + 3);
+ else
+# endif
+ ldi_uc(r2, i1 + 3);
+ lshi(r2, r2, 24);
+# else
+ ldi_i(r0, i1 - 1);
+ lshi(r0, r0, 8);
+# if __WORDSIZE == 64
+ if (sign)
+ extr_i(r0, r0);
+ else
+ extr_ui(r0, r0);
+# endif
+ ldi_uc(r2, i1 + 3);
+# endif
+ }
+ orr(r0, r0, r2);
+ jit_unget_reg(t0);
+ }
+}
+
+# if __WORDSIZE == 64
+static void
+_unldr5(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t sign)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un4, un2, un3, or, or4, or3;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, -4);
+ un4 = fallback_bner(_jit->pc.w, r1, r2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_ui(r0, r1);
+ if (sign)
+ ldxi_c(r2, r1, 4);
+ else
+ ldxi_uc(r2, r1, 4);
+ lshi(r2, r2, 32);
+# else
+ if (sign)
+ ldr_i(r0, r1);
+ else
+ ldr_ui(r0, r1);
+ lshi(r0, r0, 8);
+ ldxi_uc(r2, r1, 4);
+# endif
+ or = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un4, _jit->pc.w);
+ andi(r2, r1, -2);
+ un2 = fallback_bner(_jit->pc.w, r1, r2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_us(r0, r1);
+ ldxi_us(r2, r1, 2);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ if (sign)
+ ldxi_c(r2, r1, 4);
+ else
+ ldxi_uc(r2, r1, 4);
+ lshi(r2, r2, 32);
+# else
+ if (sign)
+ ldr_s(r0, r1);
+ else
+ ldr_us(r0, r1);
+ lshi(r0, r0, 24);
+ ldxi_us(r2, r1, 2);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_uc(r2, r1, 4);
+# endif
+ or4 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un2, _jit->pc.w);
+ andi(r2, r1, 3);
+ un3 = fallback_bnei(_jit->pc.w, r2, 3);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_uc(r0, r1);
+ if (sign)
+ ldxi_i(r2, r1, 1);
+ else
+ ldxi_ui(r2, r1, 1);
+ lshi(r2, r2, 8);
+# else
+ if (sign)
+ ldr_c(r0, r1);
+ else
+ ldr_uc(r0, r1);
+ lshi(r0, r0, 32);
+ ldxi_ui(r2, r1, 1);
+# endif
+ or3 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un3, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_uc(r0, r1);
+ ldxi_us(r2, r1, 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ if (sign)
+ ldxi_s(r2, r1, 3);
+ else
+ ldxi_us(r2, r1, 3);
+ lshi(r2, r2, 24);
+# else
+ if (sign)
+ ldr_c(r0, r1);
+ else
+ ldr_uc(r0, r1);
+ lshi(r0, r0, 32);
+ ldxi_us(r2, r1, 1);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ ldxi_us(r2, r1, 3);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(or, _jit->pc.w);
+ fallback_patch_jmpi(or4, _jit->pc.w);
+ fallback_patch_jmpi(or3, _jit->pc.w);
+ orr(r0, r0, r2);
+ jit_unget_reg(t0);
+}
+
+static void
+_unldi5(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1, jit_bool_t sign)
+{
+ jit_int32_t t0, r2;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & -4) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_ui(r0, i1);
+ if (sign)
+ ldi_c(r2, i1 + 4);
+ else
+ ldi_uc(r2, i1 + 4);
+ lshi(r2, r2, 32);
+# else
+ if (sign)
+ ldi_i(r0, i1);
+ else
+ ldi_ui(r0, i1);
+ lshi(r0, r0, 8);
+ ldi_uc(r2, i1 + 4);
+# endif
+ }
+ else if ((i1 & -2) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_us(r0, i1);
+ ldi_us(r2, i1 + 2);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ if (sign)
+ ldi_c(r2, i1 + 4);
+ else
+ ldi_uc(r2, i1 + 4);
+ lshi(r2, r2, 32);
+# else
+ if (sign)
+ ldi_s(r0, i1);
+ else
+ ldi_us(r0, i1);
+ lshi(r0, r0, 24);
+ ldi_us(r2, i1 + 2);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_uc(r2, i1 + 4);
+# endif
+ }
+ else if ((i1 & 3) == 3) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ if (sign)
+ ldi_i(r2, i1 + 1);
+ else
+ ldi_ui(r2, i1 + 1);
+ lshi(r2, r2, 8);
+# else
+ if (sign)
+ ldi_c(r0, i1);
+ else
+ ldi_uc(r0, i1);
+ lshi(r0, r0, 32);
+ ldi_ui(r2, i1 + 1);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ ldi_us(r2, i1 + 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ if (sign)
+ ldi_s(r2, i1 + 3);
+ else
+ ldi_us(r2, i1 + 3);
+ lshi(r2, r2, 24);
+# else
+ if (sign)
+ ldi_c(r0, i1);
+ else
+ ldi_uc(r0, i1);
+ lshi(r0, r0, 32);
+ ldi_us(r2, i1 + 1);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ ldi_us(r2, i1 + 3);
+# endif
+ }
+ orr(r0, r0, r2);
+ jit_unget_reg(t0);
+}
+
+static void
+_unldr6(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t sign)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un4, un2, un3, or, or2, or3;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, -4);
+ un4 = fallback_bner(_jit->pc.w, r1, r2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_ui(r0, r1);
+ if (sign)
+ ldxi_s(r2, r1, 4);
+ else
+ ldxi_us(r2, r1, 4);
+ lshi(r2, r2, 32);
+# else
+ if (sign)
+ ldr_i(r0, r1);
+ else
+ ldr_ui(r0, r1);
+ lshi(r0, r0, 16);
+ ldxi_us(r2, r1, 4);
+# endif
+ or = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un4, _jit->pc.w);
+ andi(r2, r1, -2);
+ un2 = fallback_bner(_jit->pc.w, r1, r2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_us(r0, r1);
+ if (sign)
+ ldxi_i(r2, r1, 2);
+ else
+ ldxi_ui(r2, r1, 2);
+ lshi(r2, r2, 16);
+# else
+ if (sign)
+ ldr_s(r0, r1);
+ else
+ ldr_us(r0, r1);
+ lshi(r0, r0, 32);
+ ldxi_ui(r2, r1, 2);
+# endif
+ or2 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un2, _jit->pc.w);
+ andi(r2, r1, 3);
+ un3 = fallback_bnei(_jit->pc.w, r2, 3);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_uc(r0, r1);
+ ldxi_ui(r2, r1, 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ if (sign)
+ ldxi_c(r2, r1, 5);
+ else
+ ldxi_uc(r2, r1, 5);
+ lshi(r2, r2, 40);
+# else
+ if (sign)
+ ldr_c(r0, r1);
+ else
+ ldr_uc(r0, r1);
+ lshi(r0, r0, 40);
+ ldxi_ui(r2, r1, 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_uc(r2, r1, 5);
+# endif
+ or3 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un3, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_uc(r0, r1);
+ ldxi_us(r2, r1, 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_us(r2, r1, 3);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ if (sign)
+ ldxi_c(r2, r1, 5);
+ else
+ ldxi_uc(r2, r1, 5);
+ lshi(r2, r2, 40);
+# else
+ if (sign)
+ ldr_c(r0, r1);
+ else
+ ldr_uc(r0, r1);
+ lshi(r0, r0, 40);
+ ldxi_us(r2, r1, 1);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ ldxi_us(r2, r1, 3);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_uc(r2, r1, 5);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(or, _jit->pc.w);
+ fallback_patch_jmpi(or2, _jit->pc.w);
+ fallback_patch_jmpi(or3, _jit->pc.w);
+ orr(r0, r0, r2);
+ jit_unget_reg(t0);
+}
+
+static void
+_unldi6(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1, jit_bool_t sign)
+{
+ jit_int32_t t0, r2;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & -4) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_ui(r0, i1);
+ if (sign)
+ ldi_s(r2, i1 + 4);
+ else
+ ldi_us(r2, i1 + 4);
+ lshi(r2, r2, 32);
+# else
+ if (sign)
+ ldi_i(r0, i1);
+ else
+ ldi_ui(r0, i1);
+ lshi(r0, r0, 16);
+ ldi_us(r2, i1 + 4);
+# endif
+ }
+ else if ((i1 & -2) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_us(r0, i1);
+ if (sign)
+ ldi_i(r2, i1 + 2);
+ else
+ ldi_ui(r2, i1 + 2);
+ lshi(r2, r2, 16);
+# else
+ if (sign)
+ ldi_s(r0, i1);
+ else
+ ldi_us(r0, i1);
+ lshi(r0, r0, 32);
+ ldi_ui(r2, i1 + 2);
+# endif
+ }
+ else if ((i1 & 3) == 3) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ ldi_ui(r2, i1 + 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ if (sign)
+ ldi_c(r2, i1 + 5);
+ else
+ ldi_uc(r2, i1 + 5);
+ lshi(r2, r2, 40);
+# else
+ if (sign)
+ ldi_c(r0, i1);
+ else
+ ldi_uc(r0, i1);
+ lshi(r0, r0, 40);
+ ldi_ui(r2, i1 + 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_uc(r2, i1 + 5);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ ldi_us(r2, i1 + 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_us(r2, i1 + 3);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ if (sign)
+ ldi_c(r2, i1 + 5);
+ else
+ ldi_uc(r2, i1 + 5);
+ lshi(r2, r2, 40);
+# else
+ if (sign)
+ ldi_c(r0, i1);
+ else
+ ldi_uc(r0, i1);
+ lshi(r0, r0, 40);
+ ldi_us(r2, i1 + 1);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ ldi_us(r2, i1 + 3);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_uc(r2, i1 + 5);
+# endif
+ }
+ orr(r0, r0, r2);
+ jit_unget_reg(t0);
+}
+
+static void
+_unldr7(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t sign)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un4, un2, un3, or, or2, or3;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, -4);
+ un4 = fallback_bner(_jit->pc.w, r1, r2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_ui(r0, r1);
+ ldxi_us(r2, r1, 4);
+ lshi(r2, r2, 32);
+ orr(r0, r0, r2);
+ if (sign)
+ ldxi_c(r2, r1, 6);
+ else
+ ldxi_uc(r2, r1, 6);
+ lshi(r2, r2, 48);
+# else
+ if (sign)
+ ldr_i(r0, r1);
+ else
+ ldr_ui(r0, r1);
+ lshi(r0, r0, 24);
+ ldxi_us(r2, r1, 4);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_uc(r2, r1, 6);
+# endif
+ or = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un4, _jit->pc.w);
+ andi(r2, r1, -2);
+ un2 = fallback_bner(_jit->pc.w, r1, r2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_us(r0, r1);
+ ldxi_ui(r2, r1, 2);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ if (sign)
+ ldxi_c(r2, r1, 6);
+ else
+ ldxi_uc(r2, r1, 6);
+ lshi(r2, r2, 48);
+# else
+ if (sign)
+ ldr_s(r0, r1);
+ else
+ ldr_us(r0, r1);
+ lshi(r0, r0, 40);
+ ldxi_ui(r2, r1, 2);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_uc(r2, r1, 6);
+# endif
+ or2 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un2, _jit->pc.w);
+ andi(r2, r1, 3);
+ un3 = fallback_bnei(_jit->pc.w, r2, 3);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_uc(r0, r1);
+ ldxi_ui(r2, r1, 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ if (sign)
+ ldxi_s(r2, r1, 5);
+ else
+ ldxi_us(r2, r1, 5);
+ lshi(r2, r2, 40);
+# else
+ if (sign)
+ ldr_c(r0, r1);
+ else
+ ldr_uc(r0, r1);
+ lshi(r0, r0, 48);
+ ldxi_ui(r2, r1, 1);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ ldxi_us(r2, r1, 5);
+# endif
+ or3 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un3, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_uc(r0, r1);
+ ldxi_us(r2, r1, 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ if (sign)
+ ldxi_i(r2, r1, 3);
+ else
+ ldxi_ui(r2, r1, 3);
+ lshi(r2, r2, 24);
+# else
+ if (sign)
+ ldr_c(r0, r1);
+ else
+ ldr_uc(r0, r1);
+ lshi(r0, r0, 48);
+ ldxi_us(r2, r1, 1);
+ lshi(r2, r2, 32);
+ orr(r0, r0, r2);
+ ldxi_ui(r2, r1, 3);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(or, _jit->pc.w);
+ fallback_patch_jmpi(or2, _jit->pc.w);
+ fallback_patch_jmpi(or3, _jit->pc.w);
+ orr(r0, r0, r2);
+ jit_unget_reg(t0);
+}
+
+static void
+_unldi7(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1, jit_bool_t sign)
+{
+ jit_int32_t t0, r2;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & -4) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_ui(r0, i1);
+ ldi_us(r2, i1 + 4);
+ lshi(r2, r2, 32);
+ orr(r0, r0, r2);
+ if (sign)
+ ldi_c(r2, i1 + 6);
+ else
+ ldi_uc(r2, i1 + 6);
+ lshi(r2, r2, 48);
+# else
+ if (sign)
+ ldi_i(r0, i1);
+ else
+ ldi_ui(r0, i1);
+ lshi(r0, r0, 24);
+ ldi_us(r2, i1 + 4);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_uc(r2, i1 + 6);
+# endif
+ }
+ else if ((i1 & -2) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_us(r0, i1);
+ ldi_ui(r2, i1 + 2);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ if (sign)
+ ldi_c(r2, i1 + 6);
+ else
+ ldi_uc(r2, i1 + 6);
+ lshi(r2, r2, 48);
+# else
+ if (sign)
+ ldi_s(r0, i1);
+ else
+ ldi_us(r0, i1);
+ lshi(r0, r0, 40);
+ ldi_ui(r2, i1 + 2);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_uc(r2, i1 + 6);
+# endif
+ }
+ else if ((i1 & 3) == 3) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ ldi_ui(r2, i1 + 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ if (sign)
+ ldi_s(r2, i1 + 5);
+ else
+ ldi_us(r2, i1 + 5);
+ lshi(r2, r2, 40);
+# else
+ if (sign)
+ ldi_c(r0, i1);
+ else
+ ldi_uc(r0, i1);
+ lshi(r0, r0, 48);
+ ldi_ui(r2, i1 + 1);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ ldi_us(r2, i1 + 5);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ ldi_us(r2, i1 + 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ if (sign)
+ ldi_i(r2, i1 + 3);
+ else
+ ldi_ui(r2, i1 + 3);
+ lshi(r2, r2, 24);
+# else
+ if (sign)
+ ldi_c(r0, i1);
+ else
+ ldi_uc(r0, i1);
+ lshi(r0, r0, 48);
+ ldi_us(r2, i1 + 1);
+ lshi(r2, r2, 32);
+ orr(r0, r0, r2);
+ ldi_ui(r2, i1 + 3);
+# endif
+ }
+ orr(r0, r0, r2);
+ jit_unget_reg(t0);
+}
+
+static void
+_unldr8(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un8, un4, un2, un7, un6, un5, un3, al,
+ or, or2, or7, or6, or5, or3;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, -8);
+ un8 = fallback_bner(_jit->pc.w, r1, r2);
+ ldr_l(r0, r1);
+ al = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un8, _jit->pc.w);
+ andi(r2, r1, -4);
+ un4 = fallback_bner(_jit->pc.w, r1, r2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_ui(r0, r1);
+ ldxi_i(r2, r1, 4);
+ lshi(r2, r2, 32);
+# else
+ ldr_i(r0, r1);
+ ldxi_ui(r2, r1, 4);
+ lshi(r0, r0, 32);
+# endif
+ or = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un4, _jit->pc.w);
+ andi(r2, r1, -2);
+ un2 = fallback_bner(_jit->pc.w, r1, r2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_us(r0, r1);
+ ldxi_ui(r2, r1, 2);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ ldxi_s(r2, r1, 6);
+ lshi(r2, r2, 48);
+# else
+ ldr_s(r0, r1);
+ lshi(r0, r0, 48);
+ ldxi_ui(r2, r1, 2);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ ldxi_us(r2, r1, 6);
+# endif
+ or2 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un2, _jit->pc.w);
+ andi(r2, r1, 7);
+ un7 = fallback_bnei(_jit->pc.w, r2, 7);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_uc(r0, r1);
+ ldxi_l(r2, r1, 1);
+ lshi(r2, r2, 8);
+# else
+ ldr_c(r0, r1);
+ ldxi_l(r2, r1, 1);
+ rshi_u(r2, r2, 8);
+ lshi(r0, r0, 56);
+# endif
+ or7 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un7, _jit->pc.w);
+ un6 = fallback_bnei(_jit->pc.w, r2, 6);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_us(r0, r1);
+ ldxi_l(r2, r1, 2);
+ lshi(r2, r2, 16);
+# else
+ ldr_s(r0, r1);
+ lshi(r0, r0, 48);
+ ldxi_l(r2, r1, 2);
+ rshi_u(r2, r2, 16);
+# endif
+ or6 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un6, _jit->pc.w);
+ un5 = fallback_bnei(_jit->pc.w, r2, 5);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldxi_ui(r0, r1, -1);
+ rshi_u(r0, r0, 8);
+ ldxi_ui(r2, r1, 3);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ ldxi_c(r2, r1, 7);
+ lshi(r2, r2, 56);
+# else
+ ldxi_i(r0, r1, -1);
+ lshi(r0, r0, 40);
+ ldxi_ui(r2, r1, 3);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_uc(r2, r1, 7);
+# endif
+ or5 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un5, _jit->pc.w);
+ un3 = fallback_bnei(_jit->pc.w, r2, 3);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_uc(r0, r1);
+ ldxi_ui(r2, r1, 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_i(r2, r1, 5);
+ lshi(r2, r2, 40);
+# else
+ ldr_c(r0, r1);
+ lshi(r0, r0, 56);
+ ldxi_ui(r2, r1, 1);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ ldxi_ui(r2, r1, 5);
+ rshi_u(r2, r2, 8);
+# endif
+ or3 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un3, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldr_uc(r0, r1);
+ ldxi_us(r2, r1, 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_ui(r2, r1, 3);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ ldxi_c(r2, r1, 7);
+ lshi(r2, r2, 56);
+# else
+ ldr_c(r0, r1);
+ lshi(r0, r0, 56);
+ ldxi_us(r2, r1, 1);
+ lshi(r2, r2, 40);
+ orr(r0, r0, r2);
+ ldxi_ui(r2, r1, 3);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldxi_uc(r2, r1, 7);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(or, _jit->pc.w);
+ fallback_patch_jmpi(or2, _jit->pc.w);
+ fallback_patch_jmpi(or7, _jit->pc.w);
+ fallback_patch_jmpi(or6, _jit->pc.w);
+ fallback_patch_jmpi(or5, _jit->pc.w);
+ fallback_patch_jmpi(or3, _jit->pc.w);
+ orr(r0, r0, r2);
+ fallback_flush();
+ fallback_patch_jmpi(al, _jit->pc.w);
+ jit_unget_reg(t0);
+}
+
+static void
+_unldi8(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+ if ((i1 & -8) == i1)
+ ldi_l(r0, i1);
+ else {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & -4) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_ui(r0, i1);
+ ldi_i(r2, i1 + 4);
+ lshi(r2, r2, 32);
+# else
+ ldi_i(r0, i1);
+ ldi_ui(r2, i1 + 4);
+ lshi(r0, r0, 32);
+# endif
+ }
+ else if ((i1 & -2) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_us(r0, i1);
+ ldi_ui(r2, i1 + 2);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ ldi_s(r2, i1 + 6);
+ lshi(r2, r2, 48);
+# else
+ ldi_s(r0, i1);
+ lshi(r0, r0, 48);
+ ldi_ui(r2, i1 + 2);
+ lshi(r2, r2, 16);
+ orr(r0, r0, r2);
+ ldi_us(r2, i1 + 6);
+# endif
+ }
+ else if ((i1 & 7) == 7) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ ldi_l(r2, i1 + 1);
+ lshi(r2, r2, 8);
+# else
+ ldi_c(r0, i1);
+ ldi_l(r2, i1 + 1);
+ rshi_u(r2, r2, 8);
+ lshi(r0, r0, 56);
+# endif
+ }
+ else if ((i1 & 7) == 6) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_us(r0, i1);
+ ldi_l(r2, i1 + 2);
+ lshi(r2, r2, 16);
+# else
+ ldi_s(r0, i1);
+ lshi(r0, r0, 48);
+ ldi_l(r2, i1 + 2);
+ rshi_u(r2, r2, 16);
+# endif
+ }
+ else if ((i1 & 7) == 5) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_ui(r0, i1 - 1);
+ rshi_u(r0, r0, 8);
+ ldi_ui(r2, i1 + 3);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ ldi_c(r2, i1 + 7);
+ lshi(r2, r2, 56);
+# else
+ ldi_i(r0, i1 - 1);
+ lshi(r0, r0, 40);
+ ldi_ui(r2, i1 + 3);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_uc(r2, i1 + 7);
+# endif
+ }
+ else if ((i1 & 7) == 3) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ ldi_ui(r2, i1 + 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_i(r2, i1 + 5);
+ lshi(r2, r2, 40);
+# else
+ ldi_c(r0, i1);
+ lshi(r0, r0, 56);
+ ldi_ui(r2, i1 + 1);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ ldi_ui(r2, i1 + 5);
+ rshi_u(r2, r2, 8);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ ldi_uc(r0, i1);
+ ldi_us(r2, i1 + 1);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_ui(r2, i1 + 3);
+ lshi(r2, r2, 24);
+ orr(r0, r0, r2);
+ ldi_c(r2, i1 + 7);
+ lshi(r2, r2, 56);
+# else
+ ldi_c(r0, i1);
+ lshi(r0, r0, 56);
+ ldi_us(r2, i1 + 1);
+ lshi(r2, r2, 40);
+ orr(r0, r0, r2);
+ ldi_ui(r2, i1 + 3);
+ lshi(r2, r2, 8);
+ orr(r0, r0, r2);
+ ldi_uc(r2, i1 + 7);
+# endif
+ }
+ orr(r0, r0, r2);
+ jit_unget_reg(t0);
+ }
+}
+# endif
+
+static void
+_unstr2(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un2, al;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, -2);
+ un2 = fallback_bner(_jit->pc.w, r2, r1);
+ str_s(r1, r0);
+ al = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un2, _jit->pc.w);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi_u(r2, r0, 8);
+ stxi_c(1, r1, r2);
+#else
+ stxi_c(1, r1, r0);
+ rshi_u(r2, r0, 8);
+ str_c(r1, r2);
+#endif
+ fallback_flush();
+ fallback_patch_jmpi(al, _jit->pc.w);
+ jit_unget_reg(t0);
+}
+
+static void
+_unsti2(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+ if ((i1 & -2) == i1)
+ sti_s(i1, r0);
+ else {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi_u(r2, r0, 8);
+ sti_c(1 + i1, r2);
+#else
+ sti_c(1 + i1, r0);
+ rshi_u(r2, r0, 8);
+ sti_c(i1, r2);
+#endif
+ jit_unget_reg(t0);
+ }
+}
+
+static void
+_unstr3(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un2, al;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, -2);
+ un2 = fallback_bner(_jit->pc.w, r2, r1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_s(r1, r0);
+ rshi(r2, r0, 16);
+ stxi_c(2, r1, r2);
+# else
+ stxi_c(2, r1, r0);
+ rshi(r2, r0, 8);
+ str_s(r1, r2);
+# endif
+ al = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un2, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(1, r1, r2);
+# else
+ stxi_s(1, r1, r0);
+ rshi(r2, r0, 16);
+ str_c(r1, r2);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(al, _jit->pc.w);
+ jit_unget_reg(t0);
+}
+
+static void
+_unsti3(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & -2) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_s(i1, r0);
+ rshi(r2, r0, 16);
+ sti_c(2 + i1, r2);
+# else
+ sti_c(2 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(i1, r2);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(1 + i1, r2);
+# else
+ sti_s(1 + i1, r0);
+ rshi(r2, r0, 16);
+ sti_c(i1, r2);
+# endif
+ }
+ jit_unget_reg(t0);
+}
+
+static void
+_unstr4(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un4, un2, al, al2;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, -4);
+ un4 = fallback_bner(_jit->pc.w, r2, r1);
+ str_i(r1, r0);
+ al = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un4, _jit->pc.w);
+ andi(r2, r1, -2);
+ un2 = fallback_bner(_jit->pc.w, r2, r1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_s(r1, r0);
+ rshi(r2, r0, 16);
+ stxi_s(2, r1, r2);
+# else
+ stxi_s(2, r1, r0);
+ rshi(r2, r0, 16);
+ str_s(r1, r2);
+# endif
+ al2 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un2, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_c(3, r1, r2);
+# else
+ stxi_c(3, r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ str_c(r1, r2);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(al, _jit->pc.w);
+ fallback_patch_jmpi(al2, _jit->pc.w);
+ jit_unget_reg(t0);
+}
+
+static void
+_unsti4(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+ if ((i1 & -4) == i1)
+ sti_i(i1, r0);
+ else {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & -2) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_s(i1, r0);
+ rshi(r2, r0, 16);
+ sti_s(2 + i1, r2);
+# else
+ sti_s(2 + i1, r0);
+ rshi(r2, r0, 16);
+ sti_s(i1, r2);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(3 + i1, r2);
+# else
+ sti_c(3 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(i1, r2);
+# endif
+ }
+ jit_unget_reg(t0);
+ }
+}
+
+# if __WORDSIZE == 64
+static void
+_unstr5(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un3, un2, un1, al, al2, al1;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, 3);
+ un3 = fallback_bnei(_jit->pc.w, r2, 3);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_i(1, r1, r2);
+# else
+ stxi_i(1, r1, r0);
+ rshi(r2, r0, 32);
+ str_c(r1, r2);
+# endif
+ al = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un3, _jit->pc.w);
+ un2 = fallback_bnei(_jit->pc.w, r2, 2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_s(r1, r0);
+ rshi(r2, r0, 16);
+ stxi_s(2, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_c(4, r1, r2);
+# else
+ stxi_c(4, r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(2, r1, r2);
+ rshi(r2, r2, 16);
+ str_s(r1, r2);
+# endif
+ al2 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un2, _jit->pc.w);
+ un1 = fallback_bnei(_jit->pc.w, r2, 1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_s(3, r1, r2);
+# else
+ stxi_s(3, r1, r0);
+ rshi(r2, r0, 16);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ str_c(r1, r2);
+# endif
+ al1 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un1, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_i(r1, r0);
+ rshi(r2, r0, 32);
+ stxi_c(4, r1, r2);
+# else
+ stxi_c(4, r1, r0);
+ rshi(r2, r0, 8);
+ str_i(r1, r2);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(al, _jit->pc.w);
+ fallback_patch_jmpi(al2, _jit->pc.w);
+ fallback_patch_jmpi(al1, _jit->pc.w);
+ jit_unget_reg(t0);
+}
+
+static void
+_unsti5(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & 3) == 3) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_i(1 + i1, r2);
+# else
+ sti_i(1 + i1, r0);
+ rshi(r2, r0, 32);
+ sti_c(i1, r2);
+# endif
+ }
+ else if ((i1 & 3) == 2) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_s(i1, r0);
+ rshi(r2, r0, 16);
+ sti_s(2 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(4 + i1, r2);
+# else
+ sti_c(4 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(2 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_s(i1, r2);
+# endif
+ }
+ else if ((i1 & 3) == 1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_s(3 + i1, r2);
+# else
+ sti_s(3 + i1, r0);
+ rshi(r2, r0, 16);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(i1, r2);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_i(i1, r0);
+ rshi(r2, r0, 32);
+ sti_c(4 + i1, r2);
+# else
+ sti_c(4 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_i(i1, r2);
+# endif
+ }
+ jit_unget_reg(t0);
+}
+
+static void
+_unstr6(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un3, un2, un1, al, al2, al1;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, 3);
+ un3 = fallback_bnei(_jit->pc.w, r2, 3);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_i(1, r1, r2);
+ rshi(r2, r2, 32);
+ stxi_c(5, r1, r2);
+# else
+ stxi_c(5, r1, r0);
+ rshi(r2, r0, 8);
+ stxi_i(1, r1, r2);
+ rshi(r2, r2, 32);
+ str_c(r1, r2);
+# endif
+ al = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un3, _jit->pc.w);
+ un2 = fallback_bnei(_jit->pc.w, r2, 2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_s(r1, r0);
+ rshi(r2, r0, 16);
+ stxi_s(2, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_s(4, r1, r2);
+# else
+ stxi_s(4, r1, r0);
+ rshi(r2, r0, 16);
+ stxi_s(2, r1, r2);
+ rshi(r2, r2, 16);
+ str_s(r1, r2);
+# endif
+ al2 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un2, _jit->pc.w);
+ un1 = fallback_bnei(_jit->pc.w, r2, 1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_s(3, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_c(5, r1, r2);
+# else
+ stxi_c(5, r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(3, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ str_c(r1, r2);
+# endif
+ al1 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un1, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_i(r1, r0);
+ rshi(r2, r0, 32);
+ stxi_s(4, r1, r2);
+# else
+ stxi_s(4, r1, r0);
+ rshi(r2, r0, 16);
+ str_i(r1, r2);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(al, _jit->pc.w);
+ fallback_patch_jmpi(al2, _jit->pc.w);
+ fallback_patch_jmpi(al1, _jit->pc.w);
+ jit_unget_reg(t0);
+}
+
+static void
+_unsti6(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & 3) == 3) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_i(1 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_c(5 + i1, r2);
+# else
+ sti_c(5 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_i(1 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_c(i1, r2);
+# endif
+ }
+ else if ((i1 & 3) == 2) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_s(i1, r0);
+ rshi(r2, r0, 16);
+ sti_s(2 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_s(4 + i1, r2);
+# else
+ sti_s(4 + i1, r0);
+ rshi(r2, r0, 16);
+ sti_s(2 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_s(i1, r2);
+# endif
+ }
+ else if ((i1 & 3) == 1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_s(3 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(5 + i1, r2);
+# else
+ sti_c(5 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(3 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(i1, r2);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_i(i1, r0);
+ rshi(r2, r0, 32);
+ sti_s(4 + i1, r2);
+# else
+ sti_s(4 + i1, r0);
+ rshi(r2, r0, 16);
+ sti_i(i1, r2);
+# endif
+ }
+ jit_unget_reg(t0);
+}
+
+static void
+_unstr7(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un3, un2, un1, al, al2, al1;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, 3);
+ un3 = fallback_bnei(_jit->pc.w, r2, 3);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_i(1, r1, r2);
+ rshi(r2, r2, 32);
+ stxi_s(5, r1, r2);
+# else
+ stxi_s(5, r1, r0);
+ rshi(r2, r0, 16);
+ stxi_i(1, r1, r2);
+ rshi(r2, r2, 32);
+ str_c(r1, r2);
+# endif
+ al = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un3, _jit->pc.w);
+ un2 = fallback_bnei(_jit->pc.w, r2, 2);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_s(r1, r0);
+ rshi(r2, r0, 16);
+ stxi_i(2, r1, r2);
+ rshi(r2, r2, 32);
+ stxi_c(6, r1, r2);
+# else
+ stxi_c(6, r1, r0);
+ rshi(r2, r0, 8);
+ stxi_i(2, r1, r2);
+ rshi(r2, r2, 32);
+ str_s(r1, r2);
+# endif
+ al2 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un2, _jit->pc.w);
+ un1 = fallback_bnei(_jit->pc.w, r2, 1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_i(3, r1, r2);
+# else
+ stxi_i(3, r1, r0);
+ rshi(r2, r0, 32);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ str_c(r1, r2);
+# endif
+ al1 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un1, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_i(r1, r0);
+ rshi(r2, r0, 32);
+ stxi_s(4, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_c(6, r1, r2);
+# else
+ stxi_c(6, r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(4, r1, r2);
+ rshi(r2, r2, 16);
+ str_i(r1, r2);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(al, _jit->pc.w);
+ fallback_patch_jmpi(al2, _jit->pc.w);
+ fallback_patch_jmpi(al1, _jit->pc.w);
+ jit_unget_reg(t0);
+}
+
+static void
+_unsti7(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & 3) == 3) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_i(1 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_s(5 + i1, r2);
+# else
+ sti_s(5 + i1, r0);
+ rshi(r2, r0, 16);
+ sti_i(1 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_c(i1, r2);
+# endif
+ }
+ else if ((i1 & 3) == 2) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_s(i1, r0);
+ rshi(r2, r0, 16);
+ sti_i(2 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_c(6 + i1, r2);
+# else
+ sti_c(6 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_i(2 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_s(i1, r2);
+# endif
+ }
+ else if ((i1 & 3) == 1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_i(3 + i1, r2);
+# else
+ sti_i(3 + i1, r0);
+ rshi(r2, r0, 32);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(i1, r2);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_i(i1, r0);
+ rshi(r2, r0, 32);
+ sti_s(4 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(6 + i1, r2);
+# else
+ sti_c(6 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(4 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_i(i1, r2);
+# endif
+ }
+ jit_unget_reg(t0);
+}
+
+static void
+_unstr8(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t t0, r2;
+ jit_word_t un8, un4, un2, un3, al, al4, al2, al3;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ andi(r2, r1, -8);
+ un8 = fallback_bner(_jit->pc.w, r2, r1);
+ str_l(r1, r0);
+ al = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un8, _jit->pc.w);
+ andi(r2, r1, -4);
+ un4 = fallback_bner(_jit->pc.w, r2, r1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_i(r1, r0);
+ rshi(r2, r0, 32);
+ stxi_i(4, r1, r2);
+# else
+ stxi_i(4, r1, r0);
+ rshi(r2, r0, 32);
+ str_i(r1, r2);
+# endif
+ al4 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un4, _jit->pc.w);
+ andi(r2, r1, -2);
+ un2 = fallback_bner(_jit->pc.w, r2, r1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_s(r1, r0);
+ rshi(r2, r0, 16);
+ stxi_i(2, r1, r2);
+ rshi(r2, r2, 32);
+ stxi_s(6, r1, r2);
+# else
+ stxi_s(6, r1, r0);
+ rshi(r2, r0, 16);
+ stxi_i(2, r1, r2);
+ rshi(r2, r2, 32);
+ str_s(r1, r2);
+# endif
+ al2 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bner(un2, _jit->pc.w);
+ andi(r2, r1, 3);
+ un3 = fallback_bnei(_jit->pc.w, r2, 3);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_i(1, r1, r2);
+ rshi(r2, r2, 32);
+ stxi_s(5, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_c(7, r1, r2);
+# else
+ stxi_c(7, r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(5, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_i(1, r1, r2);
+ rshi(r2, r2, 32);
+ str_c(r1, r2);
+# endif
+ al3 = fallback_jmpi(_jit->pc.w);
+ fallback_flush();
+ fallback_patch_bnei(un3, _jit->pc.w);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ str_c(r1, r0);
+ rshi(r2, r0, 8);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ stxi_i(3, r1, r2);
+ rshi(r2, r2, 32);
+ stxi_c(7, r1, r2);
+# else
+ stxi_c(7, r1, r0);
+ rshi(r2, r0, 8);
+ stxi_i(3, r1, r2);
+ rshi(r2, r2, 32);
+ stxi_s(1, r1, r2);
+ rshi(r2, r2, 16);
+ str_c(r1, r2);
+# endif
+ fallback_flush();
+ fallback_patch_jmpi(al, _jit->pc.w);
+ fallback_patch_jmpi(al4, _jit->pc.w);
+ fallback_patch_jmpi(al2, _jit->pc.w);
+ fallback_patch_jmpi(al3, _jit->pc.w);
+ jit_unget_reg(t0);
+}
+
+static void
+_unsti8(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+ if ((i1 & -8) == i1)
+ sti_l(i1, r0);
+ else {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if ((i1 & -4) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_i(i1, r0);
+ rshi(r2, r0, 32);
+ sti_i(4 + i1, r2);
+# else
+ sti_i(4 + i1, r0);
+ rshi(r2, r0, 32);
+ sti_i(i1, r2);
+# endif
+ }
+ else if ((i1 & -2) == i1) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_s(i1, r0);
+ rshi(r2, r0, 16);
+ sti_i(2 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_s(6 + i1, r2);
+# else
+ sti_s(6 + i1, r0);
+ rshi(r2, r0, 16);
+ sti_i(2 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_s(i1, r2);
+# endif
+ }
+ else if ((i1 & 3) == 3) {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_i(1 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_s(5 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(7 + i1, r2);
+# else
+ sti_c(7 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(5 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_i(1 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_c(i1, r2);
+# endif
+ }
+ else {
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ sti_c(i1, r0);
+ rshi(r2, r0, 8);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_i(3 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_c(7 + i1, r2);
+# else
+ sti_c(7 + i1, r0);
+ rshi(r2, r0, 8);
+ sti_i(3 + i1, r2);
+ rshi(r2, r2, 32);
+ sti_s(1 + i1, r2);
+ rshi(r2, r2, 16);
+ sti_c(i1, r2);
+# endif
+ }
+ jit_unget_reg(t0);
+ }
+}
+# endif
+
+
+static void
+_unldrw(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_word_t cross, done;
+ jit_int32_t t0, t1, t2, t3;
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ if (r0 == r1) {
+ t1 = fallback_jit_get_reg(jit_class_gpr);
+ movr(rn(t1), r1);
+ r1 = rn(t1);
+ }
+ else
+ t1 = JIT_NOREG;
+ andi(rn(t0), r1, -(jit_word_t)sizeof(jit_word_t));
+ ldr(r0, rn(t0));
+ done = fallback_beqr(_jit->pc.w, rn(t0), r1);
+ t2 = fallback_jit_get_reg(jit_class_gpr);
+ andi(rn(t2), r1, sizeof(jit_word_t) - 1);
+ t3 = fallback_jit_get_reg(jit_class_gpr);
+ addi(rn(t3), rn(t2), i0);
+ cross = fallback_blei(_jit->pc.w, rn(t3), sizeof(jit_word_t));
+ ldxi(rn(t0), rn(t0), sizeof(jit_word_t));
+ fallback_flush();
+ fallback_patch_blei(cross, _jit->pc.w);
+ jit_unget_reg(t3);
+ lshi(rn(t2), rn(t2), 3);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ rshr_u(r0, r0, rn(t2));
+ rsbi(rn(t2), rn(t2), __WORDSIZE);
+ lshr(rn(t0), rn(t0), rn(t2));
+#else
+ lshr(r0, r0, rn(t2));
+ rsbi(rn(t2), rn(t2), __WORDSIZE);
+ rshr_u(rn(t0), rn(t0), rn(t2));
+#endif
+ jit_unget_reg(t2);
+ orr(r0, r0, rn(t0));
+ fallback_flush();
+ fallback_patch_beqr(done, _jit->pc.w);
+ jit_unget_reg(t0);
+ if (t1 != JIT_NOREG)
+ jit_unget_reg(t1);
+}
+
+static void
+_unldiw(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
+{
+ jit_word_t addr;
+ jit_int32_t t0, sh;
+ addr = i0 & -(jit_word_t)sizeof(jit_word_t);
+ ldi(r0, addr);
+ if (i0 != addr) {
+ sh = (i0 & (sizeof(jit_word_t) - 1)) << 3;
+ if (sh + i1 > sizeof(jit_word_t)) {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ ldi(rn(t0), addr + sizeof(jit_word_t));
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ rshi_u(r0, r0, sh);
+ lshi(rn(t0), rn(t0), __WORDSIZE - sh);
+#else
+ lshi(r0, r0, sh);
+ rshi_u(rn(t0), rn(t0), __WORDSIZE - sh);
+#endif
+ orr(r0, r0, rn(t0));
+ jit_unget_reg(t0);
+ }
+ }
+}
+
+static void
+_unldx(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ switch (i0) {
+ case 2:
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ extr_s(r0, r0);
+#else
+ rshi(r0, r0, __WORDSIZE - 16);
+#endif
+ break;
+ case 3:
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ lshi(r0, r0, __WORDSIZE - 24);
+#endif
+ rshi(r0, r0, __WORDSIZE - 24);
+ break;
+#if __WORDSIZE == 32
+ default:
+#else
+ case 4:
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ extr_i(r0, r0);
+# else
+ rshi(r0, r0, __WORDSIZE - 32);
+# endif
+#endif
+ break;
+#if __WORDSIZE == 64
+ case 5:
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ lshi(r0, r0, __WORDSIZE - 40);
+# endif
+ rshi(r0, r0, __WORDSIZE - 40);
+ break;
+ case 6:
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ lshi(r0, r0, __WORDSIZE - 48);
+# endif
+ rshi(r0, r0, __WORDSIZE - 48);
+ break;
+ case 7:
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ lshi(r0, r0, __WORDSIZE - 56);
+# endif
+ rshi(r0, r0, __WORDSIZE - 56);
+ break;
+ default:
+ break;
+#endif
+ }
+}
+
+static void
+_unldx_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ switch (i0) {
+ case 2:
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ extr_us(r0, r0);
+#else
+ rshi_u(r0, r0, __WORDSIZE - 16);
+#endif
+ break;
+ case 3:
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ lshi(r0, r0, __WORDSIZE - 24);
+#endif
+ rshi_u(r0, r0, __WORDSIZE - 24);
+ break;
+#if __WORDSIZE == 32
+ default:
+#else
+ case 4:
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ extr_ui(r0, r0);
+# else
+ rshi_u(r0, r0, __WORDSIZE - 32);
+# endif
+#endif
+ break;
+#if __WORDSIZE == 64
+ case 5:
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ lshi(r0, r0, __WORDSIZE - 40);
+# endif
+ rshi_u(r0, r0, __WORDSIZE - 40);
+ break;
+ case 6:
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ lshi(r0, r0, __WORDSIZE - 48);
+# endif
+ rshi_u(r0, r0, __WORDSIZE - 48);
+ break;
+ case 7:
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ lshi(r0, r0, __WORDSIZE - 56);
+# endif
+ rshi_u(r0, r0, __WORDSIZE - 56);
+ break;
+ default:
+ break;
+#endif
+ }
+}
+
+static void
+_fallback_unldr(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t t0, r2;
+ assert(i0 >= 1 && i0 <= (__WORDSIZE >> 3));
+ if (i0 == 1)
+ ldr_c(r0, r1);
+ else if (_jitc->unld_algorithm != 0) {
+ if (r0 == r1) {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ movr(r2, r0);
+ }
+ else
+ r2 = r1;
+ switch (i0) {
+ case 2: unldr2(r0, r2, 1); break;
+ case 3: unldr3(r0, r2, 1); break;
+# if __WORDSIZE == 32
+ default: unldr4(r0, r2); break;
+# else
+ case 4: unldr4(r0, r2, 1); break;
+ case 5: unldr5(r0, r2, 1); break;
+ case 6: unldr6(r0, r2, 1); break;
+ case 7: unldr7(r0, r2, 1); break;
+ default: unldr8(r0, r2); break;
+# endif
+ }
+ if (i0 > 1 && r0 == r1)
+ jit_unget_reg(t0);
+ }
+ else {
+ unldrw(r0, r1, i0);
+ unldx(r0, i0);
+ }
+}
+
+static void
+_fallback_unldi(jit_state_t *_jit,
+ jit_int32_t r0, jit_word_t i0, jit_word_t i1)
+{
+ assert(i1 >= 1 && i1 <= (__WORDSIZE >> 3));
+ if (i1 == 1)
+ ldi_c(r0, i0);
+ else if (_jitc->unld_algorithm != 0) {
+ switch (i1) {
+ case 2: unldi2(r0, i0, 1); break;
+ case 3: unldi3(r0, i0, 1); break;
+# if __WORDSIZE == 32
+ default: unldi4(r0, i0); break;
+# else
+ case 4: unldi4(r0, i0, 1); break;
+ case 5: unldi5(r0, i0, 1); break;
+ case 6: unldi6(r0, i0, 1); break;
+ case 7: unldi7(r0, i0, 1); break;
+ default: unldi8(r0, i0); break;
+# endif
+ }
+ }
+ else {
+ unldiw(r0, i0, i1);
+ unldx(r0, i1);
+ }
+}
+
+static void
+_fallback_unldr_u(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t t0, r2;
+ assert(i0 >= 1 && i0 <= (__WORDSIZE >> 3));
+ if (i0 == 1)
+ ldr_uc(r0, r1);
+ else if (_jitc->unld_algorithm != 0) {
+ if (r0 == r1) {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ movr(r2, r0);
+ }
+ else
+ r2 = r1;
+ switch (i0) {
+ case 2: unldr2(r0, r2, 0); break;
+ case 3: unldr3(r0, r2, 0); break;
+# if __WORDSIZE == 32
+ default: unldr4(r0, r2); break;
+# else
+ case 4: unldr4(r0, r2, 0); break;
+ case 5: unldr5(r0, r2, 0); break;
+ case 6: unldr6(r0, r2, 0); break;
+ case 7: unldr7(r0, r2, 0); break;
+ default: unldr8(r0, r2); break;
+# endif
+ }
+ if (i0 > 1 && r0 == r1)
+ jit_unget_reg(t0);
+ }
+ else {
+ unldrw(r0, r1, i0);
+ unldx_u(r0, i0);
+ }
+}
+
+static void
+_fallback_unldi_u(jit_state_t *_jit,
+ jit_int32_t r0, jit_word_t i0, jit_word_t i1)
+{
+ assert(i1 >= 1 && i1 <= (__WORDSIZE >> 3));
+ if (i1 == 1)
+ ldi_uc(r0, i0);
+ else if (_jitc->unld_algorithm != 0) {
+ switch (i1) {
+ case 2: unldi2(r0, i0, 0); break;
+ case 3: unldi3(r0, i0, 0); break;
+# if __WORDSIZE == 32
+ default: unldi4(r0, i0); break;
+# else
+ case 4: unldi4(r0, i0, 0); break;
+ case 5: unldi5(r0, i0, 0); break;
+ case 6: unldi6(r0, i0, 0); break;
+ case 7: unldi7(r0, i0, 0); break;
+ default: unldi8(r0, i0); break;
+# endif
+ }
+
+ }
+ else {
+ unldiw(r0, i0, i1);
+ unldx_u(r0, i1);
+ }
+}
+
+static void
+_fallback_unstr(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_word_t done;
+ jit_int32_t t0, t1, t2, t3, t4, t5;
+ assert(i0 > 0 && i0 <= (__WORDSIZE >> 3));
+ if (i0 == 1)
+ str_c(r0, r1);
+ else if (_jitc->unst_algorithm == 0) {
+ switch (i0) {
+ case 2: unstr2(r1, r0); break;
+ case 3: unstr3(r1, r0); break;
+# if __WORDSIZE == 32
+ default: unstr4(r1, r0); break;
+# else
+ case 4: unstr4(r1, r0); break;
+ case 5: unstr5(r1, r0); break;
+ case 6: unstr6(r1, r0); break;
+ case 7: unstr7(r1, r0); break;
+ default: unstr8(r1, r0); break;
+# endif
+ }
+ }
+ else {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ t1 = fallback_jit_get_reg(jit_class_gpr);
+ t2 = fallback_jit_get_reg(jit_class_gpr);
+ t3 = fallback_jit_get_reg(jit_class_gpr);
+ /* Zero out top bits and keep value to store in t0 */
+ if (i0 != sizeof(jit_word_t)) {
+ lshi(rn(t3), r1, (sizeof(jit_word_t) - i0) << 3);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ rshi_u(rn(t3), rn(t3), (sizeof(jit_word_t) - i0) << 3);
+#endif
+ }
+ else
+ movr(rn(t3), r1);
+ /* Check alignment */
+ andi(rn(t2), r0, sizeof(jit_word_t) - 1);
+ /* Multiply by 8 */
+ lshi(rn(t2), rn(t2), 3);
+ /* Split values to store (assume will need two stores) */
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ qlshr_u(rn(t0), rn(t1), rn(t3), rn(t2));
+#else
+ qrshr_u(rn(t0), rn(t1), rn(t3), rn(t2));
+#endif
+ /* Generate masks for values in memory */
+ if (i0 == sizeof(jit_word_t))
+ movi(rn(t3), -1);
+ else {
+#if __BYTE_ORDER == __BIG_ENDIAN
+ movi(rn(t3), ((1L << (i0 << 3)) - 1) <<
+ ((sizeof(jit_word_t) - i0) << 3));
+#else
+ movi(rn(t3), (1L << (i0 << 3)) - 1);
+#endif
+ }
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ qlshr_u(rn(t2), rn(t3), rn(t3), rn(t2));
+#else
+ qrshr_u(rn(t2), rn(t3), rn(t3), rn(t2));
+#endif
+ comr(rn(t2), rn(t2));
+ comr(rn(t3), rn(t3));
+ /* Allocate two extra registers later in case need temps for *q?shr_u */
+ t4 = fallback_jit_get_reg(jit_class_gpr);
+ t5 = fallback_jit_get_reg(jit_class_gpr);
+ /* Store words */
+ andi(rn(t4), r0, -(jit_word_t)sizeof(jit_word_t));
+ ldr(rn(t5), rn(t4));
+ andr(rn(t5), rn(t5), rn(t2));
+ orr(rn(t0), rn(t0), rn(t5));
+ str(rn(t4), rn(t0));
+ /* Make sure to not read/write on possibly unmaped memory */
+ addi(rn(t5), rn(t4), i0);
+ done = fallback_blei(_jit->pc.w, rn(t5), sizeof(jit_word_t));
+ /* Store second word if vlaue crosses a word boundary */
+ ldxi(rn(t5), rn(t4), sizeof(jit_word_t));
+ andr(rn(t5), rn(t5), rn(t3));
+ orr(rn(t1), rn(t1), rn(t5));
+ stxi(sizeof(jit_word_t), rn(t4), rn(t1));
+ /* Finished */
+ fallback_flush();
+ fallback_patch_blei(done, _jit->pc.w);
+ /* Generic/simple algorithm needs 6 temporaries, as it cannot
+ * change any of the argument registers, might need to truncate
+ * the value to store, and need a pair for values to store and
+ * another for the masks. */
+ jit_unget_reg(t5);
+ jit_unget_reg(t4);
+ jit_unget_reg(t3);
+ jit_unget_reg(t2);
+ jit_unget_reg(t1);
+ jit_unget_reg(t0);
+ }
+}
+
+static void
+_fallback_unsti(jit_state_t *_jit,
+ jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t done, address;
+ jit_int32_t t0, t1, t2, t3, t4;
+ assert(i1 > 0 && i1 <= (__WORDSIZE >> 3));
+ if (i1 == 1)
+ sti_c(i0, r0);
+ else if (_jitc->unst_algorithm == 0) {
+ switch (i1) {
+ case 1: sti_c(i0, r0); break;
+ case 2: unsti2(r0, i0); break;
+ case 3: unsti3(r0, i0); break;
+# if __WORDSIZE == 32
+ default: unsti4(r0, i0); break;
+# else
+ case 4: unsti4(r0, i0); break;
+ case 5: unsti5(r0, i0); break;
+ case 6: unsti6(r0, i0); break;
+ case 7: unsti7(r0, i0); break;
+ default: unsti8(r0, i0); break;
+# endif
+ }
+ }
+ else {
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ t1 = fallback_jit_get_reg(jit_class_gpr);
+ t2 = fallback_jit_get_reg(jit_class_gpr);
+ t3 = fallback_jit_get_reg(jit_class_gpr);
+ t4 = fallback_jit_get_reg(jit_class_gpr);
+ /* Zero out top bits and keep value to store in t0 */
+ if (i1 != sizeof(jit_word_t)) {
+ lshi(rn(t2), r0, (sizeof(jit_word_t) - i1) << 3);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ rshi_u(rn(t2), rn(t2), (sizeof(jit_word_t) - i1) << 3);
+ qlshi_u(rn(t0), rn(t1), rn(t2),
+ (i0 & (sizeof(jit_word_t) - 1)) << 3);
+#else
+ qrshi_u(rn(t0), rn(t1), rn(t2),
+ (i0 & (sizeof(jit_word_t)) - 1) << 3);
+#endif
+ }
+ else {
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ qlshi_u(rn(t0), rn(t1), r0,
+ (i0 & (sizeof(jit_word_t)) - 1) << 3);
+#else
+ qrshi_u(rn(t0), rn(t1), r0,
+ (i0 & (sizeof(jit_word_t)) - 1) << 3);
+#endif
+ }
+ /* Generate masks for values in memory */
+ if (i1 == sizeof(jit_word_t))
+ movi(rn(t2), -1);
+ else {
+#if __BYTE_ORDER == __BIG_ENDIAN
+ movi(rn(t2), ((1L << (i1 << 3)) - 1) <<
+ ((sizeof(jit_word_t) - i1) << 3));
+#else
+ movi(rn(t2), (1L << (i1 << 3)) - 1);
+#endif
+ }
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ qlshi_u(rn(t2), rn(t3), rn(t2), (i0 & (sizeof(jit_word_t)) - 1) << 3);
+#else
+ qrshi_u(rn(t2), rn(t3), rn(t2), (i0 & (sizeof(jit_word_t)) - 1) << 3);
+#endif
+ comr(rn(t2), rn(t2));
+ comr(rn(t3), rn(t3));
+ /* Store words */
+ address = i0 & -(jit_word_t)sizeof(jit_word_t);
+ ldi(rn(t4), address);
+ andr(rn(t4), rn(t4), rn(t2));
+ orr(rn(t0), rn(t0), rn(t4));
+ sti(address, rn(t0));
+ if (address + i1 > sizeof(jit_word_t)) {
+ address += sizeof(jit_word_t);
+ ldi(rn(t4), address);
+ andr(rn(t4), rn(t4), rn(t3));
+ orr(rn(t1), rn(t1), rn(t4));
+ sti(address, rn(t1));
+ }
+ jit_unget_reg(t4);
+ jit_unget_reg(t3);
+ jit_unget_reg(t2);
+ jit_unget_reg(t1);
+ jit_unget_reg(t0);
+ }
+}
+
+# ifdef fallback_unldr_x
+static void
+_fallback_unldr_x(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t t0, r2;
+# if __WORDSIZE == 32
+ jit_int32_t t1, r3;
+# endif
+ assert(i0 == 4 || i0 == 8);
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if (i0 == 4) {
+ unldr(r2, r1, 4);
+ movr_w_f(r0, r2);
+ }
+ else {
+# if __WORDSIZE == 32
+ t1 = fallback_jit_get_reg(jit_class_gpr);
+ r3 = rn(t1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ unldr(r2, r1, 4);
+ addi(r3, r1, 4);
+ unldr(r3, r3, 4);
+# else
+ unldr(r3, r1, 4);
+ addi(r2, r1, 4);
+ unldr(r2, r2, 4);
+# endif
+ movr_ww_d(r0, r2, r3);
+ jit_unget_reg(t1);
+# else
+ unldr(r2, r1, 8);
+ movr_w_d(r0, r2);
+# endif
+ }
+ jit_unget_reg(t0);
+}
+# endif
+
+# ifdef fallback_unldi_x
+static void
+_fallback_unldi_x(jit_state_t *_jit,
+ jit_int32_t r0, jit_word_t i0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+# if __WORDSIZE == 32
+ jit_int32_t t1, r3;
+# endif
+ assert(i1 == 4 || i1 == 8);
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if (i1 == 4) {
+ unldi(r2, i0, 4);
+ movr_w_f(r0, r2);
+ }
+ else {
+# if __WORDSIZE == 32
+ t1 = fallback_jit_get_reg(jit_class_gpr);
+ r3 = rn(t1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ unldi(r2, i0, 4);
+ unldi(r3, i0 + 4, 4);
+# else
+ unldi(r3, i0, 4);
+ unldi(r2, i0 + 4, 4);
+# endif
+ movr_ww_d(r0, r3, r2);
+ jit_unget_reg(t1);
+# else
+ unldi(r2, i0, 8);
+ movr_w_d(r0, r2);
+# endif
+ }
+ jit_unget_reg(t0);
+}
+# endif
+
+# ifdef fallback_unstr_x
+static void
+_fallback_unstr_x(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t t0, r2;
+# if __WORDSIZE == 32
+ jit_int32_t t1, r3;
+# endif
+ assert(i0 == 4 || i0 == 8);
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if (i0 == 4) {
+ movr_f_w(r2, r1);
+ unstr(r0, r2, 4);
+ }
+ else {
+# if __WORDSIZE == 32
+ t1 = fallback_jit_get_reg(jit_class_gpr);
+ r3 = rn(t1);
+ movr_d_ww(r2, r3, r1);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ unstr(r0, r2, 4);
+ addi(r2, r0, 4);
+ unstr(r2, r3, 4);
+# else
+ unstr(r0, r3, 4);
+ addi(r3, r0, 4);
+ unstr(r3, r2, 4);
+# endif
+ jit_unget_reg(t1);
+# else
+ movr_d_w(r2, r1);
+ unstr(r0, r2, 8);
+# endif
+ }
+ jit_unget_reg(t0);
+}
+# endif
+
+# ifdef fallback_unsti_x
+static void
+_fallback_unsti_x(jit_state_t *_jit,
+ jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_int32_t t0, r2;
+# if __WORDSIZE == 32
+ jit_int32_t t1, r3;
+# endif
+ assert(i1 == 4 || i1 == 8);
+ t0 = fallback_jit_get_reg(jit_class_gpr);
+ r2 = rn(t0);
+ if (i1 == 4) {
+ movr_f_w(r2, r0);
+ unsti(i0, r2, 4);
+ }
+ else {
+# if __WORDSIZE == 32
+ t1 = fallback_jit_get_reg(jit_class_gpr);
+ r3 = rn(t1);
+ movr_d_ww(r2, r3, r0);
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ unsti(i0, r3, 4);
+ unsti(i0 + 4, r2, 4);
+# else
+ unsti(i0, r2, 4);
+ unsti(i0 + 4, r3, 4);
+# endif
+ jit_unget_reg(t1);
+# else
+ movr_d_w(r2, r0);
+ unsti(i0, r2, 8);
+# endif
+ }
+ jit_unget_reg(t0);
+}
+# endif