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