ppsspp/Common/Thunk.cpp
Henrik Rydgard b264657d56 Implement W^X-compatible path. Works on Windows and Android, hopefully iOS (untested).
Disabled block linking in this mode, can re-enable with some more work later.

To enable W^X on other platforms than iOS, simply change PlatformIsWXExclusive.
2016-08-28 14:52:08 +02:00

202 lines
5.6 KiB
C++

// Copyright (C) 2003 Dolphin Project.
// This program 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, version 2.0 or later versions.
// This program 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 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#include "MemoryUtil.h"
#include "ABI.h"
#include "Thunk.h"
#define THUNK_ARENA_SIZE 1024*1024*1
namespace
{
#ifndef _M_X64
static u8 GC_ALIGNED32(saved_fp_state[16 * 4 * 4]);
static u8 GC_ALIGNED32(saved_gpr_state[16 * 8]);
static u16 saved_mxcsr;
#endif
} // namespace
using namespace Gen;
void ThunkManager::Init()
{
#ifdef _M_X64
// Account for the return address and "home space" on Windows (which needs to be at the bottom.)
const int stackOffset = ThunkStackOffset();
int stackPosition;
#endif
AllocCodeSpace(THUNK_ARENA_SIZE);
BeginWrite();
save_regs = GetCodePtr();
#ifdef _M_X64
for (int i = 2; i < ABI_GetNumXMMRegs(); i++)
MOVAPS(MDisp(RSP, stackOffset + (i - 2) * 16), (X64Reg)(XMM0 + i));
stackPosition = (ABI_GetNumXMMRegs() - 2) * 2;
STMXCSR(MDisp(RSP, stackOffset + (stackPosition++ * 8)));
MOV(64, MDisp(RSP, stackOffset + (stackPosition++ * 8)), R(RCX));
MOV(64, MDisp(RSP, stackOffset + (stackPosition++ * 8)), R(RDX));
MOV(64, MDisp(RSP, stackOffset + (stackPosition++ * 8)), R(R8) );
MOV(64, MDisp(RSP, stackOffset + (stackPosition++ * 8)), R(R9) );
MOV(64, MDisp(RSP, stackOffset + (stackPosition++ * 8)), R(R10));
MOV(64, MDisp(RSP, stackOffset + (stackPosition++ * 8)), R(R11));
#ifndef _WIN32
MOV(64, MDisp(RSP, stackOffset + (stackPosition++ * 8)), R(RSI));
MOV(64, MDisp(RSP, stackOffset + (stackPosition++ * 8)), R(RDI));
#endif
MOV(64, MDisp(RSP, stackOffset + (stackPosition++ * 8)), R(RBX));
#else
for (int i = 2; i < ABI_GetNumXMMRegs(); i++)
MOVAPS(M(saved_fp_state + i * 16), (X64Reg)(XMM0 + i));
STMXCSR(M(&saved_mxcsr));
MOV(32, M(saved_gpr_state + 0 ), R(RCX));
MOV(32, M(saved_gpr_state + 4 ), R(RDX));
#endif
RET();
load_regs = GetCodePtr();
#ifdef _M_X64
for (int i = 2; i < ABI_GetNumXMMRegs(); i++)
MOVAPS((X64Reg)(XMM0 + i), MDisp(RSP, stackOffset + (i - 2) * 16));
stackPosition = (ABI_GetNumXMMRegs() - 2) * 2;
LDMXCSR(MDisp(RSP, stackOffset + (stackPosition++ * 8)));
MOV(64, R(RCX), MDisp(RSP, stackOffset + (stackPosition++ * 8)));
MOV(64, R(RDX), MDisp(RSP, stackOffset + (stackPosition++ * 8)));
MOV(64, R(R8) , MDisp(RSP, stackOffset + (stackPosition++ * 8)));
MOV(64, R(R9) , MDisp(RSP, stackOffset + (stackPosition++ * 8)));
MOV(64, R(R10), MDisp(RSP, stackOffset + (stackPosition++ * 8)));
MOV(64, R(R11), MDisp(RSP, stackOffset + (stackPosition++ * 8)));
#ifndef _WIN32
MOV(64, R(RSI), MDisp(RSP, stackOffset + (stackPosition++ * 8)));
MOV(64, R(RDI), MDisp(RSP, stackOffset + (stackPosition++ * 8)));
#endif
MOV(64, R(RBX), MDisp(RSP, stackOffset + (stackPosition++ * 8)));
#else
LDMXCSR(M(&saved_mxcsr));
for (int i = 2; i < ABI_GetNumXMMRegs(); i++)
MOVAPS((X64Reg)(XMM0 + i), M(saved_fp_state + i * 16));
MOV(32, R(RCX), M(saved_gpr_state + 0 ));
MOV(32, R(RDX), M(saved_gpr_state + 4 ));
#endif
RET();
EndWrite();
}
void ThunkManager::Reset()
{
thunks.clear();
ResetCodePtr();
}
void ThunkManager::Shutdown()
{
Reset();
FreeCodeSpace();
}
int ThunkManager::ThunkBytesNeeded()
{
int space = (ABI_GetNumXMMRegs() - 2) * 16;
#ifdef _M_X64
// MXCSR
space += 8;
space += 7 * 8;
#ifndef _WIN32
space += 2 * 8;
#endif
#else
// MXCSR
space += 4;
space += 2 * 4;
#endif
// Round up to the nearest 16 just in case.
return (space + 15) & ~15;
}
int ThunkManager::ThunkStackOffset()
{
#ifdef _M_X64
#ifdef _WIN32
return 0x28;
#else
return 0x8;
#endif
#else
return 0;
#endif
}
const void *ThunkManager::ProtectFunction(const void *function, int num_params) {
std::map<const void *, const u8 *>::iterator iter;
iter = thunks.find(function);
if (iter != thunks.end())
return (const void *)iter->second;
if (!region)
PanicAlert("Trying to protect functions before the emu is started. Bad bad bad.");
BeginWrite();
const u8 *call_point = GetCodePtr();
Enter(this, true);
#ifdef _M_X64
ABI_CallFunction(function);
#else
// Since parameters are in the previous stack frame, not in registers, this takes some
// trickery : we simply re-push the parameters. might not be optimal, but that doesn't really
// matter.
ABI_AlignStack(num_params * 4);
unsigned int alignedSize = ABI_GetAlignedFrameSize(num_params * 4);
for (int i = 0; i < num_params; i++) {
// ESP is changing, so we do not need i
PUSH(32, MDisp(ESP, alignedSize - 4));
}
CALL(function);
ABI_RestoreStack(num_params * 4);
#endif
Leave(this, true);
RET();
EndWrite();
thunks[function] = call_point;
return (const void *)call_point;
}
void ThunkManager::Enter(ThunkEmitter *emit, bool withinCall)
{
#ifdef _M_X64
// Make sure to align stack.
emit->SUB(64, R(ESP), Imm32(ThunkStackOffset() + ThunkBytesNeeded() + (withinCall ? 0 : 8)));
emit->ABI_CallFunction(save_regs);
#else
emit->CALL((const void *)save_regs);
#endif
}
void ThunkManager::Leave(ThunkEmitter *emit, bool withinCall)
{
#ifdef _M_X64
emit->ABI_CallFunction(load_regs);
emit->ADD(64, R(ESP), Imm32(ThunkStackOffset() + ThunkBytesNeeded() + (withinCall ? 0 : 8)));
#else
emit->CALL((void*)load_regs);
#endif
}