RandomWOW/src/jit_compiler_x86.hpp

132 lines
3.6 KiB
C++
Raw Normal View History

2018-12-18 21:00:58 +00:00
/*
Copyright (c) 2018 tevador
This file is part of RandomX.
RandomX is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
RandomX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with RandomX. If not, see<http://www.gnu.org/licenses/>.
*/
#pragma once
2019-04-20 14:53:06 +00:00
#include <cstdint>
2018-12-18 21:00:58 +00:00
#include <cstring>
#include <vector>
2019-04-20 14:53:06 +00:00
#include "common.hpp"
2018-12-18 21:00:58 +00:00
2019-04-20 09:08:01 +00:00
namespace randomx {
2018-12-18 21:00:58 +00:00
class Program;
class ProgramConfiguration;
2019-04-12 17:36:08 +00:00
class SuperscalarProgram;
2018-12-18 21:00:58 +00:00
class JitCompilerX86;
2019-04-20 14:53:06 +00:00
class Instruction;
2018-12-18 21:00:58 +00:00
2019-03-17 22:09:11 +00:00
typedef void(JitCompilerX86::*InstructionGeneratorX86)(Instruction&, int);
2018-12-18 21:00:58 +00:00
constexpr uint32_t CodeSize = 64 * 1024;
class JitCompilerX86 {
public:
JitCompilerX86();
~JitCompilerX86();
void generateProgram(Program&, ProgramConfiguration&);
void generateProgramLight(Program&, ProgramConfiguration&, uint32_t);
template<size_t N>
2019-04-20 09:08:01 +00:00
void generateSuperscalarHash(SuperscalarProgram (&programs)[N], std::vector<uint64_t> &);
void generateDatasetInitCode();
2019-04-28 16:17:29 +00:00
ProgramFunc* getProgramFunc() {
return (ProgramFunc*)code;
2018-12-18 21:00:58 +00:00
}
2019-04-28 16:17:29 +00:00
DatasetInitFunc* getDatasetInitFunc() {
return (DatasetInitFunc*)code;
}
2018-12-18 21:00:58 +00:00
uint8_t* getCode() {
return code;
}
size_t getCodeSize();
2018-12-18 21:00:58 +00:00
private:
static InstructionGeneratorX86 engine[256];
2019-03-17 22:09:11 +00:00
std::vector<int32_t> instructionOffsets;
RegisterUsage registerUsage[RegistersCount];
2018-12-18 21:00:58 +00:00
uint8_t* code;
int32_t codePos;
void generateProgramPrologue(Program&, ProgramConfiguration&);
2019-03-21 19:44:59 +00:00
void generateProgramEpilogue(Program&);
void genAddressReg(Instruction&, bool);
void genAddressRegDst(Instruction&, bool);
void genAddressImm(Instruction&);
void genSIB(int scale, int index, int base);
2019-03-17 22:09:11 +00:00
void generateCode(Instruction&, int);
2019-04-20 09:08:01 +00:00
void generateSuperscalarCode(Instruction &, std::vector<uint64_t> &);
2018-12-18 21:00:58 +00:00
void emitByte(uint8_t val) {
code[codePos] = val;
codePos++;
}
void emit32(uint32_t val) {
2019-05-04 17:40:25 +00:00
memcpy(code + codePos, &val, sizeof val);
codePos += sizeof val;
}
void emit64(uint64_t val) {
2019-05-04 17:40:25 +00:00
memcpy(code + codePos, &val, sizeof val);
codePos += sizeof val;
}
template<size_t N>
void emit(const uint8_t (&src)[N]) {
emit(src, N);
}
void emit(const uint8_t* src, size_t count) {
memcpy(code + codePos, src, count);
codePos += count;
2018-12-18 21:00:58 +00:00
}
2019-04-28 14:42:45 +00:00
void h_IADD_RS(Instruction&, int);
void h_IADD_M(Instruction&, int);
void h_ISUB_R(Instruction&, int);
void h_ISUB_M(Instruction&, int);
void h_IMUL_R(Instruction&, int);
void h_IMUL_M(Instruction&, int);
void h_IMULH_R(Instruction&, int);
void h_IMULH_M(Instruction&, int);
void h_ISMULH_R(Instruction&, int);
void h_ISMULH_M(Instruction&, int);
void h_IMUL_RCP(Instruction&, int);
void h_INEG_R(Instruction&, int);
void h_IXOR_R(Instruction&, int);
void h_IXOR_M(Instruction&, int);
void h_IROR_R(Instruction&, int);
void h_IROL_R(Instruction&, int);
void h_ISWAP_R(Instruction&, int);
void h_FSWAP_R(Instruction&, int);
void h_FADD_R(Instruction&, int);
void h_FADD_M(Instruction&, int);
void h_FSUB_R(Instruction&, int);
void h_FSUB_M(Instruction&, int);
void h_FSCAL_R(Instruction&, int);
void h_FMUL_R(Instruction&, int);
void h_FDIV_M(Instruction&, int);
void h_FSQRT_R(Instruction&, int);
void h_CBRANCH(Instruction&, int);
2019-04-28 14:42:45 +00:00
void h_CFROUND(Instruction&, int);
void h_ISTORE(Instruction&, int);
void h_NOP(Instruction&, int);
2018-12-18 21:00:58 +00:00
};
}