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