Add initial support of Nintendo Switch system calls

2024-06-23 14:43:16 -04:00 · 2018-03-11 10:45:20 +09:00 · 2018-03-11 10:45:20 +09:00 · c91314caca
parent 99d3ca8f30
commit c91314caca
7 changed files with 429 additions and 4 deletions
--- a/.gitignore
+++ b/.gitignore
@ -54,5 +54,7 @@ dkms.conf
 core
 nsemu
 *.log
+*.json
+*.diff
 *.md
 test/
--- a/ARMv8/Interpreter.cpp
+++ b/ARMv8/Interpreter.cpp
@ -8,7 +8,7 @@ int Interpreter::SingleStep() {
 	uint32_t inst = byte_swap32_uint (ARMv8::ReadInst (PC));
        X(GPR_ZERO) = 0; //Reset Zero register
 	//debug_print ("Run Code: 0x%lx: 0x%08lx\n", PC, inst);
-        ns_print ("Run Code: 0x%lx: 0x%08lx\n", PC, inst);
+        //ns_print ("Run Code: 0x%lx: 0x%08lx\n", PC, inst);
 	Disassembler::DisasA64 (inst, disas_cb);
 	PC += sizeof(uint32_t);
 	return 0;
@ -19,7 +19,7 @@ void Interpreter::Run() {
 	while (Cpu::GetState () == Cpu::State::Running) {
                char c;
                //scanf("%c", &c);
-                Cpu::DumpMachine ();                
+                Cpu::DumpMachine ();
 		SingleStep ();
                // if (PC == 0x2d54) {
 		//         SingleStep ();
@ -608,4 +608,8 @@ void IntprCallback::SetPCReg(unsigned int rt_idx) {
 void IntprCallback::SVC(unsigned int svc_num) {
        //debug_print ("SVC: %u\n", svc_num);
        ns_print ("SVC: %u\n", svc_num);
+        if (SVC::svc_handlers[svc_num])
+                SVC::svc_handlers[svc_num]();
+        else
+                ns_print ("Invalid svc number: %u\n", svc_num);
 }
--- a/Cpu.cpp
+++ b/Cpu.cpp
@ -7,6 +7,7 @@ FILE *TraceOut;

 void Init() {
 	ARMv8::Init ();
+        SVC::Init ();
 }

 void Run() {
--- a/4
+++ b/4
@ -1,7 +1,7 @@
 CXX				:= g++
 SRC_FILES := $(wildcard *.cpp ARMv8/*.cpp)
 OBJ_FILES := $(SRC_FILES:.cpp=.o)
-CXX_FLAGS	:= -std=c++11 -Iinclude
+CXX_FLAGS	:= -std=gnu++1z -Iinclude
 LD_FLAGS	:= -llz4 -lpthread
 MAKE := make

@ -15,6 +15,6 @@ testall:
 distclean:
 	$(MAKE) clean -C test/
 	$(MAKE)	clean
-clean:	
+clean:
 	rm -f *.o */*.o
 	rm -f nsemu
--- a/Svc.cpp
+++ b/Svc.cpp
@ -0,0 +1,347 @@
+/* nsemu - LGPL - Copyright 2017 rkx1209<rkx1209dev@gmail.com> */
+#include "Nsemu.hpp"
+
+#define RegisterSvc(num, func, ...) do { \
+	RegisterSvcHandler((num), [&] { \
+		(func)(__VA_ARGS__); \
+	}); \
+} while(0)
+
+#define RegisterSvcRetX0(num, func, ...) do { \
+	RegisterSvcHandler((num), [&] { \
+		auto x0 = (func)(__VA_ARGS__); \
+                X(0) = x0; \
+	}); \
+} while(0)
+
+#define RegisterSvcRetX1(num, func, ...) do { \
+	RegisterSvcHandler((num), [&] { \
+		auto x1 = (func)(__VA_ARGS__); \
+                X(1) = x1; \
+	}); \
+} while(0)
+
+#define RegisterSvcRetX01(num, func, ...) do { \
+	RegisterSvcHandler((num), [&] { \
+		auto [x0, x1] = (func)(__VA_ARGS__); \
+                X(0) = x0; \
+                X(1) = x1; \
+	}); \
+} while(0)
+
+#define RegisterSvcRetX012(num, func, ...) do { \
+	RegisterSvcHandler((num), [&] { \
+		auto [x0, x1, x2] = (func)(__VA_ARGS__); \
+                X(0) = x0; \
+                X(1) = x1; \
+                X(2) = x2; \
+	}); \
+} while(0)
+
+
+namespace SVC {
+
+std::function<void()> svc_handlers[0x80];
+
+void RegisterSvcHandler (unsigned int num, std::function<void()> handler) {
+        svc_handlers[num] = handler;
+}
+
+void Init() {
+        RegisterSvcRetX01(0x01, SetHeapSize, X(1));
+        RegisterSvcRetX0(0x03, SetMemoryAttribute, X(0), X(1), X(2), X(3));
+        RegisterSvcRetX0(0x04, MirrorStack, X(0), X(1), X(2));
+        RegisterSvcRetX0(0x05, UnmapMemory, X(0), X(1), X(2));
+        RegisterSvcRetX01(0x06, QueryMemory, X(0), X(1), X(2));
+        RegisterSvc(0x07, ExitProcess, X(0));
+        RegisterSvcRetX01(0x08, CreateThread, X(1), X(2), X(3), X(4), X(5));
+        RegisterSvcRetX0(0x09, StartThread, (uint32_t) X(0));
+        RegisterSvc(0x0A, ExitThread);
+        RegisterSvcRetX0(0x0B, SleepThread, X(0));
+        RegisterSvcRetX01(0x0C, GetThreadPriority, (uint32_t) X(0));
+        RegisterSvcRetX0(0x0D, SetThreadPriority, (uint32_t) X(0), X(1));
+        RegisterSvcRetX012(0x0E, GetThreadCoreMask, X(0));
+        RegisterSvcRetX0(0x0F, SetThreadCoreMask, X(0));
+        RegisterSvcRetX0(0x10, GetCurrentProcessorNumber, X(0));
+        RegisterSvcRetX0(0x11, SignalEvent, (uint32_t) X(0));
+        RegisterSvcRetX0(0x12, ClearEvent, (uint32_t) X(0));
+        RegisterSvcRetX0(0x13, MapMemoryBlock, (uint32_t) X(0), X(1), X(2), X(3));
+        RegisterSvcRetX01(0x15, CreateTransferMemory, X(0), X(1), X(2));
+        RegisterSvcRetX0(0x16, CloseHandle, (uint32_t) X(0));
+        RegisterSvcRetX0(0x17, ResetSignal, (uint32_t) X(0));
+        RegisterSvcRetX01(0x18, WaitSynchronization, X(1), X(2), X(3));
+        RegisterSvcRetX0(0x19, CancelSynchronization, (uint32_t) X(0));
+        RegisterSvcRetX0(0x1A, LockMutex, (uint32_t) X(0), X(1), (uint32_t) X(2));
+        RegisterSvc(0x1B, UnlockMutex, X(0));
+        RegisterSvc(0x1C, WaitProcessWideKeyAtomic, X(0), X(1), (uint32_t) X(2), X(3));
+        RegisterSvcRetX0(0x1D, SignalProcessWideKey, X(0), X(1));
+        RegisterSvcRetX01(0x1F, ConnectToPort, X(1));
+        RegisterSvcRetX0(0x21, SendSyncRequest, (uint32_t) X(0));
+        RegisterSvcRetX0(0x22, SendSyncRequestEx, X(0), X(1), (uint32_t) X(2));
+        RegisterSvcRetX01(0x24, GetProcessID, (uint32_t) X(1));
+        RegisterSvcRetX01(0x25, GetThreadId);
+        RegisterSvcRetX0(0x26, Break, X(0), X(1), X(2));
+        RegisterSvcRetX0(0x27, OutputDebugString, X(0), X(1));
+        RegisterSvcRetX01(0x29, GetInfo, X(1), (uint32_t) X(2), X(3));
+        RegisterSvcRetX012(0x40, CreateSession, (uint32_t) X(0), (uint32_t) X(1), X(2));
+        RegisterSvcRetX01(0x41, AcceptSession, (uint32_t) X(1));
+        RegisterSvcRetX01(0x43, ReplyAndReceive, X(1), X(2), (uint32_t) X(3), X(4));
+        RegisterSvcRetX012(0x45, CreateEvent, (uint32_t) X(0), (uint32_t) X(1), X(2));
+        RegisterSvcRetX01(0x4E, ReadWriteRegister, X(1), X(2), X(3));
+        RegisterSvcRetX01(0x50, CreateMemoryBlock, X(1), X(2));
+        RegisterSvcRetX0(0x51, MapTransferMemory, (uint32_t) X(0), X(1), X(2), X(3));
+        RegisterSvcRetX0(0x52, UnmapTransferMemory, (uint32_t) X(0), X(1), X(2));
+        RegisterSvcRetX01(0x53, CreateInterruptEvent, X(1));
+        RegisterSvcRetX01(0x55, QueryIoMapping, X(1), X(2));
+        RegisterSvcRetX01(0x56, CreateDeviceAddressSpace, X(1), X(2));
+        RegisterSvcRetX01(0x57, AttachDeviceAddressSpace, (uint32_t) X(0), X(1), X(2));
+        RegisterSvcRetX01(0x59, MapDeviceAddressSpaceByForce, (uint32_t) X(0), (uint32_t) X(1), X(2), X(3), X(4), X(5));
+        RegisterSvcRetX0(0x5c, UnmapDeviceAddressSpace, X(0), (uint32_t) X(1), X(2), X(3));
+        RegisterSvcRetX0(0x74, MapProcessMemory, X(0), (uint32_t) X(1), X(2), X(3));
+        RegisterSvcRetX0(0x75, UnmapProcessMemory, X(0), (uint32_t) X(1), X(2), X(3));
+        RegisterSvcRetX0(0x77, MapProcessCodeMemory, (uint32_t) X(0), X(1), X(2), X(3));
+        RegisterSvcRetX0(0x78, UnmapProcessCodeMemory, (uint32_t) X(0), X(1), X(2), X(3));
+
+}
+std::tuple<uint64_t, uint64_t> SetHeapSize(uint64_t size) {
+	ns_print("SetHeapSize 0x%lx\n", size);
+	return make_tuple(0, -1);
+}
+
+uint64_t SetMemoryAttribute(uint64_t addr, uint64_t size, uint64_t state0, uint64_t state1) {
+	return 0;
+}
+
+uint64_t MirrorStack(uint64_t dest, uint64_t src, uint64_t size) {
+	return 0;
+}
+
+uint64_t UnmapMemory(uint64_t dest, uint64_t src, uint64_t size) {
+	return 0;
+}
+
+std::tuple<uint64_t, uint64_t> QueryMemory(uint64_t meminfo, uint64_t pageinfo, uint64_t addr) {
+	return make_tuple(0, 0);
+}
+
+// the nintendo svc probably doesn't take an exitCode,
+// but this makes it easier to return values from
+// libtransistor tests.
+void ExitProcess(uint64_t exitCode) {
+	ns_print("ExitProcess\n");
+	exit((int) exitCode);
+}
+
+std::tuple<uint64_t, uint64_t> CreateThread(uint64_t pc, uint64_t x0, uint64_t sp, uint64_t prio, uint64_t proc) {
+	return make_tuple(0, 0);
+}
+
+uint64_t StartThread(uint32_t handle) {
+	return 0;
+}
+
+void ExitThread() {
+}
+
+uint64_t SleepThread(uint64_t ns) {
+	return 0;
+}
+
+std::tuple<uint64_t, uint64_t> GetThreadPriority(uint32_t handle) {
+	return make_tuple(0, 0);
+}
+
+uint64_t SetThreadPriority(uint32_t handle, uint64_t priority) {
+	return 0;
+}
+
+std::tuple<uint64_t, uint64_t, uint64_t> GetThreadCoreMask(uint64_t tmp) {
+	ns_print("GetThreadCoreMask\n");
+	return make_tuple(0, 0xFF, 0xFF);
+}
+
+uint64_t SetThreadCoreMask(uint64_t tmp) {
+	ns_print("GetThreadCoreMask\n");
+	return 0;
+}
+
+uint64_t GetCurrentProcessorNumber(uint64_t tmp) {
+	ns_print("GetCurrentProcessorNumber\n");
+	return 0;
+}
+
+uint64_t SignalEvent(uint32_t handle) {
+	ns_print("SignalEvent 0x%x\n", handle);
+	return 0;
+}
+
+uint64_t ClearEvent(uint32_t handle) {
+	ns_print("ClearEvent 0x%x\n", handle);
+	return 0;
+}
+
+uint64_t MapMemoryBlock(uint32_t handle, uint64_t addr, uint64_t size, uint64_t perm) {
+	return 0;
+}
+
+std::tuple<uint64_t, uint64_t> CreateTransferMemory(uint64_t addr, uint64_t size, uint64_t perm) {
+    return make_tuple(0, NULL);
+}
+
+uint64_t CloseHandle(uint32_t handle) {
+	ns_print("CloseHandle 0x%x\n", handle);
+	return 0;
+}
+
+uint64_t ResetSignal(uint32_t handle) {
+	ns_print("ResetSignal 0x%x", handle);
+	return 0;
+}
+
+std::tuple<uint64_t, uint64_t> WaitSynchronization(uint64_t handles, uint64_t numHandles, uint64_t timeout) {
+	return make_tuple(0, 0);
+}
+
+uint64_t CancelSynchronization(uint32_t handle) {
+	ns_print("CancelSynchronization 0x%x\n", handle);
+	return 0;
+}
+
+uint64_t ensureMutex(uint64_t mutexAddr) {
+	return 0;
+}
+
+uint64_t LockMutex(uint32_t curthread, uint64_t mutexAddr, uint32_t reqthread) {
+	return 0;
+}
+
+void UnlockMutex(uint64_t mutexAddr) {
+}
+
+uint64_t ensureSemaphore(uint64_t semaAddr) {
+	return 0;
+}
+
+void WaitProcessWideKeyAtomic(uint64_t mutexAddr, uint64_t semaAddr, uint32_t threadHandle, uint64_t timeout) {
+}
+
+uint64_t SignalProcessWideKey(uint64_t semaAddr, uint64_t target) {
+	return 0;
+}
+
+std::tuple<uint64_t, uint32_t> ConnectToPort(uint64_t name) {
+	return make_tuple(0, 0);
+}
+
+uint64_t SendSyncRequest(uint32_t handle) {
+        return 0;
+}
+
+uint64_t SendSyncRequestEx(uint64_t buf, uint64_t size, uint32_t handle) {
+	ns_print("SendSyncRequestEx not implemented\n");
+	return 0xf601;
+}
+
+std::tuple<uint64_t, uint64_t> GetProcessID(uint32_t handle) {
+	ns_print("GetProcessID 0x%x", handle);
+	return make_tuple(0, 0);
+}
+
+std::tuple<uint64_t, uint64_t> GetThreadId() {
+	return make_tuple(0, 0);
+}
+
+uint64_t Break(uint64_t X0, uint64_t X1, uint64_t info) {
+	ns_print("Break\n");
+	exit(1);
+}
+
+uint64_t OutputDebugString(uint64_t ptr, uint64_t size) {
+	return 0;
+}
+
+std::tuple<uint64_t, uint64_t> GetInfo(uint64_t id1, uint32_t handle, uint64_t id2) {
+        return make_tuple(0, 0);
+}
+
+std::tuple<uint64_t, uint64_t, uint64_t> CreateSession(uint32_t clientOut, uint32_t serverOut, uint64_t unk) {
+	return make_tuple(0, 0, 0);
+}
+
+std::tuple<uint64_t, uint64_t> AcceptSession(uint32_t hnd) {
+	return make_tuple(0, 0);
+}
+
+std::tuple<uint64_t, uint64_t> ReplyAndReceive(uint64_t handles, uint64_t numHandles, uint32_t replySession, uint64_t timeout) {
+	return make_tuple(0, 0);
+}
+
+std::tuple<uint64_t, uint64_t, uint64_t> CreateEvent(uint32_t clientOut, uint32_t serverOut, uint64_t unk) {
+	ns_print("CreateEvent\n");
+	return make_tuple(0, 0, 0);
+}
+
+std::tuple<uint64_t, uint64_t> ReadWriteRegister(uint64_t reg, uint64_t rwm, uint64_t val) {
+	ns_print("ReadWriteRegister\n");
+	return make_tuple(0, 0);
+}
+
+std::tuple<uint64_t, uint64_t> CreateMemoryBlock(uint64_t size, uint64_t perm) {
+	return make_tuple(0, 0);
+}
+
+uint64_t MapTransferMemory(uint32_t handle, uint64_t addr, uint64_t size, uint64_t perm) {
+	return 0;
+}
+
+uint64_t UnmapTransferMemory(uint32_t handle, uint64_t addr, uint64_t size) {
+	return 0;
+}
+
+std::tuple<uint64_t, uint64_t> CreateInterruptEvent(uint64_t irq) {
+	ns_print("CreateInterruptEvent\n");
+	return make_tuple(0, 0);
+}
+
+std::tuple<uint64_t, uint64_t> QueryIoMapping(uint64_t physaddr, uint64_t size) {
+	return make_tuple(0x0, 0);
+}
+
+std::tuple<uint64_t, uint64_t> CreateDeviceAddressSpace(uint64_t base, uint64_t size) {
+	ns_print("CreateDeviceAddressSpace\n");
+	return make_tuple(0, 0);
+}
+
+std::tuple<uint64_t, uint64_t> AttachDeviceAddressSpace(uint32_t handle, uint64_t dev, uint64_t addr) {
+	ns_print("AttachDeviceAddressSpace\n");
+	return make_tuple(0, 0);
+}
+
+std::tuple<uint64_t, uint64_t> MapDeviceAddressSpaceByForce(uint32_t handle, uint32_t phandle, uint64_t paddr, uint64_t size, uint64_t maddr, uint64_t perm) {
+	ns_print("MapDeviceAddressSpaceByForce\n");
+	return make_tuple(0, 0);
+}
+
+uint64_t UnmapDeviceAddressSpace(uint64_t unk0, uint32_t phandle, uint64_t maddr, uint64_t size) {
+	ns_print("UnmapDeviceAddressSpace\n");
+	return 0;
+}
+
+uint64_t MapProcessMemory(uint64_t dstaddr, uint32_t handle, uint64_t srcaddr, uint64_t size) {
+	return 0;
+}
+
+uint64_t UnmapProcessMemory(uint64_t dstaddr, uint32_t handle, uint64_t srcaddr, uint64_t size) {
+	return 0;
+}
+
+uint64_t MapProcessCodeMemory(uint32_t handle, uint64_t dstaddr, uint64_t srcaddr, uint64_t size) {
+	return 0;
+}
+
+uint64_t UnmapProcessCodeMemory(uint32_t handle, uint64_t dstaddr, uint64_t srcaddr, uint64_t size) {
+	return 0;
+}
+
+
+};
--- a/include/Nsemu.hpp
+++ b/include/Nsemu.hpp
@ -7,9 +7,11 @@
 #include <cstdlib>
 #include <cstring>
 #include <fstream>
+#include <functional>
 #include <iostream>
 #include <string>
 #include <map>
+#include <memory>
 #include <vector>

 using namespace std;
@ -18,6 +20,7 @@ using namespace std;
 #include "Util.hpp"
 #include "NintendoObject.hpp"
 #include "Cpu.hpp"
+#include "Svc.hpp"
 #include "ARMv8/ARMv8.hpp"
 #include "ARMv8/Disassembler.hpp"
 #include "ARMv8/Interpreter.hpp"
--- a/include/Svc.hpp
+++ b/include/Svc.hpp
@ -0,0 +1,68 @@
+#ifndef _SVC_HPP
+#define _SVC_HPP
+
+namespace SVC {
+
+extern std::function<void()> svc_handlers[0x80];
+
+void Init();
+
+std::tuple<uint64_t, uint64_t> SetHeapSize(uint64_t size);
+uint64_t SetMemoryAttribute(uint64_t addr, uint64_t size, uint64_t state0, uint64_t state1);
+uint64_t MirrorStack(uint64_t dest, uint64_t src, uint64_t size);
+uint64_t UnmapMemory(uint64_t dest, uint64_t src, uint64_t size);
+std::tuple<uint64_t, uint64_t> QueryMemory(uint64_t meminfo, uint64_t pageinfo, uint64_t addr);
+void ExitProcess(uint64_t exitCode);
+std::tuple<uint64_t, uint64_t> CreateThread(uint64_t pc, uint64_t x0, uint64_t sp, uint64_t prio, uint64_t proc);
+uint64_t StartThread(uint32_t handle);
+void ExitThread();
+uint64_t SleepThread(uint64_t ns);
+std::tuple<uint64_t, uint64_t> GetThreadPriority(uint32_t handle);
+uint64_t SetThreadPriority(uint32_t handle, uint64_t priority);
+std::tuple<uint64_t, uint64_t, uint64_t> GetThreadCoreMask(uint64_t tmp);
+uint64_t SetThreadCoreMask(uint64_t tmp);
+uint64_t GetCurrentProcessorNumber(uint64_t tmp);
+uint64_t SignalEvent(uint32_t handle);
+uint64_t ClearEvent(uint32_t handle);
+uint64_t MapMemoryBlock(uint32_t handle, uint64_t addr, uint64_t size, uint64_t perm);
+std::tuple<uint64_t, uint64_t> CreateTransferMemory(uint64_t addr, uint64_t size, uint64_t perm);
+uint64_t CloseHandle(uint32_t handle);
+uint64_t ResetSignal(uint32_t handle);
+std::tuple<uint64_t, uint64_t> WaitSynchronization(uint64_t handles, uint64_t numHandles, uint64_t timeout);
+uint64_t CancelSynchronization(uint32_t handle);
+uint64_t ensureMutex(uint64_t mutexAddr);
+uint64_t LockMutex(uint32_t curthread, uint64_t mutexAddr, uint32_t reqthread);
+void UnlockMutex(uint64_t mutexAddr);
+uint64_t ensureSemaphore(uint64_t semaAddr);
+void WaitProcessWideKeyAtomic(uint64_t mutexAddr, uint64_t semaAddr, uint32_t threadHandle, uint64_t timeout);
+uint64_t SignalProcessWideKey(uint64_t semaAddr, uint64_t target);
+std::tuple<uint64_t, uint32_t> ConnectToPort(uint64_t name);
+uint64_t SendSyncRequest(uint32_t handle);
+uint64_t SendSyncRequestEx(uint64_t buf, uint64_t size, uint32_t handle);
+std::tuple<uint64_t, uint64_t> GetProcessID(uint32_t handle);
+std::tuple<uint64_t, uint64_t> GetThreadId();
+uint64_t Break(uint64_t X0, uint64_t X1, uint64_t info);
+uint64_t OutputDebugString(uint64_t ptr, uint64_t size);
+std::tuple<uint64_t, uint64_t> GetInfo(uint64_t id1, uint32_t handle, uint64_t id2);
+std::tuple<uint64_t, uint64_t, uint64_t> CreateSession(uint32_t clientOut, uint32_t serverOut, uint64_t unk);
+std::tuple<uint64_t, uint64_t> AcceptSession(uint32_t hnd);
+std::tuple<uint64_t, uint64_t> ReplyAndReceive(uint64_t handles, uint64_t numHandles, uint32_t replySession, uint64_t timeout);
+std::tuple<uint64_t, uint64_t, uint64_t> CreateEvent(uint32_t clientOut, uint32_t serverOut, uint64_t unk);
+std::tuple<uint64_t, uint64_t> ReadWriteRegister(uint64_t reg, uint64_t rwm, uint64_t val);
+std::tuple<uint64_t, uint64_t> CreateMemoryBlock(uint64_t size, uint64_t perm);
+uint64_t MapTransferMemory(uint32_t handle, uint64_t addr, uint64_t size, uint64_t perm);
+uint64_t UnmapTransferMemory(uint32_t handle, uint64_t addr, uint64_t size);
+std::tuple<uint64_t, uint64_t> CreateInterruptEvent(uint64_t irq);
+std::tuple<uint64_t, uint64_t> QueryIoMapping(uint64_t physaddr, uint64_t size);
+std::tuple<uint64_t, uint64_t> CreateDeviceAddressSpace(uint64_t base, uint64_t size);
+std::tuple<uint64_t, uint64_t> AttachDeviceAddressSpace(uint32_t handle, uint64_t dev, uint64_t addr);
+std::tuple<uint64_t, uint64_t> MapDeviceAddressSpaceByForce(uint32_t handle, uint32_t phandle, uint64_t paddr, uint64_t size, uint64_t maddr, uint64_t perm);
+uint64_t UnmapDeviceAddressSpace(uint64_t unk0, uint32_t phandle, uint64_t maddr, uint64_t size);
+uint64_t MapProcessMemory(uint64_t dstaddr, uint32_t handle, uint64_t srcaddr, uint64_t size);
+uint64_t UnmapProcessMemory(uint64_t dstaddr, uint32_t handle, uint64_t srcaddr, uint64_t size);
+uint64_t MapProcessCodeMemory(uint32_t handle, uint64_t dstaddr, uint64_t srcaddr, uint64_t size);
+uint64_t UnmapProcessCodeMemory(uint32_t handle, uint64_t dstaddr, uint64_t srcaddr, uint64_t size);
+
+};
+
+#endif