/*
 * Copyright (C) 2012-2023  Free Software Foundation, Inc.
 *
 * This file is part of GNU lightning.
 *
 * GNU lightning is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 3, or (at your option)
 * any later version.
 *
 * GNU lightning is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * Authors:
 *	Paulo Cesar Pereira de Andrade
 */

#if PROTO
#  define stxi(i0,r0,r1)		stxi_i(i0,r0,r1)
#  define ldxi(r0,r1,i0)		ldxi_i(r0,r1,i0)
#  define ldr(r0,r1)			ldr_i(r0,r1)
#  define _s20P(d)			((d) >= -(int)0x80000 && d <= 0x7ffff)
#  define _s24P(d)			((d) >= -(int)0x800000 && d <= 0x7fffff)
#  define _u3(v)			((v) & 0x7)
#  define _u4(v)			((v) & 0xf)
#  define _u5(v)			((v) & 0x1f)
#  define _u8(v)			((v) & 0xff)
#  define _u12(v)			((v) & 0xfff)
#  define _u13(v)			((v) & 0x1fff)
#  define _u16(v)			((v) & 0xffff)
#  define _u24(v)			((v) & 0xffffff)
#  define jit_thumb_p()			jit_cpu.thumb
#  define jit_no_set_flags()		_jitc->no_set_flags
#  define jit_armv5_p()			(jit_cpu.version >= 5)
#  define jit_armv5e_p()		(jit_cpu.version > 5 || (jit_cpu.version == 5 && jit_cpu.extend))
#  define jit_armv6_p()			(jit_cpu.version >= 6)
#  define jit_armv7_p()			(jit_cpu.version >= 7)
#  define jit_armv7r_p()		(jit_cpu.version > 7 || (jit_cpu.version == 7 && jit_cpu.extend))
extern int	__aeabi_idivmod(int, int);
extern unsigned	__aeabi_uidivmod(unsigned, unsigned);
#  define _R0_REGNO			0x00
#  define _R1_REGNO			0x01
#  define _R2_REGNO			0x02
#  define _R3_REGNO			0x03
#  define _R4_REGNO			0x04
#  define _R5_REGNO			0x05
#  define _R6_REGNO			0x06
#  define _R7_REGNO			0x07
#  define _R8_REGNO			0x08
#  define _R9_REGNO			0x09
#  define _R10_REGNO			0x0a
#  define _R11_REGNO			0x0b
#  define _R12_REGNO			0x0c
#  define _R13_REGNO			0x0d
#  define _R14_REGNO			0x0e
#  define _R15_REGNO			0x0f
#  define _FP_REGNO			_R11_REGNO
#  define _SP_REGNO			_R13_REGNO
#  define _LR_REGNO			_R14_REGNO
#  define _PC_REGNO			_R15_REGNO
#  define ARM_CC_EQ			0x00000000	/* Z=1 */
#  define ARM_CC_NE			0x10000000	/* Z=0 */
#  define ARM_CC_HS			0x20000000	/* C=1 */
#    define ARM_CC_CS			ARM_CC_HS
#  define ARM_CC_LO			0x30000000	/* C=0 */
#    define ARM_CC_CC			ARM_CC_LO
#  define ARM_CC_MI			0x40000000	/* N=1 */
#  define ARM_CC_PL			0x50000000	/* N=0 */
#  define ARM_CC_VS			0x60000000	/* V=1 */
#  define ARM_CC_VC			0x70000000	/* V=0 */
#  define ARM_CC_HI			0x80000000	/* C=1 && Z=0 */
#  define ARM_CC_LS			0x90000000	/* C=0 || Z=1 */
#  define ARM_CC_GE			0xa0000000	/* N=V */
#  define ARM_CC_LT			0xb0000000	/* N!=V */
#  define ARM_CC_GT			0xc0000000	/* Z=0 && N=V */
#  define ARM_CC_LE			0xd0000000	/* Z=1 || N!=V */
#  define ARM_CC_AL			0xe0000000	/* always */
#  define ARM_CC_NV			0xf0000000	/* reserved */
#  define THUMB2_IT			0
#  define THUMB2_ITT			1
#  define THUMB2_ITE			2
#  define THUMB2_ITTT			3
#  define THUMB2_ITET			4
#  define THUMB2_ITTE			5
#  define THUMB2_ITEE			6
#  define THUMB2_ITTTT			7
#  define THUMB2_ITETT			8
#  define THUMB2_ITTET			9
#  define THUMB2_ITEET			10
#  define THUMB2_ITTTE			11
#  define THUMB2_ITETE			12
#  define THUMB2_ITTEE			13
#  define THUMB2_ITEEE			14
#  define ARM_MOV			0x01a00000
#  define THUMB_MOV			    0x4600
#  define ARM_MOVWI			0x03000000	/* v6t2, v7 */
#  define THUMB_MOVI			    0x2000
#  define THUMB2_MOVI			0xf0400000
#  define THUMB2_MOVWI			0xf2400000
#  define ARM_MOVTI			0x03400000
#  define THUMB2_MOVTI			0xf2c00000
#  define ARM_MVN			0x01e00000
#  define THUMB_MVN			    0x43c0
#  define THUMB2_MVN			0xea600000
#  define THUMB2_MVNI			0xf0600000
#  define ARM_I				0x02000000 /* immediate */
#  define ARM_S				0x00100000 /* set flags */
#  define ARM_ADD			0x00800000
#  define THUMB_ADD			    0x1800
#  define THUMB_ADDX			    0x4400
#  define THUMB2_ADD			0xeb000000
#  define THUMB_ADDI3			    0x1c00
#  define THUMB_ADDI8			    0x3000
#  define THUMB2_ADDI			0xf1000000
#  define THUMB2_ADDWI			0xf2000000
#  define ARM_ADC			0x00a00000
#  define THUMB_ADC			    0x4140
#  define THUMB2_ADC			0xeb400000
#  define THUMB2_ADCI			0xf1400000
#  define ARM_SUB			0x00400000
#  define THUMB_SUB			    0x1a00
#  define THUMB2_SUB			0xeba00000
#  define THUMB_SUBI3			    0x1e00
#  define THUMB_SUBI8			    0x3800
#  define THUMB2_SUBI			0xf1a00000
#  define THUMB2_SUBWI			0xf2a00000
#  define ARM_SBC			0x00c00000
#  define THUMB_SBC			    0x4180
#  define THUMB2_SBC			0xeb600000
#  define THUMB2_SBCI			0xf1600000
#  define ARM_RSB			0x00600000
#  define THUMB_RSBI			    0x4240
#  define THUMB2_RSBI			0xf1c00000
#  define ARM_MUL			0x00000090
#  define THUMB_MUL			    0x4340
#  define THUMB2_MUL			0xfb00f000
#  define ARM_UMULL			0x00800090
#  define THUMB2_UMULL			0xfba00000
#  define ARM_SMULL			0x00c00090
#  define THUMB2_SMULL			0xfb800000
/* >> ARMv7r */
#  define ARM_SDIV			0x07100010
#  define ARM_UDIV			0x07300010
#  define THUMB2_SDIV			0xfb90f0f0
#  define THUMB2_UDIV			0xfbb0f0f0
/* << ARMv7r */
#  define ARM_AND			0x00000000
#  define THUMB_AND			    0x4000
#  define THUMB2_AND			0xea000000
#  define THUMB2_ANDI			0xf0000000
#  define ARM_BIC			0x01c00000
#  define THUMB2_BIC			0xea200000
#  define THUMB2_BICI			0xf0200000
#  define ARM_ORR			0x01800000
#  define THUMB_ORR			    0x4300
#  define THUMB2_ORR			0xea400000
#  define THUMB2_ORRI			0xf0400000
#  define ARM_EOR			0x00200000
#  define THUMB_EOR			    0x4040
#  define THUMB2_EOR			0xea800000
#  define THUMB2_EORI			0xf0800000
/* >> ARMv6* */
#  define ARM_REV			0x06bf0f30
#  define THUMB_REV			    0xba00
#  define THUMB2_REV			0xfa90f080
#  define ARM_REV16			0x06bf0fb0
#  define THUMB_REV16			    0xba40
#  define THUMB2_REV16			0xfa90f090
#  define ARM_SXTB			0x06af0070
#  define THUMB_SXTB			    0xb240
#  define THUMB2_SXTB			0xfa40f080
#  define ARM_UXTB			0x06ef0070
#  define THUMB_UXTB			    0xb2c0
#  define THUMB2_UXTB			0xfa50f080
#  define ARM_SXTH			0x06bf0070
#  define THUMB_SXTH			    0xb200
#  define THUMB2_SXTH			0xfa00f080
#  define ARM_UXTH			0x06ff0070
#  define THUMB_UXTH			    0xb280
#  define THUMB2_UXTH			0xfa10f080
#  define ARM_XTR8			0x00000400 /* ?xt? rotate 8 bits */
#  define ARM_XTR16			0x00000800 /* ?xt? rotate 16 bits */
#  define ARM_XTR24			0x00000c00 /* ?xt? rotate 24 bits */
#  define ARM_LDREX			0x01900090
#  define THUMB2_LDREX			0xe8500000
#  define ARM_STREX			0x01800090
#  define THUMB2_STREX			0xe8400000
/* << ARMv6* */
/* >> ARMv6t2 */
#  define THUMB2_CLZ			0xfab0f080
#  define THUMB2_RBIT			0xfa90f0a0
#  define ARM_RBIT			0x06f00030
/* << ARMv6t2 */
#  define ARM_CLZ			0x01600010
/* >> ARMv7 */
#  define ARM_DMB			0xf57ff050
#  define THUMB2_DMB			0xf3bf8f50
#  define DMB_SY			0xf
#  define DMB_ST			0xe
#  define DMB_ISH			0xb
#  define DMB_ISHST			0xa
#  define DMB_NSH			0x7
#  define DMB_NSHT			0x6
#  define DMB_OSH			0x3
#  define DMB_OSHST			0x2
/* << ARMv7 */
#  define ARM_SHIFT			0x01a00000
#  define ARM_R				0x00000010 /* register shift */
#  define ARM_LSL			0x00000000
#  define THUMB_LSL			    0x4080
#  define THUMB2_LSL			0xfa00f000
#  define THUMB_LSLI			    0x0000
#  define THUMB2_LSLI			0xea4f0000
#  define ARM_LSR			0x00000020
#  define THUMB_LSR			    0x40c0
#  define THUMB2_LSR			0xfa20f000
#  define THUMB_LSRI			    0x0800
#  define THUMB2_LSRI			0xea4f0010
#  define ARM_ASR			0x00000040
#  define THUMB_ASR			    0x4100
#  define THUMB2_ASR			0xfa40f000
#  define THUMB_ASRI			    0x1000
#  define THUMB2_ASRI			0xea4f0020
#  define ARM_ROR			0x00000060
#  define ARM_CMP			0x01500000
#  define THUMB_CMP			    0x4280
#  define THUMB_CMPX			    0x4500
#  define THUMB2_CMP			0xebb00000
#  define THUMB_CMPI			    0x2800
#  define THUMB2_CMPI			0xf1b00000
#  define ARM_CMN			0x01700000
#  define THUMB_CMN			    0x42c0
#  define THUMB2_CMN			0xeb100000
#  define THUMB2_CMNI			0xf1100000
#  define ARM_TST			0x01100000
#  define THUMB_TST			    0x4200
#  define THUMB2_TST			0xea100000
#  define THUMB2_TSTI			0xf0100000
#  define ARM_TEQ			0x01300000
/* branch */
#  define ARM_BX			0x012fff10
#  define ARM_BLX			0x012fff30
#  define THUMB_BLX			    0x4780
#  define ARM_BLXI			0xfa000000
#  define THUMB2_BLXI			0xf000c000
#  define ARM_B				0x0a000000
#  define THUMB_CC_B			    0xd000
#  define THUMB_B			    0xe000
#  define THUMB2_CC_B			0xf0008000
#  define THUMB2_B			0xf0009000
#  define ARM_BLI			0x0b000000
#  define THUMB2_BLI			0xf000d000
/* ldr/str */
#  define ARM_P				0x00800000 /* positive offset */
#  define THUMB2_P			0x00000400
#  define THUMB2_U			0x00000200
#  define THUMB2_W			0x00000100
#  define ARM_LDRSB			0x011000d0
#  define THUMB_LDRSB			    0x5600
#  define THUMB2_LDRSB			0xf9100000
#  define ARM_LDRSBI			0x015000d0
#  define THUMB2_LDRSBI			0xf9100c00
#  define THUMB2_LDRSBWI		0xf9900000
#  define ARM_LDRB			0x07500000
#  define THUMB_LDRB			    0x5c00
#  define THUMB2_LDRB			0xf8100000
#  define ARM_LDRBI			0x05500000
#  define THUMB_LDRBI			    0x7800
#  define THUMB2_LDRBI			0xf8100c00
#  define THUMB2_LDRBWI			0xf8900000
#  define ARM_LDRSH			0x011000f0
#  define THUMB_LDRSH			    0x5e00
#  define THUMB2_LDRSH			0xf9300000
#  define ARM_LDRSHI			0x015000f0
#  define THUMB2_LDRSHI			0xf9300c00
#  define THUMB2_LDRSHWI		0xf9b00000
#  define ARM_LDRH			0x011000b0
#  define THUMB_LDRH			    0x5a00
#  define THUMB2_LDRH			0xf8300000
#  define ARM_LDRHI			0x015000b0
#  define THUMB_LDRHI			    0x8800
#  define THUMB2_LDRHI			0xf8300c00
#  define THUMB2_LDRHWI			0xf8b00000
#  define ARM_LDR			0x07100000
#  define THUMB_LDR			    0x5800
#  define THUMB2_LDR			0xf8500000
#  define ARM_LDRI			0x05100000
#  define THUMB_LDRI			    0x6800
#  define THUMB_LDRISP			    0x9800
#  define THUMB2_LDRI			0xf8500c00
#  define THUMB2_LDRWI			0xf8d00000
#  define ARM_LDRD			0x010000d0
#  define ARM_LDRDI			0x014000d0
#  define THUMB2_LDRDI			0xe8500000
#  define ARM_STRB			0x07400000
#  define THUMB_STRB			    0x5400
#  define THUMB2_STRB			0xf8000000
#  define ARM_STRBI			0x05400000
#  define THUMB_STRBI			    0x7000
#  define THUMB2_STRBI			0xf8000c00
#  define THUMB2_STRBWI			0xf8800000
#  define ARM_STRH			0x010000b0
#  define THUMB_STRH			    0x5200
#  define THUMB2_STRH			0xf8200000
#  define ARM_STRHI			0x014000b0
#  define THUMB_STRHI			    0x8000
#  define THUMB2_STRHI			0xf8200c00
#  define THUMB2_STRHWI			0xf8a00000
#  define ARM_STR			0x07000000
#  define THUMB_STR			    0x5000
#  define THUMB2_STR			0xf8400000
#  define ARM_STRI			0x05000000
#  define THUMB_STRI			    0x6000
# define THUMB2_STRWI			0xf8c00000
#  define THUMB_STRISP			    0x9000
#  define THUMB2_STRI			0xf8400c00
#  define ARM_STRD			0x010000f0
# define ARM_STRDI			0x014000f0
#  define THUMB2_STRDI			0xe8400000
/* ldm/stm */
#  define ARM_M				0x08000000
#  define ARM_M_L			0x00100000 /* load; store if not set */
#  define ARM_M_I			0x00800000 /* inc; dec if not set */
#  define ARM_M_B			0x01000000 /* before; after if not set */
#  define ARM_M_U			0x00200000 /* update Rn */
#  define THUMB2_LDM_W			0x00200000
#  define THUMB2_LDM_P			0x00008000
#  define THUMB2_LDM_M			0x00004000
#  define THUMB_LDMIA			    0xc800
#  define THUMB2_LDMIA			0xe8900000
#  define THUMB2_LDMB			0xe9100000
#  define THUMB_PUSH			    0xb400
#  define THUMB2_PUSH			0xe92d0000
#  define THUMB_POP			    0xbc00
#  define THUMB2_POP			0xe8bd0000
#  define ii(i)				*_jit->pc.ui++ = i
#  define is(i)				*_jit->pc.us++ = i
#  if __BYTE_ORDER == __LITTLE_ENDIAN
#    define iss(i, j)			do { is(j); is(i); } while (0)
#    define code2thumb(t0, t1, c0, c1)	do { t1 = c0; t0 = c1; } while (0)
#    define thumb2code(t0, t1, c0, c1)	do { c0 = t1; c1 = t0; } while (0)
#  else
#    define iss(i, j)			do { is(i); is(j); } while (0)
#    define code2thumb(t0, t1, c0, c1)	do { t0 = c0; t1 = c1; } while (0)
#    define thumb2code(t0, t1, c0, c1)	do { c0 = t0; c1 = t1; } while (0)
#  endif
static int encode_arm_immediate(unsigned int v);
static int encode_thumb_immediate(unsigned int v);
static int encode_thumb_word_immediate(unsigned int v);
static int encode_thumb_jump(int v);
static int encode_thumb_cc_jump(int v);
static int encode_thumb_shift(int v, int type) maybe_unused;
#  define corrr(cc,o,rn,rd,rm)		_corrr(_jit,cc,o,rn,rd,rm)
static void _corrr(jit_state_t*,int,int,int,int,int);
#  define corri(cc,o,rn,rd,im)		_corri(_jit,cc,o,rn,rd,im)
static void _corri(jit_state_t*,int,int,int,int,int);
#define corri8(cc,o,rn,rt,im)	_corri8(_jit,cc,o,rn,rt,im)
static void _corri8(jit_state_t*,int,int,int,int,int);
#  define torrr(o,rn,rd,rm)		_torrr(_jit,o,rn,rd,rm)
static void _torrr(jit_state_t*,int,int,int,int);
#  define torrrs(o,rn,rd,rm,im)		_torrrs(_jit,o,rn,rd,rm,im)
static void _torrrs(jit_state_t*,int,int,int,int,int) maybe_unused;
#  define torxr(o,rn,rt,rm)		_torxr(_jit,o,rn,rt,rm)
static void _torxr(jit_state_t*,int,int,int,int);
#  define torrrr(o,rn,rl,rh,rm)		_torrrr(_jit,o,rn,rl,rh,rm)
static void _torrrr(jit_state_t*,int,int,int,int,int) maybe_unused;
#  define torrri8(o,rn,rt,rt2,im)	_torrri8(_jit,o,rn,rt,rt2,im)
static void _torrri8(jit_state_t*,int,int,int,int,int) maybe_unused;
#  define coriw(cc,o,rd,im)		_coriw(_jit,cc,o,rd,im)
static void _coriw(jit_state_t*,int,int,int,int);
#  define torri(o,rd,rn,im)		_torri(_jit,o,rd,rn,im)
static void _torri(jit_state_t*,int,int,int,int);
#  define torri8(o,rn,rt,im)		_torri8(_jit,o,rn,rt,im)
static void _torri8(jit_state_t*,int,int,int,int);
#  define torri12(o,rn,rt,im)		_torri12(_jit,o,rn,rt,im)
static void _torri12(jit_state_t*,int,int,int,int);
#  define tshift(o,rd,rm,im)		_tshift(_jit,o,rd,rm,im)
static void _tshift(jit_state_t*,int,int,int,int);
#  define toriw(o,rd,im)		_toriw(_jit,o,rd,im)
static void _toriw(jit_state_t*,int,int,int);
#  define tc8(cc,im)			_tc8(_jit,cc,im)
static void _tc8(jit_state_t*,int,int) maybe_unused;
#  define t11(im)			_t11(_jit,im)
static void _t11(jit_state_t*,int);
#  define tcb(cc,im)			_tcb(_jit,cc,im)
static void _tcb(jit_state_t*,int,int);
#  define blxi(im)			_blxi(_jit,im)
static void _blxi(jit_state_t*,int) maybe_unused;
#  define tb(o,im)			_tb(_jit,o,im)
static void _tb(jit_state_t*,int,int);
#  define corrrr(cc,o,rh,rl,rm,rn)	_corrrr(_jit,cc,o,rh,rl,rm,rn)
static void _corrrr(jit_state_t*,int,int,int,int,int,int);
#  define corrrs(cc,o,rn,rd,rm,im)	_corrrs(_jit,cc,o,rn,rd,rm,im)
static void _corrrs(jit_state_t*,int,int,int,int,int,int);
#  define cshift(cc,o,rd,rm,rn,im)	_cshift(_jit,cc,o,rd,rm,rn,im)
static void _cshift(jit_state_t*,int,int,int,int,int,int);
#  define cb(cc,o,im)			_cb(_jit,cc,o,im)
static void _cb(jit_state_t*,int,int,int);
#  define cbx(cc,o,rm)			_cbx(_jit,cc,o,rm)
static void _cbx(jit_state_t*,int,int,int);
#  define corl(cc,o,r0,i0)		_corl(_jit,cc,o,r0,i0)
static void _corl(jit_state_t*,int,int,int,int);
#  define c6orr(cc,o,r0,r1)		_c6orr(_jit,cc,o,r0,r1)
static void _c6orr(jit_state_t*,int,int,int,int);
#  define tcit(cc,it)			_tcit(_jit,cc,it)
static void _tcit(jit_state_t*,unsigned int,int);
#  define IT(cc)			tcit(cc,THUMB2_IT)
#  define ITT(cc)			tcit(cc,THUMB2_ITT)
#  define ITE(cc)			tcit(cc,THUMB2_ITE)
#  define ITTT(cc)			tcit(cc,THUMB2_ITTT)
#  define ITTE(cc)			tcit(cc,THUMB2_ITTE)
#  define ITET(cc)			tcit(cc,THUMB2_ITET)
#  define ITEE(cc)			tcit(cc,THUMB2_ITEE)
#  define ITTTT(cc)			tcit(cc,THUMB2_ITTTT)
#  define ITETT(cc)			tcit(cc,THUMB2_ITETT)
#  define ITTET(cc)			tcit(cc,THUMB2_ITTET)
#  define ITEET(cc)			tcit(cc,THUMB2_ITEET)
#  define ITTTE(cc)			tcit(cc,THUMB2_ITTTE)
#  define ITETE(cc)			tcit(cc,THUMB2_ITETE)
#  define ITTEE(cc)			tcit(cc,THUMB2_ITTEE)
#  define ITEEE(cc)			tcit(cc,THUMB2_ITEEE)
#  define tpp(o,im)			_tpp(_jit,o,im)
static void _tpp(jit_state_t*,int,int);
#  define torl(o,rn,im)			_torl(_jit,o,rn,im)
static void _torl(jit_state_t*,int,int,int) maybe_unused;
#  define DMB(im)			dmb(im)
#  define T2_DMB(im)			tdmb(im)
#  define dmb(im)			_dmb(_jit, im)
static void _dmb(jit_state_t *_jit, int im);
#  define tdmb(im)			_tdmb(_jit, im)
static void _tdmb(jit_state_t *_jit, int im);
#  define CC_MOV(cc,rd,rm)		corrr(cc,ARM_MOV,0,rd,rm)
#  define MOV(rd,rm)			CC_MOV(ARM_CC_AL,rd,rm)
#  define T1_MOV(rd,rm)			is(THUMB_MOV|((_u4(rd)&8)<<4)|(_u4(rm)<<3)|(rd&7))
#  define T2_MOV(rd,rm)			T2_ORR(rd,_R15_REGNO,rm)
#  define CC_MOVI(cc,rd,im)		corri(cc,ARM_MOV|ARM_I,0,rd,im)
#  define MOVI(rd,im)			CC_MOVI(ARM_CC_AL,rd,im)
#  define CC_MOVWI(cc,rd,im)		coriw(cc,ARM_MOVWI,rd,im)
#  define MOVWI(rd,im)			CC_MOVWI(ARM_CC_AL,rd,im)
#  define T1_MOVI(rd,im)		is(THUMB_MOVI|(_u3(rd)<<8)|_u8(im))
#  define T2_MOVI(rd,im)		torri(THUMB2_MOVI,_R15_REGNO,rd,im)
#  define T2_MOVWI(rd,im)		toriw(THUMB2_MOVWI,rd,im)
#  define CC_MOVTI(cc,rd,im)		coriw(cc,ARM_MOVTI,rd,im)
#  define MOVTI(rd,im)			CC_MOVTI(ARM_CC_AL,rd,im)
#  define T2_MOVTI(rd,im)		toriw(THUMB2_MOVTI,rd,im)
#  define CC_MVN(cc,rd,rm)		corrr(cc,ARM_MVN,0,rd,rm)
#  define MVN(rd,rm)			CC_MVN(ARM_CC_AL,rd,rm)
#  define T1_MVN(rd,rm)			is(THUMB_MVN|(_u3(rm)<<3)|_u3(rd))
#  define T2_MVN(rd,rm)			torrr(THUMB2_MVN,_R15_REGNO,rd,rm)
#  define CC_MVNI(cc,rd,im)		corri(cc,ARM_MVN|ARM_I,0,rd,im)
#  define MVNI(rd,im)			CC_MVNI(ARM_CC_AL,rd,im)
#  define T2_MVNI(rd,im)		torri(THUMB2_MVNI,_R15_REGNO,rd,im)
#  define CC_NOT(cc,rd,rm)		CC_MVN(cc,rd,rm)
#  define NOT(rd,rm)			CC_NOT(ARM_CC_AL,rd,rm)
#  define T1_NOT(rd,rm)			T1_MVN(rd,rm)
#  define T2_NOT(rd,rm)			T2_MVN(rd,rm)
#  define T2_CLZ(rd,rm)			torrr(THUMB2_CLZ,rm,rd,rm)
#  define CC_CLZ(cc,rd,rm)		corrrr(cc,ARM_CLZ,_R15_REGNO,rd,_R15_REGNO,rm)
#  define CLZ(rd,rm)			CC_CLZ(ARM_CC_AL,rd,rm)
#  define T2_RBIT(rd,rm)		torrr(THUMB2_RBIT,rm,rd,rm)
#  define CC_RBIT(cc,rd,rm)		corrrr(cc,ARM_RBIT,_R15_REGNO,rd,_R15_REGNO,rm)
#  define RBIT(rd,rm)			CC_RBIT(ARM_CC_AL,rd,rm)
#  define NOP()				MOV(_R0_REGNO, _R0_REGNO)
#  define T1_NOP()			is(0xbf00)
#  define CC_ADD(cc,rd,rn,rm)		corrr(cc,ARM_ADD,rn,rd,rm)
#  define ADD(rd,rn,rm)			CC_ADD(ARM_CC_AL,rd,rn,rm)
#  define T1_ADD(rd,rn,rm)		is(THUMB_ADD|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rd))
#  define T1_ADDX(rdn,rm)		is(THUMB_ADDX|((_u4(rdn)&8)<<4)|(_u4(rm)<<3)|(rdn&7))
#  define T2_ADD(rd,rn,rm)		torrr(THUMB2_ADD,rn,rd,rm)
#  define CC_ADDI(cc,rd,rn,im)		corri(cc,ARM_ADD|ARM_I,rn,rd,im)
#  define ADDI(rd,rn,im)		CC_ADDI(ARM_CC_AL,rd,rn,im)
#  define T1_ADDI3(rd,rn,im)		is(THUMB_ADDI3|(_u3(im)<<6)|(_u3(rn)<<3)|_u3(rd))
#  define T1_ADDI8(rdn,im)		is(THUMB_ADDI8|(_u3(rdn)<<8)|_u8(im))
#  define T2_ADDI(rd,rn,im)		torri(THUMB2_ADDI,rn,rd,im)
#  define T2_ADDWI(rd,rn,im)		torri(THUMB2_ADDWI,rn,rd,im)
#  define CC_ADDS(cc,rd,rn,rm)		corrr(cc,ARM_ADD|ARM_S,rn,rd,rm)
#  define ADDS(rd,rn,rm)		CC_ADDS(ARM_CC_AL,rd,rn,rm)
#  define T2_ADDS(rd,rn,rm)		torrr(THUMB2_ADD|ARM_S,rn,rd,rm)
#  define ADDSI(rd,rn,im)		corri(ARM_CC_AL,ARM_ADD|ARM_S|ARM_I,rn,rd,im)
#  define T2_ADDSI(rd,rn,im)		torri(THUMB2_ADDI|ARM_S,rn,rd,im)
#  define CC_ADC(cc,rd,rn,rm)		corrr(cc,ARM_ADC,rn,rd,rm)
#  define ADC(rd,rn,rm)			CC_ADC(ARM_CC_AL,rd,rn,rm)
#  define T1_ADC(rdn,rm)		is(THUMB_ADC|(_u3(rm)<<3)|_u3(rdn))
#  define T2_ADC(rd,rn,rm)		torrr(THUMB2_ADC,rn,rd,rm)
#  define CC_ADCI(cc,rd,rn,im)		corri(cc,ARM_ADC|ARM_I,rn,rd,im)
#  define ADCI(rd,rn,im)		CC_ADCI(ARM_CC_AL,rd,rn,im)
#  define T2_ADCI(rd,rn,im)		torri(THUMB2_ADCI,rn,rd,im)
#  define CC_ADCS(cc,rd,rn,rm)		corrr(cc,ARM_ADC|ARM_S,rn,rd,rm)
#  define ADCS(rd,rn,rm)		CC_ADCS(ARM_CC_AL,rd,rn,rm)
#  define T2_ADCS(rd,rn,rm)		torrr(THUMB2_ADC|ARM_S,rn,rd,rm)
#  define CC_ADCSI(cc,rd,rn,im)		corri(cc,ARM_ADC|ARM_S|ARM_I,rn,rd,im)
#  define ADCSI(rd,rn,im)		CC_ADCSI(ARM_CC_AL,rd,rn,im)
#  define T2_ADCSI(rd,rn,im)		torri(THUMB2_ADCI|ARM_S,rn,rd,im)
#  define CC_SUB(cc,rd,rn,rm)		corrr(cc,ARM_SUB,rn,rd,rm)
#  define SUB(rd,rn,rm)			CC_SUB(ARM_CC_AL,rd,rn,rm)
#  define T1_SUB(rd,rn,rm)		is(THUMB_SUB|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rd))
#  define T2_SUB(rd,rn,rm)		torrr(THUMB2_SUB,rn,rd,rm)
#  define CC_SUBI(cc,rd,rn,im)		corri(cc,ARM_SUB|ARM_I,rn,rd,im)
#  define SUBI(rd,rn,im)		CC_SUBI(ARM_CC_AL,rd,rn,im)
#  define T1_SUBI3(rd,rn,im)		is(THUMB_SUBI3|(_u3(im)<<6)|(_u3(rn)<<3)|_u3(rd))
#  define T1_SUBI8(rdn,im)		is(THUMB_SUBI8|(_u3(rdn)<<8)|_u8(im))
#  define T2_SUBI(rd,rn,im)		torri(THUMB2_SUBI,rn,rd,im)
#  define T2_SUBWI(rd,rn,im)		torri(THUMB2_SUBWI,rn,rd,im)
#  define CC_SUBS(cc,rd,rn,rm)		corrr(cc,ARM_SUB|ARM_S,rn,rd,rm)
#  define SUBS(rd,rn,rm)		CC_SUBS(ARM_CC_AL,rd,rn,rm)
#  define T2_SUBS(rd,rn,rm)		torrr(THUMB2_SUB|ARM_S,rn,rd,rm)
#  define CC_SUBSI(cc,rd,rn,im)		corri(cc,ARM_SUB|ARM_S|ARM_I,rn,rd,im)
#  define SUBSI(rd,rn,im)		CC_SUBSI(ARM_CC_AL,rd,rn,im)
#  define T2_SUBSI(rd,rn,im)		torri(THUMB2_SUBI|ARM_S,rn,rd,im)
#  define CC_SBC(cc,rd,rn,rm)		corrr(cc,ARM_SBC,rn,rd,rm)
#  define SBC(rd,rn,rm)			CC_SBC(ARM_CC_AL,rd,rn,rm)
#  define T1_SBC(rdn,rm)		is(THUMB_SBC|(_u3(rm)<<3)|_u3(rdn))
#  define T2_SBC(rd,rn,rm)		torrr(THUMB2_SBC,rn,rd,rm)
#  define CC_SBCI(cc,rd,rn,im)		corri(cc,ARM_SBC|ARM_I,rn,rd,im)
#  define SBCI(rd,rn,im)		CC_SBCI(ARM_CC_AL,rd,rn,im)
#  define T2_SBCI(rd,rn,im)		torri(THUMB2_SBCI,rn,rd,im)
#  define CC_SBCS(cc,rd,rn,rm)		corrr(cc,ARM_SBC|ARM_S,rn,rd,rm)
#  define SBCS(rd,rn,rm)		CC_SBCS(ARM_CC_AL,rd,rn,rm)
#  define T2_SBCS(rd,rn,rm)		torrr(THUMB2_SBC|ARM_S,rn,rd,rm)
#  define CC_SBCSI(cc,rd,rn,im)		corri(cc,ARM_SBC|ARM_S|ARM_I,rn,rd,im)
#  define SBCSI(rd,rn,im)		CC_SBCSI(ARM_CC_AL,rd,rn,im)
#  define T2_SBCSI(rd,rn,im)		torri(THUMB2_SBCI|ARM_S,rn,rd,im)
#  define CC_RSB(cc,rd,rn,rm)		corrr(cc,ARM_RSB,rn,rd,rm)
#  define RSB(rd,rn,rm)			CC_RSB(ARM_CC_AL,rd,rn,rm)
#  define T2_RSB(rd,rn,rm)		torrr(THUMB2_RSB,rn,rd,rm)
#  define CC_RSBI(cc,rd,rn,im)		corri(cc,ARM_RSB|ARM_I,rn,rd,im)
#  define RSBI(rd,rn,im)		CC_RSBI(ARM_CC_AL,rd,rn,im)
#  define T1_RSBI(rd,rn)		is(THUMB_RSBI|(_u3(rn)<<3)|_u3(rd))
#  define T2_RSBI(rd,rn,im)		torri(THUMB2_RSBI,rn,rd,im)
#  define CC_MUL(cc,rl,rn,rm)		corrrr(cc,ARM_MUL,rl,0,rm,rn)
#  define MUL(rl,rn,rm)			CC_MUL(ARM_CC_AL,rl,rn,rm)
#  define T1_MUL(rdm,rn)		is(THUMB_MUL|(_u3(rn)<<3)|_u3(rdm))
#  define T2_MUL(rd,rn,rm)		torrr(THUMB2_MUL,rn,rd,rm)
#  define CC_SMULL(cc,rl,rh,rn,rm)	corrrr(cc,ARM_SMULL,rh,rl,rm,rn)
#  define SMULL(rl,rh,rn,rm)		CC_SMULL(ARM_CC_AL,rl,rh,rn,rm)
#  define T2_SMULL(rl,rh,rn,rm)		torrrr(THUMB2_SMULL,rn,rl,rh,rm)
#  define CC_UMULL(cc,rl,rh,rn,rm)	corrrr(cc,ARM_UMULL,rh,rl,rm,rn)
#  define UMULL(rl,rh,rn,rm)		CC_UMULL(ARM_CC_AL,rl,rh,rn,rm)
#  define T2_UMULL(rl,rh,rn,rm)		torrrr(THUMB2_UMULL,rn,rl,rh,rm)
#  define CC_SDIV(cc,rd,rn,rm)		corrrr(cc,ARM_SDIV,rd,15,rn,rm)
#  define SDIV(rd,rn,rm)		CC_SDIV(ARM_CC_AL,rd,rm,rn)
#  define CC_UDIV(cc,rd,rn,rm)		corrrr(cc,ARM_UDIV,rd,15,rn,rm)
#  define UDIV(rd,rn,rm)		CC_UDIV(ARM_CC_AL,rd,rm,rn)
#  define T2_SDIV(rd,rn,rm)		torrr(THUMB2_SDIV,rn,rd,rm)
#  define T2_UDIV(rd,rn,rm)		torrr(THUMB2_UDIV,rn,rd,rm)
#  define CC_AND(cc,rd,rn,rm)		corrr(cc,ARM_AND,rn,rd,rm)
#  define AND(rd,rn,rm)			CC_AND(ARM_CC_AL,rd,rn,rm)
#  define T1_AND(rdn,rm)		is(THUMB_AND|(_u3(rm)<<3)|_u3(rdn))
#  define T2_AND(rd,rn,rm)		torrr(THUMB2_AND,rn,rd,rm)
#  define CC_ANDI(cc,rd,rn,im)		corri(cc,ARM_AND|ARM_I,rn,rd,im)
#  define ANDI(rd,rn,im)		CC_ANDI(ARM_CC_AL,rd,rn,im)
#  define T2_ANDI(rd,rn,im)		torri(THUMB2_ANDI,rn,rd,im)
#  define CC_ANDS(cc,rd,rn,rm)		corrr(cc,ARM_AND|ARM_S,rn,rd,rm)
#  define ANDS(rd,rn,rm)		CC_ANDS(ARM_CC_AL,rd,rn,rm)
#  define T2_ANDS(rd,rn,rm)		torrr(THUMB2_AND|ARM_S,rn,rd,rm)
#  define CC_ANDSI(cc,rd,rn,im)		corri(cc,ARM_AND|ARM_S|ARM_I,rn,rd,im)
#  define ANDSI(rd,rn,im)		CC_ANDSI(ARM_CC_AL,rd,rn,im)
#  define T2_ANDSI(rd,rn,im)		torri(ARM_CC_AL,THUMB2_ANDI|ARM_S,rn,rd,im)
#  define CC_BIC(cc,rd,rn,rm)		corrr(cc,ARM_BIC,rn,rd,rm)
#  define BIC(rd,rn,rm)			CC_BIC(ARM_CC_AL,rd,rn,rm)
#  define T2_BIC(rd,rn,rm)		torrr(THUMB2_BIC,rn,rd,rm)
#  define CC_BICI(cc,rd,rn,im)		corri(cc,ARM_BIC|ARM_I,rn,rd,im)
#  define BICI(rd,rn,im)		CC_BICI(ARM_CC_AL,rd,rn,im)
#  define T2_BICI(rd,rn,im)		torri(THUMB2_BICI,rn,rd,im)
#  define CC_BICS(cc,rd,rn,rm)		corrr(cc,ARM_BIC|ARM_S,rn,rd,rm)
#  define BICS(rd,rn,rm)		CC_BICS(ARM_CC_AL,rd,rn,rm)
#  define T2_BICS(rd,rn,rm)		torrr(THUMB2_BIC|ARM_S,rn,rd,rm)
#  define CC_BICSI(cc,rd,rn,im)		corri(cc,ARM_BIC|ARM_S|ARM_I,rn,rd,im)
#  define BICSI(rd,rn,im)		CC_BICSI(ARM_CC_AL,rd,rn,im)
#  define T2_BICSI(rd,rn,im)		torri(ARM_CC_AL,THUMB2_BICI|ARM_S,rn,rd,im)
#  define CC_ORR(cc,rd,rn,rm)		corrr(cc,ARM_ORR,rn,rd,rm)
#  define ORR(rd,rn,rm)			CC_ORR(ARM_CC_AL,rd,rn,rm)
#  define T1_ORR(rdn,rm)		is(THUMB_ORR|(_u3(rm)<<3)|_u3(rdn))
#  define T2_ORR(rd,rn,rm)		torrr(THUMB2_ORR,rn,rd,rm)
#  define CC_ORR_SI(cc,rd,rn,rt,sh,im)	corrrs(cc,ARM_ORR|sh,rn,rd,rm,im)
#  define ORR_SI(r0,r1,r2,sh,im)	CC_ORR_SI(ARM_CC_AL,r0,r1,r2,sh,im)
#  define CC_ORRI(cc,rd,rn,im)		corri(cc,ARM_ORR|ARM_I,rn,rd,im)
#  define ORRI(rd,rn,im)		CC_ORRI(ARM_CC_AL,rd,rn,im)
#  define T2_ORRI(rd,rn,im)		torri(THUMB2_ORRI,rn,rd,im)
#  define CC_EOR(cc,rd,rn,rm)		corrr(cc,ARM_EOR,rn,rd,rm)
#  define EOR(rd,rn,rm)			CC_EOR(ARM_CC_AL,rd,rn,rm)
#  define T1_EOR(rdn,rm)		is(THUMB_EOR|(_u3(rm)<<3)|_u3(rdn))
#  define T2_EOR(rd,rn,rm)		torrr(THUMB2_EOR,rn,rd,rm)
#  define CC_EOR_SI(cc,rd,rn,rm,sh,im)	corrrs(cc,ARM_EOR|sh,rn,rd,rm,im)
#  define EOR_SI(r0,r1,r2,sh,im)	CC_EOR_SI(ARM_CC_AL,r0,r1,r2,sh,im)
#  define CC_EORI(cc,rd,rn,im)		corri(cc,ARM_EOR|ARM_I,rn,rd,im)
#  define EORI(rd,rn,im)		CC_EORI(ARM_CC_AL,rd,rn,im)
#  define T2_EORI(rd,rn,im)		torri(THUMB2_EORI,rn,rd,im)
#  define CC_REV(cc,rd,rm)		c6orr(cc,ARM_REV,rd,rm)
#  define REV(rd,rm)			CC_REV(ARM_CC_AL,rd,rm)
#  define T1_REV(rd,rm)			is(THUMB_REV|(_u3(rm)<<3)|_u3(rd))
#  define T2_REV(rd,rm)			torrr(THUMB2_REV,rm,rd,rm)
#  define CC_REV16(cc,rd,rm)		c6orr(cc,ARM_REV16,rd,rm)
#  define REV16(rd,rm)			CC_REV16(ARM_CC_AL,rd,rm)
#  define T1_REV16(rd,rm)		is(THUMB_REV16|(_u3(rm)<<3)|_u3(rd))
#  define T2_REV16(rd,rm)		torrr(THUMB2_REV16,rm,rd,rm)
#  define CC_SXTB(cc,rd,rm)		c6orr(cc,ARM_SXTB,rd,rm)
#  define SXTB(rd,rm)			CC_SXTB(ARM_CC_AL,rd,rm)
#  define T1_SXTB(rd,rm)		is(THUMB_SXTB|(_u3(rm)<<3)|_u3(rd))
#  define T2_SXTB(rd,rm)		torrr(THUMB2_SXTB,_R15_REGNO,rd,rm)
#  define CC_UXTB(cc,rd,rm)		c6orr(cc,ARM_UXTB,rd,rm)
#  define UXTB(rd,rm)			CC_UXTB(ARM_CC_AL,rd,rm)
#  define T1_UXTB(rd,rm)		is(THUMB_UXTB|(_u3(rm)<<3)|_u3(rd))
#  define T2_UXTB(rd,rm)		torrr(THUMB2_UXTB,_R15_REGNO,rd,rm)
#  define CC_SXTH(cc,rd,rm)		c6orr(cc,ARM_SXTH,rd,rm)
#  define SXTH(rd,rm)			CC_SXTH(ARM_CC_AL,rd,rm)
#  define T1_SXTH(rd,rm)		is(THUMB_SXTH|(_u3(rm)<<3)|_u3(rd))
#  define T2_SXTH(rd,rm)		torrr(THUMB2_SXTH,_R15_REGNO,rd,rm)
#  define CC_UXTH(cc,rd,rm)		c6orr(cc,ARM_UXTH,rd,rm)
#  define UXTH(rd,rm)			CC_UXTH(ARM_CC_AL,rd,rm)
#  define T1_UXTH(rd,rm)		is(THUMB_UXTH|(_u3(rm)<<3)|_u3(rd))
#  define T2_UXTH(rd,rm)		torrr(THUMB2_UXTH,_R15_REGNO,rd,rm)
#  define CC_SHIFT(cc,o,rd,rm,rn,im)	cshift(cc,o,rd,rm,rn,im)
#  define CC_LSL(cc,rd,rn,rm)		CC_SHIFT(cc,ARM_LSL|ARM_R,rd,rm,rn,0)
#  define LSL(rd,rn,rm)			CC_LSL(ARM_CC_AL,rd,rn,rm)
#  define T1_LSL(rdn,rm)		is(THUMB_LSL|(_u3(rm)<<3)|_u3(rdn))
#  define T2_LSL(rd,rn,rm)		torrr(THUMB2_LSL,rn,rd,rm)
#  define CC_LSLI(cc,rd,rn,im)		CC_SHIFT(cc,ARM_LSL,rd,0,rn,im)
#  define LSLI(rd,rn,im)		CC_LSLI(ARM_CC_AL,rd,rn,im)
#  define T1_LSLI(rd,rm,im)		is(THUMB_LSLI|(_u5(im)<<6)|(_u3(rm)<<3)|_u3(rd))
#  define T2_LSLI(rd,rm,im)		tshift(THUMB2_LSLI,rd,rm,im)
#  define CC_LSR(cc,rd,rn,rm)		CC_SHIFT(cc,ARM_LSR|ARM_R,rd,rm,rn,0)
#  define LSR(rd,rn,rm)			CC_LSR(ARM_CC_AL,rd,rn,rm)
#  define T1_LSR(rdn,rm)		is(THUMB_LSR|(_u3(rm)<<3)|_u3(rdn))
#  define T2_LSR(rd,rn,rm)		torrr(THUMB2_LSR,rn,rd,rm)
#  define CC_LSRI(cc,rd,rn,im)		CC_SHIFT(cc,ARM_LSR,rd,0,rn,im)
#  define LSRI(rd,rn,im)		CC_LSRI(ARM_CC_AL,rd,rn,im)
#  define T1_LSRI(rd,rm,im)		is(THUMB_LSRI|(_u5(im)<<6)|(_u3(rm)<<3)|_u3(rd))
#  define T2_LSRI(rd,rm,im)		tshift(THUMB2_LSRI,rd,rm,im)
#  define CC_ASR(cc,rd,rn,rm)		CC_SHIFT(cc,ARM_ASR|ARM_R,rd,rm,rn,0)
#  define ASR(rd,rn,rm)			CC_ASR(ARM_CC_AL,rd,rn,rm)
#  define T1_ASR(rdn,rm)		is(THUMB_ASR|(_u3(rm)<<3)|_u3(rdn))
#  define T2_ASR(rd,rn,rm)		torrr(THUMB2_ASR,rn,rd,rm)
#  define CC_ASRI(cc,rd,rn,im)		CC_SHIFT(cc,ARM_ASR,rd,0,rn,im)
#  define ASRI(rd,rn,im)		CC_ASRI(ARM_CC_AL,rd,rn,im)
#  define T1_ASRI(rd,rm,im)		is(THUMB_ASRI|(_u5(im)<<6)|(_u3(rm)<<3)|_u3(rd))
#  define T2_ASRI(rd,rm,im)		tshift(THUMB2_ASRI,rd,rm,im)
#  define CC_CMP(cc,rn,rm)		corrr(cc,ARM_CMP,rn,0,rm)
#  define CMP(rn,rm)			CC_CMP(ARM_CC_AL,rn,rm)
#  define T1_CMP(rn,rm)			is(THUMB_CMP|(_u3(rm)<<3)|_u3(rn))
#  define T1_CMPX(rn,rm)		is(THUMB_CMPX|((_u4(rn)&8)<<4)|(_u4(rm)<<3)|(rn&7))
#  define T2_CMP(rn,rm)			torrr(THUMB2_CMP,rn,_R15_REGNO,rm)
#  define CC_CMPI(cc,rn,im)		corri(cc,ARM_CMP|ARM_I,rn,0,im)
#  define CMPI(rn,im)			CC_CMPI(ARM_CC_AL,rn,im)
#  define T1_CMPI(rn,im)		is(THUMB_CMPI|(_u3(rn)<<8)|_u8(im))
#  define T2_CMPI(rn,im)		torri(THUMB2_CMPI,rn,_R15_REGNO,im)
#  define CC_CMN(cc,rn,rm)		corrr(cc,ARM_CMN,rn,0,rm)
#  define CMN(rn,rm)			CC_CMN(ARM_CC_AL,rn,rm)
#  define T1_CMN(rn,rm)			is(THUMB_CMN|(_u3(rm)<<3)|_u3(rm))
#  define T2_CMN(rn,rm)			torrr(THUMB2_CMN,rn,_R15_REGNO,rm)
#  define CC_CMNI(cc,rn,im)		corri(cc,ARM_CMN|ARM_I,rn,0,im)
#  define CMNI(rn,im)			CC_CMNI(ARM_CC_AL,rn,im)
#  define T2_CMNI(rn,im)		torri(THUMB2_CMNI,rn,_R15_REGNO,im)
#  define CC_TST(cc,rn,rm)		corrr(cc,ARM_TST,rn,r0,rm)
#  define TST(rn,rm)			corrr(ARM_CC_AL,ARM_TST,rn,0,rm)
#  define T1_TST(rn,rm)			is(THUMB_TST|(_u3(rm)<<3)|_u3(rn))
#  define T2_TST(rn,rm)			torrr(THUMB2_TST,rn,_R15_REGNO,rm)
#  define CC_TSTI(cc,rn,im)		corri(cc,ARM_TST|ARM_I,rn,0,im)
#  define TSTI(rn,im)			CC_TSTI(ARM_CC_AL,rn,im)
#  define T2_TSTI(rn,im)		torri(THUMB2_TSTI,rn,_R15_REGNO,im)
#  define CC_TEQ(cc,rn,rm)		corrr(cc,ARM_TEQ,rn,0,rm)
#  define TEQ(rn,rm)			CC_TEQ(ARM_CC_AL,rn,rm)
#  define CC_TEQI(cc,rm,im)		corri(cc,ARM_TEQ|ARM_I,rn,0,im)
#  define TEQI(rn,im)			CC_TEQI(ARM_CC_AL,rn,im)
#  define CC_BX(cc,rm)			cbx(cc,ARM_BX,rm)
#  define BX(rm)			CC_BX(ARM_CC_AL,rm)
#  define T1_BX(rm)			is(0x4700|(_u4(rm)<<3))
#  define CC_BLX(cc,rm)			cbx(cc,ARM_BLX,rm)
#  define BLX(rm)			CC_BLX(ARM_CC_AL,rm)
#  define T1_BLX(rm)			is(THUMB_BLX|(_u4(rm)<<3))
#  define BLXI(im)			blxi(im)
#  define T2_BLXI(im)			tb(THUMB2_BLXI,im)
#  define CC_B(cc,im)			cb(cc,ARM_B,im)
#  define B(im)				CC_B(ARM_CC_AL,im)
#  define T1_CC_B(cc,im)		tc8(cc,im)
#  define T1_B(im)			t11(im)
#  define T2_CC_B(cc,im)		tcb(cc,im)
#  define T2_B(im)			tb(THUMB2_B,im)
#  define CC_BLI(cc,im)			cb(cc,ARM_BLI,im)
#  define BLI(im)			CC_BLI(ARM_CC_AL,im)
#  define T2_BLI(im)			tb(THUMB2_BLI,im)
#  define CC_LDRSB(cc,rt,rn,rm)		corrr(cc,ARM_LDRSB|ARM_P,rn,rt,rm)
#  define LDRSB(rt,rn,rm)		CC_LDRSB(ARM_CC_AL,rt,rn,rm)
#  define T1_LDRSB(rt,rn,rm)		is(THUMB_LDRSB|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_LDRSB(rt,rn,rm)		torxr(THUMB2_LDRSB,rn,rt,rm)
#  define CC_LDRSBN(cc,rt,rn,rm)	corrr(cc,ARM_LDRSB,rn,rt,rm)
#  define LDRSBN(rt,rn,rm)		CC_LDRSBN(ARM_CC_AL,rt,rn,rm)
#  define CC_LDRSBI(cc,rt,rn,im)	corri8(cc,ARM_LDRSBI|ARM_P,rn,rt,im)
#  define LDRSBI(rt,rn,im)		CC_LDRSBI(ARM_CC_AL,rt,rn,im)
#  define T2_LDRSBI(rt,rn,im)		torri8(THUMB2_LDRSBI|THUMB2_U,rn,rt,im)
#  define T2_LDRSBWI(rt,rn,im)		torri12(THUMB2_LDRSBWI,rn,rt,im)
#  define CC_LDRSBIN(cc,rt,rn,im)	corri8(cc,ARM_LDRSBI,rn,rt,im)
#  define LDRSBIN(rt,rn,im)		CC_LDRSBIN(ARM_CC_AL,rt,rn,im)
#  define T2_LDRSBIN(rt,rn,im)		torri8(THUMB2_LDRSBI,rn,rt,im)
#  define CC_LDRB(cc,rt,rn,rm)		corrr(cc,ARM_LDRB|ARM_P,rn,rt,rm)
#  define LDRB(rt,rn,rm)		CC_LDRB(ARM_CC_AL,rt,rn,rm)
#  define T1_LDRB(rt,rn,rm)		is(THUMB_LDRB|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_LDRB(rt,rn,rm)		torxr(THUMB2_LDRB,rn,rt,rm)
#  define CC_LDRBN(cc,rt,rn,rm)		corrr(cc,ARM_LDRB,rn,rt,rm)
#  define LDRBN(rt,rn,rm)		CC_LDRBN(ARM_CC_AL,rt,rn,rm)
#  define CC_LDRBI(cc,rt,rn,im)		corri(cc,ARM_LDRBI|ARM_P,rn,rt,im)
#  define LDRBI(rt,rn,im)		CC_LDRBI(ARM_CC_AL,rt,rn,im)
#  define T1_LDRBI(rt,rn,im)		is(THUMB_LDRBI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_LDRBI(rt,rn,im)		torri8(THUMB2_LDRBI|THUMB2_U,rn,rt,im)
#  define T2_LDRBWI(rt,rn,im)		torri12(THUMB2_LDRBWI,rn,rt,im)
#  define CC_LDRBIN(cc,rt,rn,im)	corri(cc,ARM_LDRBI,rn,rt,im)
#  define LDRBIN(rt,rn,im)		CC_LDRBIN(ARM_CC_AL,rt,rn,im)
#  define T2_LDRBIN(rt,rn,im)		torri8(THUMB2_LDRBI,rn,rt,im)
#  define CC_LDRSH(cc,rt,rn,rm)		corrr(cc,ARM_LDRSH|ARM_P,rn,rt,rm)
#  define LDRSH(rt,rn,rm)		CC_LDRSH(ARM_CC_AL,rt,rn,rm)
#  define T1_LDRSH(rt,rn,rm)		is(THUMB_LDRSH|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_LDRSH(rt,rn,rm)		torxr(THUMB2_LDRSH,rn,rt,rm)
#  define CC_LDRSHN(cc,rt,rn,rm)	corrr(cc,ARM_LDRSH,rn,rt,rm)
#  define LDRSHN(rt,rn,rm)		CC_LDRSHN(ARM_CC_AL,rt,rn,rm)
#  define CC_LDRSHI(cc,rt,rn,im)	corri8(cc,ARM_LDRSHI|ARM_P,rn,rt,im)
#  define LDRSHI(rt,rn,im)		CC_LDRSHI(ARM_CC_AL,rt,rn,im)
#  define T2_LDRSHI(rt,rn,im)		torri8(THUMB2_LDRSHI|THUMB2_U,rn,rt,im)
#  define T2_LDRSHWI(rt,rn,im)		torri12(THUMB2_LDRSHWI,rn,rt,im)
#  define CC_LDRSHIN(cc,rt,rn,im)	corri8(cc,ARM_LDRSHI,rn,rt,im)
#  define LDRSHIN(rt,rn,im)		CC_LDRSHIN(ARM_CC_AL,rt,rn,im)
#  define T2_LDRSHIN(rt,rn,im)		torri8(THUMB2_LDRSHI,rn,rt,im)
#  define CC_LDRH(cc,rt,rn,rm)		corrr(cc,ARM_LDRH|ARM_P,rn,rt,rm)
#  define LDRH(rt,rn,rm)		CC_LDRH(ARM_CC_AL,rt,rn,rm)
#  define T1_LDRH(rt,rn,rm)		is(THUMB_LDRH|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_LDRH(rt,rn,rm)		torxr(THUMB2_LDRH,rn,rt,rm)
#  define CC_LDRHN(cc,rt,rn,rm)		corrr(cc,ARM_LDRH,rn,rt,rm)
#  define LDRHN(rt,rn,rm)		CC_LDRHN(ARM_CC_AL,rt,rn,rm)
#  define CC_LDRHI(cc,rt,rn,im)		corri8(cc,ARM_LDRHI|ARM_P,rn,rt,im)
#  define LDRHI(rt,rn,im)		CC_LDRHI(ARM_CC_AL,rt,rn,im)
#  define T1_LDRHI(rt,rn,im)		is(THUMB_LDRHI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_LDRHI(rt,rn,im)		torri8(THUMB2_LDRHI|THUMB2_U,rn,rt,im)
#  define T2_LDRHWI(rt,rn,im)		torri12(THUMB2_LDRHWI,rn,rt,im)
#  define CC_LDRHIN(cc,rt,rn,im)	corri8(cc,ARM_LDRHI,rn,rt,im)
#  define LDRHIN(rt,rn,im)		CC_LDRHIN(ARM_CC_AL,rt,rn,im)
#  define T2_LDRHIN(rt,rn,im)		torri8(THUMB2_LDRHI,rn,rt,im)
#  define CC_LDR(cc,rt,rn,rm)		corrr(cc,ARM_LDR|ARM_P,rn,rt,rm)
#  define LDR(rt,rn,rm)			CC_LDR(ARM_CC_AL,rt,rn,rm)
#  define T1_LDR(rt,rn,rm)		is(THUMB_LDR|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_LDR(rt,rn,rm)		torxr(THUMB2_LDR,rn,rt,rm)
#  define CC_LDRN(cc,rt,rn,rm)		corrr(cc,ARM_LDR,rn,rt,rm)
#  define LDRN(rt,rn,rm)		CC_LDRN(ARM_CC_AL,rt,rn,rm)
#  define CC_LDRI(cc,rt,rn,im)		corri(cc,ARM_LDRI|ARM_P,rn,rt,im)
#  define LDRI(rt,rn,im)		CC_LDRI(ARM_CC_AL,rt,rn,im)
#  define T1_LDRI(rt,rn,im)		is(THUMB_LDRI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T1_LDRISP(rt,im)		is(THUMB_LDRISP|(_u3(rt)<<8)|_u8(im))
#  define T2_LDRI(rt,rn,im)		torri8(THUMB2_LDRI|THUMB2_U,rn,rt,im)
#  define T2_LDRWI(rt,rn,im)		torri12(THUMB2_LDRWI,rn,rt,im)
#  define CC_LDRIN(cc,rt,rn,im)		corri(cc,ARM_LDRI,rn,rt,im)
#  define LDRIN(rt,rn,im)		CC_LDRIN(ARM_CC_AL,rt,rn,im)
#  define T2_LDRIN(rt,rn,im)		torri8(THUMB2_LDRI,rn,rt,im)
#  define CC_LDRD(cc,rt,rn,rm)		corrr(cc,ARM_LDRD|ARM_P,rn,rt,rm)
#  define LDRD(rt,rn,rm)		CC_LDRD(ARM_CC_AL,rt,rn,rm)
#  define T2_LDRDI(rt,rt2,rn,im)	torrri8(THUMB2_LDRDI|ARM_P,rn,rt,rt2,im)
#  define CC_LDRDN(cc,rt,rn,rm)		corrr(cc,ARM_LDRD,rn,rt,rm)
#  define LDRDN(rd,rn,rm)		CC_LDRDN(ARM_CC_AL,rt,rn,rm)
#  define CC_LDRDI(cc,rt,rn,im)		corri8(cc,ARM_LDRDI|ARM_P,rn,rt,im)
#  define LDRDI(rt,rn,im)		CC_LDRDI(ARM_CC_AL,rt,rn,im)
#  define CC_LDRDIN(cc,rt,rn,im)	corri8(cc,ARM_LDRDI,rn,rt,im)
#  define LDRDIN(rt,rn,im)		CC_LDRDIN(ARM_CC_AL,rt,rn,im)
#  define T2_LDRDIN(rt,rt2,rn,im)	torrri8(THUMB2_LDRDI,rn,rt,rt2,im)
#  define CC_LDREX(cc,rt,rn)		corrrr(cc,ARM_LDREX,rn,rt,0xf,0xf)
#  define LDREX(rt,rn)			CC_LDREX(ARM_CC_AL,rt,rn)
#  define T2_LDREX(rt,rn,im)		torrri8(THUMB2_LDREX,rn,rt,0xf,im)
#  define CC_STRB(cc,rt,rn,rm)		corrr(cc,ARM_STRB|ARM_P,rn,rt,rm)
#  define STRB(rt,rn,rm)		CC_STRB(ARM_CC_AL,rt,rn,rm)
#  define T1_STRB(rt,rn,rm)		is(THUMB_STRB|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_STRB(rt,rn,rm)		torxr(THUMB2_STRB,rn,rt,rm)
#  define CC_STRBN(cc,rt,rn,rm)		corrr(cc,ARM_STRB,rn,rt,rm)
#  define STRBN(rt,rn,rm)		CC_STRBN(ARM_CC_AL,rt,rn,rm)
#  define CC_STRBI(cc,rt,rn,im)		corri(cc,ARM_STRBI|ARM_P,rn,rt,im)
#  define STRBI(rt,rn,im)		CC_STRBI(ARM_CC_AL,rt,rn,im)
#  define T1_STRBI(rt,rn,im)		is(THUMB_STRBI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_STRBI(rt,rn,im)		torri8(THUMB2_STRBI|THUMB2_U,rn,rt,im)
#  define T2_STRBWI(rt,rn,im)		torri12(THUMB2_STRBWI,rn,rt,im)
#  define CC_STRBIN(cc,rt,rn,im)	corri(cc,ARM_STRBI,rn,rt,im)
#  define STRBIN(rt,rn,im)		CC_STRBIN(ARM_CC_AL,rt,rn,im)
#  define T2_STRBIN(rt,rn,im)		torri8(THUMB2_STRBI,rn,rt,im)
#  define CC_STRH(cc,rt,rn,rm)		corrr(cc,ARM_STRH|ARM_P,rn,rt,rm)
#  define STRH(rt,rn,rm)		CC_STRH(ARM_CC_AL,rt,rn,rm)
#  define T1_STRH(rt,rn,rm)		is(THUMB_STRH|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_STRH(rt,rn,rm)		torxr(THUMB2_STRH,rn,rt,rm)
#  define CC_STRHN(cc,rt,rn,rm)		corrr(cc,ARM_STRH,rn,rt,rm)
#  define STRHN(rt,rn,rm)		CC_STRHN(ARM_CC_AL,rt,rn,rm)
#  define CC_STRHI(cc,rt,rn,im)		corri8(cc,ARM_STRHI|ARM_P,rn,rt,im)
#  define STRHI(rt,rn,im)		CC_STRHI(ARM_CC_AL,rt,rn,im)
#  define T1_STRHI(rt,rn,im)		is(THUMB_STRHI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_STRHI(rt,rn,im)		torri8(THUMB2_STRHI|THUMB2_U,rn,rt,im)
#  define T2_STRHWI(rt,rn,im)		torri12(THUMB2_STRHWI,rn,rt,im)
#  define CC_STRHIN(cc,rt,rn,im)	corri8(cc,ARM_STRHI,rn,rt,im)
#  define STRHIN(rt,rn,im)		CC_STRHIN(ARM_CC_AL,rt,rn,im)
#  define T2_STRHIN(rt,rn,im)		torri8(THUMB2_STRHI,rn,rt,im)
#  define CC_STR(cc,rt,rn,rm)		corrr(cc,ARM_STR|ARM_P,rn,rt,rm)
#  define STR(rt,rn,rm)			CC_STR(ARM_CC_AL,rt,rn,rm)
#  define T1_STR(rt,rn,rm)		is(THUMB_STR|(_u3(rm)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T2_STR(rt,rn,rm)		torxr(THUMB2_STR,rn,rt,rm)
#  define CC_STRN(cc,rt,rn,rm)		corrr(cc,ARM_STR,rn,rt,rm)
#  define STRN(rt,rn,rm)		CC_STRN(ARM_CC_AL,rt,rn,rm)
#  define CC_STRI(cc,rt,rn,im)		corri(cc,ARM_STRI|ARM_P,rn,rt,im)
#  define STRI(rt,rn,im)		CC_STRI(ARM_CC_AL,rt,rn,im)
#  define T1_STRI(rt,rn,im)		is(THUMB_STRI|(_u5(im)<<6)|(_u3(rn)<<3)|_u3(rt))
#  define T1_STRISP(rt,im)		is(THUMB_STRISP|(_u3(rt)<<8)|(_u8(im)))
#  define T2_STRI(rt,rn,im)		torri8(THUMB2_STRI|THUMB2_U,rn,rt,im)
#  define T2_STRWI(rt,rn,im)		torri12(THUMB2_STRWI,rn,rt,im)
#  define CC_STRIN(cc,rt,rn,im)		corri(cc,ARM_STRI,rn,rt,im)
#  define STRIN(rt,rn,im)		CC_STRIN(ARM_CC_AL,rt,rn,im)
#  define T2_STRIN(rt,rn,im)		torri8(THUMB2_STRI,rn,rt,im)
#  define CC_STRD(cc,rt,rn,rm)		corrr(cc,ARM_STRD|ARM_P,rn,rt,rm)
#  define STRD(rt,rn,rm)		CC_STRD(ARM_CC_AL,rt,rn,rm)
#  define CC_STRDN(cc,rt,rn,rm)		corrr(cc,ARM_STRD,rn,rt,rm)
#  define STRDN(rt,rn,rm)		CC_STRDN(ARM_CC_AL,rt,rn,rm)
#  define CC_STRDI(cc,rt,rn,im)		corri8(cc,ARM_STRDI|ARM_P,rn,rt,im)
#  define STRDI(rt,rn,im)		CC_STRDI(ARM_CC_AL,rt,rn,im)
#  define T2_STRDI(rt,rt2,rn,im)	torrri8(THUMB2_STRDI|ARM_P,rn,rt,rt2,im)
#  define CC_STRDIN(cc,rt,rn,im)	corri8(cc,ARM_STRDI,rn,rt,im)
#  define STRDIN(rt,rn,im)		CC_STRDIN(ARM_CC_AL,rt,rn,im)
#  define T2_STRDIN(rt,rt2,rn,im)	torrri8(THUMB2_STRDI,rn,rt,rt2,im)
#  define CC_STREX(cc,rd,rt,rn)		corrrr(cc,ARM_STREX,rn,rd,0xf,rt)
#  define STREX(rd,rt,rn)		CC_STREX(ARM_CC_AL,rd,rt,rn)
#  define T2_STREX(rd,rt,rn,im)		torrri8(THUMB2_STREX,rn,rt,rd,im)
#  define CC_LDMIA(cc,rn,im)		corl(cc,ARM_M|ARM_M_L|ARM_M_I,rn,im)
#  define LDMIA(rn,im)			CC_LDMIA(ARM_CC_AL,rn,im)
#  define CC_LDM(cc,rn,im)		CC_LDMIA(cc,rn,im)
#  define LDM(rn,im)			LDMIA(rn,im)
#  define T1_LDMIA(rn,im)		is(THUMB_LDMIA|(_u3(rn)<<8)|im)
#  define T2_LDMIA(rn,im)		torl(THUMB2_LDMIA,rn,im)
#  define CC_LDMIA_U(cc,rn,im)		corl(cc,ARM_M|ARM_M_L|ARM_M_I|ARM_M_U,rn,im)
#  define LDMIA_U(rn,im)		CC_LDMIA_U(ARM_CC_AL,rn,im)
#  define LDM_U(r0,i0)			LDMIA_U(r0,i0)
#  define CC_LDMIB(cc,rn,im)		corl(cc,ARM_M|ARM_M_L|ARM_M_I|ARM_M_B,rn,im)
#  define LDMIB(rn,im)			CC_LDMIB(ARM_CC_AL,rn,im)
#  define CC_LDMIB_U(cc,rn,im)		corl(cc,ARM_M|ARM_M_L|ARM_M_I|ARM_M_B|ARM_M_U,rn,im)
#  define LDMIB_U(rn,im)		CC_LDMIB_U(ARM_CC_AL,rn,im)
#  define CC_LDMDA(cc,rn,im)		corl(cc,ARM_M|ARM_M_L,rn,im)
#  define LDMDA(rn,im)			CC_LDMDA(ARM_CC_AL,rn,im)
#  define CC_LDMDA_U(cc,rn,im)		corl(cc,ARM_M|ARM_M_L|ARM_M_U,rn,im)
#  define LDMDA_U(rn,im)		CC_LDMDA_U(ARM_CC_AL,rn,im)
#  define CC_LDMDB(cc,rn,im)		corl(cc,ARM_M|ARM_M_L|ARM_M_B,rn,im)
#  define LDMDB(rn,im)			CC_LDMDB(ARM_CC_AL,rn,im)
#  define T2_LDMDB(rn,im)		torl(THUMB2_LDMDB,rn,im)
#  define CC_LDMDB_U(cc,rn,im)		corl(cc,ARM_M|ARM_M_L|ARM_M_B|ARM_M_U,rn,im)
#  define LDMDB_U(rn,im)		CC_LDMDB_U(ARM_CC_AL,rn,im)
#  define CC_STMIA(cc,rn,im)		corl(cc,ARM_M|ARM_M_I,rn,im)
#  define STMIA(rn,im)			CC_STMIA(ARM_CC_AL,rn,im)
#  define CC_STM(cc,rn,im)		CC_STMIA(cc,rn,im)
#  define STM(rn,im)			STMIA(rn,im)
#  define CC_STMIA_U(cc,rn,im)		corl(cc,ARM_M|ARM_M_I|ARM_M_U,rn,im)
#  define STMIA_U(rn,im)		CC_STMIA_U(ARM_CC_AL,rn,im)
#  define CC_STM_U(cc,rn,im)		CC_STMIA_U(cc,rn,im)
#  define STM_U(rn,im)			STMIA_U(rn,im)
#  define CC_STMIB(cc,rn,im)		corl(cc,ARM_M|ARM_M_I|ARM_M_B,rn,im)
#  define STMIB(rn,im)			CC_STMIB(ARM_CC_AL,rn,im)
#  define CC_STMIB_U(cc,rn,im)		corl(cc,ARM_M|ARM_M_I|ARM_M_B|ARM_M_U,rn,im)
#  define STMIB_U(rn,im)		CC_STMIB_U(ARM_CC_AL,rn,im)
#  define CC_STMDA(cc,rn,im)		corl(cc,ARM_M,rn,im)
#  define STMDA(rn,im)			CC_STMDA(ARM_CC_AL,rn,im)
#  define CC_STMDA_U(cc,rn,im)		corl(cc,ARM_M|ARM_M_U,rn,im)
#  define STMDA_U(rn,im)		CC_STMDA_U(ARM_CC_AL,rn,im)
#  define CC_STMDB(cc,rn,im)		corl(cc,ARM_M|ARM_M_B,rn,im)
#  define STMDB(rn,im)			CC_STMDB(ARM_CC_AL,rn,im)
#  define CC_STMDB_U(cc,rn,im)		corl(cc,ARM_M|ARM_M_B|ARM_M_U,rn,im)
#  define STMDB_U(rn,im)		CC_STMDB_U(ARM_CC_AL,rn,im)
#  define CC_PUSH(cc,im)		CC_STMDB_U(cc,_SP_REGNO,im)
#  define PUSH(im)			STMDB_U(_SP_REGNO,im)
#  define T1_PUSH(im)			is(THUMB_PUSH|((im&0x4000)>>6)|(im&0xff))
#  define T2_PUSH(im)			tpp(THUMB2_PUSH,im)
#  define CC_POP(cc,im)			LDMIA_U(cc,_SP_REGNO,im)
#  define POP(im)			LDMIA_U(_SP_REGNO,im)
#  define T1_POP(im)			is(THUMB_POP|((im&0x8000)>>7)|(im&0xff))
#  define T2_POP(im)			tpp(THUMB2_POP,im)
#  define jit_get_reg_args()						\
    do {								\
	CHECK_REG_ARGS();						\
	jit_check_frame();						\
	(void)jit_get_reg(_R0|jit_class_named|jit_class_gpr);		\
	(void)jit_get_reg(_R1|jit_class_named|jit_class_gpr);		\
	(void)jit_get_reg(_R2|jit_class_named|jit_class_gpr);		\
	(void)jit_get_reg(_R3|jit_class_named|jit_class_gpr);		\
    } while (0)
#  define jit_unget_reg_args()						\
    do {								\
	jit_unget_reg(_R3);						\
	jit_unget_reg(_R2);						\
	jit_unget_reg(_R1);						\
	jit_unget_reg(_R0);						\
    } while (0)
#  define nop(i0)			_nop(_jit,i0)
static void _nop(jit_state_t*,jit_int32_t);
#  define movr(r0,r1)			_movr(_jit,r0,r1)
static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
#  define movi(r0,i0)			_movi(_jit,r0,i0)
static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
#  define movi_p(r0,i0)			_movi_p(_jit,r0,i0)
static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
#  define movnr(r0,r1,r2)		_movnr(_jit,r0,r1,r2)
static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define movzr(r0,r1,r2)		_movzr(_jit,r0,r1,r2)
static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define casx(r0, r1, r2, r3, i0)	_casx(_jit, r0, r1, r2, r3, i0)
static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
		  jit_int32_t,jit_int32_t,jit_word_t);
#define casr(r0, r1, r2, r3)		casx(r0, r1, r2, r3, 0)
#define casi(r0, i0, r1, r2)		casx(r0, _NOREG, r1, r2, i0)
#  define comr(r0,r1)			_comr(_jit,r0,r1)
static void _comr(jit_state_t*,jit_int32_t,jit_int32_t);
#  define negr(r0,r1)			_negr(_jit,r0,r1)
static void _negr(jit_state_t*,jit_int32_t,jit_int32_t);
#  define clor(r0, r1)			_clor(_jit, r0, r1)
static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
#  define clzr(r0, r1)			_clzr(_jit, r0, r1)
static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t);
#  define ctor(r0, r1)			_ctor(_jit, r0, r1)
static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
#  define ctzr(r0, r1)			_ctzr(_jit, r0, r1)
static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
#  define addr(r0,r1,r2)		_addr(_jit,r0,r1,r2)
static void _addr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define addi(r0,r1,i0)		_addi(_jit,r0,r1,i0)
static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define addcr(r0,r1,r2)		_addcr(_jit,r0,r1,r2)
static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define addci(r0,r1,i0)		_addci(_jit,r0,r1,i0)
static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define addxr(r0,r1,r2)		_addxr(_jit,r0,r1,r2)
static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define addxi(r0,r1,i0)		_addxi(_jit,r0,r1,i0)
static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define subr(r0,r1,r2)		_subr(_jit,r0,r1,r2)
static void _subr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define subi(r0,r1,i0)		_subi(_jit,r0,r1,i0)
static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define subcr(r0,r1,r2)		_subcr(_jit,r0,r1,r2)
static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define subci(r0,r1,i0)		_subci(_jit,r0,r1,i0)
static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define subxr(r0,r1,r2)		_subxr(_jit,r0,r1,r2)
static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define subxi(r0,r1,i0)		_subxi(_jit,r0,r1,i0)
static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define rsbi(r0, r1, i0)		_rsbi(_jit, r0, r1, i0)
static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define mulr(r0,r1,r2)		_mulr(_jit,r0,r1,r2)
static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define muli(r0,r1,i0)		_muli(_jit,r0,r1,i0)
static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define qmulr(r0,r1,r2,r3)		iqmulr(r0,r1,r2,r3,1)
#  define qmulr_u(r0,r1,r2,r3)		iqmulr(r0,r1,r2,r3,0)
#  define iqmulr(r0,r1,r2,r3,cc)	_iqmulr(_jit,r0,r1,r2,r3,cc)
static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
		    jit_int32_t,jit_int32_t,jit_bool_t);
#  define qmuli(r0,r1,r2,i0)		iqmuli(r0,r1,r2,i0,1)
#  define qmuli_u(r0,r1,r2,i0)		iqmuli(r0,r1,r2,i0,0)
#  define iqmuli(r0,r1,r2,i0,cc)	_iqmuli(_jit,r0,r1,r2,i0,cc)
static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
		    jit_int32_t,jit_word_t,jit_bool_t);
#  define divrem(d,s,r0,r1,r2)		_divrem(_jit,d,s,r0,r1,r2)
static void _divrem(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_int32_t);
#  define divr(r0,r1,r2)		_divr(_jit,r0,r1,r2)
static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define divi(r0,r1,i0)		_divi(_jit,r0,r1,i0)
static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define divr_u(r0,r1,r2)		_divr_u(_jit,r0,r1,r2)
static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define divi_u(r0,r1,i0)		_divi_u(_jit,r0,r1,i0)
static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define qdivr(r0,r1,r2,r3)		iqdivr(r0,r1,r2,r3,1)
#  define qdivr_u(r0,r1,r2,r3)		iqdivr(r0,r1,r2,r3,0)
#  define iqdivr(r0,r1,r2,r3,cc)	_iqdivr(_jit,r0,r1,r2,r3,cc)
static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
		    jit_int32_t,jit_int32_t,jit_bool_t);
#  define qdivi(r0,r1,r2,i0)		iqdivi(r0,r1,r2,i0,1)
#  define qdivi_u(r0,r1,r2,i0)		iqdivi(r0,r1,r2,i0,0)
#  define iqdivi(r0,r1,r2,i0,cc)	_iqdivi(_jit,r0,r1,r2,i0,cc)
static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
		    jit_int32_t,jit_word_t,jit_bool_t);
#  define remr(r0,r1,r2)		_remr(_jit,r0,r1,r2)
static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define remi(r0,r1,i0)		_remi(_jit,r0,r1,i0)
static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define remr_u(r0,r1,r2)		_remr_u(_jit,r0,r1,r2)
static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define remi_u(r0,r1,i0)		_remi_u(_jit,r0,r1,i0)
static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define andr(r0,r1,r2)		_andr(_jit,r0,r1,r2)
static void _andr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define andi(r0,r1,i0)		_andi(_jit,r0,r1,i0)
static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define orr(r0,r1,r2)			_orr(_jit,r0,r1,r2)
static void _orr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define ori(r0,r1,i0)			_ori(_jit,r0,r1,i0)
static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define xorr(r0,r1,r2)		_xorr(_jit,r0,r1,r2)
static void _xorr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define xori(r0,r1,i0)		_xori(_jit,r0,r1,i0)
static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define lshr(r0,r1,r2)		_lshr(_jit,r0,r1,r2)
static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define lshi(r0,r1,i0)		_lshi(_jit,r0,r1,i0)
static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define rshr(r0,r1,r2)		_rshr(_jit,r0,r1,r2)
static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define rshi(r0,r1,i0)		_rshi(_jit,r0,r1,i0)
static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define rshr_u(r0,r1,r2)		_rshr_u(_jit,r0,r1,r2)
static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define rshi_u(r0,r1,i0)		_rshi_u(_jit,r0,r1,i0)
static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define ccr(ct,cf,r0,r1,r2)		_ccr(_jit,ct,cf,r0,r1,r2)
static void _ccr(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_int32_t);
#  define cci(ct,cf,r0,r1,i0)		_cci(_jit,ct,cf,r0,r1,i0)
static void _cci(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_word_t);
#  define ltr(r0, r1, r2)		ccr(ARM_CC_LT,ARM_CC_GE,r0,r1,r2)
#  define lti(r0, r1, i0)		cci(ARM_CC_LT,ARM_CC_GE,r0,r1,i0)
#  define ltr_u(r0, r1, r2)		ccr(ARM_CC_LO,ARM_CC_HS,r0,r1,r2)
#  define lti_u(r0, r1, i0)		cci(ARM_CC_LO,ARM_CC_HS,r0,r1,i0)
#  define ler(r0, r1, r2)		ccr(ARM_CC_LE,ARM_CC_GT,r0,r1,r2)
#  define lei(r0, r1, i0)		cci(ARM_CC_LE,ARM_CC_GT,r0,r1,i0)
#  define ler_u(r0, r1, r2)		ccr(ARM_CC_LS,ARM_CC_HI,r0,r1,r2)
#  define lei_u(r0, r1, i0)		cci(ARM_CC_LS,ARM_CC_HI,r0,r1,i0)
#  define eqr(r0, r1, r2)		ccr(ARM_CC_EQ,ARM_CC_NE,r0,r1,r2)
#  define eqi(r0, r1, i0)		cci(ARM_CC_EQ,ARM_CC_NE,r0,r1,i0)
#  define ger(r0, r1, r2)		ccr(ARM_CC_GE,ARM_CC_LT,r0,r1,r2)
#  define gei(r0, r1, i0)		cci(ARM_CC_GE,ARM_CC_LT,r0,r1,i0)
#  define ger_u(r0, r1, r2)		ccr(ARM_CC_HS,ARM_CC_LO,r0,r1,r2)
#  define gei_u(r0, r1, i0)		cci(ARM_CC_HS,ARM_CC_LO,r0,r1,i0)
#  define gtr(r0, r1, r2)		ccr(ARM_CC_GT,ARM_CC_LE,r0,r1,r2)
#  define gti(r0, r1, i0)		cci(ARM_CC_GT,ARM_CC_LE,r0,r1,i0)
#  define gtr_u(r0, r1, r2)		ccr(ARM_CC_HI,ARM_CC_LS,r0,r1,r2)
#  define gti_u(r0, r1, i0)		cci(ARM_CC_HI,ARM_CC_LS,r0,r1,i0)
#  define ner(r0,r1,r2)			_ner(_jit,r0,r1,r2)
static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define nei(r0,r1,i0)			_nei(_jit,r0,r1,i0)
static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define jmpr(r0)			_jmpr(_jit,r0)
static void _jmpr(jit_state_t*,jit_int32_t);
#  define jmpi(i0)			_jmpi(_jit,i0)
static void _jmpi(jit_state_t*,jit_word_t);
#  define jmpi_p(i0, i1)		_jmpi_p(_jit,i0, i1)
static jit_word_t _jmpi_p(jit_state_t*,jit_word_t,jit_bool_t);
#  define bccr(cc,i0,r0,r1)		_bccr(_jit,cc,i0,r0,r1)
static jit_word_t _bccr(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
#  define bcci(cc,i0,r0,i1)		_bcci(_jit,cc,i0,r0,i1)
static jit_word_t _bcci(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
#  define bltr(i0, r0, r1)		bccr(ARM_CC_LT,i0,r0,r1)
#  define blti(i0, r0, i1)		bcci(ARM_CC_LT,i0,r0,i1)
#  define bltr_u(i0, r0, r1)		bccr(ARM_CC_LO,i0,r0,r1)
#  define blti_u(i0, r0, i1)		bcci(ARM_CC_LO,i0,r0,i1)
#  define bler(i0, r0, r1)		bccr(ARM_CC_LE,i0,r0,r1)
#  define blei(i0, r0, i1)		bcci(ARM_CC_LE,i0,r0,i1)
#  define bler_u(i0, r0, r1)		bccr(ARM_CC_LS,i0,r0,r1)
#  define blei_u(i0, r0, i1)		bcci(ARM_CC_LS,i0,r0,i1)
#  define beqr(i0, r0, r1)		bccr(ARM_CC_EQ,i0,r0,r1)
#  define beqi(i0, r0, i1)		bcci(ARM_CC_EQ,i0,r0,i1)
#  define bger(i0, r0, r1)		bccr(ARM_CC_GE,i0,r0,r1)
#  define bgei(i0, r0, i1)		bcci(ARM_CC_GE,i0,r0,i1)
#  define bger_u(i0, r0, r1)		bccr(ARM_CC_HS,i0,r0,r1)
#  define bgei_u(i0, r0, i1)		bcci(ARM_CC_HS,i0,r0,i1)
#  define bgtr(i0, r0, r1)		bccr(ARM_CC_GT,i0,r0,r1)
#  define bgti(i0, r0, i1)		bcci(ARM_CC_GT,i0,r0,i1)
#  define bgtr_u(i0, r0, r1)		bccr(ARM_CC_HI,i0,r0,r1)
#  define bgti_u(i0, r0, i1)		bcci(ARM_CC_HI,i0,r0,i1)
#  define bner(i0, r0, r1)		bccr(ARM_CC_NE,i0,r0,r1)
#  define bnei(i0, r0, i1)		bcci(ARM_CC_NE,i0,r0,i1)
#  define baddr(cc,i0,r0,r1)		_baddr(_jit,cc,i0,r0,r1)
static jit_word_t _baddr(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
#  define baddi(cc,i0,r0,r1)		_baddi(_jit,cc,i0,r0,r1)
static jit_word_t _baddi(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
#  define boaddr(i0,r0,r1)		baddr(ARM_CC_VS,i0,r0,r1)
#  define boaddi(i0,r0,i1)		baddi(ARM_CC_VS,i0,r0,i1)
#  define boaddr_u(i0,r0,r1)		baddr(ARM_CC_HS,i0,r0,r1)
#  define boaddi_u(i0,r0,i1)		baddi(ARM_CC_HS,i0,r0,i1)
#  define bxaddr(i0,r0,r1)		baddr(ARM_CC_VC,i0,r0,r1)
#  define bxaddi(i0,r0,i1)		baddi(ARM_CC_VC,i0,r0,i1)
#  define bxaddr_u(i0,r0,r1)		baddr(ARM_CC_LO,i0,r0,r1)
#  define bxaddi_u(i0,r0,i1)		baddi(ARM_CC_LO,i0,r0,i1)
#  define bsubr(cc,i0,r0,r1)		_bsubr(_jit,cc,i0,r0,r1)
static jit_word_t _bsubr(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
#  define bsubi(cc,i0,r0,r1)		_bsubi(_jit,cc,i0,r0,r1)
static jit_word_t _bsubi(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
#  define bosubr(i0,r0,r1)		bsubr(ARM_CC_VS,i0,r0,r1)
#  define bosubi(i0,r0,i1)		bsubi(ARM_CC_VS,i0,r0,i1)
#  define bosubr_u(i0,r0,r1)		bsubr(ARM_CC_LO,i0,r0,r1)
#  define bosubi_u(i0,r0,i1)		bsubi(ARM_CC_LO,i0,r0,i1)
#  define bxsubr(i0,r0,r1)		bsubr(ARM_CC_VC,i0,r0,r1)
#  define bxsubi(i0,r0,i1)		bsubi(ARM_CC_VC,i0,r0,i1)
#  define bxsubr_u(i0,r0,r1)		bsubr(ARM_CC_HS,i0,r0,r1)
#  define bxsubi_u(i0,r0,i1)		bsubi(ARM_CC_HS,i0,r0,i1)
#  define bmxr(cc,i0,r0,r1)		_bmxr(_jit,cc,i0,r0,r1)
static jit_word_t _bmxr(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
#  define bmxi(cc,i0,r0,r1)		_bmxi(_jit,cc,i0,r0,r1)
static jit_word_t _bmxi(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
#  define bmsr(i0,r0,r1)		bmxr(ARM_CC_NE,i0,r0,r1)
#  define bmsi(i0,r0,i1)		bmxi(ARM_CC_NE,i0,r0,i1)
#  define bmcr(i0,r0,r1)		bmxr(ARM_CC_EQ,i0,r0,r1)
#  define bmci(i0,r0,i1)		bmxi(ARM_CC_EQ,i0,r0,i1)
#  define ldr_c(r0,r1)			_ldr_c(_jit,r0,r1)
static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
#  define ldi_c(r0,i0)			_ldi_c(_jit,r0,i0)
static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
#  define ldxr_c(r0,r1,r2)		_ldxr_c(_jit,r0,r1,r2)
static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define ldxi_c(r0,r1,i0)		_ldxi_c(_jit,r0,r1,i0)
static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define ldr_uc(r0,r1)			_ldr_uc(_jit,r0,r1)
static void _ldr_uc(jit_state_t*,jit_int32_t,jit_int32_t);
#  define ldi_uc(r0,i0)			_ldi_uc(_jit,r0,i0)
static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
#  define ldxr_uc(r0,r1,r2)		_ldxr_uc(_jit,r0,r1,r2)
static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define ldxi_uc(r0,r1,i0)		_ldxi_uc(_jit,r0,r1,i0)
static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define ldr_s(r0,r1)			_ldr_s(_jit,r0,r1)
static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
#  define ldi_s(r0,i0)			_ldi_s(_jit,r0,i0)
static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
#  define ldxr_s(r0,r1,r2)		_ldxr_s(_jit,r0,r1,r2)
static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define ldxi_s(r0,r1,i0)		_ldxi_s(_jit,r0,r1,i0)
static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define ldr_us(r0,r1)			_ldr_us(_jit,r0,r1)
static void _ldr_us(jit_state_t*,jit_int32_t,jit_int32_t);
#  define ldi_us(r0,i0)			_ldi_us(_jit,r0,i0)
static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
#  define ldxr_us(r0,r1,r2)		_ldxr_us(_jit,r0,r1,r2)
static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define ldxi_us(r0,r1,i0)		_ldxi_us(_jit,r0,r1,i0)
static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define ldr_i(r0,r1)			_ldr_i(_jit,r0,r1)
static void _ldr_i(jit_state_t*,jit_int32_t,jit_int32_t);
#  define ldi_i(r0,i0)			_ldi_i(_jit,r0,i0)
static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
#  define ldxr_i(r0,r1,r2)		_ldxr_i(_jit,r0,r1,r2)
static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define ldxi_i(r0,r1,i0)		_ldxi_i(_jit,r0,r1,i0)
static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
#  define str_c(r0,r1)			_str_c(_jit,r0,r1)
static void _str_c(jit_state_t*,jit_int32_t,jit_int32_t);
#  define sti_c(i0,r0)			_sti_c(_jit,i0,r0)
static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
#  define stxr_c(r0,r1,r2)		_stxr_c(_jit,r0,r1,r2)
static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define stxi_c(r0,r1,i0)		_stxi_c(_jit,r0,r1,i0)
static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
#  define str_s(r0,r1)			_str_s(_jit,r0,r1)
static void _str_s(jit_state_t*,jit_int32_t,jit_int32_t);
#  define sti_s(i0,r0)			_sti_s(_jit,i0,r0)
static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
#  define stxr_s(r0,r1,r2)		_stxr_s(_jit,r0,r1,r2)
static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
#  define stxi_s(r0,r1,i0)		_stxi_s(_jit,r0,r1,i0)
static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
#  define str_i(r0,r1)			_str_i(_jit,r0,r1)
static void _str_i(jit_state_t*,jit_int32_t,jit_int32_t);
#  define sti_i(i0,r0)			_sti_i(_jit,i0,r0)
static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
#  define stxr_i(r0,r1,r2)		_stxr_i(_jit,r0,r1,r2)
static void _stxr_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
#  define stxi_i(r0,r1,i0)		_stxi_i(_jit,r0,r1,i0)
static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
#  define bswapr_us(r0,r1)		_bswapr_us(_jit,r0,r1)
static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
#  define bswapr_ui(r0,r1)		_bswapr_ui(_jit,r0,r1)
static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
#  define extr_c(r0,r1)			_extr_c(_jit,r0,r1)
static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
#  define extr_uc(r0,r1)		_extr_uc(_jit,r0,r1)
static void _extr_uc(jit_state_t*,jit_int32_t,jit_int32_t);
#  define extr_s(r0,r1)			_extr_s(_jit,r0,r1)
static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
#  define extr_us(r0,r1)		_extr_us(_jit,r0,r1)
static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
#  define prolog(i0)			_prolog(_jit,i0)
static void _prolog(jit_state_t*,jit_node_t*);
#  define epilog(i0)			_epilog(_jit,i0)
static void _epilog(jit_state_t*,jit_node_t*);
#  define callr(r0)			_callr(_jit,r0)
static void _callr(jit_state_t*,jit_int32_t);
#  define calli(i0,i1)			_calli(_jit,i0,i1)
static void _calli(jit_state_t*,jit_word_t,jit_bool_t);
#  define calli_p(i0,i1)		_calli_p(_jit,i0,i1)
static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_bool_t);
#  define vastart(r0)			_vastart(_jit, r0)
static void _vastart(jit_state_t*, jit_int32_t);
#  define vaarg(r0, r1)			_vaarg(_jit, r0, r1)
static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
#  define patch_at(kind,jump,label)	_patch_at(_jit,kind,jump,label)
static void _patch_at(jit_state_t*,jit_int32_t,jit_word_t,jit_word_t);
#endif

#if CODE
/* from binutils */
#  define rotate_left(v, n)	(v << n | v >> (32 - n))
static int
encode_arm_immediate(unsigned int v)
{
    unsigned int	a, i;

    for (i = 0; i < 32; i += 2)
	if ((a = rotate_left(v, i)) <= 0xff)
	    return (a | (i << 7));

    return (-1);
}

static int
encode_thumb_immediate(unsigned int v)
{
    int			i;
    unsigned int	m;
    unsigned int	n;
    /* 00000000 00000000 00000000 abcdefgh */
    if ((v & 0xff) == v)
	return (v);
    /* 00000000 abcdefgh 00000000 abcdefgh */
    if ((v & 0xff00ff) == v && ((v & 0xff0000) >> 16) == (v & 0xff))
	return ((v & 0xff) | (1 << 12));
    /* abcdefgh 00000000 abcdefgh 00000000 */
    if (((v & 0xffff0000) >> 16) == (v & 0xffff) && (v & 0xff) == 0)
	return ((v & 0x000000ff) | (2 << 12));
    /* abcdefgh abcdefgh abcdefgh abcdefgh */
    if ( (v &    0xff)        == ((v &     0xff00) >>  8) &&
	((v &   0xff00) >> 8) == ((v &   0xff0000) >> 16) &&
	((v & 0xff0000) << 8) ==  (v & 0xff000000))
	return ((v & 0xff) | (3 << 12));
    /* 1bcdefgh << 24 ... 1bcdefgh << 1 */
    for (i = 8, m = 0xff000000, n = 0x80000000;
	 i < 23; i++, m >>= 1,  n >>= 1) {
	if ((v & m) == v && (v & n)) {
	    v >>= 32 - i;
	    if (!(i & 1))
		v &= 0x7f;
	    i >>= 1;
	    return (((i & 7) << 12) | ((i & 8) << 23) | v);
	}
    }
    return (-1);
}

static int
encode_thumb_word_immediate(unsigned int v)
{
    if ((v & 0xfffff000) == 0)
	return (((v & 0x800) << 15) | ((v & 0x700) << 4) | (v & 0xff));
    return (-1);
}

static int
encode_thumb_jump(int v)
{
    int		s, i1, i2, j1, j2;
    if (v >= (int)-0x800000 && v <= 0x7fffff) {
	s  = !!(v & 0x800000);
	i1 = !!(v & 0x400000);
	i2 = !!(v & 0x200000);
	j1 = s ? i1 : !i1;
	j2 = s ? i2 : !i2;
	return ((s<<26)|((v&0x1ff800)<<5)|(j1<<13)|(j2<<11)|(v&0x7ff));
    }
    return (-1);
}

static int
encode_thumb_cc_jump(int v)
{
    int		s, j1, j2;
    if (v >= (int)-0x80000 && v <= 0x7ffff) {
	s  = !!(v & 0x80000);
	j1 = !!(v & 0x20000);
	j2 = !!(v & 0x40000);
	return ((s<<26)|((v&0x1f800)<<5)|(j1<<13)|(j2<<11)|(v&0x7ff));
    }
    return (-1);
}

static int
encode_thumb_shift(int v, int type)
{
    switch (type) {
	case ARM_ASR:
	case ARM_LSL:
	case ARM_LSR:		type >>= 1;	break;
	default:		assert(!"handled shift");
    }
    assert(v >= 0 && v <= 31);
    return (((v & 0x1c) << 10) | ((v & 3) << 6) | type);
}

static void
_tcit(jit_state_t *_jit, unsigned int tc, int it)
{
    int		c;
    int		m;
    c = (tc >> 28) & 1;
    assert(!(tc & 0xfffffff) && tc != ARM_CC_NV);
    switch (it) {
	case THUMB2_IT:		m =   1<<3; 			break;
	case THUMB2_ITT:	m =  (c<<3)| (1<<2);		break;
	case THUMB2_ITE:	m = (!c<<3)| (1<<2);		break;
	case THUMB2_ITTT:	m =  (c<<3)| (c<<2)| (1<<1);	break;
	case THUMB2_ITET:	m = (!c<<3)| (c<<2)| (1<<1);	break;
	case THUMB2_ITTE:	m =  (c<<3)|(!c<<2)| (1<<1);	break;
	case THUMB2_ITEE:	m = (!c<<3)|(!c<<2)| (1<<1);	break;
	case THUMB2_ITTTT:	m =  (c<<3)| (c<<2)| (c<<1)|1;	break;
	case THUMB2_ITETT:	m = (!c<<3)| (c<<2)| (c<<1)|1;	break;
	case THUMB2_ITTET:	m =  (c<<3)|(!c<<2)| (c<<1)|1;	break;
	case THUMB2_ITEET:	m = (!c<<3)|(!c<<2)| (c<<1)|1;	break;
	case THUMB2_ITTTE:	m =  (c<<3)| (c<<2)|(!c<<1)|1;	break;
	case THUMB2_ITETE:	m = (!c<<3)| (c<<2)|(!c<<1)|1;	break;
	case THUMB2_ITTEE:	m =  (c<<3)|(!c<<2)|(!c<<1)|1;	break;
	case THUMB2_ITEEE:	m = (!c<<3)|(!c<<2)|(!c<<1)|1;	break;
	default:		abort();
    }
    assert(m && (tc != ARM_CC_AL || !(m & (m - 1))));
    is(0xbf00 | (tc >> 24) | m);
}

static void
_corrr(jit_state_t *_jit, int cc, int o, int rn, int rd, int rm)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xf00fff0f));
    ii(cc|o|(_u4(rn)<<16)|(_u4(rd)<<12)|_u4(rm));
}

static void
_corri(jit_state_t *_jit, int cc, int o, int rn, int rd, int im)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xf00fffff));
    assert(!(im & 0xfffff000));
    ii(cc|o|(_u4(rn)<<16)|(_u4(rd)<<12)|_u12(im));
}

static void
_corri8(jit_state_t *_jit, int cc, int o, int rn, int rt, int im)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xf00fff0f));
    assert(!(im & 0xffffff00));
    ii(cc|o|(_u4(rn)<<16)|(_u4(rt)<<12)|((im&0xf0)<<4)|(im&0x0f));
}

static void
_coriw(jit_state_t *_jit, int cc, int o, int rd, int im)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xf00fffff));
    assert(!(im & 0xffff0000));
    ii(cc|o|((im&0xf000)<<4)|(_u4(rd)<<12)|(im&0xfff));
}

static void
_torrr(jit_state_t *_jit, int o, int rn, int rd, int rm)
{
    jit_thumb_t	thumb;
    assert(!(o & 0xf0f0f));
    thumb.i = o|(_u4(rn)<<16)|(_u4(rd)<<8)|_u4(rm);
    iss(thumb.s[0], thumb.s[1]);
}

static void
_torrrs(jit_state_t *_jit, int o, int rn, int rd, int rm, int im)
{
    jit_thumb_t	thumb;
    assert(!(o  & 0x000f0f0f));
    assert(!(im & 0xffff8f0f));
    thumb.i = o|(_u4(rn)<<16)|(_u4(rd)<<8)|im|_u4(rm);
    iss(thumb.s[0], thumb.s[1]);
}

static void
_torxr(jit_state_t *_jit, int o, int rn, int rt, int rm)
{
    jit_thumb_t	thumb;
    assert(!(o & 0xf0f0f));
    thumb.i = o|(_u4(rn)<<16)|(_u4(rt)<<12)|_u4(rm);
    iss(thumb.s[0], thumb.s[1]);
}

static void
_torrrr(jit_state_t *_jit, int o, int rn, int rl, int rh, int rm)
{
    jit_thumb_t	thumb;
    assert(!(o & 0x000fff0f));
    thumb.i = o|(_u4(rn)<<16)|(_u4(rl)<<12)|(_u4(rh)<<8)|_u4(rm);
    iss(thumb.s[0], thumb.s[1]);
}

static void
_torrri8(jit_state_t *_jit, int o, int rn, int rt, int rt2, int im)
{
    jit_thumb_t	thumb;
    assert(!(o  & 0x000fffff));
    assert(!(im & 0xffffff00));
    thumb.i = o|(_u4(rn)<<16)|(_u4(rt)<<12)|(_u4(rt2)<<8)|im;
    iss(thumb.s[0], thumb.s[1]);
}

static void
_torri(jit_state_t *_jit, int o, int rn, int rd, int im)
{
    jit_thumb_t	thumb;
    assert(!(o  & 0x0c0f7fff));
    assert(!(im & 0xfbff8f00));
    thumb.i = o|(_u4(rn)<<16)|(_u4(rd)<<8)|im;
    iss(thumb.s[0], thumb.s[1]);
}

static void
_torri8(jit_state_t *_jit, int o, int rn, int rt, int im)
{
    jit_thumb_t	thumb;
    assert(!(o  & 0x000ff0ff));
    assert(!(im & 0xffffff00));
    thumb.i = o|(_u4(rn)<<16)|(_u4(rt)<<12)|im;
    iss(thumb.s[0], thumb.s[1]);
}

static void
_torri12(jit_state_t *_jit, int o, int rn, int rt, int im)
{
    jit_thumb_t	thumb;
    assert(!(o  & 0x000fffff));
    assert(!(im & 0xfffff000));
    thumb.i = o|(_u4(rn)<<16)|(_u4(rt)<<12)|im;
    iss(thumb.s[0], thumb.s[1]);
}

static void
_tshift(jit_state_t *_jit, int o, int rd, int rm, int im)
{
    jit_thumb_t	thumb;
    assert(!(o & 0x7fcf));
    assert(im >= 0 && im < 32);
    thumb.i = o|((im&0x1c)<<10)|(_u4(rd)<<8)|((im&3)<<6)|_u4(rm);
    iss(thumb.s[0], thumb.s[1]);
}

static void
_toriw(jit_state_t *_jit, int o, int rd, int im)
{
    jit_thumb_t	thumb;
    assert(!(im & 0xffff0000));
    thumb.i = o|((im&0xf000)<<4)|((im&0x800)<<15)|((im&0x700)<<4)|(_u4(rd)<<8)|(im&0xff);
    iss(thumb.s[0], thumb.s[1]);
}

static void
_tc8(jit_state_t *_jit, int cc, int im)
{
    assert(!(cc & 0x0fffffff));
    assert(cc != ARM_CC_AL && cc != ARM_CC_NV);
    assert(im >= -128 && im <= 127);
    is(THUMB_CC_B|(cc>>20)|(im&0xff));
}

static void
_t11(jit_state_t *_jit, int im)
{
    assert(!(im & 0xfffff800));
    is(THUMB_B|im);
}

static void
_tcb(jit_state_t *_jit, int cc, int im)
{
    jit_thumb_t	thumb;
    assert(!(cc & 0xfffffff));
    assert(cc != ARM_CC_AL && cc != ARM_CC_NV);
    cc = ((jit_uint32_t)cc) >> 6;
    assert(!(im & (THUMB2_CC_B|cc)));
    thumb.i = THUMB2_CC_B|cc|im;
    iss(thumb.s[0], thumb.s[1]);
}

static void
_blxi(jit_state_t *_jit, int im)
{
    assert(!(im & 0xfe000000));
    ii(ARM_BLXI|im);
}

static void
_tb(jit_state_t *_jit, int o, int im)
{
    jit_thumb_t	thumb;
    assert(!(o & 0x07ff2fff));
    assert(!(o & im));
    thumb.i = o|im;
    iss(thumb.s[0], thumb.s[1]);
}

static void
_corrrr(jit_state_t *_jit, int cc, int o, int rh, int rl, int rm, int rn)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o & 0xf00fff0f));
    ii(cc|o|(_u4(rh)<<16)|(_u4(rl)<<12)|(_u4(rm)<<8)|_u4(rn));
}

static void
_corrrs(jit_state_t *_jit, int cc, int o, int rn, int rd, int rm, int im)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xf000ff8f));
    ii(cc|o|(_u4(rd)<<12)|(_u4(rn)<<16)|(im<<7)|_u4(rm));
}

static void
_cshift(jit_state_t *_jit, int cc, int o, int rd, int rm, int rn, int im)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xffe0ff8f));
    assert(((_u4(rm)<<8)&(im<<7)) == 0);
    ii(cc|ARM_SHIFT|o|(_u4(rd)<<12)|(_u4(rm)<<8)|(im<<7)|_u4(rn));
}

static void
_cb(jit_state_t *_jit, int cc, int o, int im)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xf0ffffff));
    ii(cc|o|_u24(im));
}

static void
_cbx(jit_state_t *_jit, int cc, int o, int rm)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xf000000f));
    ii(cc|o|_u4(rm));
}

static void
_corl(jit_state_t *_jit, int cc, int o, int r0, int i0)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xf00fffff));
    ii(cc|o|(_u4(r0)<<16)|_u16(i0));
}

static void
_c6orr(jit_state_t *_jit, int cc, int o, int rd, int rm)
{
    assert(!(cc & 0x0fffffff));
    assert(!(o  & 0xf000f00f));
    ii(cc|o|(_u4(rd)<<12)|_u4(rm));
}

static void
_tpp(jit_state_t *_jit, int o, int im)
{
    jit_thumb_t	thumb;
    assert(!(o & 0x0000ffff));
    if (o == THUMB2_PUSH)
	assert(!(im & 0x8000));
    assert(__builtin_popcount(im & 0x7fff) > 1);
    thumb.i = o|im;
    iss(thumb.s[0], thumb.s[1]);
}

static void
_torl(jit_state_t *_jit, int o, int rn, int im)
{
    jit_thumb_t	thumb;
    assert(!(o & 0xf1fff));
    assert(rn != _R15 || !im || ((o & 0xc000) == 0xc000));
    assert(!(o & THUMB2_LDM_W) || !(im & (1 << rn)));
    thumb.i = o | (_u4(rn)<<16)|_u13(im);
    iss(thumb.s[0], thumb.s[1]);
}

static void
_dmb(jit_state_t *_jit, int im)
{
    assert(!(im & 0xfffffff0));
    ii(ARM_DMB|im);
}

static void
_tdmb(jit_state_t *_jit, int im)
{
    jit_thumb_t	thumb;
    assert(!(im & 0xfffffff0));
    thumb.i = THUMB2_DMB | im;
    iss(thumb.s[0], thumb.s[1]);
}

static void
_nop(jit_state_t *_jit, jit_int32_t i0)
{
    if (jit_thumb_p()) {
	for (; i0 > 0; i0 -= 2)
	    T1_NOP();
    }
    else {
	for (; i0 > 0; i0 -= 4)
	    NOP();
    }
    assert(i0 == 0);
}

static void
_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (r0 != r1) {
	if (jit_thumb_p())
	    T1_MOV(r0, r1);
	else
	    MOV(r0, r1);
    }
}

static void
_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
{
    int			i;
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && r0 < 8 && !(i0 & 0xffffff80))
	    T1_MOVI(r0, i0);
	else if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_MOVI(r0, i);
	else if ((i = encode_thumb_immediate(~i0)) != -1)
	    T2_MVNI(r0, i);
	else {
	    T2_MOVWI(r0, (jit_uint16_t)i0);
	    if (i0 & 0xffff0000)
		T2_MOVTI(r0, (jit_uint16_t)((unsigned)i0 >> 16));
	}
    }
    else {
	if (jit_armv6_p() && !(i0 & 0xffff0000))
	    MOVWI(r0, i0);
	else if ((i = encode_arm_immediate(i0)) != -1)
	    MOVI(r0, i);
	else if ((i = encode_arm_immediate(~i0)) != -1)
	    MVNI(r0, i);
	else if (jit_armv6_p()) {
	    MOVWI(r0, (jit_uint16_t)(i0));
	    if ((i0 & 0xffff0000))
		MOVTI(r0, (jit_uint16_t)((unsigned)i0 >> 16));
	}
	else
	    load_const(0, r0, i0);
    }
}

static jit_word_t
_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
{
    jit_word_t		w;
    w = _jit->pc.w;
    if (jit_thumb_p()) {
	T2_MOVWI(r0, (jit_uint16_t)(i0));
	T2_MOVTI(r0, (jit_uint16_t)((unsigned)i0 >> 16));
    }
    else
	load_const(1, r0, 0);
    return (w);
}

static void
_movznr(jit_state_t *_jit, int ct, jit_int32_t r0,
        jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
        if (r2 < 7)
            T1_CMPI(r2, 0);
        else
            T2_CMPI(r2, 0);
        IT(ct);
        T1_MOV(r0, r1);
    } else {
        CMPI(r2, 0);
        CC_MOV(ct, r0, r1);
    }
}

static void
_movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    _movznr(_jit, ARM_CC_NE, r0, r1, r2);
}

static void
_movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    _movznr(_jit, ARM_CC_EQ, r0, r1, r2);
}

static void
_casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
      jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
{
    jit_int32_t		r1_reg, iscasi;
    jit_word_t		retry, done, jump0, jump1;
    if (!jit_armv7_p())
	fallback_casx(r0, r1, r2, r3, i0);
    else {
	if ((iscasi = (r1 == _NOREG))) {
	    r1_reg = jit_get_reg(jit_class_gpr);
	    r1 = rn(r1_reg);
	    movi(r1, i0);
	}
	if (jit_thumb_p()) {
	    T2_DMB(DMB_ISH);
	    /* retry: */
	    retry = _jit->pc.w;
	    T2_LDREX(r0, r1, 0);
	    eqr(r0, r0, r2);
	    jump0 = beqi(_jit->pc.w, r0, 0);	/* beqi done r0 0 */
	    T2_STREX(r0, r3, r1, 0);
	    jump1 = bnei(_jit->pc.w, r0, 0);	/* bnei retry r0 0 */
	    /* r0 = 0 if memory updated, 1 otherwise */
	    xori(r0, r0, 1);
	    /* done: */
	    done = _jit->pc.w;
	    T2_DMB(DMB_ISH);
	}
	else {
	    DMB(DMB_ISH);
	    /* retry: */
	    retry = _jit->pc.w;
	    LDREX(r0, r1);
	    eqr(r0, r0, r2);
	    jump0 = beqi(_jit->pc.w, r0, 0);	/* beqi done r0 0 */
	    STREX(r0, r3, r1);
	    jump1 = bnei(_jit->pc.w, r0, 0);	/* bnei retry r0 0 */
	    /* r0 = 0 if memory updated, 1 otherwise */
	    xori(r0, r0, 1);
	    /* done: */
	    done = _jit->pc.w;
	    DMB(DMB_ISH);
	}
	patch_at(arm_patch_jump, jump0, done);
	patch_at(arm_patch_jump, jump1, retry);
	if (iscasi)
	    jit_unget_reg(r1_reg);
    }
}

static void
_comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1) < 8)
	    T1_NOT(r0, r1);
	else
	    T2_NOT(r0, r1);
    }
    else
	NOT(r0, r1);
}

static void
_negr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1) < 8)
	    T1_RSBI(r0, r1);
	else
	    T2_RSBI(r0, r1, 0);
    }
    else
	RSBI(r0, r1, 0);
}

static void
_clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (!jit_thumb_p() && jit_armv5e_p())
	CLZ(r0, r1);
    else if (jit_thumb_p() && jit_armv7_p()) {	/* armv6t2 actually */
	T2_CLZ(r0, r1);
    }
    else
	fallback_clz(r0, r0);
}

static void
_clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    comr(r0, r1);
    clzr(r0, r0);
}

static void
_ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_armv7_p()) {	/* armv6t2 actually */
	if (jit_thumb_p())
	    T2_RBIT(r0, r1);
	else
	    RBIT(r0, r1);
	clor(r0, r0);
    }
    else
	fallback_cto(r0, r1);
}

static void
_ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_armv7_p()) {	/* armv6t2 actually */
	if (jit_thumb_p())
	    T2_RBIT(r0, r1);
	else
	    RBIT(r0, r1);
	clzr(r0, r0);
    }
    else
	fallback_ctz(r0, r1);
}

static void
_addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1|r2) < 8)
	    T1_ADD(r0, r1, r2);
	else if (r0 == r1 || r0 == r2)
	    T1_ADDX(r0, r0 == r1 ? r2 : r1);
	else
	    T2_ADD(r0, r1, r2);
    }
    else
	ADD(r0, r1, r2);
}

static void
_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1) < 8 && !(i0 & ~7))
	    T1_ADDI3(r0, r1, i0);
	else if (!jit_no_set_flags() && (r0|r1) < 8 && !(-i0 & ~7))
	    T1_SUBI3(r0, r1, -i0);
	else if (!jit_no_set_flags() && r0 < 8 && r0 == r1 && !(i0 & ~0xff))
	    T1_ADDI8(r0, i0);
	else if (!jit_no_set_flags() && r0 < 8 && r0 == r1 && !(-i0 & ~0xff))
	    T1_SUBI8(r0, -i0);
	else if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_ADDI(r0, r1, i);
	else if ((i = encode_thumb_immediate(-i0)) != -1)
	    T2_SUBI(r0, r1, i);
	else if ((i = encode_thumb_word_immediate(i0)) != -1)
	    T2_ADDWI(r0, r1, i);
	else if ((i = encode_thumb_word_immediate(-i0)) != -1)
	    T2_SUBWI(r0, r1, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    T2_ADD(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    ADDI(r0, r1, i);
	else if ((i = encode_arm_immediate(-i0)) != -1)
	    SUBI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    ADD(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    ADD(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	/* thumb auto set carry if not inside IT block */
	if ((r0|r1|r2) < 8)
	    T1_ADD(r0, r1, r2);
	else
	    T2_ADDS(r0, r1, r2);
    }
    else
	ADDS(r0, r1, r2);
}

static void
_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8 && !(i0 & ~7))
	    T1_ADDI3(r0, r1, i0);
	else if ((r0|r1) < 8 && !(-i0 & ~7))
	    T1_SUBI3(r0, r1, -i0);
	else if (r0 < 8 && r0 == r1 && !(i0 & ~0xff))
	    T1_ADDI8(r0, i0);
	else if (r0 < 8 && r0 == r1 && !(-i0 & ~0xff))
	    T1_SUBI8(r0, -i0);
	else if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_ADDSI(r0, r1, i);
	else if ((i = encode_thumb_immediate(-i0)) != -1)
	    T2_SUBSI(r0, r1, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    T2_ADDS(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    ADDSI(r0, r1, i);
	else if ((i = encode_arm_immediate(-i0)) != -1)
	    SUBSI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    ADDS(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    ADDS(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    /* keep setting carry because don't know last ADC */
    if (jit_thumb_p()) {
	/* thumb auto set carry if not inside IT block */
	if ((r0|r1|r2) < 8 && (r0 == r1 || r0 == r2))
	    T1_ADC(r0, r0 == r1 ? r2 : r1);
	else
	    T2_ADCS(r0, r1, r2);
    }
    else
	ADCS(r0, r1, r2);
}

static void
_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    int			no_set_flags;
    if (jit_thumb_p()) {
	no_set_flags = jit_no_set_flags();
	jit_no_set_flags() = 1;
	if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_ADCSI(r0, r1, i);
	else if ((i = encode_thumb_immediate(-i0)) != -1)
	    T2_SBCSI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    T2_ADCS(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    T2_ADCS(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
	jit_no_set_flags() = no_set_flags;
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    ADCSI(r0, r1, i);
	else if ((i = encode_arm_immediate(-i0)) != -1)
	    SBCSI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    ADCS(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    ADCS(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_subr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1|r2) < 8)
	    T1_SUB(r0, r1, r2);
	else
	    T2_SUB(r0, r1, r2);
    }
    else
	SUB(r0, r1, r2);
}

static void
_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1) < 8 && !(i0 & ~7))
	    T1_SUBI3(r0, r1, i0);
	else if (!jit_no_set_flags() && (r0|r1) < 8 && !(-i0 & ~7))
	    T1_ADDI3(r0, r1, -i0);
	else if (!jit_no_set_flags() && r0 < 8 && r0 == r1 && !(i0 & ~0xff))
	    T1_SUBI8(r0, i0);
	else if (!jit_no_set_flags() && r0 < 8 && r0 == r1 && !(-i0 & ~0xff))
	    T1_ADDI8(r0, -i0);
	else if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_SUBI(r0, r1, i);
	else if ((i = encode_thumb_immediate(-i0)) != -1)
	    T2_ADDI(r0, r1, i);
	else if ((i = encode_thumb_word_immediate(i0)) != -1)
	    T2_SUBWI(r0, r1, i);
	else if ((i = encode_thumb_word_immediate(-i0)) != -1)
	    T2_ADDWI(r0, r1, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    T2_SUB(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    SUBI(r0, r1, i);
	else if ((i = encode_arm_immediate(-i0)) != -1)
	    ADDI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    SUB(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    SUB(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	/* thumb auto set carry if not inside IT block */
	if ((r0|r1|r2) < 8)
	    T1_SUB(r0, r1, r2);
	else
	    T2_SUBS(r0, r1, r2);
    }
    else
	SUBS(r0, r1, r2);
}

static void
_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8 && !(i0 & ~7))
	    T1_SUBI3(r0, r1, i0);
	else if ((r0|r1) < 8 && !(-i0 & ~7))
	    T1_ADDI3(r0, r1, -i0);
	else if (r0 < 8 && r0 == r1 && !(i0 & ~0xff))
	    T1_SUBI8(r0, i0);
	else if (r0 < 8 && r0 == r1 && !(-i0 & ~0xff))
	    T1_ADDI8(r0, -i0);
	else if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_SUBSI(r0, r1, i);
	else if ((i = encode_thumb_immediate(-i0)) != -1)
	    T2_ADDSI(r0, r1, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    T2_SUBS(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    SUBSI(r0, r1, i);
	else if ((i = encode_arm_immediate(-i0)) != -1)
	    ADDSI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    SUBS(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    SUBS(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    /* keep setting carry because don't know last SBC */
    if (jit_thumb_p()) {
	/* thumb auto set carry if not inside IT block */
	if ((r0|r1|r2) < 8 && r0 == r1)
	    T1_SBC(r0, r2);
	else
	    T2_SBCS(r0, r1, r2);
    }
    else
	SBCS(r0, r1, r2);
}

static void
_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    int			no_set_flags;
    if (jit_thumb_p()) {
	no_set_flags = jit_no_set_flags();
	jit_no_set_flags() = 1;
	if ((i = encode_arm_immediate(i0)) != -1)
	    T2_SBCSI(r0, r1, i);
	else if ((i = encode_arm_immediate(-i0)) != -1)
	    T2_ADCSI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    T2_SBCS(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    SBCS(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
	jit_no_set_flags() = no_set_flags;
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    SBCSI(r0, r1, i);
	else if ((i = encode_arm_immediate(-i0)) != -1)
	    ADCSI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    SBCS(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    SBCS(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    subi(r0, r1, i0);
    negr(r0, r0);
}

static void
_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && r0 == r2 && (r0|r1) < 8)
	    T1_MUL(r0, r1);
	else if (!jit_no_set_flags() && r0 == r1 && (r0|r2) < 8)
	    T1_MUL(r0, r2);
	else
	    T2_MUL(r0, r1, r2);
    }
    else {
	if (r0 == r1 && !jit_armv6_p()) {
	    if (r0 != r2)
		MUL(r0, r2, r1);
	    else {
		reg = jit_get_reg(jit_class_gpr);
		MOV(rn(reg), r1);
		MUL(r0, rn(reg), r2);
		jit_unget_reg(reg);
	    }
	}
	else
	    MUL(r0, r1, r2);
    }
}

static void
_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    mulr(r0, r1, rn(reg));
    jit_unget_reg(reg);
}

static void
_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
	jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (r2 == r3) {
	    reg = jit_get_reg(jit_class_gpr);
	    movr(rn(reg), r2);
	    if (sign)
		T2_SMULL(r0, r1, rn(reg), r2);
	    else
		T2_UMULL(r0, r1, rn(reg), r2);
	    jit_unget_reg(reg);
	}
	else if (r0 != r2 && r1 != r2) {
	    if (sign)
		T2_SMULL(r0, r1, r2, r3);
	    else
		T2_UMULL(r0, r1, r2, r3);
	}
	else {
	    if (sign)
		T2_SMULL(r0, r1, r3, r2);
	    else
		T2_UMULL(r0, r1, r3, r2);
	}
    }
    else {
	if (r2 == r3) {
	    reg = jit_get_reg(jit_class_gpr);
	    movr(rn(reg), r2);
	    if (sign)
		SMULL(r0, r1, rn(reg), r2);
	    else
		UMULL(r0, r1, rn(reg), r2);
	    jit_unget_reg(reg);
	}
	else if (r0 != r2 && r1 != r2) {
	    if (sign)
		SMULL(r0, r1, r2, r3);
	    else
		UMULL(r0, r1, r2, r3);
	}
	else {
	    if (sign)
		SMULL(r0, r1, r3, r2);
	    else
		UMULL(r0, r1, r3, r2);
	}
    }
}

static void
_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
	jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    iqmulr(r0, r1, r2, rn(reg), sign);
    jit_unget_reg(reg);
}

static void
_divrem(jit_state_t *_jit, int div, int sign,
	jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    jit_word_t		d;
    jit_word_t		w;
    jit_get_reg_args();
    movr(_R0_REGNO, r1);
    movr(_R1_REGNO, r2);
    if (sign)			w = (jit_word_t)__aeabi_idivmod;
    else			w = (jit_word_t)__aeabi_uidivmod;
    if (!jit_exchange_p()) {
	if (jit_thumb_p())	d = ((w - _jit->pc.w) >> 1) - 2;
	else			d = ((w - _jit->pc.w) >> 2) - 2;
	if (_s24P(d)) {
	    if (jit_thumb_p())	T2_BLI(encode_thumb_jump(d));
	    else		BLI(d & 0x00ffffff);
	}
	else			goto fallback;
    }
    else {
    fallback:
	movi(_R2_REGNO, w);
	if (jit_thumb_p())	T1_BLX(_R2_REGNO);
	else			BLX(_R2_REGNO);
    }
    if (div)			movr(r0, _R0_REGNO);
    else			movr(r0, _R1_REGNO);
    jit_unget_reg_args();
}

static void
_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_armv7r_p()) {
	if (jit_thumb_p())
	    T2_SDIV(r0, r1, r2);
	else
	    SDIV(r0, r1, r2);
    }
    else
	divrem(1, 1, r0, r1, r2);
}

static void
_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    divr(r0, r1, rn(reg));
    jit_unget_reg(reg);
}

static void
_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_armv7r_p()) {
	if (jit_thumb_p())
	    T2_UDIV(r0, r1, r2);
	else
	    UDIV(r0, r1, r2);
    }
    else
	divrem(1, 0, r0, r1, r2);
}

static void
_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    divr_u(r0, r1, rn(reg));
    jit_unget_reg(reg);
}

static void
_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
	jit_int32_t r2, jit_int32_t r3,	jit_bool_t sign)
{
    jit_word_t		d;
    jit_word_t		w;
    jit_get_reg_args();
    movr(_R0_REGNO, r2);
    movr(_R1_REGNO, r3);
    if (sign)			w = (jit_word_t)__aeabi_idivmod;
    else			w = (jit_word_t)__aeabi_uidivmod;
    if (!jit_exchange_p()) {
	if (jit_thumb_p())	d = ((w - _jit->pc.w) >> 1) - 2;
	else			d = ((w - _jit->pc.w) >> 2) - 2;
	if (_s24P(d)) {
	    if (jit_thumb_p())	T2_BLI(encode_thumb_jump(d));
	    else		BLI(d & 0x00ffffff);
	}
	else			goto fallback;
    }
    else {
    fallback:
	movi(_R2_REGNO, w);
	if (jit_thumb_p())	T1_BLX(_R2_REGNO);
	else			BLX(_R2_REGNO);
    }
    movr(r0, _R0_REGNO);
    movr(r1, _R1_REGNO);
    jit_unget_reg_args();
}

static void
_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
	jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    iqdivr(r0, r1, r2, rn(reg), sign);
    jit_unget_reg(reg);
}

static void
_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_armv7r_p()) {
	jit_int32_t		reg;
	if (r0 == r1 || r0 == r2) {
	    reg = jit_get_reg(jit_class_gpr);
	    divr(rn(reg), r1, r2);
	    mulr(rn(reg), r2, rn(reg));
	    subr(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
	else {
	    divr(r0, r1, r2);
	    mulr(r0, r2, r0);
	    subr(r0, r1, r0);
	}
    }
    else
	divrem(0, 1, r0, r1, r2);
}

static void
_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    remr(r0, r1, rn(reg));
    jit_unget_reg(reg);
}

static void
_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_armv7r_p()) {
	jit_int32_t		reg;
	if (r0 == r1 || r0 == r2) {
	    reg = jit_get_reg(jit_class_gpr);
	    divr_u(rn(reg), r1, r2);
	    mulr(rn(reg), r2, rn(reg));
	    subr(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
	else {
	    divr_u(r0, r1, r2);
	    mulr(r0, r2, r0);
	    subr(r0, r1, r0);
	}
    }
    else
	divrem(0, 0, r0, r1, r2);
}

static void
_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    remr_u(r0, r1,rn(reg));
    jit_unget_reg(reg);
}

static void
_andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1|r2) < 8 && (r0 == r1 || r0 == r2))
	    T1_AND(r0, r0 == r1 ? r2 : r1);
	else
	    T2_AND(r0, r1, r2);
    }
    else
	AND(r0, r1, r2);
}

static void
_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_ANDI(r0, r1, i);
	else if ((i = encode_thumb_immediate(~i0)) != -1)
	    T2_BICI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    T2_AND(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    T2_AND(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    ANDI(r0, r1, i);
	else if ((i = encode_arm_immediate(~i0)) != -1)
	    BICI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    AND(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    AND(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_orr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1|r2) < 8 && (r0 == r1 || r0 == r2))
	    T1_ORR(r0, r0 == r1 ? r2 : r1);
	else
	    T2_ORR(r0, r1, r2);
    }
    else
	ORR(r0, r1, r2);
}

static void
_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_ORRI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    T2_ORR(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    T2_ORR(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    ORRI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    ORR(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    ORR(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_xorr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1|r2) < 8 && (r0 == r1 || r0 == r2))
	    T1_EOR(r0, r0 == r1 ? r2 : r1);
	else
	    T2_EOR(r0, r1, r2);
    }
    else
	EOR(r0, r1, r2);
}

static void
_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_EORI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    T2_EOR(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    T2_EOR(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    EORI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    EOR(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    EOR(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1|r2) < 8 && r0 == r1)
	    T1_LSL(r0, r2);
	else
	    T2_LSL(r0, r1, r2);
    }
    else
	LSL(r0, r1, r2);
}

static void
_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    assert(i0 >= 0 && i0 <= 31);
    if (i0 == 0)
	movr(r0, r1);
    else if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1) < 8)
	    T1_LSLI(r0, r1, i0);
	else
	    T2_LSLI(r0, r1, i0);
    }
    else
	LSLI(r0, r1, i0);
}

static void
_rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1|r2) < 8 && r0 == r1)
	    T1_ASR(r0, r2);
	else
	    T2_ASR(r0, r1, r2);
    }
    else
	ASR(r0, r1, r2);
}

static void
_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    assert(i0 >= 0 && i0 <= 31);
    if (i0 == 0)
	movr(r0, r1);
    else if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1) < 8)
	    T1_ASRI(r0, r1, i0);
	else
	    T2_ASRI(r0, r1, i0);
    }
    else
	ASRI(r0, r1, i0);
}

static void
_rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1|r2) < 8 && r0 == r1)
	    T1_LSR(r0, r2);
	else
	    T2_LSR(r0, r1, r2);
    }
    else
	LSR(r0, r1, r2);
}

static void
_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    assert(i0 >= 0 && i0 <= 31);
    if (i0 == 0)
	movr(r0, r1);
    else if (jit_thumb_p()) {
	if (!jit_no_set_flags() && (r0|r1) < 8)
	    T1_LSRI(r0, r1, i0);
	else
	    T2_LSRI(r0, r1, i0);
    }
    else
	LSRI(r0, r1, i0);
}

static void
_ccr(jit_state_t *_jit, int ct, int cf,
     jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	assert((ct ^ cf) >> 28 == 1);
	if ((r1|r2) < 8)
	    T1_CMP(r1, r2);
	else if ((r1&r2) & 8)
	    T1_CMPX(r1, r2);
	else
	    T2_CMP(r1, r2);
	ITE(ct);
	if (r0 < 8) {
	    T1_MOVI(r0, 1);
	    T1_MOVI(r0, 0);
	}
	else {
	    T2_MOVI(r0, 1);
	    T2_MOVI(r0, 0);
	}
    }
    else {
	CMP(r1, r2);
	CC_MOVI(ct, r0, 1);
	CC_MOVI(cf, r0, 0);
    }
}

static void
_cci(jit_state_t *_jit, int ct, int cf,
     jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (r1 < 7 && !(i0 & 0xffffff00))
	    T1_CMPI(r1, i0);
	else if ((i = encode_thumb_immediate(i0)) != -1)
	    T2_CMPI(r1, i);
	else if ((i = encode_thumb_immediate(-i0)) != -1)
	    T2_CMNI(r1, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    ccr(ct, cf, r0, r1, rn(reg));
	    jit_unget_reg(reg);
	    return;
	}
	ITE(ct);
	if (r0 < 8) {
	    T1_MOVI(r0, 1);
	    T1_MOVI(r0, 0);
	}
	else {
	    T2_MOVI(r0, 1);
	    T2_MOVI(r0, 0);
	}
    }
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    CMPI(r1, i);
	else if ((i = encode_arm_immediate(-i0)) != -1)
	    CMNI(r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    CMP(r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    CMP(r1, rn(reg));
	    jit_unget_reg(reg);
	}
	CC_MOVI(ct, r0, 1);
	CC_MOVI(cf, r0, 0);
    }
}

static void
_ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p())
	ccr(ARM_CC_NE, ARM_CC_EQ, r0, r1, r2);
    else {
	SUBS(r0, r1, r2);
	CC_MOVI(ARM_CC_NE, r0, 1);
    }
}

static void
_nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p())
	cci(ARM_CC_NE, ARM_CC_EQ, r0, r1, i0);
    else {
	if ((i = encode_arm_immediate(i0)) != -1)
	    SUBSI(r0, r1, i);
	else if ((i = encode_arm_immediate(-i0)) != -1)
	    ADDSI(r0, r1, i);
	else if (r0 != r1) {
	    movi(r0, i0);
	    SUBS(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    SUBS(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
	CC_MOVI(ARM_CC_NE, r0, 1);
    }
}

static void
_jmpr(jit_state_t *_jit, jit_int32_t r0)
{
    if (jit_thumb_p())
	T1_MOV(_R15_REGNO, r0);
    else
	MOV(_R15_REGNO, r0);
}

static void
_jmpi(jit_state_t *_jit, jit_word_t i0)
{
    jit_word_t		w;
    jit_word_t		d;
    jit_int32_t		reg;
    w = _jit->pc.w;
    /* if thumb and in thumb mode */
    if (jit_thumb_p() && _jitc->thumb) {
	d = ((i0 - w) >> 1) - 2;
	if (d >= -1024 && d <= 1023)
	    T1_B(d & 0x7ff);
	else if (_s24P(d))
	    T2_B(encode_thumb_jump(d));
	else {
	    reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
	    movi(rn(reg), i0);
	    jmpr(rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	d = ((i0 - w) >> 2) - 2;
	if (_s24P(d))
	    B(d & 0x00ffffff);
	else {
	    reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
	    movi(rn(reg), i0);
	    jmpr(rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static jit_word_t
_jmpi_p(jit_state_t *_jit, jit_word_t i0, jit_bool_t i1)
{
    jit_word_t		w;
    jit_word_t		d;
    jit_int32_t		reg;
    /* i1 means jump is reachable in signed 24 bits  */
    if (i1) {
	w = _jit->pc.w;
	/* if thumb and in thumb mode */
	if (jit_thumb_p() && _jitc->thumb) {
	    d = ((i0 - w) >> 1) - 2;
	    assert(_s24P(d));
	    T2_B(encode_thumb_jump(d));
	}
	else {
	    d = ((i0 - w) >> 2) - 2;
	    assert(_s24P(d));
	    B(d & 0x00ffffff);
	}
    }
    else {
	reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
	w = movi_p(rn(reg), i0);
	jmpr(rn(reg));
	jit_unget_reg(reg);
    }
    return (w);
}

static jit_word_t
_bccr(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
    jit_word_t		w;
    jit_word_t		d;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_CMP(r0, r1);
	else if ((r0&r1) & 8)
	    T1_CMPX(r0, r1);
	else
	    T2_CMP(r0, r1);
	/* use only thumb2 conditional as does not know if will be patched */
	w = _jit->pc.w;
	d = ((i0 - w) >> 1) - 2;
	assert(_s20P(d));
	T2_CC_B(cc, encode_thumb_cc_jump(d));
    }
    else {
	CMP(r0, r1);
	w = _jit->pc.w;
	d = ((i0 - w) >> 2) - 2;
	assert(_s24P(d));
	CC_B(cc, d & 0x00ffffff);
    }
    return (w);
}

static jit_word_t
_bcci(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
{
    jit_word_t		w;
    jit_word_t		d;
    int			i;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (r0 < 7 && !(i1 & 0xffffff00))
	    T1_CMPI(r0, i1);
	else if ((i = encode_thumb_immediate(i1)) != -1)
	    T2_CMPI(r0, i);
	else if ((i = encode_thumb_immediate(-i1)) != -1)
	    T2_CMNI(r0, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i1);
	    T2_CMP(r0, rn(reg));
	    jit_unget_reg(reg);
	}
	/* use only thumb2 conditional as does not know if will be patched */
	w = _jit->pc.w;
	d = ((i0 - w) >> 1) - 2;
	assert(_s20P(d));
	T2_CC_B(cc, encode_thumb_cc_jump(d));
    }
    else {
	if ((i = encode_arm_immediate(i1)) != -1)
	    CMPI(r0, i);
	else if ((i = encode_arm_immediate(-i1)) != -1)
	    CMNI(r0, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i1);
	    CMP(r0, rn(reg));
	    jit_unget_reg(reg);
	}
	w = _jit->pc.w;
	d = ((i0 - w) >> 2) - 2;
	assert(_s24P(d));
	CC_B(cc, d & 0x00ffffff);
    }
    return (w);
}

static jit_word_t
_baddr(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
    jit_word_t		w;
    jit_word_t		d;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_ADD(r0, r0, r1);
	else
	    T2_ADDS(r0, r0, r1);
	w = _jit->pc.w;
	d = ((i0 - w) >> 1) - 2;
	assert(_s20P(d));
	T2_CC_B(cc, encode_thumb_cc_jump(d));
    }
    else {
	ADDS(r0, r0, r1);
	w = _jit->pc.w;
	d = ((i0 - w) >> 2) - 2;
	assert(_s24P(d));
	CC_B(cc, d & 0x00ffffff);
    }
    return (w);
}

static jit_word_t
_baddi(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, int i1)
{
    int			i;
    jit_word_t		w;
    jit_word_t		d;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (r0 < 8 && !(i1 & ~7))
	    T1_ADDI3(r0, r0, i1);
	else if (r0 < 8 && !(-i1 & ~7))
	    T1_SUBI3(r0, r0, -i1);
	else if (r0 < 8 && !(i1 & ~0xff))
	    T1_ADDI8(r0, i1);
	else if (r0 < 8 && !(-i1 & ~0xff))
	    T1_SUBI8(r0, -i1);
	else if ((i = encode_thumb_immediate(i1)) != -1)
	    T2_ADDSI(r0, r0, i);
	else if ((i = encode_thumb_immediate(-i1)) != -1)
	    T2_SUBSI(r0, r0, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i1);
	    T2_ADDS(r0, r0, rn(reg));
	    jit_unget_reg(reg);
	}
	w = _jit->pc.w;
	d = ((i0 - w) >> 1) - 2;
	assert(_s20P(d));
	T2_CC_B(cc, encode_thumb_cc_jump(d));
    }
    else {
	if ((i = encode_arm_immediate(i1)) != -1)
	    ADDSI(r0, r0, i);
	else if ((i = encode_arm_immediate(-i1)) != -1)
	    SUBSI(r0, r0, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i1);
	    ADDS(r0, r0, rn(reg));
	    jit_unget_reg(reg);
	}
	w = _jit->pc.w;
	d = ((i0 - w) >> 2) - 2;
	assert(_s24P(d));
	CC_B(cc, d & 0x00ffffff);
    }
    return (w);
}

static jit_word_t
_bsubr(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
    jit_word_t		w;
    jit_word_t		d;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_SUB(r0, r0, r1);
	else
	    T2_SUBS(r0, r0, r1);
	w = _jit->pc.w;
	d = ((i0 - w) >> 1) - 2;
	assert(_s20P(d));
	T2_CC_B(cc, encode_thumb_cc_jump(d));
    }
    else {
	SUBS(r0, r0, r1);
	w = _jit->pc.w;
	d = ((i0 - w) >> 2) - 2;
	assert(_s24P(d));
	CC_B(cc, d & 0x00ffffff);
    }
    return (w);
}

static jit_word_t
_bsubi(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, int i1)
{
    int			i;
    jit_word_t		w;
    jit_word_t		d;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (r0 < 8 && !(i1 & ~7))
	    T1_SUBI3(r0, r0, i1);
	else if (r0 < 8 && !(-i1 & ~7))
	    T1_ADDI3(r0, r0, -i1);
	else if (r0 < 8 && !(i1 & ~0xff))
	    T1_SUBI8(r0, i1);
	else if (r0 < 8 && !(-i1 & ~0xff))
	    T1_ADDI8(r0, -i1);
	else if ((i = encode_thumb_immediate(i1)) != -1)
	    T2_SUBSI(r0, r0, i);
	else if ((i = encode_thumb_immediate(-i1)) != -1)
	    T2_SUBSI(r0, r0, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i1);
	    T2_SUBS(r0, r0, rn(reg));
	    jit_unget_reg(reg);
	}
	w = _jit->pc.w;
	d = ((i0 - w) >> 1) - 2;
	assert(_s20P(d));
	T2_CC_B(cc, encode_thumb_cc_jump(d));
    }
    else {
	if ((i = encode_arm_immediate(i1)) != -1)
	    SUBSI(r0, r0, i);
	else if ((i = encode_arm_immediate(-i1)) != -1)
	    ADDSI(r0, r0, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i1);
	    SUBS(r0, r0, rn(reg));
	    jit_unget_reg(reg);
	}
	w = _jit->pc.w;
	d = ((i0 - w) >> 2) - 2;
	assert(_s24P(d));
	CC_B(cc, d & 0x00ffffff);
    }
    return (w);
}

static jit_word_t
_bmxr(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
    jit_word_t		w;
    jit_word_t		d;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_TST(r0, r1);
	else
	    T2_TST(r0, r1);
	w = _jit->pc.w;
	d = ((i0 - w) >> 1) - 2;
	assert(_s20P(d));
	T2_CC_B(cc, encode_thumb_cc_jump(d));
    }
    else {
	if (jit_armv5_p())
	    TST(r0, r1);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    ANDS(rn(reg), r0, r1);
	    jit_unget_reg(reg);
	}
	w = _jit->pc.w;
	d = ((i0 - w) >> 2) - 2;
	assert(_s24P(d));
	CC_B(cc, d & 0x00ffffff);
    }
    return (w);
}

static jit_word_t
_bmxi(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
{
    int			i;
    jit_word_t		w;
    jit_word_t		d;
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((i = encode_thumb_immediate(i1)) != -1)
	    T2_TSTI(r0, i);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i1);
	    T2_TST(r0, rn(reg));
	    jit_unget_reg(reg);
	}
	w = _jit->pc.w;
	d = ((i0 - w) >> 1) - 2;
	assert(_s20P(d));
	T2_CC_B(cc, encode_thumb_cc_jump(d));
    }
    else {
	if (jit_armv5_p()) {
	    if ((i = encode_arm_immediate(i1)) != -1)
		TSTI(r0, i);
	    else {
		reg = jit_get_reg(jit_class_gpr);
		movi(rn(reg), i1);
		TST(r0, rn(reg));
		jit_unget_reg(reg);
	    }
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    if ((i = encode_arm_immediate(i1)) != -1)
		ANDSI(rn(reg), r0, i);
	    else if ((i = encode_arm_immediate(~i1)) != -1)
		BICSI(rn(reg), r0, i);
	    else {
		movi(rn(reg), i1);
		ANDS(rn(reg), r0, rn(reg));
	    }
	    jit_unget_reg(reg);
	}
	w = _jit->pc.w;
	d = ((i0 - w) >> 2) - 2;
	assert(_s24P(d));
	CC_B(cc, d & 0x00ffffff);
    }
    return (w);
}

static void
_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p())
	T2_LDRSBI(r0, r1, 0);
    else
	LDRSBI(r0, r1, 0);
}

static void
_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    if (jit_thumb_p())
	T2_LDRSBI(r0, rn(reg), 0);
    else
	LDRSBI(r0, rn(reg), 0);
    jit_unget_reg(reg);
}

static void
_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if ((r0|r1|r2) < 8)
	    T1_LDRSB(r0, r1, r2);
	else
	    T2_LDRSB(r0, r1, r2);
    }
    else
	LDRSB(r0, r1, r2);
}

static void
_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
	    T2_LDRSBI(r0, r1, i0);
	else if (i0 < 0 && i0 >= -255)
	    T2_LDRSBIN(r0, r1, -i0);
	else if (i0 >= 0 && i0 <= 4095)
	    T2_LDRSBWI(r0, r1, i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    if ((r0|r1) < 8)
		T1_LDRSB(r0, r1, r0);
	    else
		T2_LDRSB(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    if ((r0|r1|rn(reg)) < 8)
		T1_LDRSB(r0, r1, rn(reg));
	    else
		T2_LDRSB(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if (i0 >= 0 && i0 <= 255)
	    LDRSBI(r0, r1, i0);
	else if (i0 < 0 && i0 >= -255)
	    LDRSBIN(r0, r1, -i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    LDRSB(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    LDRSB(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_ldr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p())
	T2_LDRBI(r0, r1, 0);
    else
	LDRBI(r0, r1, 0);
}

static void
_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    if (jit_thumb_p())
	T2_LDRBI(r0, rn(reg), 0);
    else
	LDRBI(r0, rn(reg), 0);
    jit_unget_reg(reg);
}

static void
_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if ((r0|r1|r2) < 8)
	    T1_LDRB(r0, r1, r2);
	else
	    T2_LDRB(r0, r1, r2);
    }
    else
	LDRB(r0, r1, r2);
}

static void
_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8 && i0 >= 0 && i0 < 0x20)
	    T1_LDRBI(r0, r1, i0);
	else if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
	    T2_LDRBI(r0, r1, i0);
	else if (i0 < 0 && i0 >= -255)
	    T2_LDRBIN(r0, r1, -i0);
	else if (i0 >= 0 && i0 <= 4095)
	    T2_LDRBWI(r0, r1, i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    if ((r0|r1) < 8)
		T1_LDRB(r0, r1, r0);
	    else
		T2_LDRB(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    if ((r0|r1|rn(reg)) < 8)
		T1_LDRB(r0, r1, rn(reg));
	    else
		T2_LDRB(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if (i0 >= 0 && i0 <= 4095)
	    LDRBI(r0, r1, i0);
	else if (i0 < 0 && i0 >= -4095)
	    LDRBIN(r0, r1, -i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    LDRB(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    LDRB(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p())
	T2_LDRSHI(r0, r1, 0);
    else
	LDRSHI(r0, r1, 0);
}

static void
_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    if (jit_thumb_p())
	T2_LDRSHI(r0, rn(reg), 0);
    else
	LDRSHI(r0, rn(reg), 0);
    jit_unget_reg(reg);
}

static void
_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if ((r0|r1|r2) < 8)
	    T1_LDRSH(r0, r1, r2);
	else
	    T2_LDRSH(r0, r1, r2);
    }
    else
	LDRSH(r0, r1, r2);
}

static void
_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
	    T2_LDRSHI(r0, r1, i0);
	else if (i0 < 0 && i0 >= -255)
	    T2_LDRSHIN(r0, r1, -i0);
	else if (i0 >= 0 && i0 <= 4095)
	    T2_LDRSHWI(r0, r1, i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    if ((r0|r1) < 8)
		T1_LDRSH(r0, r1, r0);
	    else
		T2_LDRSH(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    if ((r0|r1|rn(reg)) < 8)
		T1_LDRSH(r0, r1, rn(reg));
	    else
		T2_LDRSH(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if (i0 >= 0 && i0 <= 255)
	    LDRSHI(r0, r1, i0);
	else if (i0 < 0 && i0 >= -255)
	    LDRSHIN(r0, r1, -i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    LDRSH(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    LDRSH(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_ldr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p())
	T2_LDRHI(r0, r1, 0);
    else
	LDRHI(r0, r1, 0);
}

static void
_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    if (jit_thumb_p())
	T2_LDRHI(r0, rn(reg), 0);
    else
	LDRHI(r0, rn(reg), 0);
    jit_unget_reg(reg);
}

static void
_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if ((r0|r1|r2) < 8)
	    T1_LDRH(r0, r1, r2);
	else
	    T2_LDRH(r0, r1, r2);
    }
    else
	LDRH(r0, r1, r2);
}

static void
_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 1) && (i0 >> 1) < 0x20)
	    T1_LDRHI(r0, r1, i0 >> 1);
	else if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
	    T2_LDRHI(r0, r1, i0);
	else if (i0 < 0 && i0 >= -255)
	    T2_LDRHIN(r0, r1, -i0);
	else if (i0 >= 0 && i0 <= 4095)
	    T2_LDRHWI(r0, r1, i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    if ((r0|r1) < 8)
		T1_LDRH(r0, r1, r0);
	    else
		T2_LDRH(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    if ((r0|r1|rn(reg)) < 8)
		T1_LDRH(r0, r1, rn(reg));
	    else
		T2_LDRH(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if (i0 >= 0 && i0 <= 255)
	    LDRHI(r0, r1, i0);
	else if (i0 < 0 && i0 >= -255)
	    LDRHIN(r0, r1, -i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    LDRH(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    LDRH(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_ldr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p())
	T2_LDRI(r0, r1, 0);
    else
	LDRI(r0, r1, 0);
}

static void
_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    if (jit_thumb_p())
	T2_LDRI(r0, rn(reg), 0);
    else
	LDRI(r0, rn(reg), 0);
    jit_unget_reg(reg);
}

static void
_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if ((r0|r1|r2) < 8)
	    T1_LDR(r0, r1, r2);
	else
	    T2_LDR(r0, r1, r2);
    }
    else
	LDR(r0, r1, r2);
}

static void
_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 3) && (i0 >> 2) < 0x20)
	    T1_LDRI(r0, r1, i0 >> 2);
	else if (r1 == _R13_REGNO && r0 < 8 &&
		 i0 >= 0 && !(i0 & 3) && (i0 >> 2) <= 255)
	    T1_LDRISP(r0, i0 >> 2);
	else if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
	    T2_LDRI(r0, r1, i0);
	else if (i0 < 0 && i0 > -255)
	    T2_LDRIN(r0, r1, -i0);
	else if (i0 >= 0 && i0 <= 4095)
	    T2_LDRWI(r0, r1, i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    if ((r0|r1) < 8)
		T1_LDR(r0, r1, r0);
	    else
		T2_LDR(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    if ((r0|r1|rn(reg)) < 8)
		T1_LDR(r0, r1, rn(reg));
	    else
		T2_LDR(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if (i0 >= 0 && i0 <= 4095)
	    LDRI(r0, r1, i0);
	else if (i0 < 0 && i0 >= -4095)
	    LDRIN(r0, r1, -i0);
	else if (r0 != r1) {
	    movi(r0, i0);
	    LDR(r0, r1, r0);
	}
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    LDR(r0, r1, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_str_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p())
	T2_STRBI(r1, r0, 0);
    else
	STRBI(r1, r0, 0);
}

static void
_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    if (jit_thumb_p())
	T2_STRBI(r0, rn(reg), 0);
    else
	STRBI(r0, rn(reg), 0);
    jit_unget_reg(reg);
}

static void
_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if ((r0|r1|r2) < 8)
	    T1_STRB(r2, r1, r0);
	else
	    T2_STRB(r2, r1, r0);
    }
    else
	STRB(r2, r1, r0);
}

static void
_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8 && i0 >= 0 && i0 < 0x20)
	    T1_STRBI(r1, r0, i0);
	else if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
	    T2_STRBI(r1, r0, i0);
	else if (i0 < 0 && i0 >= -255)
	    T2_STRBIN(r1, r0, -i0);
	else if (i0 >= 0 && i0 <= 4095)
	    T2_STRBWI(r1, r0, i0);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    if ((r0|r1|rn(reg)) < 8)
		T1_STRB(r1, r0, rn(reg));
	    else
		T2_STRB(r1, r0, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if (i0 >= 0 && i0 <= 4095)
	    STRBI(r1, r0, i0);
	else if (i0 < 0 && i0 >= -4095)
	    STRBIN(r1, r0, -i0);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    STRB(r1, r0, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_str_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p())
	T2_STRHI(r1, r0, 0);
    else
	STRHI(r1, r0, 0);
}

static void
_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    if (jit_thumb_p())
	T2_STRHI(r0, rn(reg), 0);
    else
	STRHI(r0, rn(reg), 0);
    jit_unget_reg(reg);
}

static void
_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if ((r0|r1|r2) < 8)
	    T1_STRH(r2, r1, r0);
	else
	    T2_STRH(r2, r1, r0);
    }
    else
	STRH(r2, r1, r0);
}

static void
_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 1) && (i0 >> 1) < 0x20)
	    T1_STRHI(r1, r0, i0 >> 1);
	else if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
	    T2_STRHI(r1, r0, i0);
	else if (i0 < 0 && i0 >= -255)
	    T2_STRHIN(r1, r0, -i0);
	else if (i0 >= 0 && i0 <= 4095)
	    T2_STRHWI(r1, r0, i0);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    if ((r0|r1|rn(reg)) < 8)
		T1_STRH(r1, r0, rn(reg));
	    else
		T2_STRH(r1, r0, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if (i0 >= 0 && i0 <= 255)
	    STRHI(r1, r0, i0);
	else if (i0 < 0 && i0 >= -255)
	    STRHIN(r1, r0, -i0);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    STRH(r1, r0, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_str_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p())
	T2_STRI(r1, r0, 0);
    else
	STRI(r1, r0, 0);
}

static void
_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
{
    jit_int32_t		reg;
    reg = jit_get_reg(jit_class_gpr);
    movi(rn(reg), i0);
    if (jit_thumb_p())
	T2_STRI(r0, rn(reg), 0);
    else
	STRI(r0, rn(reg), 0);
    jit_unget_reg(reg);
}

static void
_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
    if (jit_thumb_p()) {
	if ((r0|r1|r2) < 8)
	    T1_STR(r2, r1, r0);
	else
	    T2_STR(r2, r1, r0);
    }
    else
	STR(r2, r1, r0);
}

static void
_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 3) && (i0 >> 2) < 0x20)
	    T1_STRI(r1, r0, i0 >> 2);
	else if (r0 == _R13_REGNO && r1 < 8 &&
		 i0 >= 0 && !(i0 & 3) && (i0 >> 2) <= 255)
	    T1_STRISP(r1, i0 >> 2);
	else if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
	    T2_STRI(r1, r0, i0);
	else if (i0 < 0 && i0 >= -255)
	    T2_STRIN(r1, r0, -i0);
	else if (i0 >= 0 && i0 <= 4095)
	    T2_STRWI(r1, r0, i0);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    if ((r0|r1|rn(reg)) < 8)
		T1_STR(r1, r0, rn(reg));
	    else
		T2_STR(r1, r0, rn(reg));
	    jit_unget_reg(reg);
	}
    }
    else {
	if (i0 >= 0 && i0 <= 4095)
	    STRI(r1, r0, i0);
	else if (i0 < 0 && i0 >= -4095)
	    STRIN(r1, r0, -i0);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    movi(rn(reg), i0);
	    STR(r1, r0, rn(reg));
	    jit_unget_reg(reg);
	}
    }
}

static void
_bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_REV(r0, r1);
	else
	    T2_REV(r0, r1);
	rshi_u(r0, r0, 16);
    }
    else {
	if (jit_armv6_p()) {
	    REV(r0, r1);
	    rshi_u(r0, r0, 16);
	}
	else {
		generic_bswapr_us(_jit, r0, r1);
	}
    }
}

/* inline glibc htonl (without register clobber) */
static void
_bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    jit_int32_t		reg;
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_REV(r0, r1);
	else
	    T2_REV(r0, r1);
    }
    else {
	if (jit_armv6_p())
	    REV(r0, r1);
	else {
	    reg = jit_get_reg(jit_class_gpr);
	    EOR_SI(rn(reg), r1, r1, ARM_ROR, 16);
	    LSRI(rn(reg), rn(reg), 8);
	    BICI(rn(reg), rn(reg), encode_arm_immediate(0xff00));
	    EOR_SI(r0, rn(reg), r1, ARM_ROR, 8);
	    jit_unget_reg(reg);
	}
    }
}

static void
_extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_SXTB(r0, r1);
	else
	    T2_SXTB(r0, r1);
    }
    else {
	if (jit_armv6_p())
	    SXTB(r0, r1);
	else {
	    LSLI(r0, r1, 24);
	    ASRI(r0, r0, 24);
	}
    }
}

static void
_extr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_UXTB(r0, r1);
	else
	    T2_UXTB(r0, r1);
    }
    else {
	if (jit_armv6_p())
	    UXTB(r0, r1);
	else
	    ANDI(r0, r1, 0xff);
    }
}

static void
_extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_SXTH(r0, r1);
	else
	    T2_SXTH(r0, r1);
    }
    else {
	if (jit_armv6_p())
	    SXTH(r0, r1);
	else {
	    LSLI(r0, r1, 16);
	    ASRI(r0, r0, 16);
	}
    }
}

static void
_extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    if (jit_thumb_p()) {
	if ((r0|r1) < 8)
	    T1_UXTH(r0, r1);
	else
	    T2_UXTH(r0, r1);
    }
    else {
	if (jit_armv6_p())
	    UXTH(r0, r1);
	else {
	    LSLI(r0, r1, 16);
	    LSRI(r0, r0, 16);
	}
    }
}

static void
_callr(jit_state_t *_jit, jit_int32_t r0)
{
    if (jit_thumb_p())
	T1_BLX(r0);
    else
	BLX(r0);
}

static void
_calli(jit_state_t *_jit, jit_word_t i0, jit_bool_t exchange_p)
{
    jit_word_t		d;
    jit_int32_t		reg;
    if (!exchange_p) {
	if (jit_thumb_p()) {
	    if (jit_exchange_p())
		/* skip switch from  arm to thumb 
		 * exchange_p set to zero means a jit function
		 * call in the same jit code buffer */
		d = ((i0 + 8 - _jit->pc.w) >> 1) - 2;
	    else
		d = ((i0 - _jit->pc.w) >> 1) - 2;
	}
	else			d = ((i0 - _jit->pc.w) >> 2) - 2;
	if (_s24P(d)) {
	    if (jit_thumb_p())	T2_BLI(encode_thumb_jump(d));
	    else		BLI(d & 0x00ffffff);
	}
	else			goto fallback;
    }
    else {
    fallback:
	reg = jit_get_reg(jit_class_gpr);
	movi(rn(reg), i0);
	if (jit_thumb_p())
	    T1_BLX(rn(reg));
	else
	    BLX(rn(reg));
	jit_unget_reg(reg);
    }
}

static jit_word_t
_calli_p(jit_state_t *_jit, jit_word_t i0, jit_bool_t i1)
{
    jit_word_t		w;
    jit_word_t		d;
    jit_int32_t		reg;
    /* i1 means call is reachable in signed 24 bits  */
    if (i1) {
	w = _jit->pc.w;
	if (jit_thumb_p())	d = ((i0 - _jit->pc.w) >> 1) - 2;
	else			d = ((i0 - _jit->pc.w) >> 2) - 2;
	assert(_s24P(d));
	if (jit_thumb_p())	T2_BLI(encode_thumb_jump(d));
	else			BLI(d & 0x00ffffff);
    }
    else {
	reg = jit_get_reg(jit_class_gpr);
	w = _jit->pc.w;
	movi_p(rn(reg), i0);
	if (jit_thumb_p())
	    T1_BLX(rn(reg));
	else
	    BLX(rn(reg));
	jit_unget_reg(reg);
    }
    return (w);
}

static void
_prolog(jit_state_t *_jit, jit_node_t *node)
{
    jit_int32_t		reg, mask, count;
    if (_jitc->function->define_frame || _jitc->function->assume_frame) {
	jit_int32_t	frame = -_jitc->function->frame;
	jit_check_frame();
	assert(_jitc->function->self.aoff >= frame);
	if (jit_swf_p())
	    CHECK_SWF_OFFSET();
	CHECK_REG_ARGS();
	if (_jitc->function->assume_frame) {
	    if (jit_thumb_p() && !_jitc->thumb)
		_jitc->thumb = _jit->pc.w;
	    return;
	}
	_jitc->function->self.aoff = frame;
    }
    if (_jitc->function->allocar)
	_jitc->function->self.aoff &= -8;
    _jitc->function->stack = ((_jitc->function->self.alen -
			      /* align stack at 8 bytes */
			      _jitc->function->self.aoff) + 7) & -8;
    /* If this jit_check_frame() succeeds, it actually is just a need_stack,
     * usually for arguments, so, allocai was not called, but pusharg*
     * was called increasing stack size, for negative access offsets.
     * This can be optimized for one less prolog instruction, that is,
     * do not create the frame pointer, and only add _jitc->function->stack
     * to sp, and on epilog, instead of moving fp to sp, just add negative
     * value of _jitc->function->stack. Since this condition requires a
     * large function body for excess arguments to called function, keep
     * things a bit simpler for now, as this is the only place need_stack
     * would be useful. */
    if (_jitc->function->stack)
	jit_check_frame();

    for (reg = mask = count = 0; reg < jit_size(iregs); reg++) {
	if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
	    mask |= 1 << rn(iregs[reg]);
	    ++count;
	}
    }
    /* One extra register to keep stack 8 bytes aligned */
    if (count & 1) {
	for (reg = 4; reg < 10; reg++) {
	    if (!(mask & (1 << reg))) {
		mask |= 1 << reg;
		break;
	    }
	}
    }
    if (_jitc->function->need_frame || _jitc->function->need_return)
	mask |= (1 << _FP_REGNO) | (1 << _LR_REGNO);
    if (!jit_swf_p() && _jitc->function->save_reg_args &&
	!(_jitc->function->self.call & jit_call_varargs))
	mask |= 0xf;

    if (jit_thumb_p()) {
	/*  switch to thumb mode (better approach would be to
	 * ORR 1 address being called, but no clear distinction
	 * of what is a pointer to a jit function, or if patching
	 * a pointer to a jit function) */
	if (jit_exchange_p()) {
	    ADDI(_R12_REGNO, _R15_REGNO, 1);
	    BX(_R12_REGNO);
	}
	if (!_jitc->thumb)
	    _jitc->thumb = _jit->pc.w;
	if (jit_swf_p() || (_jitc->function->save_reg_args &&
			    (_jitc->function->self.call & jit_call_varargs)))
	    T2_PUSH(0xf);
	if (mask)
	    T2_PUSH(mask);
    }
    else {
	if (jit_swf_p() || (_jitc->function->save_reg_args &&
			    (_jitc->function->self.call & jit_call_varargs)))
	    PUSH(0xf);
	if (mask)
	    PUSH(mask);
    }
    if (_jitc->function->need_frame)
	movr(_FP_REGNO, _SP_REGNO);
    if (_jitc->function->stack)
	subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
    if (_jitc->function->allocar) {
	reg = jit_get_reg(jit_class_gpr);
	movi(rn(reg), _jitc->function->self.aoff);
	stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
	jit_unget_reg(reg);
    }
}

static void
_epilog(jit_state_t *_jit, jit_node_t *node)
{
    jit_int32_t		reg, mask, count;
    if (_jitc->function->assume_frame)
	return;

    for (reg = mask = count = 0; reg < jit_size(iregs); reg++) {
	if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
	    mask |= 1 << rn(iregs[reg]);
	    ++count;
	}
    }
    /* One extra register to keep stack 8 bytes aligned */
    if (count & 1) {
	for (reg = 4; reg < 10; reg++) {
	    if (!(mask & (1 << reg))) {
		mask |= 1 << reg;
		break;
	    }
	}
    }
    if (_jitc->function->need_frame || _jitc->function->need_return)
	mask |= (1 << _FP_REGNO) | (1 << _LR_REGNO);
    if (_jitc->function->need_frame)
	movr(_SP_REGNO, _FP_REGNO);
    if (!jit_swf_p() && _jitc->function->save_reg_args &&
	!(_jitc->function->self.call & jit_call_varargs))
	addi(_SP_REGNO, _SP_REGNO, 16);
    if (mask) {
	if (jit_thumb_p())
	    T2_POP(mask);
	else
	    POP(mask);
    }
    if (jit_swf_p() || (_jitc->function->save_reg_args &&
			(_jitc->function->self.call & jit_call_varargs)))
	addi(_SP_REGNO, _SP_REGNO, 16);
    if (jit_thumb_p())
	T1_BX(_LR_REGNO);
    else
	BX(_LR_REGNO);
    if (jit_thumb_p() && (_jit->pc.w & 2))
	T1_NOP();
}

static void
_vastart(jit_state_t *_jit, jit_int32_t r0)
{
    assert(_jitc->function->self.call & jit_call_varargs);

    /* Initialize stack pointer to the first stack argument.
     * The -16 is to account for the 4 argument registers
     * always saved, and _jitc->function->vagp is to account
     * for declared arguments. */
    addi(r0, _FP_REGNO, jit_selfsize() - 16 + _jitc->function->vagp);
}

static void
_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
    assert(_jitc->function->self.call & jit_call_varargs);

    /* Load argument. */
    ldr(r0, r1);

    /* Update stack pointer. */
    addi(r1, r1, sizeof(jit_word_t));
}

static void
_patch_at(jit_state_t *_jit,
	  jit_int32_t kind, jit_word_t instr, jit_word_t label)
{
    jit_word_t		 d;
    jit_thumb_t		 thumb;
    union {
	jit_int16_t	*s;
	jit_int32_t	*i;
	jit_word_t	 w;
    } u;
    u.w = instr;
    if (kind == arm_patch_call) {
	if (jit_thumb_p() && (jit_uword_t)instr >= _jitc->thumb) {
	    code2thumb(thumb.s[0], thumb.s[1], u.s[0], u.s[1]);
	    assert((thumb.i & THUMB2_BLI) == THUMB2_BLI);
	    /* skip code to switch from arm to thumb mode */
	    if (jit_exchange_p())
		d = ((label + 8 - instr) >> 1) - 2;
	    else
		d = ((label - instr) >> 1) - 2;
	    assert(_s24P(d));
	    thumb.i = THUMB2_BLI | encode_thumb_jump(d);
	    thumb2code(thumb.s[0], thumb.s[1], u.s[0], u.s[1]);
	}
	else {
	    thumb.i = u.i[0];
	    assert((thumb.i & 0x0f000000) == ARM_BLI);
	    d = ((label - instr) >> 2) - 2;
	    assert(_s24P(d));
	    u.i[0] = (thumb.i & 0xff000000) | (d & 0x00ffffff);
	}
    }
    else if (kind == arm_patch_jump) {
	if (jit_thumb_p() && (jit_uword_t)instr >= _jitc->thumb) {
	    code2thumb(thumb.s[0], thumb.s[1], u.s[0], u.s[1]);
	    if ((thumb.i & THUMB2_B) == THUMB2_B) {
		d = ((label - instr) >> 1) - 2;
		assert(_s24P(d));
		thumb.i = THUMB2_B | encode_thumb_jump(d);
		thumb2code(thumb.s[0], thumb.s[1], u.s[0], u.s[1]);
	    }
	    else if ((thumb.i & THUMB2_B) == THUMB2_CC_B) {
		d = ((label - instr) >> 1) - 2;
		assert(_s20P(d));
		thumb.i = THUMB2_CC_B | (thumb.i & 0x3c00000) |
			  encode_thumb_cc_jump(d);
		thumb2code(thumb.s[0], thumb.s[1], u.s[0], u.s[1]);
	    }
	    else {
		/* for the sake of simplicity in case choose to
		 * movw+movt+[bx|blx], e.g. if changing to instead
		 * of asserting target is reachable, load constant
		 * and do indirect jump if not reachable */
		if ((thumb.i & 0xfbf00000) == THUMB2_MOVWI)
		    goto indirect_jump;
		assert(!"handled branch opcode");
	    }
	}
	else {
	    thumb.i = u.i[0];
	    /* 0x0e000000 because 0x01000000 is (branch&) link modifier */
	    assert((thumb.i & 0x0e000000) == ARM_B);
	    d = ((label - instr) >> 2) - 2;
	    assert(_s24P(d));
	    u.i[0] = (thumb.i & 0xff000000) | (d & 0x00ffffff);
	}
    }
    else if (kind == arm_patch_load) {
	/* offset may be negative for a forward patch because it
	 * is relative to pc + 8, for example:
	 *	    ldr r0, [pc, #-4]
	 *	    bx r0		;; [pc, #-8]
	 *	    .data ...		;; [pc, #-4]
	 *	    ... 		;; [pc]
	 */
	assert(!jit_thumb_p());
	thumb.i = u.i[0];
	assert((thumb.i & 0x0f700000) == ARM_LDRI);
	d = label - (instr + 8);
	if (d < 0) {
	    thumb.i &= ~ARM_P;
	    d = -d;
	}
	else
	    thumb.i |= ARM_P;
	assert(!(d & 0xfffff000));
	u.i[0] = (thumb.i & 0xfffff000) | d;
    }
    else if (kind == arm_patch_word) {
	if (jit_thumb_p()) {
	    code2thumb(thumb.s[0], thumb.s[1], u.s[0], u.s[1]);
	    assert((thumb.i & 0xfbf00000) == THUMB2_MOVWI);
	indirect_jump:
	    thumb.i = ((thumb.i & 0xfbf00f00) |
		       ( (label & 0x0000f000) <<  4) |
		       ( (label & 0x00000800) << 15) |
		       ( (label & 0x00000700) <<  4) |
		       (  label & 0x000000ff));
	    thumb2code(thumb.s[0], thumb.s[1], u.s[0], u.s[1]);
	    label >>= 16;
	    code2thumb(thumb.s[0], thumb.s[1], u.s[2], u.s[3]);
	    assert((thumb.i & 0xfbf00000) == THUMB2_MOVTI);
	    thumb.i = ((thumb.i & 0xfbf00f00) |
		       ( (label & 0x0000f000) <<  4) |
		       ( (label & 0x00000800) << 15) |
		       ( (label & 0x00000700) <<  4) |
		       (  label & 0x000000ff));
	    thumb2code(thumb.s[0], thumb.s[1], u.s[2], u.s[3]);
	}
	else
	    u.i[0] = label;
    }
    else
	assert(!"handled patch");
}
#endif
