randomx

var ADD_EBX_I = []byte{0x81, 0xc3}

var ADD_RAX_RCX = []byte{0x48, 0x01, 0xC8}

var ADD_RDX_R = []byte{0x4c, 0x01}

var ADD_R_RAX = []byte{0x4C, 0x03}

var AND_EAX_I byte = 0x25

var AND_ECX_I = []byte{0x81, 0xe1}

var AND_OR_MOV_LDMXCSR = []byte{0x25, 0x00, 0x60, 0x00, 0x00, 0x0D, 0xC0, 0x9F, 0x00, 0x00, 0x50, 0x0F, 0xAE, 0x14, 0x24, 0x58}

var BranchesWithin32B = func() bool {
	a, b, c, d := asm.Cpuid(0)
	v := string(valAsString(b, d, c))

	if v == "GenuineIntel" {
		family, model, stepping := familyModel(a)

		if family == 6 {

			return ((model == 0x4E) && (stepping == 0x3)) ||
				((model == 0x55) && ((stepping == 0x4) || (stepping == 0x7))) ||
				((model == 0x5E) && (stepping == 0x3)) ||
				((model == 0x8E) && (stepping >= 0x9) && (stepping <= 0xC)) ||
				((model == 0x9E) && (stepping >= 0x9) && (stepping <= 0xD)) ||
				((model == 0xA6) && (stepping == 0x0)) ||
				((model == 0xAE) && (stepping == 0xA))
		}
	}
	return false
}()

var CALL = 0xe8

var CodeSize = uint32(RandomXCodeSize + SuperscalarSize)

var ErrLargePagesNotSupported = errors.New("large pages not supported")

var IADD_C7 = Instruction{Opcode: S_IADD_C7, UOP: M_Add_ri, SrcOP: -1}

var IADD_C8 = Instruction{Opcode: S_IADD_C8, UOP: M_Add_ri, SrcOP: -1}

var IADD_C9 = Instruction{Opcode: S_IADD_C9, UOP: M_Add_ri, SrcOP: -1}

var IADD_RS = Instruction{Opcode: S_IADD_RS, UOP: M_Lea_SIB, SrcOP: 0}

var IMULH_R = Instruction{Opcode: S_IMULH_R, UOP_Array: []MacroOP{M_Mov_rr, M_Mul_r, M_Mov_rr}, ResultOP: 1, DstOP: 0, SrcOP: 1}

var IMUL_R = Instruction{Opcode: S_IMUL_R, UOP: M_Imul_rr, SrcOP: 0}

var IMUL_RCP = Instruction{Opcode: S_IMUL_RCP, UOP_Array: []MacroOP{M_Mov_ri64, M_Imul_r_dependent}, ResultOP: 1, DstOP: 1, SrcOP: -1}

var IROR_C = Instruction{Opcode: S_IROR_C, UOP: M_Ror_ri, SrcOP: -1}

var ISMULH_R = Instruction{Opcode: S_ISMULH_R, UOP_Array: []MacroOP{M_Mov_rr, M_Imul_r, M_Mov_rr}, ResultOP: 1, DstOP: 0, SrcOP: 1}

var ISUB_R = Instruction{Opcode: S_ISUB_R, UOP: M_Sub_rr, SrcOP: 0}

var IXOR_C7 = Instruction{Opcode: S_IXOR_C7, UOP: M_Xor_ri, SrcOP: -1}

var IXOR_C8 = Instruction{Opcode: S_IXOR_C8, UOP: M_Xor_ri, SrcOP: -1}

var IXOR_C9 = Instruction{Opcode: S_IXOR_C9, UOP: M_Xor_ri, SrcOP: -1}

var IXOR_R = Instruction{Opcode: S_IXOR_R, UOP: M_Xor_rr, SrcOP: 0}

var JMP byte = 0xe9

var JMP_ALIGN_PREFIX = [14][]byte{
	{},
	{0x2E},
	{0x2E, 0x2E},
	{0x2E, 0x2E, 0x2E},
	{0x2E, 0x2E, 0x2E, 0x2E},
	{0x2E, 0x2E, 0x2E, 0x2E, 0x2E},
	{0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E},
	{0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E},
	{0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E},
	{0x90, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E},
	{0x66, 0x90, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E},
	{0x66, 0x66, 0x90, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E},
	{0x0F, 0x1F, 0x40, 0x00, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E},
	{0x0F, 0x1F, 0x44, 0x00, 0x00, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E},
}

var JNZ = []byte{0x0f, 0x85}

var JNZ_SHORT byte = 0x75

var JZ = []byte{0x0f, 0x84}

var JZ_SHORT byte = 0x74

var LEA_32 = []byte{0x41, 0x8d}

var MOVAPD = []byte{0x66, 0x0f, 0x29}

var MOVNTI = []byte{0x4c, 0x0f, 0xc3}

var MOV_EAX_I byte = 0xb8

var MOV_RAX_I = []byte{0x48, 0xb8}

var MOV_RCX_I = []byte{0x48, 0xb9}

var MOV_RCX_RAX_SAR_RCX_63 = []byte{0x48, 0x89, 0xc1, 0x48, 0xc1, 0xf9, 0x3f}

var MUL_RCX = []byte{0x48, 0xf7, 0xe1}

var M_Add_ri = MacroOP{"add r,i", 7, 1, P015, Null, false}

var M_Add_rr = MacroOP{"add r,r", 3, 1, P015, Null, false}

var M_Imul_r = MacroOP{"imul r", 3, 4, P1, P5, false}

var M_Imul_r_dependent = MacroOP{"imul r", 3, 3, P1, Null, true} // this is the dependent version where current instruction depends on previous instruction

var M_Imul_rr = MacroOP{"imul r,r", 4, 3, P1, Null, false}

var M_Lea_SIB = MacroOP{"lea r,r+r*s", 4, 1, P01, Null, false}

var M_Mov_ri64 = MacroOP{"mov rax,i64", 10, 1, P015, Null, false}

var M_Mov_rr = MacroOP{"mov r,r", 3, 0, Null, Null, false}

var M_Mul_r = MacroOP{"mul r", 3, 4, P1, P5, false}

var M_Ror_ri = MacroOP{"ror r,i", 4, 1, P05, Null, false}

var M_Sub_rr = MacroOP{"sub r,r", 3, 1, P015, Null, false}

var M_Xor_ri = MacroOP{"xor r,i", 7, 1, P015, Null, false}

var M_Xor_rr = MacroOP{"xor r,r", 3, 1, P015, Null, false}

var NEG_RAX = []byte{0x48, 0xF7, 0xD8}

var NOP1 = []byte{0x90}

var NOP2 = []byte{0x66, 0x90}

var NOP3 = []byte{0x66, 0x66, 0x90}

var NOP4 = []byte{0x0F, 0x1F, 0x40, 0x00}

var NOP5 = []byte{0x0F, 0x1F, 0x44, 0x00, 0x00}

var NOP6 = []byte{0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00}

var NOP7 = []byte{0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00}

var NOP8 = []byte{0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00}

var NOPX = [][]byte{NOP1, NOP2, NOP3, NOP4, NOP5, NOP6, NOP7, NOP8}

var PADD_OPCODES = []byte{0xfc, 0xfd, 0xfe, 0xd4}

var RAX_ADD_SBB_1 = []byte{0x48, 0x83, 0xC0, 0x01, 0x48, 0x83, 0xD8, 0x00}

var RET byte = 0xc3

var REX_81 = []byte{0x49, 0x81}

var REX_ADDPD = []byte{0x66, 0x41, 0x0f, 0x58}

var REX_ADD_I = []byte{0x49, 0x81}

var REX_ADD_RM = []byte{0x4c, 0x03}

var REX_ADD_RR = []byte{0x4d, 0x03}

var REX_ANDPS_XMM12 = []byte{0x45, 0x0F, 0x54, 0xE5, 0x45, 0x0F, 0x56, 0xE6}

var REX_CMP_M32I = []byte{0x81, 0x3c, 0x06}

var REX_CMP_R32I = []byte{0x41, 0x81}

var REX_CVTDQ2PD_XMM12 = []byte{0xf3, 0x44, 0x0f, 0xe6, 0x24, 0x06}

var REX_DIVPD = []byte{0x66, 0x41, 0x0f, 0x5e}

var REX_IMUL_MEM = []byte{0x48, 0xf7, 0x2c, 0x0e}

var REX_IMUL_RM = []byte{0x4c, 0x0f, 0xaf}

var REX_IMUL_RR = []byte{0x4d, 0x0f, 0xaf}

var REX_IMUL_RRI = []byte{0x4d, 0x69}

var REX_LEA = []byte{0x4f, 0x8d}

var REX_MAXPD = []byte{0x66, 0x41, 0x0f, 0x5f}

var REX_MOV_MR = []byte{0x4c, 0x89}

var REX_MOV_R64R = []byte{0x4c, 0x8b}

var REX_MOV_RR = []byte{0x41, 0x8b}

var REX_MOV_RR64 = []byte{0x49, 0x8b}

var REX_MULPD = []byte{0x66, 0x41, 0x0f, 0x59}

var REX_MUL_M = []byte{0x48, 0xf7}

var REX_MUL_MEM = []byte{0x48, 0xf7, 0x24, 0x0e}

var REX_MUL_R = []byte{0x49, 0xf7}

var REX_NEG = []byte{0x49, 0xF7}

var REX_PADD = []byte{0x66, 0x44, 0x0f}

var REX_ROT_CL = []byte{0x49, 0xd3}

var REX_ROT_I8 = []byte{0x49, 0xc1}

var REX_SH = []byte{0x49, 0xc1}

var REX_SHR_RAX = []byte{0x48, 0xc1, 0xe8}

var REX_SHR_RDX = []byte{0x48, 0xc1, 0xea}

var REX_SUBPD = []byte{0x66, 0x41, 0x0f, 0x5c}

var REX_SUB_RM = []byte{0x4c, 0x2b}

var REX_SUB_RR = []byte{0x4d, 0x2b}

var REX_TEST = []byte{0x49, 0xF7}

var REX_XCHG = []byte{0x4d, 0x87}

var REX_XORPS = []byte{0x41, 0x0f, 0x57}

var REX_XOR_EAX = []byte{0x41, 0x33}

var REX_XOR_RAX_R64 = []byte{0x49, 0x33}

var REX_XOR_RI = []byte{0x49, 0x81}

var REX_XOR_RM = []byte{0x4c, 0x33}

var REX_XOR_RR = []byte{0x4D, 0x33}

var ROL_RAX = []byte{0x48, 0xc1, 0xc0}

var RandomXCodeSize = alignSize[uint64](ReserveCodeSize+MaxRandomXInstrCodeSize*RANDOMX_PROGRAM_SIZE, CodeAlign)

var SAR_RAX_I8 = []byte{0x48, 0xC1, 0xF8}

var SAR_RDX_I8 = []byte{0x48, 0xC1, 0xFA}

var SETS_AL_ADD_RDX_RAX = []byte{0x0F, 0x98, 0xC0, 0x48, 0x03, 0xD0}

var SHUFPD = []byte{0x66, 0x0f, 0xc6}

var SQRTPD = []byte{0x66, 0x0f, 0x51}

var SUB_EBX = []byte{0x83, 0xEB, 0x01}

var SUB_RDX_R = []byte{0x4c, 0x29}

var SuperscalarSize = alignSize[uint64](ReserveCodeSize+(SuperscalarProgramHeader+MaxSuperscalarInstrSize*SuperscalarMaxSize)*RANDOMX_CACHE_ACCESSES, CodeAlign)

var TEST_EAX_60SL13 = []byte{0xa9, 0x00, 0x80, 0x07, 0x00}

var TEST_RDX_RDX = []byte{0x48, 0x85, 0xD2}

var XOR_EAX_EAX = []byte{0x33, 0xC0}

var XOR_ECX_ECX = []byte{0x33, 0xC9}