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