core/sourcehook/sourcehook_hookmangen_x86.h
author Scott Ehlert <ds@alliedmods.net>
Thu Dec 10 00:59:50 2009 -0600 (2009-12-10)
changeset 689 4065ba5e9155
parent 539 db914129ae01
child 733 2365240861a2
permissions -rw-r--r--
Rewrote user message caching code to always use IServerGameDLL::GetUserMessageInfo (bug 4117, r=dvander).

Games where the above function can crash are handled by detouring tier0's Error() function and jumping back to our own code. So in theory this should work on all games now.
     1 /* ======== SourceHook ========
     2 * vim: set ts=4 :
     3 * Copyright (C) 2004-2008 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