core/sourcehook/sourcehook_hookmangen_x86.h
author Nicholas Hastings <skamonkey@gmail.com>
Wed May 21 17:26:09 2014 -0400 (2014-05-21)
changeset 917 95639ee45d3d
parent 733 2365240861a2
permissions -rw-r--r--
Trigger build for hl2sdk-l4d changes.
     1 /* ======== SourceHook ========
     2 * vim: set ts=4 :
     3 * Copyright (C) 2004-2010 AlliedModders LLC.  All rights reserved.
     4 * No warranties of any kind
     5 *
     6 * License: zlib/libpng
     7 *
     8 * from the SourcePawn JIT SDK
     9 * ============================
    10 */
    11 
    12 #ifndef __SOURCEHOOK_HOOKMANGEN_X86_H__
    13 #define __SOURCEHOOK_HOOKMANGEN_X86_H__
    14 
    15 #include <limits.h>
    16 
    17 #undef REG_EAX
    18 #undef REG_ECX
    19 #undef REG_EDX
    20 #undef REG_EBX
    21 #undef REG_ESP
    22 #undef REG_SIB
    23 #undef REG_EBP
    24 #undef REG_ESI
    25 #undef REG_EDI
    26 
    27 //MOD R/M
    28 #define MOD_MEM_REG	0
    29 #define MOD_DISP8	1
    30 #define MOD_DISP32	2
    31 #define MOD_REG		3
    32 
    33 //SIB
    34 #define NOSCALE		0
    35 #define	SCALE2		1
    36 #define	SCALE4		2
    37 #define SCALE8		3
    38 
    39 //Register codes
    40 #define REG_EAX			0
    41 #define REG_ECX			1
    42 #define REG_EDX			2
    43 #define REG_EBX			3
    44 #define	REG_ESP			4
    45 #define	REG_SIB			4
    46 #define REG_NOIDX		4
    47 #define REG_IMM_BASE	5
    48 #define REG_EBP			5
    49 #define REG_ESI			6
    50 #define REG_EDI			7
    51 
    52 #define IA32_16BIT_PREFIX	0x66
    53 
    54 //condition codes (for example, Jcc opcodes)
    55 #define CC_B	0x2
    56 #define CC_NAE	CC_B
    57 #define CC_NB	0x3
    58 #define CC_AE	CC_NB
    59 #define CC_E	0x4
    60 #define CC_Z	CC_E
    61 #define CC_NE	0x5
    62 #define CC_NZ	CC_NE
    63 #define CC_NA	0x6
    64 #define CC_BE	CC_NA
    65 #define CC_A	0x7
    66 #define CC_NBE	CC_A
    67 #define CC_L	0xC
    68 #define CC_NGE	CC_L
    69 #define CC_NL	0xD
    70 #define CC_GE	CC_NL
    71 #define CC_NG	0xE
    72 #define CC_LE	CC_NG
    73 #define CC_G	0xF
    74 #define CC_NLE	CC_G
    75 
    76 //Opcodes with encoding information
    77 #define IA32_XOR_RM_REG			0x31	// encoding is /r
    78 #define IA32_XOR_REG_RM			0x33	// encoding is /r
    79 #define IA32_XOR_EAX_IMM32		0x35	// encoding is /r
    80 #define IA32_XOR_RM_IMM32		0x81	// encoding is /6
    81 #define IA32_XOR_RM_IMM8		0x83	// encoding is /6
    82 #define IA32_ADD_RM_REG			0x01	// encoding is /r
    83 #define IA32_ADD_REG_RM			0x03	// encoding is /r
    84 #define IA32_ADD_RM_IMM32		0x81	// encoding is /0
    85 #define IA32_ADD_RM_IMM8		0x83	// encoding is /0
    86 #define IA32_ADD_EAX_IMM32		0x05	// no extra encoding
    87 #define IA32_SUB_RM_REG			0x29	// encoding is /r
    88 #define IA32_SUB_REG_RM			0x2B	// encoding is /r
    89 #define IA32_SUB_RM_IMM8		0x83	// encoding is /5 <imm8>
    90 #define IA32_SUB_RM_IMM32		0x81	// encoding is /5 <imm32>
    91 #define IA32_SBB_REG_RM			0x1B	// encoding is /r
    92 #define IA32_SBB_RM_IMM8		0x83	// encoding is <imm32>
    93 #define IA32_JMP_IMM32			0xE9	// encoding is imm32
    94 #define IA32_JMP_IMM8			0xEB	// encoding is imm8
    95 #define IA32_JMP_RM				0xFF	// encoding is /4
    96 #define IA32_CALL_IMM32			0xE8	// relative call, <imm32>
    97 #define IA32_CALL_RM			0xFF	// encoding is /2
    98 #define IA32_MOV_REG_IMM		0xB8	// encoding is +r <imm32>
    99 #define	IA32_MOV_RM8_REG		0x88	// encoding is /r
   100 #define	IA32_MOV_RM_REG			0x89	// encoding is /r
   101 #define	IA32_MOV_REG_RM			0x8B	// encoding is /r
   102 #define IA32_MOV_REG8_RM8		0x8A	// encoding is /r
   103 #define IA32_MOV_RM8_REG8		0x88	// encoding is /r
   104 #define IA32_MOV_RM_IMM32		0xC7	// encoding is /0
   105 #define IA32_CMP_RM_IMM32		0x81	// encoding is /7 <imm32>
   106 #define IA32_CMP_RM_IMM8		0x83	// encoding is /7 <imm8>
   107 #define IA32_CMP_AL_IMM32		0x3C	// no extra encoding
   108 #define IA32_CMP_EAX_IMM32		0x3D	// no extra encoding
   109 #define IA32_CMP_RM_REG			0x39	// encoding is /r
   110 #define IA32_CMP_REG_RM			0x3B	// encoding is /r
   111 #define IA32_CMPSB				0xA6	// no extra encoding
   112 #define IA32_TEST_RM_REG8		0x84	// encoding is /r
   113 #define IA32_TEST_RM_REG		0x85	// encoding is /r
   114 #define IA32_TEST_RM_IMM32		0xF7	// encoding is /0 <imm32>
   115 #define IA32_JCC_IMM			0x70	// encoding is +cc <imm8>
   116 #define IA32_JCC_IMM32_1		0x0F	// opcode part 1
   117 #define IA32_JCC_IMM32_2		0x80	// encoding is +cc <imm32>
   118 #define IA32_RET				0xC3	// no extra encoding
   119 #define IA32_RETN				0xC2	// encoding is <imm16> 
   120 #define IA32_NEG_RM				0xF7	// encoding is /3
   121 #define IA32_INC_REG			0x40	// encoding is +r
   122 #define IA32_INC_RM				0xFF	// encoding is /0
   123 #define IA32_DEC_REG			0x48	// encoding is +r
   124 #define IA32_DEC_RM				0xFF	// encoding is /1
   125 #define IA32_OR_REG_RM			0x0B	// encoding is /r
   126 #define IA32_AND_REG_RM			0x23	// encoding is /r
   127 #define IA32_AND_EAX_IMM32		0x25	// encoding is <imm32>
   128 #define IA32_AND_RM_IMM32		0x81	// encoding is /4
   129 #define IA32_AND_RM_IMM8		0x83	// encoding is /4
   130 #define IA32_NOT_RM				0xF7	// encoding is /2
   131 #define IA32_DIV_RM				0xF7	// encoding is /6
   132 #define IA32_MUL_RM				0xF7	// encoding is /4
   133 #define IA32_IDIV_RM			0xF7	// encoding is /7
   134 #define IA32_IMUL_RM			0xF7	// encoding is /5
   135 #define IA32_IMUL_REG_IMM32		0x69	// encoding is /r
   136 #define IA32_IMUL_REG_IMM8		0x6B	// encoding is /r
   137 #define IA32_IMUL_REG_RM_1		0x0F	// encoding is _2
   138 #define IA32_IMUL_REG_RM_2		0xAF	// encoding is /r
   139 #define IA32_SHR_RM_IMM8		0xC1	// encoding is /5 <ib>
   140 #define IA32_SHR_RM_1			0xD1	// encoding is /5
   141 #define IA32_SHL_RM_IMM8		0xC1	// encoding is /4 <ib>
   142 #define IA32_SHL_RM_1			0xD1	// encoding is /4
   143 #define IA32_SAR_RM_CL			0xD3	// encoding is /7
   144 #define IA32_SAR_RM_1			0xD1	// encoding is /7
   145 #define IA32_SHR_RM_CL			0xD3	// encoding is /5
   146 #define IA32_SHL_RM_CL			0xD3	// encoding is /4
   147 #define IA32_SAR_RM_IMM8		0xC1	// encoding is /7 <ib>
   148 #define IA32_SETCC_RM8_1		0x0F	// opcode part 1
   149 #define IA32_SETCC_RM8_2		0x90	// encoding is +cc /0 (8bits)
   150 #define IA32_CMOVCC_RM_1		0x0F	// opcode part 1
   151 #define IA32_CMOVCC_RM_2		0x40	// encoding is +cc /r
   152 #define IA32_XCHG_EAX_REG		0x90	// encoding is +r
   153 #define IA32_LEA_REG_MEM		0x8D	// encoding is /r
   154 #define IA32_POP_REG			0x58	// encoding is +r
   155 #define IA32_PUSH_REG			0x50	// encoding is +r
   156 #define IA32_PUSH_RM			0xFF	// encoding is /6
   157 #define IA32_PUSH_IMM32			0x68	// encoding is <imm32>
   158 #define IA32_PUSH_IMM8			0x6A	// encoding is <imm8>
   159 #define IA32_REP				0xF3	// no extra encoding
   160 #define IA32_MOVSD				0xA5	// no extra encoding
   161 #define IA32_MOVSB				0xA4	// no extra encoding
   162 #define IA32_STOSD				0xAB	// no extra encoding
   163 #define IA32_CLD				0xFC	// no extra encoding
   164 #define IA32_PUSHAD				0x60	// no extra encoding
   165 #define IA32_POPAD				0x61	// no extra encoding
   166 #define IA32_NOP				0x90	// no extra encoding
   167 #define IA32_INT3				0xCC	// no extra encoding
   168 #define IA32_FSTP_MEM32			0xD9	// encoding is /3
   169 #define IA32_FSTP_MEM64			0xDD	// encoding is /3
   170 #define IA32_FLD_MEM32			0xD9	// encoding is /0
   171 #define IA32_FLD_MEM64			0xDD	// encoding is /0
   172 #define IA32_FILD_MEM32			0xDB	// encoding is /0
   173 #define IA32_FADD_MEM32			0xD8	// encoding is /0
   174 #define IA32_FADD_FPREG_ST0_1	0xDC	// opcode part 1
   175 #define IA32_FADD_FPREG_ST0_2	0xC0	// encoding is +r
   176 #define IA32_FSUB_MEM32			0xD8	// encoding is /4
   177 #define IA32_FMUL_MEM32			0xD8	// encoding is /1
   178 #define IA32_FDIV_MEM32			0xD8	// encoding is /6
   179 #define IA32_FSTCW_MEM16_1		0x9B	// opcode part 1
   180 #define IA32_FSTCW_MEM16_2		0xD9	// encoding is /7
   181 #define IA32_FLDCW_MEM16		0xD9	// encoding is /5
   182 #define IA32_FISTP_MEM32		0xDB	// encoding is /3
   183 #define IA32_FUCOMIP_1			0xDF	// opcode part 1
   184 #define IA32_FUCOMIP_2			0xE8	// encoding is +r
   185 #define IA32_FSTP_FPREG_1		0xDD	// opcode part 1
   186 #define IA32_FSTP_FPREG_2		0xD8	// encoding is +r
   187 #define IA32_MOVZX_R32_RM8_1	0x0F	// opcode part 1
   188 #define IA32_MOVZX_R32_RM8_2	0xB6	// encoding is /r
   189 #define IA32_MOVZX_R32_RM16_1	0x0F	// opcode part 1
   190 #define IA32_MOVZX_R32_RM16_2	0xB7	// encoding is /r
   191 
   192 
   193 namespace SourceHook
   194 {
   195 	namespace Impl
   196 	{
   197 		typedef GenBuffer JitWriter;
   198 
   199 		inline jit_uint8_t ia32_modrm(jit_uint8_t mode, jit_uint8_t reg, jit_uint8_t rm)
   200 		{
   201 			jit_uint8_t modrm = (mode << 6);
   202 
   203 			modrm |= (reg << 3);
   204 			modrm |= (rm);
   205 
   206 			return modrm;
   207 		}
   208 
   209 		//mode is the scaling method - NOSCALE ... SCALE8
   210 		//index is the register that is scaled
   211 		//base is the base register
   212 		inline jit_uint8_t ia32_sib(jit_uint8_t mode, jit_uint8_t index, jit_uint8_t base)
   213 		{
   214 			jit_uint8_t sib = (mode << 6);
   215 
   216 			sib |= (index << 3);
   217 			sib |= (base);
   218 
   219 			return sib;
   220 		}
   221 
   222 		inline void IA32_Int3(JitWriter *jit)
   223 		{
   224 			jit->write_ubyte(IA32_INT3);
   225 		}
   226 
   227 		/***********************
   228 		* INCREMENT/DECREMENT *
   229 		***********************/
   230 
   231 		inline void IA32_Inc_Reg(JitWriter *jit, jit_uint8_t reg)
   232 		{
   233 			jit->write_ubyte(IA32_INC_REG+reg);
   234 		}
   235 
   236 		inline void IA32_Inc_Rm_Disp8(JitWriter *jit, jit_uint8_t reg, jit_int8_t disp)
   237 		{
   238 			jit->write_ubyte(IA32_INC_RM);
   239 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, reg));
   240 			jit->write_byte(disp);
   241 		}
   242 
   243 		inline void IA32_Inc_Rm_Disp32(JitWriter *jit, jit_uint8_t reg, jit_int32_t disp)
   244 		{
   245 			jit->write_ubyte(IA32_INC_RM);
   246 			jit->write_ubyte(ia32_modrm(MOD_DISP32, 0, reg));
   247 			jit->write_int32(disp);
   248 		}
   249 
   250 		inline void IA32_Inc_Rm_Disp_Reg(JitWriter *jit, jit_uint8_t base, jit_uint8_t reg, jit_uint8_t scale)
   251 		{
   252 			jit->write_ubyte(IA32_INC_RM);
   253 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 0, REG_SIB));
   254 			jit->write_ubyte(ia32_sib(scale, reg, base));
   255 		}
   256 
   257 		inline void IA32_Dec_Reg(JitWriter *jit, jit_uint8_t reg)
   258 		{
   259 			jit->write_ubyte(IA32_DEC_REG+reg);
   260 		}
   261 
   262 		inline void IA32_Dec_Rm_Disp8(JitWriter *jit, jit_uint8_t reg, jit_int8_t disp)
   263 		{
   264 			jit->write_ubyte(IA32_DEC_RM);
   265 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 1, reg));
   266 			jit->write_byte(disp);
   267 		}
   268 
   269 		inline void IA32_Dec_Rm_Disp32(JitWriter *jit, jit_uint8_t reg, jit_int32_t disp)
   270 		{
   271 			jit->write_ubyte(IA32_DEC_RM);
   272 			jit->write_ubyte(ia32_modrm(MOD_DISP32, 1, reg));
   273 			jit->write_int32(disp);
   274 		}
   275 
   276 		inline void IA32_Dec_Rm_Disp_Reg(JitWriter *jit, jit_uint8_t base, jit_uint8_t reg, jit_uint8_t scale)
   277 		{
   278 			jit->write_ubyte(IA32_DEC_RM);
   279 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 1, REG_SIB));
   280 			jit->write_ubyte(ia32_sib(scale, reg, base));
   281 		}
   282 
   283 		/****************
   284 		* BINARY LOGIC *
   285 		****************/
   286 
   287 		inline void IA32_Xor_Rm_Reg(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t dest_mode)
   288 		{
   289 			jit->write_ubyte(IA32_XOR_RM_REG);
   290 			jit->write_ubyte(ia32_modrm(dest_mode, src, dest));
   291 		}
   292 
   293 		inline void IA32_Xor_Reg_Rm(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t dest_mode)
   294 		{
   295 			jit->write_ubyte(IA32_XOR_REG_RM);
   296 			jit->write_ubyte(ia32_modrm(dest_mode, dest, src));
   297 		}
   298 
   299 		inline void IA32_Xor_Rm_Imm8(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode, jit_int8_t value)
   300 		{
   301 			jit->write_ubyte(IA32_XOR_RM_IMM8);
   302 			jit->write_ubyte(ia32_modrm(mode, 6, reg));
   303 			jit->write_byte(value);
   304 		}
   305 
   306 		inline void IA32_Xor_Rm_Imm32(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode, jit_int32_t value)
   307 		{
   308 			jit->write_ubyte(IA32_XOR_RM_IMM32);
   309 			jit->write_ubyte(ia32_modrm(mode, 6, reg));
   310 			jit->write_int32(value);
   311 		}
   312 
   313 		inline void IA32_Xor_Eax_Imm32(JitWriter *jit, jit_int32_t value)
   314 		{
   315 			jit->write_ubyte(IA32_XOR_EAX_IMM32);
   316 			jit->write_int32(value);
   317 		}
   318 
   319 		inline void IA32_Neg_Rm(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
   320 		{
   321 			jit->write_ubyte(IA32_NEG_RM);
   322 			jit->write_ubyte(ia32_modrm(mode, 3, reg));
   323 		}
   324 
   325 		inline void IA32_Or_Reg_Rm(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   326 		{
   327 			jit->write_ubyte(IA32_OR_REG_RM);
   328 			jit->write_ubyte(ia32_modrm(mode, dest, src));
   329 		}
   330 
   331 		inline void IA32_And_Reg_Rm(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   332 		{
   333 			jit->write_ubyte(IA32_AND_REG_RM);
   334 			jit->write_ubyte(ia32_modrm(mode, dest, src));
   335 		}
   336 
   337 		inline void IA32_And_Rm_Imm32(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode, jit_int32_t value)
   338 		{
   339 			jit->write_ubyte(IA32_AND_RM_IMM32);
   340 			jit->write_ubyte(ia32_modrm(mode, 4, reg));
   341 			jit->write_int32(value);
   342 		}
   343 
   344 		inline void IA32_And_Rm_Imm8(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode, jit_int8_t value)
   345 		{
   346 			jit->write_ubyte(IA32_AND_RM_IMM8);
   347 			jit->write_ubyte(ia32_modrm(mode, 4, reg));
   348 			jit->write_byte(value);
   349 		}
   350 
   351 		inline void IA32_And_Eax_Imm32(JitWriter *jit, jit_int32_t value)
   352 		{
   353 			jit->write_ubyte(IA32_AND_EAX_IMM32);
   354 			jit->write_int32(value);
   355 		}
   356 
   357 		inline void IA32_Not_Rm(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
   358 		{
   359 			jit->write_ubyte(IA32_NOT_RM);
   360 			jit->write_ubyte(ia32_modrm(mode, 2, reg));
   361 		}
   362 
   363 		inline void IA32_Shr_Rm_Imm8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t value, jit_uint8_t mode)
   364 		{
   365 			jit->write_ubyte(IA32_SHR_RM_IMM8);
   366 			jit->write_ubyte(ia32_modrm(mode, 5, dest));
   367 			jit->write_ubyte(value);
   368 		}
   369 
   370 		inline void IA32_Shr_Rm_1(JitWriter *jit, jit_uint8_t dest, jit_uint8_t mode)
   371 		{
   372 			jit->write_ubyte(IA32_SHR_RM_1);
   373 			jit->write_ubyte(ia32_modrm(mode, 5, dest));
   374 		}
   375 
   376 		inline void IA32_Shl_Rm_Imm8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t value, jit_uint8_t mode)
   377 		{
   378 			jit->write_ubyte(IA32_SHL_RM_IMM8);
   379 			jit->write_ubyte(ia32_modrm(mode, 4, dest));
   380 			jit->write_ubyte(value);
   381 		}
   382 
   383 		inline void IA32_Shl_Rm_1(JitWriter *jit, jit_uint8_t dest, jit_uint8_t mode)
   384 		{
   385 			jit->write_ubyte(IA32_SHL_RM_1);
   386 			jit->write_ubyte(ia32_modrm(mode, 4, dest));
   387 		}
   388 
   389 		inline void IA32_Sar_Rm_Imm8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t value, jit_uint8_t mode)
   390 		{
   391 			jit->write_ubyte(IA32_SAR_RM_IMM8);
   392 			jit->write_ubyte(ia32_modrm(mode, 7, dest));
   393 			jit->write_ubyte(value);
   394 		}
   395 
   396 		inline void IA32_Sar_Rm_CL(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
   397 		{
   398 			jit->write_ubyte(IA32_SAR_RM_CL);
   399 			jit->write_ubyte(ia32_modrm(mode, 7, reg));
   400 		}
   401 
   402 		inline void IA32_Sar_Rm_1(JitWriter *jit, jit_uint8_t dest, jit_uint8_t mode)
   403 		{
   404 			jit->write_ubyte(IA32_SAR_RM_1);
   405 			jit->write_ubyte(ia32_modrm(mode, 7, dest));
   406 		}
   407 
   408 		inline void IA32_Shr_Rm_CL(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
   409 		{
   410 			jit->write_ubyte(IA32_SHR_RM_CL);
   411 			jit->write_ubyte(ia32_modrm(mode, 5, reg));
   412 		}
   413 
   414 		inline void IA32_Shl_Rm_CL(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
   415 		{
   416 			jit->write_ubyte(IA32_SHL_RM_CL);
   417 			jit->write_ubyte(ia32_modrm(mode, 4, reg));
   418 		}
   419 
   420 		inline void IA32_Xchg_Eax_Reg(JitWriter *jit, jit_uint8_t reg)
   421 		{
   422 			jit->write_ubyte(IA32_XCHG_EAX_REG+reg);
   423 		}
   424 
   425 		/**********************
   426 		* ARITHMETIC (BASIC) *
   427 		**********************/
   428 
   429 		inline void IA32_Add_Rm_Reg(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   430 		{
   431 			jit->write_ubyte(IA32_ADD_RM_REG);
   432 			jit->write_ubyte(ia32_modrm(mode, src, dest));
   433 		}
   434 
   435 		inline void IA32_Add_Reg_Rm(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   436 		{
   437 			jit->write_ubyte(IA32_ADD_REG_RM);
   438 			jit->write_ubyte(ia32_modrm(mode, dest, src));
   439 		}
   440 
   441 		inline void IA32_Add_Rm_Imm8(JitWriter *jit, jit_uint8_t reg, jit_int8_t value, jit_uint8_t mode)
   442 		{
   443 			jit->write_ubyte(IA32_ADD_RM_IMM8);
   444 			jit->write_ubyte(ia32_modrm(mode, 0, reg));
   445 			jit->write_byte(value);
   446 		}
   447 
   448 		inline void IA32_Add_Rm_Imm32(JitWriter *jit, jit_uint8_t reg, jit_int32_t value, jit_uint8_t mode)
   449 		{
   450 			jit->write_ubyte(IA32_ADD_RM_IMM32);
   451 			jit->write_ubyte(ia32_modrm(mode, 0, reg));
   452 			jit->write_int32(value);
   453 		}
   454 
   455 		inline void IA32_Add_Rm_ImmAuto(JitWriter *jit, jit_uint8_t reg, jit_int32_t value, jit_uint8_t mode)
   456 		{
   457 			if (value >= SCHAR_MIN && value <= SCHAR_MAX)
   458 				IA32_Add_Rm_Imm8(jit, reg, static_cast<jit_int8_t>(value), mode);
   459 			else
   460 				IA32_Add_Rm_Imm32(jit, reg, value, mode);
   461 		}
   462 
   463 		inline void IA32_Add_Eax_Imm32(JitWriter *jit, jit_int32_t value)
   464 		{
   465 			jit->write_ubyte(IA32_ADD_EAX_IMM32);
   466 			jit->write_int32(value);
   467 		}
   468 
   469 		inline void IA32_Sub_Rm_Reg(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   470 		{
   471 			jit->write_ubyte(IA32_SUB_RM_REG);
   472 			jit->write_ubyte(ia32_modrm(mode, src, dest));
   473 		}
   474 
   475 		inline void IA32_Sub_Reg_Rm(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   476 		{
   477 			jit->write_ubyte(IA32_SUB_REG_RM);
   478 			jit->write_ubyte(ia32_modrm(mode, dest, src));
   479 		}
   480 
   481 		inline void IA32_Sub_Reg_Rm_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp8)
   482 		{
   483 			jit->write_ubyte(IA32_SUB_REG_RM);
   484 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, src));
   485 			jit->write_byte(disp8);
   486 		}
   487 
   488 		inline void IA32_Sub_Rm_Reg_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp8)
   489 		{
   490 			jit->write_ubyte(IA32_SUB_RM_REG);
   491 			jit->write_ubyte(ia32_modrm(MOD_DISP8, src, dest));
   492 			jit->write_byte(disp8);
   493 		}
   494 
   495 		inline void IA32_Sub_Rm_Imm8(JitWriter *jit, jit_uint8_t reg, jit_int8_t val, jit_uint8_t mode)
   496 		{
   497 			jit->write_ubyte(IA32_SUB_RM_IMM8);
   498 			jit->write_ubyte(ia32_modrm(mode, 5, reg));
   499 			jit->write_byte(val);
   500 		}
   501 
   502 		inline void IA32_Sub_Rm_Imm32(JitWriter *jit, jit_uint8_t reg, jit_int32_t val, jit_uint8_t mode)
   503 		{
   504 			jit->write_ubyte(IA32_SUB_RM_IMM32);
   505 			jit->write_ubyte(ia32_modrm(mode, 5, reg));
   506 			jit->write_int32(val);
   507 		}
   508 
   509 		inline void IA32_Sub_Rm_ImmAuto(JitWriter *jit, jit_uint8_t reg, jit_int32_t val, jit_uint8_t mode)
   510 		{
   511 			if (val >= SCHAR_MIN && val <= SCHAR_MAX)
   512 				IA32_Sub_Rm_Imm8(jit, reg, static_cast<jit_int8_t>(val), mode);
   513 			else
   514 				IA32_Sub_Rm_Imm32(jit, reg, val, mode);
   515 		}
   516 
   517 		inline void IA32_Sbb_Reg_Rm(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   518 		{
   519 			jit->write_ubyte(IA32_SBB_REG_RM);
   520 			jit->write_ubyte(ia32_modrm(mode, dest, src));
   521 		}
   522 
   523 		inline void IA32_Sbb_Rm_Imm8(JitWriter *jit, jit_uint8_t dest, jit_int8_t value, jit_uint8_t mode)
   524 		{
   525 			jit->write_ubyte(IA32_SBB_RM_IMM8);
   526 			jit->write_ubyte(ia32_modrm(mode, 3, dest));
   527 			jit->write_byte(value);
   528 		}
   529 
   530 		inline void IA32_Div_Rm(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
   531 		{
   532 			jit->write_ubyte(IA32_DIV_RM);
   533 			jit->write_ubyte(ia32_modrm(mode, 6, reg));
   534 		}
   535 
   536 		inline void IA32_IDiv_Rm(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
   537 		{
   538 			jit->write_ubyte(IA32_IDIV_RM);
   539 			jit->write_ubyte(ia32_modrm(mode, 7, reg));
   540 		}
   541 
   542 		inline void IA32_Mul_Rm(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
   543 		{
   544 			jit->write_ubyte(IA32_MUL_RM);
   545 			jit->write_ubyte(ia32_modrm(mode, 4, reg));
   546 		}
   547 
   548 		inline void IA32_IMul_Rm(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
   549 		{
   550 			jit->write_ubyte(IA32_IMUL_RM);
   551 			jit->write_ubyte(ia32_modrm(mode, 5, reg));
   552 		}
   553 
   554 		inline void IA32_IMul_Reg_Imm8(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode, jit_int8_t value)
   555 		{
   556 			jit->write_ubyte(IA32_IMUL_REG_IMM8);
   557 			jit->write_ubyte(ia32_modrm(mode, 0, reg));
   558 			jit->write_byte(value);
   559 		}
   560 
   561 		inline void IA32_IMul_Reg_Imm32(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode, jit_int32_t value)
   562 		{
   563 			jit->write_ubyte(IA32_IMUL_REG_IMM32);
   564 			jit->write_ubyte(ia32_modrm(mode, 0, reg));
   565 			jit->write_int32(value);
   566 		}
   567 
   568 		inline void IA32_IMul_Reg_Rm(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   569 		{
   570 			jit->write_ubyte(IA32_IMUL_REG_RM_1);
   571 			jit->write_ubyte(IA32_IMUL_REG_RM_2);
   572 			jit->write_ubyte(ia32_modrm(mode, dest, src));
   573 		}
   574 
   575 		inline void IA32_Add_Rm_Reg_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp)
   576 		{
   577 			jit->write_ubyte(IA32_ADD_RM_REG);
   578 			jit->write_ubyte(ia32_modrm(MOD_DISP8, src, dest));
   579 			jit->write_byte(disp);
   580 		}
   581 
   582 		inline void IA32_Add_Reg_Rm_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp)
   583 		{
   584 			jit->write_ubyte(IA32_ADD_REG_RM);
   585 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, src));
   586 			jit->write_byte(disp);
   587 		}
   588 
   589 		inline void IA32_Add_Rm_Imm8_Disp8(JitWriter *jit, 
   590 									jit_uint8_t dest, 
   591 									jit_int8_t val, 
   592 									jit_int8_t disp8)
   593 		{
   594 			jit->write_ubyte(IA32_ADD_RM_IMM8);
   595 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, dest));
   596 			jit->write_byte(disp8);
   597 			jit->write_byte(val);
   598 		}
   599 
   600 		inline void IA32_Add_Rm_Imm32_Disp8(JitWriter *jit, 
   601 									jit_uint8_t dest, 
   602 									jit_int32_t val, 
   603 									jit_int8_t disp8)
   604 		{
   605 			jit->write_ubyte(IA32_ADD_RM_IMM32);
   606 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, dest));
   607 			jit->write_byte(disp8);
   608 			jit->write_int32(val);
   609 		}
   610 
   611 		inline jitoffs_t IA32_Add_Rm_Imm32_Later(JitWriter *jit, 
   612 											jit_uint8_t dest, 
   613 											jit_uint8_t mode)
   614 		{
   615 			jit->write_ubyte(IA32_ADD_RM_IMM32);
   616 			jit->write_ubyte(ia32_modrm(mode, 0, dest));
   617 			jitoffs_t ptr = jit->get_outputpos();
   618 			jit->write_int32(0);
   619 			return ptr;
   620 		}
   621 
   622 		inline void IA32_Add_Rm_Imm8_Disp32(JitWriter *jit, 
   623 									jit_uint8_t dest, 
   624 									jit_int8_t val, 
   625 									jit_int32_t disp32)
   626 		{
   627 			jit->write_ubyte(IA32_ADD_RM_IMM8);
   628 			jit->write_ubyte(ia32_modrm(MOD_DISP32, 0, dest));
   629 			jit->write_int32(disp32);
   630 			jit->write_byte(val);
   631 		}
   632 
   633 		inline void IA32_Add_RmEBP_Imm8_Disp_Reg(JitWriter *jit, 
   634 										jit_uint8_t dest_base, 
   635 										jit_uint8_t dest_index,
   636 										jit_uint8_t dest_scale,
   637 										jit_int8_t val)
   638 		{
   639 			jit->write_ubyte(IA32_ADD_RM_IMM8);
   640 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, REG_SIB));
   641 			jit->write_ubyte(ia32_sib(dest_scale, dest_index, dest_base));
   642 			jit->write_byte(0);
   643 			jit->write_byte(val);
   644 		}
   645 
   646 		inline void IA32_Sub_Rm_Imm8_Disp8(JitWriter *jit, 
   647 									jit_uint8_t dest, 
   648 									jit_int8_t val, 
   649 									jit_int8_t disp8)
   650 		{
   651 			jit->write_ubyte(IA32_SUB_RM_IMM8);
   652 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 5, dest));
   653 			jit->write_byte(disp8);
   654 			jit->write_byte(val);
   655 		}
   656 
   657 		inline void IA32_Sub_Rm_Imm8_Disp32(JitWriter *jit, 
   658 									jit_uint8_t dest, 
   659 									jit_int8_t val, 
   660 									jit_int32_t disp32)
   661 		{
   662 			jit->write_ubyte(IA32_SUB_RM_IMM8);
   663 			jit->write_ubyte(ia32_modrm(MOD_DISP32, 5, dest));
   664 			jit->write_int32(disp32);
   665 			jit->write_byte(val);
   666 		}
   667 
   668 		inline void IA32_Sub_RmEBP_Imm8_Disp_Reg(JitWriter *jit, 
   669 									jit_uint8_t dest_base, 
   670 									jit_uint8_t dest_index,
   671 									jit_uint8_t dest_scale,
   672 									jit_int8_t val)
   673 		{
   674 			jit->write_ubyte(IA32_SUB_RM_IMM8);
   675 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 5, REG_SIB));
   676 			jit->write_ubyte(ia32_sib(dest_scale, dest_index, dest_base));
   677 			jit->write_byte(0);
   678 			jit->write_byte(val);
   679 		}
   680 
   681 		/**
   682 		* Memory Instructions
   683 		*/
   684 
   685 		inline void IA32_Lea_Reg_DispRegMult(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src_base, jit_uint8_t src_index, jit_uint8_t scale)
   686 		{
   687 			jit->write_ubyte(IA32_LEA_REG_MEM);
   688 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, dest, REG_SIB));
   689 			jit->write_ubyte(ia32_sib(scale, src_index, src_base));
   690 		}
   691 
   692 		inline void IA32_Lea_Reg_DispEBPRegMult(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src_base, jit_uint8_t src_index, jit_uint8_t scale)
   693 		{
   694 			jit->write_ubyte(IA32_LEA_REG_MEM);
   695 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, REG_SIB));
   696 			jit->write_ubyte(ia32_sib(scale, src_index, src_base));
   697 			jit->write_byte(0);
   698 		}
   699 
   700 		inline void IA32_Lea_Reg_DispRegMultImm8(JitWriter *jit, 
   701 									jit_uint8_t dest, 
   702 									jit_uint8_t src_base, 
   703 									jit_uint8_t src_index, 
   704 									jit_uint8_t scale, 
   705 									jit_int8_t val)
   706 		{
   707 			jit->write_ubyte(IA32_LEA_REG_MEM);
   708 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, REG_SIB));
   709 			jit->write_ubyte(ia32_sib(scale, src_index, src_base));
   710 			jit->write_byte(val);
   711 		}
   712 
   713 		inline void IA32_Lea_Reg_DispRegMultImm32(JitWriter *jit, 
   714 												jit_uint8_t dest, 
   715 												jit_uint8_t src_base, 
   716 												jit_uint8_t src_index, 
   717 												jit_uint8_t scale, 
   718 												jit_int32_t val)
   719 		{
   720 			jit->write_ubyte(IA32_LEA_REG_MEM);
   721 			jit->write_ubyte(ia32_modrm(MOD_DISP32, dest, REG_SIB));
   722 			jit->write_ubyte(ia32_sib(scale, src_index, src_base));
   723 			jit->write_int32(val);
   724 		}
   725 
   726 		inline void IA32_Lea_Reg_RegMultImm32(JitWriter *jit, 
   727 												jit_uint8_t dest, 
   728 												jit_uint8_t src_index, 
   729 												jit_uint8_t scale, 
   730 												jit_int32_t val)
   731 		{
   732 			jit->write_ubyte(IA32_LEA_REG_MEM);
   733 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, dest, REG_SIB));
   734 			jit->write_ubyte(ia32_sib(scale, src_index, REG_IMM_BASE));
   735 			jit->write_int32(val);
   736 		}
   737 
   738 		inline void IA32_Lea_DispRegImm8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src_base, jit_int8_t val)
   739 		{
   740 			jit->write_ubyte(IA32_LEA_REG_MEM);
   741 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, src_base));
   742 			jit->write_byte(val);
   743 		}
   744 
   745 		inline void IA32_Lea_DispRegImm32(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src_base, jit_int32_t val)
   746 		{
   747 			jit->write_ubyte(IA32_LEA_REG_MEM);
   748 			jit->write_ubyte(ia32_modrm(MOD_DISP32, dest, src_base));
   749 			jit->write_int32(val);
   750 		}
   751 
   752 		inline void IA32_Lea_DispRegImmAuto(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src_base, jit_int32_t val)
   753 		{
   754 			if (val >= SCHAR_MIN && val <= SCHAR_MAX)
   755 				IA32_Lea_DispRegImm8(jit, dest, src_base, static_cast<jit_int8_t>(val));
   756 			else
   757 				IA32_Lea_DispRegImm32(jit, dest, src_base, val);
   758 		}
   759 
   760 		/**
   761 		* Stack Instructions
   762 		*/
   763 
   764 		inline void IA32_Pop_Reg(JitWriter *jit, jit_uint8_t reg)
   765 		{
   766 			jit->write_ubyte(IA32_POP_REG+reg);
   767 		}
   768 
   769 		inline void IA32_Push_Reg(JitWriter *jit, jit_uint8_t reg)
   770 		{
   771 			jit->write_ubyte(IA32_PUSH_REG+reg);
   772 		}
   773 
   774 		inline void IA32_Push_Imm8(JitWriter *jit, jit_int8_t val)
   775 		{
   776 			jit->write_ubyte(IA32_PUSH_IMM8);
   777 			jit->write_byte(val);
   778 		}
   779 
   780 		inline void IA32_Push_Imm32(JitWriter *jit, jit_int32_t val)
   781 		{
   782 			jit->write_ubyte(IA32_PUSH_IMM32);
   783 			jit->write_int32(val);
   784 		}
   785 
   786 		inline void IA32_Pushad(JitWriter *jit)
   787 		{
   788 			jit->write_ubyte(IA32_PUSHAD);
   789 		}
   790 
   791 		inline void IA32_Popad(JitWriter *jit)
   792 		{
   793 			jit->write_ubyte(IA32_POPAD);
   794 		}
   795 
   796 		inline void IA32_Push_Rm_Disp8(JitWriter *jit, jit_uint8_t reg, jit_int8_t disp8)
   797 		{
   798 			jit->write_ubyte(IA32_PUSH_RM);
   799 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 6, reg));
   800 			jit->write_byte(disp8);
   801 		}
   802 
   803 		inline void IA32_Push_Rm_Disp32(JitWriter *jit, jit_uint8_t reg, jit_int32_t disp32)
   804 		{
   805 			jit->write_ubyte(IA32_PUSH_RM);
   806 			jit->write_ubyte(ia32_modrm(MOD_DISP32, 6, reg));
   807 			jit->write_int32(disp32);
   808 		}
   809 
   810 		inline void IA32_Push_Rm_DispAuto(JitWriter *jit, jit_uint8_t reg, jit_int32_t disp)
   811 		{
   812 			if (disp >= SCHAR_MIN && disp <= SCHAR_MAX)
   813 				IA32_Push_Rm_Disp8(jit, reg, static_cast<jit_int8_t>(disp));
   814 			else
   815 				IA32_Push_Rm_Disp32(jit, reg, disp);
   816 		}
   817 
   818 		inline void IA32_Push_Rm_Disp8_ESP(JitWriter *jit, jit_int8_t disp8)
   819 		{
   820 			jit->write_ubyte(IA32_PUSH_RM);
   821 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 6, REG_SIB));
   822 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
   823 			jit->write_byte(disp8);
   824 		}
   825 
   826 		/**
   827 		* Moving from REGISTER/MEMORY to REGISTER
   828 		*/
   829 
   830 		inline void IA32_Mov_Reg_Rm(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   831 		{
   832 			jit->write_ubyte(IA32_MOV_REG_RM);
   833 			jit->write_ubyte(ia32_modrm(mode, dest, src));
   834 		}
   835 
   836 		inline void IA32_Mov_Reg8_Rm8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   837 		{
   838 			jit->write_ubyte(IA32_MOV_REG8_RM8);
   839 			jit->write_ubyte(ia32_modrm(mode, dest, src));
   840 		}
   841 
   842 		inline void IA32_Mov_Reg_RmESP(JitWriter *jit, jit_uint8_t dest)
   843 		{
   844 			jit->write_ubyte(IA32_MOV_REG_RM);
   845 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, dest, REG_ESP));
   846 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
   847 		}
   848 
   849 		inline void IA32_Mov_Reg_Rm_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp)
   850 		{
   851 			jit->write_ubyte(IA32_MOV_REG_RM);
   852 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, src));
   853 			jit->write_byte(disp);
   854 		}
   855 
   856 		inline void IA32_Mov_Reg8_Rm8_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp)
   857 		{
   858 			jit->write_ubyte(IA32_MOV_REG8_RM8);
   859 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, src));
   860 			jit->write_byte(disp);
   861 		}
   862 
   863 		inline void IA32_Mov_Reg_Esp_Disp8(JitWriter *jit, jit_uint8_t dest, jit_int8_t disp)
   864 		{
   865 			jit->write_ubyte(IA32_MOV_REG_RM);
   866 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, REG_SIB));
   867 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
   868 			jit->write_byte(disp);
   869 		}
   870 
   871 		inline void IA32_Mov_Reg_Rm_Disp32(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
   872 		{
   873 			jit->write_ubyte(IA32_MOV_REG_RM);
   874 			jit->write_ubyte(ia32_modrm(MOD_DISP32, dest, src));
   875 			jit->write_int32(disp);
   876 		}
   877 
   878 		inline void IA32_Mov_Reg8_Rm8_Disp32(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
   879 		{
   880 			jit->write_ubyte(IA32_MOV_REG8_RM8);
   881 			jit->write_ubyte(ia32_modrm(MOD_DISP32, dest, src));
   882 			jit->write_int32(disp);
   883 		}
   884 
   885 		inline void IA32_Mov_Reg_Rm_Disp_Reg(JitWriter *jit, 
   886 									jit_uint8_t dest, 
   887 									jit_uint8_t src_base, 
   888 									jit_uint8_t src_index,
   889 									jit_uint8_t src_scale)
   890 		{
   891 			jit->write_ubyte(IA32_MOV_REG_RM);
   892 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, dest, REG_SIB));
   893 			jit->write_ubyte(ia32_sib(src_scale, src_index, src_base));
   894 		}
   895 
   896 		inline void IA32_Mov_Reg_Rm_Disp_Reg_Disp8(JitWriter *jit, 
   897 											jit_uint8_t dest, 
   898 											jit_uint8_t src_base, 
   899 											jit_uint8_t src_index,
   900 											jit_uint8_t src_scale,
   901 											jit_int8_t disp8)
   902 		{
   903 			jit->write_ubyte(IA32_MOV_REG_RM);
   904 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, REG_SIB));
   905 			jit->write_ubyte(ia32_sib(src_scale, src_index, src_base));
   906 			jit->write_byte(disp8);
   907 		}
   908 
   909 		inline void IA32_Mov_Reg_RmEBP_Disp_Reg(JitWriter *jit, 
   910 											jit_uint8_t dest, 
   911 											jit_uint8_t src_base, 
   912 											jit_uint8_t src_index,
   913 											jit_uint8_t src_scale)
   914 		{
   915 			jit->write_ubyte(IA32_MOV_REG_RM);
   916 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, REG_SIB));
   917 			jit->write_ubyte(ia32_sib(src_scale, src_index, src_base));
   918 			jit->write_byte(0);
   919 		}
   920 
   921 		inline void IA32_Mov_Reg_Rm_DispAuto(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
   922 		{
   923 			if (disp == 0)
   924 				IA32_Mov_Reg_Rm(jit, dest, src, MOD_MEM_REG);
   925 			else if (disp <= SCHAR_MAX)
   926 				IA32_Mov_Reg_Rm_Disp8(jit, dest, src, static_cast<jit_int8_t>(disp));
   927 			else
   928 				IA32_Mov_Reg_Rm_Disp32(jit, dest, src, disp);
   929 		}
   930 
   931 		/**
   932 		* Moving from REGISTER to REGISTER/MEMORY
   933 		*/
   934 
   935 		inline void IA32_Mov_Rm_Reg(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   936 		{
   937 			jit->write_ubyte(IA32_MOV_RM_REG);
   938 			jit->write_ubyte(ia32_modrm(mode, src, dest));
   939 		}
   940 
   941 		inline void IA32_Mov_Rm8_Reg8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
   942 		{
   943 			jit->write_ubyte(IA32_MOV_RM8_REG8);
   944 			jit->write_ubyte(ia32_modrm(mode, src, dest));
   945 		}
   946 
   947 		inline void IA32_Mov_Rm8_Reg8_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp)
   948 		{
   949 			jit->write_ubyte(IA32_MOV_RM8_REG8);
   950 			jit->write_ubyte(ia32_modrm(MOD_DISP8, src, dest));
   951 			jit->write_byte(disp);
   952 		}
   953 
   954 		inline void IA32_Mov_Rm8_Reg8_Disp32(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
   955 		{
   956 			jit->write_ubyte(IA32_MOV_RM8_REG8);
   957 			jit->write_ubyte(ia32_modrm(MOD_DISP32, src, dest));
   958 			jit->write_int32(disp);
   959 		}
   960 
   961 		inline void IA32_Mov_Rm8_Reg8_DispAuto(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
   962 		{
   963 			if (disp >= SCHAR_MIN && disp <= SCHAR_MAX)
   964 				IA32_Mov_Rm8_Reg8_Disp8(jit, dest, src, static_cast<jit_int8_t>(disp));
   965 			else
   966 				IA32_Mov_Rm8_Reg8_Disp32(jit, dest, src, disp);
   967 		}
   968 		
   969 		inline void IA32_Mov_RmESP_Reg(JitWriter *jit, jit_uint8_t src)
   970 		{
   971 			jit->write_ubyte(IA32_MOV_RM_REG);
   972 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, src, REG_ESP));
   973 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
   974 		}
   975 
   976 		inline void IA32_Mov_Rm_Reg_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp)
   977 		{
   978 			jit->write_ubyte(IA32_MOV_RM_REG);
   979 			jit->write_ubyte(ia32_modrm(MOD_DISP8, src, dest));
   980 			jit->write_byte(disp);
   981 		}
   982 
   983 		inline void IA32_Mov_Rm_Reg_Disp32(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
   984 		{
   985 			jit->write_ubyte(IA32_MOV_RM_REG);
   986 			jit->write_ubyte(ia32_modrm(MOD_DISP32, src, dest));
   987 			jit->write_int32(disp);
   988 		}
   989 
   990 		inline void IA32_Mov_Rm_Reg_DispAuto(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
   991 		{
   992 			if (disp >= SCHAR_MIN && disp <= SCHAR_MAX)
   993 				IA32_Mov_Rm_Reg_Disp8(jit, dest, src, static_cast<jit_int8_t>(disp));
   994 			else
   995 				IA32_Mov_Rm_Reg_Disp32(jit, dest, src, disp);
   996 		}
   997 
   998 		inline void IA32_Mov_RmEBP_Reg_Disp_Reg(JitWriter *jit, 
   999 									jit_uint8_t dest_base, 
  1000 									jit_uint8_t dest_index,
  1001 									jit_uint8_t dest_scale,
  1002 									jit_uint8_t src)
  1003 		{
  1004 			jit->write_ubyte(IA32_MOV_RM_REG);
  1005 			jit->write_ubyte(ia32_modrm(MOD_DISP8, src, REG_SIB));
  1006 			jit->write_ubyte(ia32_sib(dest_scale, dest_index, dest_base));
  1007 			jit->write_byte(0);
  1008 		}
  1009 
  1010 		inline void IA32_Mov_Rm8EBP_Reg_Disp_Reg(JitWriter *jit, 
  1011 											jit_uint8_t dest_base, 
  1012 											jit_uint8_t dest_index,
  1013 											jit_uint8_t dest_scale,
  1014 											jit_uint8_t src)
  1015 		{
  1016 			jit->write_ubyte(IA32_MOV_RM8_REG);
  1017 			jit->write_ubyte(ia32_modrm(MOD_DISP8, src, REG_SIB));
  1018 			jit->write_ubyte(ia32_sib(dest_scale, dest_index, dest_base));
  1019 			jit->write_byte(0);
  1020 		}
  1021 
  1022 		inline void IA32_Mov_Rm16EBP_Reg_Disp_Reg(JitWriter *jit, 
  1023 											jit_uint8_t dest_base, 
  1024 											jit_uint8_t dest_index,
  1025 											jit_uint8_t dest_scale,
  1026 											jit_uint8_t src)
  1027 		{
  1028 			jit->write_ubyte(IA32_16BIT_PREFIX);
  1029 			jit->write_ubyte(IA32_MOV_RM_REG);
  1030 			jit->write_ubyte(ia32_modrm(MOD_DISP8, src, REG_SIB));
  1031 			jit->write_ubyte(ia32_sib(dest_scale, dest_index, dest_base));
  1032 			jit->write_byte(0);
  1033 		}
  1034 
  1035 		/**
  1036 		* Moving from IMMEDIATE to REGISTER
  1037 		*/
  1038 
  1039 		inline jitoffs_t IA32_Mov_Reg_Imm32(JitWriter *jit, jit_uint8_t dest, jit_int32_t num)
  1040 		{
  1041 			jitoffs_t offs;
  1042 			jit->write_ubyte(IA32_MOV_REG_IMM+dest);
  1043 			offs = jit->get_outputpos();
  1044 			jit->write_int32(num);
  1045 			return offs;
  1046 		}
  1047 
  1048 		inline void IA32_Mov_Rm_Imm32(JitWriter *jit, jit_uint8_t dest, jit_int32_t val, jit_uint8_t mode)
  1049 		{
  1050 			jit->write_ubyte(IA32_MOV_RM_IMM32);
  1051 			jit->write_ubyte(ia32_modrm(mode, 0, dest));
  1052 			jit->write_int32(val);
  1053 		}
  1054 
  1055 		inline void IA32_Mov_Rm_Imm32_Disp8(JitWriter *jit, 
  1056 									jit_uint8_t dest, 
  1057 									jit_int32_t val, 
  1058 									jit_int8_t disp8)
  1059 		{
  1060 			jit->write_ubyte(IA32_MOV_RM_IMM32);
  1061 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, dest));
  1062 			jit->write_byte(disp8);
  1063 			jit->write_int32(val);
  1064 		}
  1065 
  1066 		inline void IA32_Mov_Rm_Imm32_Disp32(JitWriter *jit, 
  1067 									jit_uint8_t dest, 
  1068 									jit_int32_t val, 
  1069 									jit_int32_t disp32)
  1070 		{
  1071 			jit->write_ubyte(IA32_MOV_RM_IMM32);
  1072 			jit->write_ubyte(ia32_modrm(MOD_DISP32, 0, dest));
  1073 			jit->write_int32(disp32);
  1074 			jit->write_int32(val);
  1075 		}
  1076 
  1077 		inline void IA32_Mov_RmEBP_Imm32_Disp_Reg(JitWriter *jit, 
  1078 										jit_uint8_t dest_base, 
  1079 										jit_uint8_t dest_index, 
  1080 										jit_uint8_t dest_scale, 
  1081 										jit_int32_t val)
  1082 		{
  1083 			jit->write_ubyte(IA32_MOV_RM_IMM32);
  1084 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, REG_SIB));
  1085 			jit->write_ubyte(ia32_sib(dest_scale, dest_index, dest_base));
  1086 			jit->write_byte(0);
  1087 			jit->write_int32(val);
  1088 		}
  1089 
  1090 		inline void IA32_Mov_ESP_Disp8_Imm32(JitWriter *jit, jit_int8_t disp8, jit_int32_t val)
  1091 		{
  1092 			jit->write_ubyte(IA32_MOV_RM_IMM32);
  1093 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, REG_SIB));
  1094 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1095 			jit->write_byte(disp8);
  1096 			jit->write_int32(val);
  1097 		}
  1098 
  1099 		/**
  1100 		* Floating Point Instructions
  1101 		*/
  1102 
  1103 		inline void IA32_Fstcw_Mem16_ESP(JitWriter *jit)
  1104 		{
  1105 			jit->write_ubyte(IA32_FSTCW_MEM16_1);
  1106 			jit->write_ubyte(IA32_FSTCW_MEM16_2);
  1107 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 7, REG_SIB));
  1108 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1109 		}
  1110 
  1111 		inline void IA32_Fldcw_Mem16_ESP(JitWriter *jit)
  1112 		{
  1113 			jit->write_ubyte(IA32_FLDCW_MEM16);
  1114 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 5, REG_SIB));
  1115 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1116 		}
  1117 
  1118 		inline void IA32_Fldcw_Mem16_Disp8_ESP(JitWriter *jit, jit_int8_t disp8)
  1119 		{
  1120 			jit->write_ubyte(IA32_FLDCW_MEM16);
  1121 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 5, REG_SIB));
  1122 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1123 			jit->write_byte(disp8);
  1124 		}
  1125 
  1126 		inline void IA32_Fistp_Mem32_ESP(JitWriter *jit)
  1127 		{
  1128 			jit->write_ubyte(IA32_FISTP_MEM32);
  1129 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 3, REG_SIB));
  1130 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1131 		}
  1132 
  1133 		inline void IA32_Fistp_Mem32_Disp8_Esp(JitWriter *jit, jit_int8_t disp8)
  1134 		{
  1135 			jit->write_ubyte(IA32_FISTP_MEM32);
  1136 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 3, REG_SIB));
  1137 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1138 			jit->write_byte(disp8);
  1139 		}
  1140 
  1141 		inline void IA32_Fucomip_ST0_FPUreg(JitWriter *jit, jit_uint8_t reg)
  1142 		{
  1143 			jit->write_ubyte(IA32_FUCOMIP_1);
  1144 			jit->write_ubyte(IA32_FUCOMIP_2+reg);
  1145 		}
  1146 
  1147 		inline void IA32_Fadd_FPUreg_ST0(JitWriter *jit, jit_uint8_t reg)
  1148 		{
  1149 			jit->write_ubyte(IA32_FADD_FPREG_ST0_1);
  1150 			jit->write_ubyte(IA32_FADD_FPREG_ST0_2+reg);
  1151 		}
  1152 
  1153 		inline void IA32_Fadd_Mem32_Disp8(JitWriter *jit, jit_uint8_t src, jit_int8_t val)
  1154 		{
  1155 			jit->write_ubyte(IA32_FADD_MEM32);
  1156 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, src));
  1157 			jit->write_byte(val);
  1158 		}
  1159 
  1160 		inline void IA32_Fadd_Mem32_ESP(JitWriter *jit)
  1161 		{
  1162 			jit->write_ubyte(IA32_FADD_MEM32);
  1163 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 0, REG_SIB));
  1164 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1165 		}
  1166 
  1167 		inline void IA32_Fsub_Mem32_Disp8(JitWriter *jit, jit_uint8_t src, jit_int8_t val)
  1168 		{
  1169 			jit->write_ubyte(IA32_FSUB_MEM32);
  1170 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 4, src));
  1171 			jit->write_byte(val);
  1172 		}
  1173 
  1174 		inline void IA32_Fmul_Mem32_Disp8(JitWriter *jit, jit_uint8_t src, jit_int8_t val)
  1175 		{
  1176 			jit->write_ubyte(IA32_FMUL_MEM32);
  1177 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 1, src));
  1178 			jit->write_byte(val);
  1179 		}
  1180 
  1181 		inline void IA32_Fdiv_Mem32_Disp8(JitWriter *jit, jit_uint8_t src, jit_int8_t val)
  1182 		{
  1183 			jit->write_ubyte(IA32_FDIV_MEM32);
  1184 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 6, src));
  1185 			jit->write_byte(val);
  1186 		}
  1187 
  1188 		inline void IA32_Fild_Mem32(JitWriter *jit, jit_uint8_t src)
  1189 		{
  1190 			jit->write_ubyte(IA32_FILD_MEM32);
  1191 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 0, src));
  1192 		}
  1193 
  1194 		inline void IA32_Fstp_Mem32(JitWriter *jit, jit_uint8_t dest)
  1195 		{
  1196 			jit->write_ubyte(IA32_FSTP_MEM32);
  1197 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 3, dest));
  1198 		}
  1199 
  1200 		inline void IA32_Fstp_Mem32_DispAuto(JitWriter *jit, jit_uint8_t dest, jit_int32_t disp)
  1201 		{
  1202 			jit->write_ubyte(IA32_FSTP_MEM32);
  1203 
  1204 			if (disp > SCHAR_MIN && disp < SCHAR_MAX)
  1205 			{
  1206 				jit->write_ubyte(ia32_modrm(MOD_DISP8, 3, dest));
  1207 				jit->write_byte(static_cast<jit_int8_t>(disp));
  1208 			}
  1209 			else
  1210 			{
  1211 				jit->write_ubyte(ia32_modrm(MOD_DISP32, 3, dest));
  1212 				jit->write_byte(disp);
  1213 			}
  1214 		}
  1215 
  1216 		inline void IA32_Fstp_Mem64(JitWriter *jit, jit_uint8_t dest)
  1217 		{
  1218 			jit->write_ubyte(IA32_FSTP_MEM64);
  1219 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 3, dest));
  1220 		}
  1221 
  1222 		inline void IA32_Fstp_Mem64_DispAuto(JitWriter *jit, jit_uint8_t dest, jit_int32_t disp)
  1223 		{
  1224 			jit->write_ubyte(IA32_FSTP_MEM64);
  1225 
  1226 			if (disp > SCHAR_MIN && disp < SCHAR_MAX)
  1227 			{
  1228 				jit->write_ubyte(ia32_modrm(MOD_DISP8, 3, dest));
  1229 				jit->write_byte(static_cast<jit_int8_t>(disp));
  1230 			}
  1231 			else
  1232 			{
  1233 				jit->write_ubyte(ia32_modrm(MOD_DISP32, 3, dest));
  1234 				jit->write_byte(disp);
  1235 			}
  1236 		}
  1237 
  1238 		inline void IA32_Fstp_Mem32_ESP(JitWriter *jit)
  1239 		{
  1240 			jit->write_ubyte(IA32_FSTP_MEM32);
  1241 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 3, REG_SIB));
  1242 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1243 		}
  1244 
  1245 		inline void IA32_Fstp_Mem64_ESP(JitWriter *jit)
  1246 		{
  1247 			jit->write_ubyte(IA32_FSTP_MEM64);
  1248 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 3, REG_SIB));
  1249 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1250 		}
  1251 
  1252 		inline void IA32_Fstp_FPUreg(JitWriter *jit, jit_uint8_t reg)
  1253 		{
  1254 			jit->write_ubyte(IA32_FSTP_FPREG_1);
  1255 			jit->write_ubyte(IA32_FSTP_FPREG_2+reg);
  1256 		}
  1257 
  1258 		inline void IA32_Fld_Mem32(JitWriter *jit, jit_uint8_t src)
  1259 		{
  1260 			jit->write_ubyte(IA32_FLD_MEM32);
  1261 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 0, src));
  1262 		}
  1263 
  1264 		inline void IA32_Fld_Mem64(JitWriter *jit, jit_uint8_t src)
  1265 		{
  1266 			jit->write_ubyte(IA32_FLD_MEM64);
  1267 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 0, src));
  1268 		}
  1269 
  1270 		inline void IA32_Fld_Mem32_Disp8(JitWriter *jit, jit_uint8_t src, jit_int8_t val)
  1271 		{
  1272 			jit->write_ubyte(IA32_FLD_MEM32);
  1273 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, src));
  1274 			jit->write_byte(val);
  1275 		}
  1276 
  1277 		inline void IA32_Fld_Mem64_Disp8(JitWriter *jit, jit_uint8_t src, jit_int8_t val)
  1278 		{
  1279 			jit->write_ubyte(IA32_FLD_MEM64);
  1280 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, src));
  1281 			jit->write_byte(val);
  1282 		}
  1283 
  1284 		inline void IA32_Fld_Mem32_Disp32(JitWriter *jit, jit_uint8_t src, jit_int32_t val)
  1285 		{
  1286 			jit->write_ubyte(IA32_FLD_MEM32);
  1287 			jit->write_ubyte(ia32_modrm(MOD_DISP32, 0, src));
  1288 			jit->write_int32(val);
  1289 		}
  1290 
  1291 		inline void IA32_Fld_Mem64_Disp32(JitWriter *jit, jit_uint8_t src, jit_int32_t val)
  1292 		{
  1293 			jit->write_ubyte(IA32_FLD_MEM64);
  1294 			jit->write_ubyte(ia32_modrm(MOD_DISP32, 0, src));
  1295 			jit->write_int32(val);
  1296 		}
  1297 
  1298 		inline void IA32_Fld_Mem32_DispAuto(JitWriter *jit, jit_uint8_t src, jit_int32_t disp)
  1299 		{
  1300 			if (disp == 0)
  1301 				IA32_Fld_Mem32(jit, src);
  1302 			else if (disp <= SCHAR_MAX)
  1303 				IA32_Fld_Mem32_Disp8(jit, src, static_cast<jit_int8_t>(disp));
  1304 			else
  1305 				IA32_Fld_Mem32_Disp32(jit, src, disp);
  1306 		}
  1307 
  1308 		inline void IA32_Fld_Mem64_DispAuto(JitWriter *jit, jit_uint8_t src, jit_int32_t disp)
  1309 		{
  1310 			if (disp == 0)
  1311 				IA32_Fld_Mem64(jit, src);
  1312 			else if (disp <= SCHAR_MAX)
  1313 				IA32_Fld_Mem64_Disp8(jit, src, static_cast<jit_int8_t>(disp));
  1314 			else
  1315 				IA32_Fld_Mem64_Disp32(jit, src, disp);
  1316 		}
  1317 
  1318 		/**
  1319 		* Move data with zero extend
  1320 		*/
  1321 
  1322 		inline void IA32_Movzx_Reg32_Rm8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
  1323 		{
  1324 			jit->write_ubyte(IA32_MOVZX_R32_RM8_1);
  1325 			jit->write_ubyte(IA32_MOVZX_R32_RM8_2);
  1326 			jit->write_ubyte(ia32_modrm(mode, dest, src));
  1327 		}
  1328 
  1329 		inline void IA32_Movzx_Reg32_Rm8_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp)
  1330 		{
  1331 			jit->write_ubyte(IA32_MOVZX_R32_RM8_1);
  1332 			jit->write_ubyte(IA32_MOVZX_R32_RM8_2);
  1333 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, src));
  1334 			jit->write_byte(disp);
  1335 		}
  1336 
  1337 		inline void IA32_Movzx_Reg32_Rm8_Disp32(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
  1338 		{
  1339 			jit->write_ubyte(IA32_MOVZX_R32_RM8_1);
  1340 			jit->write_ubyte(IA32_MOVZX_R32_RM8_2);
  1341 			jit->write_ubyte(ia32_modrm(MOD_DISP32, dest, src));
  1342 			jit->write_int32(disp);
  1343 		}
  1344 
  1345 		inline void IA32_Movzx_Reg32_Rm8_DispAuto(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
  1346 		{
  1347 			if (disp >= SCHAR_MIN && disp <= SCHAR_MAX)
  1348 				IA32_Movzx_Reg32_Rm8_Disp8(jit, dest, src, static_cast<jit_int8_t>(disp));
  1349 			else
  1350 				IA32_Movzx_Reg32_Rm8_Disp32(jit, dest, src, disp);
  1351 		}
  1352 
  1353 		inline void IA32_Movzx_Reg32_Rm16(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
  1354 		{
  1355 			jit->write_ubyte(IA32_MOVZX_R32_RM16_1);
  1356 			jit->write_ubyte(IA32_MOVZX_R32_RM16_2);
  1357 			jit->write_ubyte(ia32_modrm(mode, dest, src));
  1358 		}
  1359 
  1360 		inline void IA32_Movzx_Reg32_Rm16_Disp8(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int8_t disp)
  1361 		{
  1362 			jit->write_ubyte(IA32_MOVZX_R32_RM16_1);
  1363 			jit->write_ubyte(IA32_MOVZX_R32_RM16_2);
  1364 			jit->write_ubyte(ia32_modrm(MOD_DISP8, dest, src));
  1365 			jit->write_byte(disp);
  1366 		}
  1367 
  1368 		inline void IA32_Movzx_Reg32_Rm16_Disp32(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
  1369 		{
  1370 			jit->write_ubyte(IA32_MOVZX_R32_RM16_1);
  1371 			jit->write_ubyte(IA32_MOVZX_R32_RM16_2);
  1372 			jit->write_ubyte(ia32_modrm(MOD_DISP32, dest, src));
  1373 			jit->write_int32(disp);
  1374 		}
  1375 
  1376 		inline void IA32_Movzx_Reg32_Rm16_DispAuto(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_int32_t disp)
  1377 		{
  1378 			if (disp >= SCHAR_MIN && disp <= SCHAR_MAX)
  1379 				IA32_Movzx_Reg32_Rm16_Disp8(jit, dest, src, static_cast<jit_int8_t>(disp));
  1380 			else
  1381 				IA32_Movzx_Reg32_Rm16_Disp32(jit, dest, src, disp);
  1382 		}
  1383 
  1384 		/**
  1385 		* Branching/Jumping
  1386 		*/
  1387 
  1388 		inline jitoffs_t IA32_Jump_Cond_Imm8(JitWriter *jit, jit_uint8_t cond, jit_int8_t disp)
  1389 		{
  1390 			jitoffs_t ptr;
  1391 			jit->write_ubyte(IA32_JCC_IMM+cond);
  1392 			ptr = jit->get_outputpos();
  1393 			jit->write_byte(disp);
  1394 			return ptr;
  1395 		}
  1396 
  1397 		inline jitoffs_t IA32_Jump_Imm32(JitWriter *jit, jit_int32_t disp)
  1398 		{
  1399 			jitoffs_t ptr;
  1400 			jit->write_ubyte(IA32_JMP_IMM32);
  1401 			ptr = jit->get_outputpos();
  1402 			jit->write_int32(disp);
  1403 			return ptr;
  1404 		}
  1405 
  1406 		inline jitoffs_t IA32_Jump_Imm8(JitWriter *jit, jit_int8_t disp)
  1407 		{
  1408 			jitoffs_t ptr;
  1409 			jit->write_ubyte(IA32_JMP_IMM8);
  1410 			ptr = jit->get_outputpos();
  1411 			jit->write_byte(disp);
  1412 			return ptr;
  1413 		}
  1414 
  1415 		inline jitoffs_t IA32_Jump_Cond_Imm32(JitWriter *jit, jit_uint8_t cond, jit_int32_t disp)
  1416 		{
  1417 			jitoffs_t ptr;
  1418 			jit->write_ubyte(IA32_JCC_IMM32_1);
  1419 			jit->write_ubyte(IA32_JCC_IMM32_2+cond);
  1420 			ptr = jit->get_outputpos();
  1421 			jit->write_int32(disp);
  1422 			return ptr;
  1423 		}
  1424 
  1425 		inline void IA32_Jump_Reg(JitWriter *jit, jit_uint8_t reg)
  1426 		{
  1427 			jit->write_ubyte(IA32_JMP_RM);
  1428 			jit->write_ubyte(ia32_modrm(MOD_REG, 4, reg));
  1429 		}
  1430 
  1431 		inline void IA32_Jump_Rm(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
  1432 		{
  1433 			jit->write_ubyte(IA32_JMP_RM);
  1434 			jit->write_ubyte(ia32_modrm(mode, 4, reg));
  1435 		}
  1436 
  1437 		inline jitoffs_t IA32_Call_Imm32(JitWriter *jit, jit_int32_t disp)
  1438 		{
  1439 			jitoffs_t ptr;
  1440 			jit->write_ubyte(IA32_CALL_IMM32);
  1441 			ptr = jit->get_outputpos();
  1442 			jit->write_int32(disp);
  1443 			return ptr;
  1444 		}
  1445 
  1446 		inline void IA32_Call_Reg(JitWriter *jit, jit_uint8_t reg)
  1447 		{
  1448 			jit->write_ubyte(IA32_CALL_RM);
  1449 			jit->write_ubyte(ia32_modrm(MOD_REG, 2, reg));
  1450 		}
  1451 
  1452 		inline void IA32_Call_Rm(JitWriter *jit, jit_uint8_t reg, jit_uint8_t mode)
  1453 		{
  1454 			jit->write_ubyte(IA32_CALL_RM);
  1455 			jit->write_ubyte(ia32_modrm(mode, 4, reg));
  1456 		}
  1457 
  1458 		inline void IA32_Return(JitWriter *jit)
  1459 		{
  1460 			jit->write_ubyte(IA32_RET);
  1461 		}
  1462 
  1463 		inline void IA32_Return_Popstack(JitWriter *jit, unsigned short bytes)
  1464 		{
  1465 			jit->write_ubyte(IA32_RETN);
  1466 			jit->write_ushort(bytes);
  1467 		}
  1468 
  1469 		inline void IA32_Test_Rm_Reg(JitWriter *jit, jit_uint8_t reg1, jit_uint8_t reg2, jit_uint8_t mode)
  1470 		{
  1471 			jit->write_ubyte(IA32_TEST_RM_REG);
  1472 			jit->write_ubyte(ia32_modrm(mode, reg2, reg1));
  1473 		}
  1474 
  1475 		inline void IA32_Test_Rm_Reg8(JitWriter *jit, jit_uint8_t reg1, jit_uint8_t reg2, jit_uint8_t mode)
  1476 		{
  1477 			jit->write_ubyte(IA32_TEST_RM_REG8);
  1478 			jit->write_ubyte(ia32_modrm(mode, reg2, reg1));
  1479 		}
  1480 
  1481 		inline void IA32_Test_Rm_Imm32(JitWriter *jit, jit_uint8_t operand1, jit_int32_t imm_operand, jit_uint8_t mode)
  1482 		{
  1483 			jit->write_ubyte(IA32_TEST_RM_IMM32);
  1484 			jit->write_ubyte(ia32_modrm(mode, 0, operand1));
  1485 			jit->write_int32(imm_operand);
  1486 		}
  1487 
  1488 		inline void IA32_Cmp_Rm_Reg(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
  1489 		{
  1490 			jit->write_ubyte(IA32_CMP_RM_REG);
  1491 			jit->write_ubyte(ia32_modrm(mode, src, dest));
  1492 		}
  1493 
  1494 		inline void IA32_Cmp_Reg_Rm(JitWriter *jit, jit_uint8_t dest, jit_uint8_t src, jit_uint8_t mode)
  1495 		{
  1496 			jit->write_ubyte(IA32_CMP_REG_RM);
  1497 			jit->write_ubyte(ia32_modrm(mode, dest, src));
  1498 		}
  1499 
  1500 		inline void IA32_Cmp_Reg_Rm_ESP(JitWriter *jit, jit_uint8_t cmpreg)
  1501 		{
  1502 			jit->write_ubyte(IA32_CMP_REG_RM);
  1503 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, cmpreg, REG_SIB));
  1504 			jit->write_ubyte(ia32_sib(NOSCALE, REG_NOIDX, REG_ESP));
  1505 		}
  1506 
  1507 		inline void IA32_Cmp_Reg_Rm_Disp8(JitWriter *jit, jit_uint8_t reg1, jit_uint8_t reg2, jit_int8_t disp8)
  1508 		{
  1509 			jit->write_ubyte(IA32_CMP_REG_RM);
  1510 			jit->write_ubyte(ia32_modrm(MOD_DISP8, reg1, reg2));
  1511 			jit->write_byte(disp8);
  1512 		}
  1513 
  1514 		inline void IA32_Cmp_Rm_Imm8(JitWriter *jit, jit_uint8_t mode, jit_uint8_t rm, jit_int8_t imm8)
  1515 		{
  1516 			jit->write_ubyte(IA32_CMP_RM_IMM8);
  1517 			jit->write_ubyte(ia32_modrm(mode, 7, rm));
  1518 			jit->write_byte(imm8);
  1519 		}
  1520 
  1521 		inline void IA32_Cmp_Rm_Imm32(JitWriter *jit, jit_uint8_t mode, jit_uint8_t rm, jit_int32_t imm32)
  1522 		{
  1523 			jit->write_ubyte(IA32_CMP_RM_IMM32);
  1524 			jit->write_ubyte(ia32_modrm(mode, 7, rm));
  1525 			jit->write_int32(imm32);
  1526 		}
  1527 
  1528 		inline void IA32_Cmp_Rm_Imm32_Disp8(JitWriter *jit, jit_uint8_t reg, jit_int8_t disp8, jit_int32_t imm32)
  1529 		{
  1530 			jit->write_ubyte(IA32_CMP_RM_IMM32);
  1531 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 7, reg));
  1532 			jit->write_byte(disp8);
  1533 			jit->write_int32(imm32);
  1534 		}
  1535 
  1536 		inline void IA32_Cmp_Rm_Disp8_Imm8(JitWriter *jit, jit_uint8_t reg, jit_int8_t disp, jit_int8_t imm8)
  1537 		{
  1538 			jit->write_ubyte(IA32_CMP_RM_IMM8);
  1539 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 7, reg));
  1540 			jit->write_byte(disp);
  1541 			jit->write_byte(imm8);
  1542 		}
  1543 
  1544 		inline void IA32_Cmp_Al_Imm8(JitWriter *jit, jit_int8_t value)
  1545 		{
  1546 			jit->write_ubyte(IA32_CMP_AL_IMM32);
  1547 			jit->write_byte(value);
  1548 		}
  1549 
  1550 		inline void IA32_Cmp_Eax_Imm32(JitWriter *jit, jit_int32_t value)
  1551 		{
  1552 			jit->write_ubyte(IA32_CMP_EAX_IMM32);
  1553 			jit->write_int32(value);
  1554 		}
  1555 
  1556 		inline void IA32_SetCC_Rm8(JitWriter *jit, jit_uint8_t reg, jit_uint8_t cond)
  1557 		{
  1558 			jit->write_ubyte(IA32_SETCC_RM8_1);
  1559 			jit->write_ubyte(IA32_SETCC_RM8_2+cond);
  1560 			jit->write_ubyte(ia32_modrm(MOD_REG, 0, reg));
  1561 		}
  1562 
  1563 		inline void IA32_CmovCC_Rm(JitWriter *jit, jit_uint8_t src, jit_uint8_t cond)
  1564 		{
  1565 			jit->write_ubyte(IA32_CMOVCC_RM_1);
  1566 			jit->write_ubyte(IA32_CMOVCC_RM_2+cond);
  1567 			jit->write_ubyte(ia32_modrm(MOD_MEM_REG, 0, src));
  1568 		}
  1569 
  1570 		inline void IA32_CmovCC_Rm_Disp8(JitWriter *jit, jit_uint8_t src, jit_uint8_t cond, jit_int8_t disp)
  1571 		{
  1572 			jit->write_ubyte(IA32_CMOVCC_RM_1);
  1573 			jit->write_ubyte(IA32_CMOVCC_RM_2+cond);
  1574 			jit->write_ubyte(ia32_modrm(MOD_DISP8, 0, src));
  1575 			jit->write_byte(disp);
  1576 		}
  1577 
  1578 		inline void IA32_Cmpsb(JitWriter *jit)
  1579 		{
  1580 			jit->write_ubyte(IA32_CMPSB);
  1581 		}
  1582 
  1583 		inline void IA32_Rep(JitWriter *jit)
  1584 		{
  1585 			jit->write_ubyte(IA32_REP);
  1586 		}
  1587 
  1588 		inline void IA32_Movsd(JitWriter *jit)
  1589 		{
  1590 			jit->write_ubyte(IA32_MOVSD);
  1591 		}
  1592 
  1593 		inline void IA32_Movsb(JitWriter *jit)
  1594 		{
  1595 			jit->write_ubyte(IA32_MOVSB);
  1596 		}
  1597 
  1598 		inline void IA32_Stosd(JitWriter *jit)
  1599 		{
  1600 			jit->write_ubyte(IA32_STOSD);
  1601 		}
  1602 
  1603 		inline void IA32_Cld(JitWriter *jit)
  1604 		{
  1605 			jit->write_ubyte(IA32_CLD);
  1606 		}
  1607 
  1608 	}
  1609 }
  1610 
  1611 #endif //_INCLUDE_JIT_X86_MACROS_H