mirror of
https://github.com/FEX-Emu/FEX.git
synced 2026-10-07 01:00:17 +02:00
113 lines
3.4 KiB
C++
113 lines
3.4 KiB
C++
// SPDX-License-Identifier: MIT
|
|
/*
|
|
$info$
|
|
tags: glue|x86-guest-code
|
|
desc: Guest-side assembly helpers used by the backends
|
|
$end_info$
|
|
*/
|
|
|
|
#include "Interface/Core/X86HelperGen.h"
|
|
#include "FEXCore/Utils/AllocatorHooks.h"
|
|
|
|
#include <FEXCore/Config/Config.h>
|
|
#include <FEXCore/Utils/Allocator.h>
|
|
#include <FEXHeaderUtils/Syscalls.h>
|
|
|
|
#include <cstdint>
|
|
#include <cstring>
|
|
|
|
namespace FEXCore {
|
|
constexpr size_t CODE_SIZE = 0x1000;
|
|
|
|
X86GeneratedCode::X86GeneratedCode() {
|
|
#ifdef _WIN32
|
|
// No need to allocate anything in this config.
|
|
#else
|
|
|
|
// Allocate a page for our emulated guest
|
|
CodePtr = AllocateGuestCodeSpace(CODE_SIZE);
|
|
|
|
constexpr std::array<uint8_t, 2> SignalReturnCode = {
|
|
0x0F, 0x37, // CALLBACKRET FEX Instruction
|
|
};
|
|
|
|
// Signal return handlers need to be bit-exact to what the Linux kernel provides in VDSO.
|
|
// GDB and unwinding libraries key off of these instructions to understand if the stack frame is a signal frame or not.
|
|
// This two code sections match exactly what libSegFault expects.
|
|
//
|
|
// Typically this handlers are provided by the 32-bit VDSO thunk library, but that isn't available in all cases.
|
|
// Falling back to this generated code segment still allows a backtrace to work, just might not show
|
|
// the symbol as VDSO since there is no ELF to parse.
|
|
constexpr std::array<uint8_t, 9> sigreturn_32_code = {
|
|
0x58, // pop eax
|
|
0xb8, 0x77, 0x00, 0x00, 0x00, // mov eax, 0x77
|
|
0xcd, 0x80, // int 0x80
|
|
0x90, // nop
|
|
};
|
|
|
|
constexpr std::array<uint8_t, 7> rt_sigreturn_32_code = {
|
|
0xb8, 0xad, 0x00, 0x00, 0x00, // mov eax, 0xad
|
|
0xcd, 0x80, // int 0x80
|
|
};
|
|
|
|
CallbackReturn = reinterpret_cast<uint64_t>(CodePtr);
|
|
sigreturn_32 = CallbackReturn + SignalReturnCode.size();
|
|
rt_sigreturn_32 = sigreturn_32 + sigreturn_32_code.size();
|
|
|
|
memcpy(reinterpret_cast<void*>(CallbackReturn), &SignalReturnCode.at(0), SignalReturnCode.size());
|
|
memcpy(reinterpret_cast<void*>(sigreturn_32), &sigreturn_32_code.at(0), sigreturn_32_code.size());
|
|
memcpy(reinterpret_cast<void*>(rt_sigreturn_32), &rt_sigreturn_32_code.at(0), rt_sigreturn_32_code.size());
|
|
|
|
mprotect(CodePtr, CODE_SIZE, PROT_READ);
|
|
#endif
|
|
}
|
|
|
|
X86GeneratedCode::~X86GeneratedCode() {
|
|
#ifndef _WIN32
|
|
FEXCore::Allocator::VirtualFree(CodePtr, CODE_SIZE);
|
|
#endif
|
|
}
|
|
|
|
void* X86GeneratedCode::AllocateGuestCodeSpace(size_t Size) {
|
|
#ifndef _WIN32
|
|
FEX_CONFIG_OPT(Is64BitMode, IS64BIT_MODE);
|
|
|
|
if (Is64BitMode()) {
|
|
// 64bit mode can have its sigret handler anywhere
|
|
return FEXCore::Allocator::VirtualAlloc(Size);
|
|
}
|
|
|
|
// First 64bit page
|
|
constexpr uintptr_t LOCATION_MAX = 0x1'0000'0000;
|
|
|
|
// 32bit mode
|
|
// We need to have the sigret handler in the lower 32bits of memory space
|
|
// Scan top down and try to allocate a location
|
|
for (size_t Location = 0xFFFF'E000; Location != 0x0; Location -= 0x1000) {
|
|
void *Ptr = ::mmap(reinterpret_cast<void*>(Location), Size, PROT_READ | PROT_WRITE, MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
|
|
|
if (Ptr != MAP_FAILED &&
|
|
reinterpret_cast<uintptr_t>(Ptr) >= LOCATION_MAX) {
|
|
// Failed to map in the lower 32bits
|
|
// Try again
|
|
// Can happen in the case that host kernel ignores MAP_FIXED_NOREPLACE
|
|
::munmap(Ptr, Size);
|
|
continue;
|
|
}
|
|
|
|
if (Ptr != MAP_FAILED) {
|
|
return Ptr;
|
|
}
|
|
}
|
|
|
|
// Can't do anything about this
|
|
// Here's hoping the application doesn't use signals
|
|
return MAP_FAILED;
|
|
#else
|
|
return nullptr;
|
|
#endif
|
|
}
|
|
|
|
}
|
|
|