diff --git a/FEXCore/Source/Interface/Core/ArchHelpers/Arm64Emitter.cpp b/FEXCore/Source/Interface/Core/ArchHelpers/Arm64Emitter.cpp
index 8990eb78a7..b63b18ff5b 100644
--- a/FEXCore/Source/Interface/Core/ArchHelpers/Arm64Emitter.cpp
+++ b/FEXCore/Source/Interface/Core/ArchHelpers/Arm64Emitter.cpp
@@ -354,8 +354,10 @@ Arm64Emitter::Arm64Emitter(FEXCore::Context::ContextImpl *ctx, void* EmissionPtr
   // Only setup the disassembler if enabled.
   // vixl's decoder is expensive to setup.
   if (Disassemble()) {
+    DisasmBuffer = static_cast<char*>(FEXCore::Allocator::malloc(DISASM_BUFFER_SIZE));
+    Disasm = fextl::make_unique<vixl::aarch64::Disassembler>(DisasmBuffer, DISASM_BUFFER_SIZE);
     DisasmDecoder = fextl::make_unique<vixl::aarch64::Decoder>();
-    DisasmDecoder->AppendVisitor(&Disasm);
+    DisasmDecoder->AppendVisitor(Disasm.get());
   }
 #endif
 
diff --git a/FEXCore/Source/Interface/Core/ArchHelpers/Arm64Emitter.h b/FEXCore/Source/Interface/Core/ArchHelpers/Arm64Emitter.h
index 70b9bd92e5..6448a024a8 100644
--- a/FEXCore/Source/Interface/Core/ArchHelpers/Arm64Emitter.h
+++ b/FEXCore/Source/Interface/Core/ArchHelpers/Arm64Emitter.h
@@ -63,6 +63,14 @@ class Arm64Emitter : public FEXCore::ARMEmitter::Emitter {
 protected:
   Arm64Emitter(FEXCore::Context::ContextImpl *ctx, void* EmissionPtr = nullptr, size_t size = 0);
 
+  virtual ~Arm64Emitter() {
+#ifdef VIXL_DISASSEMBLER
+    if (DisasmBuffer) {
+      FEXCore::Allocator::free(DisasmBuffer);
+    }
+#endif
+  }
+
   FEXCore::Context::ContextImpl *EmitterCTX;
   vixl::aarch64::CPU CPU;
 
@@ -233,7 +241,9 @@ class Arm64Emitter : public FEXCore::ARMEmitter::Emitter {
 #endif
 
 #ifdef VIXL_DISASSEMBLER
-  vixl::aarch64::Disassembler Disasm;
+  char *DisasmBuffer{};
+  constexpr static int DISASM_BUFFER_SIZE {256};
+  fextl::unique_ptr<vixl::aarch64::Disassembler> Disasm;
   fextl::unique_ptr<vixl::aarch64::Decoder> DisasmDecoder;
 
   FEX_CONFIG_OPT(Disassemble, DISASSEMBLE);
diff --git a/FEXCore/Source/Interface/Core/Dispatcher/Dispatcher.cpp b/FEXCore/Source/Interface/Core/Dispatcher/Dispatcher.cpp
index 0b7ed0468c..8e4c9b3c90 100644
--- a/FEXCore/Source/Interface/Core/Dispatcher/Dispatcher.cpp
+++ b/FEXCore/Source/Interface/Core/Dispatcher/Dispatcher.cpp
@@ -513,7 +513,7 @@ void Dispatcher::EmitDispatcher() {
     const auto DisasmEnd = GetCursorAddress<const vixl::aarch64::Instruction*>();
     for (auto PCToDecode = DisasmBegin; PCToDecode < DisasmEnd; PCToDecode += 4) {
       DisasmDecoder->Decode(PCToDecode);
-      auto Output = Disasm.GetOutput();
+      auto Output = Disasm->GetOutput();
       LogMan::Msg::IFmt("{}", Output);
     }
   }
diff --git a/FEXCore/Source/Interface/Core/Dispatcher/Dispatcher.h b/FEXCore/Source/Interface/Core/Dispatcher/Dispatcher.h
index b4b964a022..8284a4468d 100644
--- a/FEXCore/Source/Interface/Core/Dispatcher/Dispatcher.h
+++ b/FEXCore/Source/Interface/Core/Dispatcher/Dispatcher.h
@@ -39,7 +39,7 @@ class Dispatcher final : public Arm64Emitter {
   static fextl::unique_ptr<Dispatcher> Create(FEXCore::Context::ContextImpl *CTX);
 
   Dispatcher(FEXCore::Context::ContextImpl *ctx);
-  ~Dispatcher();
+  virtual ~Dispatcher();
 
   /**
    * @name Dispatch Helper functions
diff --git a/FEXCore/Source/Interface/Core/JIT/Arm64/JIT.cpp b/FEXCore/Source/Interface/Core/JIT/Arm64/JIT.cpp
index 390e9ab571..3d524276c5 100644
--- a/FEXCore/Source/Interface/Core/JIT/Arm64/JIT.cpp
+++ b/FEXCore/Source/Interface/Core/JIT/Arm64/JIT.cpp
@@ -876,7 +876,7 @@ CPUBackend::CompiledCode Arm64JITCore::CompileCode(uint64_t Entry,
     LogMan::Msg::IFmt("Disassemble Begin");
     for (auto PCToDecode = DisasmBegin; PCToDecode < DisasmEnd; PCToDecode += 4) {
       DisasmDecoder->Decode(PCToDecode);
-      auto Output = Disasm.GetOutput();
+      auto Output = Disasm->GetOutput();
       LogMan::Msg::IFmt("{}", Output);
     }
     LogMan::Msg::IFmt("Disassemble End");
diff --git a/Scripts/GenerateSyscallHandlers.py b/Scripts/GenerateSyscallHandlers.py
new file mode 100755
index 0000000000..515bfdd036
--- /dev/null
+++ b/Scripts/GenerateSyscallHandlers.py
@@ -0,0 +1,220 @@
+#!/usr/bin/python3
+from dataclasses import dataclass, field
+import json
+import struct
+import sys
+from json_config_parse import parse_json
+import logging
+logger = logging.getLogger()
+logger.setLevel(logging.WARNING)
+
+@dataclass
+class SyscallDefinition:
+    Name: str
+    CustomHandler: bool
+    HandlerType: str
+    ArgCount: int
+    Flags: str
+    MinimumKernel: str
+    SyscallRedirect: str
+
+    def __init__(self, Name, CustomHandler, HandlerType, ArgCount, Flags, MinimumKernel, SyscallRedirect):
+        self.Name = Name
+        self.CustomHandler = CustomHandler
+        self.HandlerType = HandlerType
+        self.ArgCount = ArgCount
+        self.Flags = Flags
+        self.MinimumKernel = MinimumKernel
+        self.SyscallRedirect = SyscallRedirect
+
+SyscallDefinitionsCommon = {}
+SyscallDefinitionsx64 = {}
+SyscallDefinitionsx32 = {}
+
+def ParseTable(json_object, table, name):
+    data = json_object[name]
+    for data_key, data_val in data.items():
+        name = data_key
+
+        argcount = 0
+        flags = ""
+        MinimumKernel = ""
+        SyscallRedirect = ""
+        CustomHandler = False
+
+        if "CustomHandler" in data_val:
+            CustomHandler = bool(data_val["CustomHandler"])
+
+        if "ArchSpecific" in data_val:
+            if bool(data_val["ArchSpecific"]):
+                continue
+
+        if not CustomHandler:
+            if not "ArgCount" in data_val:
+                logging.critical("Syscall {} doesn't have argument count".format(name))
+
+            if not "Flags" in data_val:
+                logging.critical("Syscall {} doesn't have flags".format(name))
+
+            argcount = data_val["ArgCount"]
+            flags = data_val["Flags"]
+
+        if "MinimumKernel" in data_val:
+            MinimumKernel = data_val["MinimumKernel"]
+
+            Splits = MinimumKernel.split(".")
+            if len(Splits) != 3:
+                logging.critical("Syscall {} has invalid kernel version as '{}'. Expecting format 'Major.Minor.Patch'".format(name, MinimumKernel))
+
+        if "SyscallRedirect" in data_val:
+            SyscallRedirect = data_val["SyscallRedirect"]
+
+        table[name] = SyscallDefinition(name, CustomHandler, "Common", argcount, flags, MinimumKernel, SyscallRedirect)
+
+def ParseJson(JsonText):
+    json_object = json.loads(JsonText)
+
+    if not "Common" in json_object:
+        logging.critical ("Need to have common syscalls")
+
+    if not "x64" in json_object:
+        logging.critical ("Need to have x64 syscalls")
+
+    if not "x32" in json_object:
+        logging.critical ("Need to have x32 syscalls")
+
+    ParseTable(json_object, SyscallDefinitionsCommon, "Common")
+    ParseTable(json_object, SyscallDefinitionsx64, "x64")
+    ParseTable(json_object, SyscallDefinitionsx32, "x32")
+
+def PrintHandlers(output_file, wrapper_name, table, impl_flags, impl, redirect_impl_flags, redirect_impl):
+    output_file.write("#ifdef {}\n".format(wrapper_name))
+    output_file.write("#undef {}\n".format(wrapper_name))
+    for data_key, data_val in table.items():
+        if data_val.CustomHandler:
+            continue
+
+        HasMinimumKernel = data_val.MinimumKernel != ""
+        HasSyscallRedirect = data_val.SyscallRedirect != ""
+
+        which_impl_flags = impl_flags
+        which_impl = impl
+
+        if HasSyscallRedirect:
+            which_impl_flags = redirect_impl_flags
+            which_impl = redirect_impl
+
+        if HasMinimumKernel:
+            Splits = data_val.MinimumKernel.split(".")
+            output_file.write ("if (Handler->IsHostKernelVersionAtLeast({}, {}, {})) {{\n".format(Splits[0], Splits[1], Splits[2]))
+
+        if HasSyscallRedirect:
+            output_file.write ("{}({}, {}, {},\n".format(which_impl_flags, data_key, data_val.SyscallRedirect, data_val.Flags))
+        else:
+            output_file.write ("{}({}, {},\n".format(which_impl_flags, data_key, data_val.Flags))
+        output_file.write ("  SyscallPassthrough{}<SYSCALL_DEF({})>);\n".format(data_val.ArgCount, data_key))
+
+        if HasMinimumKernel:
+            output_file.write ("}\n")
+            output_file.write ("else {\n")
+
+            output_file.write ("  {}({}, UnimplementedSyscallSafe);\n".format(which_impl, data_key))
+            output_file.write ("}\n")
+
+    output_file.write("#endif\n")
+
+def PrintPassthroughHandlers(output_file):
+    output_file.write("#ifdef PASSTHROUGH_HANDLERS\n")
+    output_file.write("#undef PASSTHROUGH_HANDLERS\n")
+
+    output_file.write("#ifdef _M_ARM_64\n")
+    for i in range(0, 8):
+        output_file.write("template<int syscall_num>\n");
+        output_file.write("uint64_t SyscallPassthrough{}(FEXCore::Core::CpuStateFrame *Frame".format(i))
+
+        for j in range(0, i):
+            output_file.write(", uint64_t arg{}".format(j + 1))
+
+        output_file.write(") {\n")
+        if i > 0:
+            for j in range(0, i):
+                output_file.write("  register uint64_t x{} asm (\"x{}\") = arg{};\n".format(j, j, j + 1))
+        else:
+            output_file.write("  register uint64_t x0 asm (\"x0\");\n")
+
+        output_file.write("  register int x8 asm (\"x8\") = syscall_num;\n");
+        output_file.write("  __asm volatile(R\"(\n")
+        output_file.write("    svc #0;\n")
+        output_file.write("  )\"\n")
+        output_file.write("  : \"=r\" (x0)\n")
+        output_file.write("  : \"r\" (x8)\n")
+        for j in range(0, i):
+            output_file.write("  , \"r\" (x{})\n".format(j))
+
+        output_file.write("  : \"memory\");\n")
+
+        output_file.write("  return x0;\n")
+        output_file.write("}\n\n")
+
+    output_file.write("#else\n")
+
+    for i in range(0, 8):
+        output_file.write("template<int syscall_num>\n")
+        output_file.write("uint64_t SyscallPassthrough{}(FEXCore::Core::CpuStateFrame *Frame".format(i))
+
+        for j in range(0, i):
+            output_file.write(", uint64_t arg{}".format(j + 1))
+
+        output_file.write(") {\n")
+
+        output_file.write("  uint64_t Result = ::syscall(syscall_num")
+        for j in range(0, i):
+            output_file.write(", arg{}".format(j + 1))
+
+        output_file.write(");\n")
+
+        output_file.write("  SYSCALL_ERRNO();\n")
+        output_file.write("}\n")
+    output_file.write("#endif\n")
+    output_file.write("#endif\n")
+
+def main():
+    if sys.version_info[0] < 3:
+        logging.critical ("Python 3 or a more recent version is required.")
+
+    if (len(sys.argv) < 3):
+        print ("usage: %s <Syscall description json> <output file>" % (sys.argv[0]))
+
+    JsonDescPath = sys.argv[1]
+    OutputFilePath = sys.argv[2]
+
+    JsonFile = open(JsonDescPath, "r")
+    JsonText = JsonFile.read()
+    JsonFile.close()
+
+    ParseJson(JsonText)
+
+    output_file = open(OutputFilePath, "w")
+    PrintPassthroughHandlers(output_file)
+
+    PrintHandlers(output_file,
+        "SYSCALL_COMMON_IMPL",
+        SyscallDefinitionsCommon,
+        "REGISTER_SYSCALL_IMPL_PASS_FLAGS", "REGISTER_SYSCALL_IMPL",
+        "<UNSUPPORTED>", "<UNSUPPORTED>")
+    PrintHandlers(output_file,
+        "SYSCALL_X64_IMPL",
+        SyscallDefinitionsx64,
+        "REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS", "REGISTER_SYSCALL_IMPL_X64",
+        "<UNSUPPORTED>", "<UNSUPPORTED>")
+    PrintHandlers(output_file,
+        "SYSCALL_X32_IMPL",
+        SyscallDefinitionsx32,
+        "REGISTER_SYSCALL_IMPL_X32_PASS_FLAGS", "REGISTER_SYSCALL_IMPL_X32",
+        "REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL_FLAGS", "REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL")
+
+    output_file.close()
+
+if __name__ == "__main__":
+# execute only if run as a script
+    sys.exit(main())
diff --git a/Source/Tools/LinuxEmulation/CMakeLists.txt b/Source/Tools/LinuxEmulation/CMakeLists.txt
index 71eeaedd8c..4f9056cc2e 100644
--- a/Source/Tools/LinuxEmulation/CMakeLists.txt
+++ b/Source/Tools/LinuxEmulation/CMakeLists.txt
@@ -32,41 +32,40 @@ set (SRCS
   LinuxSyscalls/x32/IoctlEmulation.cpp
   LinuxSyscalls/x64/EPoll.cpp
   LinuxSyscalls/x64/FD.cpp
-  LinuxSyscalls/x64/IO.cpp
-  LinuxSyscalls/x64/Ioctl.cpp
   LinuxSyscalls/x64/Info.cpp
   LinuxSyscalls/x64/Memory.cpp
-  LinuxSyscalls/x64/Msg.cpp
   LinuxSyscalls/x64/NotImplemented.cpp
   LinuxSyscalls/x64/Semaphore.cpp
-  LinuxSyscalls/x64/Sched.cpp
   LinuxSyscalls/x64/Signals.cpp
-  LinuxSyscalls/x64/Socket.cpp
   LinuxSyscalls/x64/Thread.cpp
   LinuxSyscalls/x64/Syscalls.cpp
   LinuxSyscalls/x64/Time.cpp
   LinuxSyscalls/Syscalls/EPoll.cpp
   LinuxSyscalls/Syscalls/FD.cpp
   LinuxSyscalls/Syscalls/FS.cpp
+  LinuxSyscalls/Syscalls/Generated.cpp
   LinuxSyscalls/Syscalls/Info.cpp
   LinuxSyscalls/Syscalls/IO.cpp
-  LinuxSyscalls/Syscalls/IOUring.cpp
-  LinuxSyscalls/Syscalls/Key.cpp
   LinuxSyscalls/Syscalls/Memory.cpp
-  LinuxSyscalls/Syscalls/Msg.cpp
-  LinuxSyscalls/Syscalls/Namespace.cpp
-  LinuxSyscalls/Syscalls/Sched.cpp
-  LinuxSyscalls/Syscalls/Semaphore.cpp
-  LinuxSyscalls/Syscalls/SHM.cpp
   LinuxSyscalls/Syscalls/Signals.cpp
-  LinuxSyscalls/Syscalls/Socket.cpp
   LinuxSyscalls/Syscalls/Thread.cpp
-  LinuxSyscalls/Syscalls/Time.cpp
   LinuxSyscalls/Syscalls/Timer.cpp
   LinuxSyscalls/Syscalls/NotImplemented.cpp
   LinuxSyscalls/Syscalls/Stubs.cpp)
 
+set(OUTPUT_LINUXSYSCALLS_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/")
+
+add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/GeneratedSyscallHandlers.inl"
+  DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/SyscallDescription.json"
+  DEPENDS "${PROJECT_SOURCE_DIR}/Scripts/GenerateSyscallHandlers.py"
+  COMMAND "python3" ARGS "${PROJECT_SOURCE_DIR}/Scripts/GenerateSyscallHandlers.py"
+  "${CMAKE_CURRENT_SOURCE_DIR}/SyscallDescription.json"
+  "${CMAKE_CURRENT_BINARY_DIR}/GeneratedSyscallHandlers.inl")
+
+add_custom_target(GeneratedSyscallHandlers DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/GeneratedSyscallHandlers.inl")
+
 add_library(LinuxEmulation STATIC ${SRCS})
+add_dependencies(LinuxEmulation GeneratedSyscallHandlers)
 
 target_compile_options(LinuxEmulation
 PRIVATE
@@ -82,6 +81,7 @@ PRIVATE
 target_include_directories(LinuxEmulation
 PRIVATE
   ${CMAKE_BINARY_DIR}/generated
+  ${CMAKE_CURRENT_BINARY_DIR}/
   ${CMAKE_CURRENT_SOURCE_DIR}/
   ${PROJECT_SOURCE_DIR}/External/drm-headers/include/
 )
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls.h b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls.h
index 6bd4d84ce0..169ee56299 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls.h
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls.h
@@ -63,22 +63,14 @@ class SignalDelegator;
   void RegisterFS(FEX::HLE::SyscallHandler *Handler);
   void RegisterInfo(FEX::HLE::SyscallHandler *Handler);
   void RegisterIO(FEX::HLE::SyscallHandler *Handler);
-  void RegisterIOUring(FEX::HLE::SyscallHandler *Handler);
-  void RegisterKey(FEX::HLE::SyscallHandler *Handler);
   void RegisterMemory(FEX::HLE::SyscallHandler *Handler);
-  void RegisterMsg(FEX::HLE::SyscallHandler *Handler);
-  void RegisterNamespace(FEX::HLE::SyscallHandler *Handler);
   void RegisterNuma(FEX::HLE::SyscallHandler *Handler);
-  void RegisterSched(FEX::HLE::SyscallHandler *Handler);
-  void RegisterSemaphore(FEX::HLE::SyscallHandler *Handler);
-  void RegisterSHM(FEX::HLE::SyscallHandler *Handler);
   void RegisterSignals(FEX::HLE::SyscallHandler *Handler);
-  void RegisterSocket(FEX::HLE::SyscallHandler *Handler);
   void RegisterThread(FEX::HLE::SyscallHandler *Handler);
-  void RegisterTime(FEX::HLE::SyscallHandler *Handler);
   void RegisterTimer(FEX::HLE::SyscallHandler *Handler);
   void RegisterNotImplemented(FEX::HLE::SyscallHandler *Handler);
   void RegisterStubs(FEX::HLE::SyscallHandler *Handler);
+  void RegisterGenerated(FEX::HLE::SyscallHandler *Handler);
 
 uint64_t UnimplementedSyscall(FEXCore::Core::CpuStateFrame *Frame, uint64_t SyscallNumber);
 uint64_t UnimplementedSyscallSafe(FEXCore::Core::CpuStateFrame *Frame, uint64_t SyscallNumber);
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/EPoll.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/EPoll.cpp
index e214bfb0fa..b7217d4c44 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/EPoll.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/EPoll.cpp
@@ -5,7 +5,6 @@ meta: LinuxSyscalls|syscalls-shared ~ Syscall implementations shared between x86
 tags: LinuxSyscalls|syscalls-shared
 $end_info$
 */
-
 #include "LinuxSyscalls/Syscalls.h"
 #include "LinuxSyscalls/x64/Syscalls.h"
 #include "LinuxSyscalls/x32/Syscalls.h"
@@ -19,16 +18,10 @@ namespace FEX::HLE {
   void RegisterEpoll(FEX::HLE::SyscallHandler *Handler) {
     using namespace FEXCore::IR;
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(epoll_create, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(epoll_create, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int size) -> uint64_t {
       uint64_t Result = epoll_create(size);
       SYSCALL_ERRNO();
     });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(epoll_create1, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int flags) -> uint64_t {
-      uint64_t Result = epoll_create1(flags);
-      SYSCALL_ERRNO();
-    });
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FD.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FD.cpp
index fb3806d5ba..e5d384e7a0 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FD.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FD.cpp
@@ -32,18 +32,6 @@ namespace FEX::HLE {
   void RegisterFD(FEX::HLE::SyscallHandler *Handler) {
     using namespace FEXCore::IR;
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(read, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, void *buf, size_t count) -> uint64_t {
-      uint64_t Result = ::read(fd, buf, count);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(write, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, void *buf, size_t count) -> uint64_t {
-      uint64_t Result = ::write(fd, buf, count);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(open, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, int flags, uint32_t mode) -> uint64_t {
       flags = FEX::HLE::RemapFromX86Flags(flags);
@@ -57,37 +45,25 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(chown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(chown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, uid_t owner, gid_t group) -> uint64_t {
       uint64_t Result = ::chown(pathname, owner, group);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, uid_t owner, gid_t group) -> uint64_t {
-      uint64_t Result = ::fchown(fd, owner, group);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(lchown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(lchown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, uid_t owner, gid_t group) -> uint64_t {
       uint64_t Result = ::lchown(pathname, owner, group);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(lseek, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, uint64_t offset, int whence) -> uint64_t {
-      uint64_t Result = ::lseek(fd, offset, whence);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(access, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, int mode) -> uint64_t {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Access(pathname, mode);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(pipe, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(pipe, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int pipefd[2]) -> uint64_t {
       uint64_t Result = ::pipe(pipefd);
       SYSCALL_ERRNO();
@@ -100,60 +76,11 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(flock, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, int operation) -> uint64_t {
-      uint64_t Result = ::flock(fd, operation);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsync, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd) -> uint64_t {
-      uint64_t Result = ::fsync(fd);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fdatasync, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd) -> uint64_t {
-      uint64_t Result = ::fdatasync(fd);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(ftruncate, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, off_t length) -> uint64_t {
-      uint64_t Result = ::ftruncate(fd, length);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchmod, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, int mode) -> uint64_t {
-      uint64_t Result = ::fchmod(fd, mode);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fadvise64, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, off_t offset, off_t len, int advice) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(fadvise64), fd, offset, len, advice);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_init, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(inotify_init, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
       uint64_t Result = ::inotify_init();
       SYSCALL_ERRNO();
     });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_add_watch, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, const char *pathname, uint32_t mask) -> uint64_t {
-      uint64_t Result = ::inotify_add_watch(fd, pathname, mask);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_rm_watch, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, int wd) -> uint64_t {
-      uint64_t Result = ::inotify_rm_watch(fd, wd);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(openat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int dirfs, const char *pathname, int flags, uint32_t mode) -> uint64_t {
       flags = FEX::HLE::RemapFromX86Flags(flags);
@@ -161,63 +88,12 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(mkdirat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, mode_t mode) -> uint64_t {
-      uint64_t Result = ::mkdirat(dirfd, pathname, mode);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(mknodat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, mode_t mode, dev_t dev) -> uint64_t {
-      uint64_t Result = ::mknodat(dirfd, pathname, mode, dev);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchownat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, uid_t owner, gid_t group, int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::fchownat(dirfd, pathname, owner, group, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(unlinkat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::unlinkat(dirfd, pathname, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(renameat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int olddirfd, const char *oldpath, int newdirfd, const char *newpath) -> uint64_t {
-      uint64_t Result = ::renameat(olddirfd, oldpath, newdirfd, newpath);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(linkat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::linkat(olddirfd, oldpath, newdirfd, newpath, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(symlinkat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *target, int newdirfd, const char *linkpath) -> uint64_t {
-      uint64_t Result = ::symlinkat(target, newdirfd, linkpath);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(readlinkat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, char *buf, size_t bufsiz) -> uint64_t {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Readlinkat(dirfd, pathname, buf, bufsiz);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchmodat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, mode_t mode) -> uint64_t {
-      uint64_t Result = syscall(SYSCALL_DEF(fchmodat), dirfd, pathname, mode);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(faccessat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, int mode) -> uint64_t {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.FAccessat(dirfd, pathname, mode);
@@ -232,12 +108,6 @@ namespace FEX::HLE {
         SYSCALL_ERRNO();
       });
 
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(pidfd_getfd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int pidfd, int fd, unsigned int flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(pidfd_getfd), pidfd, fd, flags);
-        SYSCALL_ERRNO();
-      });
-
       REGISTER_SYSCALL_IMPL_FLAGS(openat2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
         [](FEXCore::Core::CpuStateFrame *Frame, int dirfs, const char *pathname, struct open_how *how, size_t usize) -> uint64_t {
         open_how HostHow{};
@@ -251,32 +121,10 @@ namespace FEX::HLE {
     }
     else {
       REGISTER_SYSCALL_IMPL(faccessat2, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(pidfd_getfd, UnimplementedSyscallSafe);
       REGISTER_SYSCALL_IMPL(openat2, UnimplementedSyscallSafe);
     }
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(splice, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::splice(fd_in, off_in, fd_out, off_out, len, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(tee, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd_in, int fd_out, size_t len, unsigned int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::tee(fd_in, fd_out, len, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(timerfd_create, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int32_t clockid, int32_t flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::timerfd_create(clockid, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(eventfd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(eventfd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, uint32_t count) -> uint64_t {
       uint64_t Result = ::syscall(SYSCALL_DEF(eventfd2), count, 0);
       SYSCALL_ERRNO();
@@ -289,27 +137,6 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_init1, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::inotify_init1(flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(renameat2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int olddirfd, const char *oldpath, int newdirfd, const char *newpath, unsigned int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = FHU::Syscalls::renameat2(olddirfd, oldpath, newdirfd, newpath, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(memfd_create, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *name, uint32_t flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::syscall(SYSCALL_DEF(memfd_create), name, flags);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(statx, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, int flags, uint32_t mask, struct statx *statxbuf) -> uint64_t {
       // Flags don't need remapped
@@ -317,45 +144,6 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(name_to_handle_at, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, struct file_handle *handle, int *mount_id, int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::syscall(SYSCALL_DEF(name_to_handle_at), dirfd, pathname, handle, mount_id, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(open_by_handle_at, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int mount_fd, struct file_handle *handle, int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::syscall(SYSCALL_DEF(open_by_handle_at), mount_fd, handle, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(eventfd2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, unsigned int count, int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::syscall(SYSCALL_DEF(eventfd2), count, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(copy_file_range, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::syscall(SYSCALL_DEF(copy_file_range), fd_in, off_in, fd_out, off_out, len, flags);
-      SYSCALL_ERRNO();
-    });
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 3, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(pidfd_open, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, unsigned int flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(pidfd_open), pid, flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(pidfd_open, UnimplementedSyscallSafe);
-    }
-
     if (Handler->IsHostKernelVersionAtLeast(5, 9, 0)) {
       REGISTER_SYSCALL_IMPL_FLAGS(close_range, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
         [](FEXCore::Core::CpuStateFrame *Frame, unsigned int first, unsigned int last, unsigned int flags) -> uint64_t {
@@ -366,72 +154,5 @@ namespace FEX::HLE {
     else {
       REGISTER_SYSCALL_IMPL(close_range, UnimplementedSyscallSafe);
     }
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 13, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(landlock_create_ruleset, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, void *const rule_attr, size_t size, uint32_t flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(landlock_create_ruleset), rule_attr, size, flags);
-        SYSCALL_ERRNO();
-      });
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(landlock_add_rule, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, uint32_t ruleset_fd, uint64_t rule_type, void *const rule_attr, uint32_t flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(landlock_add_rule), ruleset_fd, rule_type, rule_attr, flags);
-        SYSCALL_ERRNO();
-      });
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(landlock_restrict_self, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, uint32_t ruleset_fd, uint32_t flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(landlock_restrict_self), ruleset_fd, flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(landlock_create_ruleset, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(landlock_add_rule, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(landlock_restrict_self, UnimplementedSyscallSafe);
-    }
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 14, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(memfd_secret, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, uint32_t flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(memfd_secret), flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(memfd_secret, UnimplementedSyscallSafe);
-    }
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 15, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(process_mrelease, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int pidfd, uint32_t flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(process_mrelease), pidfd, flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(process_mrelease, UnimplementedSyscallSafe);
-    }
-
-    if (Handler->IsHostKernelVersionAtLeast(6, 5, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(cachestat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int fd, void* cstat_range, void* cstat, uint32_t flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(cachestat), fd, cstat_range, cstat, flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(cachestat, UnimplementedSyscallSafe);
-    }
-
-    if (Handler->IsHostKernelVersionAtLeast(6, 6, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchmodat2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, mode_t mode, uint32_t flags) -> uint64_t {
-        uint64_t Result = syscall(SYSCALL_DEF(fchmodat2), dirfd, pathname, mode, flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(fchmodat2, UnimplementedSyscallSafe);
-    }
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FS.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FS.cpp
index dba921aa28..52683a287f 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FS.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FS.cpp
@@ -25,55 +25,37 @@ namespace FEX::HLE {
   void RegisterFS(FEX::HLE::SyscallHandler *Handler) {
     using namespace FEXCore::IR;
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getcwd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, char *buf, size_t size) -> uint64_t {
-      uint64_t Result = syscall(SYSCALL_DEF(getcwd), buf, size);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(chdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *path) -> uint64_t {
-      uint64_t Result = ::chdir(path);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd) -> uint64_t {
-      uint64_t Result = ::fchdir(fd);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(rename, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(rename, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *oldpath, const char *newpath) -> uint64_t {
       uint64_t Result = ::rename(oldpath, newpath);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(mkdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(mkdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, mode_t mode) -> uint64_t {
       uint64_t Result = ::mkdir(pathname, mode);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(rmdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(rmdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname) -> uint64_t {
       uint64_t Result = ::rmdir(pathname);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(link, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(link, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *oldpath, const char *newpath) -> uint64_t {
       uint64_t Result = ::link(oldpath, newpath);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(unlink, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(unlink, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname) -> uint64_t {
       uint64_t Result = ::unlink(pathname);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(symlink, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(symlink, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *target, const char *linkpath) -> uint64_t {
       uint64_t Result = ::symlink(target, linkpath);
       SYSCALL_ERRNO();
@@ -85,103 +67,24 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(chmod, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(chmod, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, mode_t mode) -> uint64_t {
       uint64_t Result = ::chmod(pathname, mode);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(umask, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, mode_t mask) -> uint64_t {
-      uint64_t Result = ::umask(mask);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(mknod, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, mode_t mode, dev_t dev) -> uint64_t {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Mknod(pathname, mode, dev);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(ustat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, dev_t dev, struct ustat *ubuf) -> uint64_t {
-      // Doesn't exist on AArch64, will return -ENOSYS
-      // Since version 2.28 of GLIBC it has stopped providing a wrapper for this syscall
-      uint64_t Result = syscall(SYSCALL_DEF(ustat), dev, ubuf);
-      SYSCALL_ERRNO();
-    });
-
-    /*
-      arg1 is one of: void, unsigned int fs_index, const char *fsname
-      arg2 is one of: void, char *buf
-    */
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sysfs, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int option,  uint64_t arg1,  uint64_t arg2) -> uint64_t {
-      // Doesn't exist on AArch64, will return -ENOSYS
-      uint64_t Result = syscall(SYSCALL_DEF(sysfs), option, arg1, arg2);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(truncate, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *path, off_t length) -> uint64_t {
-      uint64_t Result = ::truncate(path, length);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(creat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(creat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, mode_t mode) -> uint64_t {
       uint64_t Result = ::creat(pathname, mode);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(chroot, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *path) -> uint64_t {
-      uint64_t Result = ::chroot(path);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sync, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      sync();
-      return 0; // always successful
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(acct, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *filename) -> uint64_t {
-      uint64_t Result = ::acct(filename);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(mount, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *source, const char *target, const char *filesystemtype, unsigned long mountflags, const void *data) -> uint64_t {
-      uint64_t Result = ::mount(source, target, filesystemtype, mountflags, data);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(umount2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *target, int flags) -> uint64_t {
-      uint64_t Result = ::umount2(target, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(swapon, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *path, int swapflags) -> uint64_t {
-      uint64_t Result = ::swapon(path, swapflags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(swapoff, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *path) -> uint64_t {
-      uint64_t Result = ::swapoff(path);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(syncfs, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(syncfs), fd);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL(setxattr,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *path, const char *name, const void *value, size_t size, int flags) -> uint64_t {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Setxattr(path, name, value, size, flags);
@@ -194,12 +97,6 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsetxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, const char *name, const void *value, size_t size, int flags) -> uint64_t {
-      uint64_t Result = ::fsetxattr(fd, name, value, size, flags);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL(getxattr,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *path, const char *name, void *value, size_t size) -> uint64_t {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Getxattr(path, name, value, size);
@@ -212,12 +109,6 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fgetxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, const char *name, void *value, size_t size) -> uint64_t {
-      uint64_t Result = ::fgetxattr(fd, name, value, size);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL(listxattr,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *path, char *list, size_t size) -> uint64_t {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Listxattr(path, list, size);
@@ -230,12 +121,6 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(flistxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, char *list, size_t size) -> uint64_t {
-      uint64_t Result = ::flistxattr(fd, list, size);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL(removexattr,
       [](FEXCore::Core::CpuStateFrame *Frame, const char *path, const char *name) -> uint64_t {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Removexattr(path, name);
@@ -247,40 +132,5 @@ namespace FEX::HLE {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.LRemovexattr(path, name);
       SYSCALL_ERRNO();
     });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fremovexattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, const char *name) -> uint64_t {
-      uint64_t Result = ::fremovexattr(fd, name);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fanotify_init, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, unsigned int flags, unsigned int event_f_flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(fanotify_init), flags, event_f_flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(fanotify_mark, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fanotify_fd, unsigned int flags, uint64_t mask, int dirfd, const char *pathname) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(fanotify_mark), fanotify_fd, flags, mask, dirfd, pathname);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(pivot_root, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *new_root, const char *put_old) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(pivot_root), new_root, put_old);
-      SYSCALL_ERRNO();
-    });
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 14, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(quotactl_fd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, uint32_t fd, uint32_t cmd, uint32_t id, void* addr) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(quotactl_fd), fd, cmd, id, addr);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(quotactl_fd, UnimplementedSyscallSafe);
-    }
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Generated.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Generated.cpp
new file mode 100644
index 0000000000..cfa223f1da
--- /dev/null
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Generated.cpp
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+/*
+$info$
+meta: LinuxSyscalls|syscalls-shared ~ Syscall implementations shared between x86 and x86-64
+tags: LinuxSyscalls|syscalls-shared
+$end_info$
+*/
+
+#include "LinuxSyscalls/Syscalls.h"
+#include "LinuxSyscalls/x64/Syscalls.h"
+#include "LinuxSyscalls/x32/Syscalls.h"
+
+#include <FEXCore/IR/IR.h>
+
+#include <stdint.h>
+#include <sys/epoll.h>
+
+namespace FEX::HLE {
+#define PASSTHROUGH_HANDLERS
+#include "GeneratedSyscallHandlers.inl"
+
+  void RegisterGenerated(FEX::HLE::SyscallHandler *Handler) {
+    using namespace FEXCore::IR;
+#define SYSCALL_COMMON_IMPL
+#include "GeneratedSyscallHandlers.inl"
+  }
+
+  namespace x64 {
+    void RegisterGenerated(FEX::HLE::SyscallHandler *Handler) {
+      using namespace FEXCore::IR;
+#define SYSCALL_X64_IMPL
+#include "GeneratedSyscallHandlers.inl"
+    }
+  }
+
+  namespace x32 {
+    void RegisterGenerated(FEX::HLE::SyscallHandler *Handler) {
+      using namespace FEXCore::IR;
+#define SYSCALL_X32_IMPL
+#include "GeneratedSyscallHandlers.inl"
+    }
+  }
+}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IO.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IO.cpp
index 7e4c57c8ab..3a304f1af4 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IO.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IO.cpp
@@ -19,52 +19,16 @@ namespace FEX::HLE {
   void RegisterIO(FEX::HLE::SyscallHandler *Handler) {
     using namespace FEXCore::IR;
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(iopl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(iopl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int level) -> uint64_t {
       // Just claim we don't have permission
       return -EPERM;
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(ioperm, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(ioperm, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, unsigned long from, unsigned long num, int turn_on) -> uint64_t {
       // ioperm not available on our architecture
       return -EPERM;
     });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_setup, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, unsigned nr_events, aio_context_t *ctx_idp) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(io_setup), nr_events, ctx_idp);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_destroy, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, aio_context_t ctx_id) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(io_destroy), ctx_id);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_submit, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, aio_context_t ctx_id, long nr, struct iocb **iocbpp) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(io_submit), ctx_id, nr, iocbpp);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_cancel, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, aio_context_t ctx_id, struct iocb *iocb, struct io_event *result) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(io_cancel), ctx_id, iocb, result);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(ioprio_set, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int which, int who) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(ioprio_set), which, who);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(ioprio_get, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int which, int who, int ioprio) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(ioprio_get), which, who, ioprio);
-      SYSCALL_ERRNO();
-    });
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IOUring.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IOUring.cpp
deleted file mode 100644
index 302d107fda..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IOUring.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-shared
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/Syscalls/Thread.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-#include "LinuxSyscalls/x32/Syscalls.h"
-
-#include <FEXCore/IR/IR.h>
-
-#include <signal.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-
-namespace SignalDelegator {
-  struct GuestSigAction;
-}
-
-
-namespace FEX::HLE {
-  void RegisterIOUring(FEX::HLE::SyscallHandler *Handler) {
-    using namespace FEXCore::IR;
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 1, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_uring_setup, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, uint32_t entries, void* params) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(io_uring_setup), entries, params);
-        SYSCALL_ERRNO();
-      });
-
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_uring_enter, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, unsigned int fd, uint32_t to_submit, uint32_t min_complete, uint32_t flags, void *argp, size_t argsz) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(io_uring_enter), fd, to_submit, min_complete, flags, argp, argsz);
-        SYSCALL_ERRNO();
-      });
-
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_uring_register, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, unsigned int fd, unsigned int opcode, void *arg, uint32_t nr_args) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(io_uring_register), fd, opcode, arg, nr_args);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(io_uring_setup, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(io_uring_enter, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(io_uring_register, UnimplementedSyscallSafe);
-    }
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Info.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Info.cpp
index 84b3501f7a..e91ea6bf09 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Info.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Info.cpp
@@ -63,44 +63,6 @@ namespace FEX::HLE {
       return 0;
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(syslog, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int type, char *bufp, int len) -> uint64_t {
-      uint64_t Result = ::klogctl(type, bufp, len);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getrandom, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, void *buf, size_t buflen, unsigned int flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(getrandom), buf, buflen, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(capget, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, cap_user_header_t hdrp, cap_user_data_t datap) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(capget), hdrp, datap);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(capset, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, cap_user_header_t hdrp, const cap_user_data_t datap) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(capset), hdrp, datap);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_FLAGS(getcpu, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, unsigned *cpu, unsigned *node, struct getcpu_cache *tcache) -> uint64_t {
-      // tcache is ignored
-      uint64_t Result = ::syscall(SYSCALL_DEF(getcpu), cpu, node, nullptr);
-      SYSCALL_ERRNO();
-    });
-
-    //compare  two  processes  to determine if they share a kernel resource
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(kcmp, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(kcmp), pid1, pid2, type, idx1, idx2);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(seccomp, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, unsigned int operation, unsigned int flags, void *args) -> uint64_t {
       // FEX doesn't support seccomp
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Key.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Key.cpp
deleted file mode 100644
index 32bd64c701..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Key.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-shared
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/Types.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-#include "LinuxSyscalls/x32/Syscalls.h"
-
-#include <FEXCore/IR/IR.h>
-
-#include <sys/mman.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-
-namespace FEX::HLE {
-  void RegisterKey(FEX::HLE::SyscallHandler *Handler) {
-    using namespace FEXCore::IR;
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(add_key, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *type, const char *description, const void *payload, size_t plen, key_serial_t keyring) -> uint64_t {
-      uint64_t Result = syscall(SYS_add_key, type, description, payload, plen, keyring);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(request_key, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *type, const char *description, const char *callout_info, key_serial_t dest_keyring) -> uint64_t {
-      uint64_t Result = syscall(SYS_request_key, type, description, callout_info, dest_keyring);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(keyctl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int operation, uint64_t arg2, uint64_t arg3, uint64_t arg4, uint64_t arg5) -> uint64_t {
-      uint64_t Result = syscall(SYS_keyctl, operation, arg2, arg3, arg4, arg5);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(pkey_mprotect, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t len, int prot, int pkey) -> uint64_t {
-      // Added in Linux 4.9
-      uint64_t Result = ::syscall(SYSCALL_DEF(pkey_mprotect), addr, len, prot, pkey);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(pkey_alloc, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, unsigned int flags, unsigned int access_rights) -> uint64_t {
-      // Added in Linux 4.9
-      uint64_t Result = ::syscall(SYSCALL_DEF(pkey_alloc), flags, access_rights);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(pkey_free, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int pkey) -> uint64_t {
-      // Added in Linux 4.9
-      uint64_t Result = ::syscall(SYSCALL_DEF(pkey_free), pkey);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Memory.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Memory.cpp
index 245adf317d..35e868ffa3 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Memory.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Memory.cpp
@@ -28,18 +28,6 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(msync, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t length, int32_t flags) -> uint64_t {
-      uint64_t Result = ::msync(addr, length, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(mincore, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t length, uint8_t *vec) -> uint64_t {
-      uint64_t Result = ::mincore(addr, length, vec);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(madvise, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t length, int32_t advice) -> uint64_t {
       uint64_t Result = ::madvise(addr, length, advice);
@@ -49,77 +37,5 @@ namespace FEX::HLE {
       }
       SYSCALL_ERRNO();
     });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(mlock, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const void *addr, size_t len) -> uint64_t {
-      uint64_t Result = ::mlock(addr, len);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(munlock, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const void *addr, size_t len) -> uint64_t {
-      uint64_t Result = ::munlock(addr, len);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(mlock2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const void *addr, size_t len, int flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mlock2), addr, len, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(remap_file_pages, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t size, int prot, size_t pgoff, int flags) -> uint64_t {
-      // This syscall is deprecated, not sure when it will end up being removed
-      uint64_t Result = ::syscall(SYSCALL_DEF(remap_file_pages), addr, size, prot, pgoff, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(mbind, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, void *addr, unsigned long len, int mode, const unsigned long *nodemask, unsigned long maxnode, unsigned flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mbind), addr, len, mode, nodemask, maxnode, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(get_mempolicy, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int *mode, unsigned long *nodemask, unsigned long maxnode, void *addr, unsigned long flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(get_mempolicy), mode, nodemask, maxnode, addr, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(set_mempolicy, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int mode, const unsigned long *nodemask, unsigned long maxnode) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(set_mempolicy), mode, nodemask, maxnode);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(migrate_pages, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int pid, unsigned long maxnode, const unsigned long *old_nodes, const unsigned long *new_nodes) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(migrate_pages), pid, maxnode, old_nodes, new_nodes);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(move_pages, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int pid, unsigned long count, void **pages, const int *nodes, int *status, int flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(move_pages), pid, count, pages, nodes, status, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(membarrier, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int cmd, int flags) -> uint64_t {
-        uint64_t Result = syscall(SYSCALL_DEF(membarrier), cmd, flags);
-        SYSCALL_ERRNO();
-    });
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 17, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(set_mempolicy_home_node, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, uint64_t start, uint64_t len, uint64_t home_node, uint64_t flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(set_mempolicy_home_node), start, len, home_node, flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(set_mempolicy_home_node, UnimplementedSyscallSafe);
-    }
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Msg.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Msg.cpp
deleted file mode 100644
index f6dfdc9795..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Msg.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-shared
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-#include "LinuxSyscalls/x32/Syscalls.h"
-
-#include <FEXCore/IR/IR.h>
-
-#include <sys/types.h>
-#include <sys/msg.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-
-namespace FEX::HLE {
-  void RegisterMsg(FEX::HLE::SyscallHandler *Handler) {
-    using namespace FEXCore::IR;
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgget, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, key_t key, int msgflg) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(msgget), key, msgflg);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgsnd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int msqid, const void *msgp, size_t msgsz, int msgflg) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(msgsnd), msqid, msgp, msgsz, msgflg);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgrcv, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(msgrcv), msqid, msgp, msgsz, msgtyp, msgflg);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgctl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int msqid, int cmd, struct msqid_ds *buf) -> uint64_t {
-      // A quirk of this syscall
-      // On 32-bit this syscall ONLY supports IPC_64 msqid_ds encoding
-      // If an application want to use the old style encoding then it needs to use the ipc syscall with MSGCTL command
-      // ipc syscall supports both IPC_64 and old encoding
-      uint64_t Result = ::syscall(SYSCALL_DEF(msgctl), msqid, cmd, buf);
-      SYSCALL_ERRNO();
-    });
-
-    // last two parameters are optional
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(mq_unlink, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, const char *name) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mq_unlink), name);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Namespace.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Namespace.cpp
deleted file mode 100644
index 48196b67de..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Namespace.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-shared
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/Syscalls/Thread.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-#include "LinuxSyscalls/x32/Syscalls.h"
-
-#include <FEXCore/IR/IR.h>
-
-#include <signal.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-
-namespace SignalDelegator {
-  struct GuestSigAction;
-}
-
-
-namespace FEX::HLE {
-  void RegisterNamespace(FEX::HLE::SyscallHandler *Handler) {
-    using namespace FEXCore::IR;
-
-    if (Handler->GetHostKernelVersion() >= FEX::HLE::SyscallHandler::KernelVersion(5, 1, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(open_tree, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int dfd, const char *filename, unsigned int flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(open_tree), dfd, filename, flags);
-        SYSCALL_ERRNO();
-      });
-
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(move_mount, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int from_dfd, const char *from_pathname, int to_dfd, const char *to_pathname, unsigned int flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(move_mount), from_dfd, from_pathname, to_dfd, to_pathname, flags);
-        SYSCALL_ERRNO();
-      });
-
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsopen, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int dfd, const char *path, unsigned int flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(fsopen), dfd, path, flags);
-        SYSCALL_ERRNO();
-      });
-
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsconfig, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int fd, unsigned int cmd, const char *key, const void *value, int aux) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(fsconfig), fd, cmd, key, value, aux);
-        SYSCALL_ERRNO();
-      });
-
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsmount, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int fs_fd, uint32_t flags, uint32_t attr_flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(fsmount), fs_fd, flags, attr_flags);
-        SYSCALL_ERRNO();
-      });
-
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(fspick, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int dfd, const char *path, unsigned int flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(fspick), dfd, path, flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(open_tree, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(move_mount, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(fsopen, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(fsconfig, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(fsmount, UnimplementedSyscallSafe);
-      REGISTER_SYSCALL_IMPL(fspick, UnimplementedSyscallSafe);
-    }
-
-    if (Handler->GetHostKernelVersion() >= FEX::HLE::SyscallHandler::KernelVersion(5, 12, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(mount_setattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int dfd, const char *path, unsigned int flags, void *uattr, size_t usize) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(mount_setattr), dfd, path, flags, uattr, usize);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(mount_setattr, UnimplementedSyscallSafe);
-    }
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/SHM.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/SHM.cpp
deleted file mode 100644
index 54fcca1d79..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/SHM.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-shared
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-#include "LinuxSyscalls/x32/Syscalls.h"
-
-#include <FEXCore/IR/IR.h>
-
-#include <stddef.h>
-#include <stdint.h>
-#include <sys/shm.h>
-
-namespace FEX::HLE {
-  void RegisterSHM(FEX::HLE::SyscallHandler *Handler) {
-    using namespace FEXCore::IR;
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(_shmget, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, key_t key, size_t size, int shmflg) -> uint64_t {
-      uint64_t Result = shmget(key, size, shmflg);
-      SYSCALL_ERRNO();
-    });
-
-    // XXX: shmid_ds is definitely not correct for 32-bit
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(_shmctl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int shmid, int cmd, struct shmid_ds *buf) -> uint64_t {
-      uint64_t Result = ::shmctl(shmid, cmd, buf);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Sched.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Sched.cpp
deleted file mode 100644
index 08c0100c49..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Sched.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-shared
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-#include "LinuxSyscalls/x32/Syscalls.h"
-
-#include <FEXCore/Utils/MathUtils.h>
-
-#include <FEXCore/IR/IR.h>
-
-#include <stdint.h>
-#include <sched.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-
-namespace FEX::HLE {
-  void RegisterSched(FEX::HLE::SyscallHandler *Handler) {
-    using namespace FEXCore::IR;
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_yield, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::sched_yield();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpriority, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int which, int who) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(getpriority), which, who);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setpriority, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int which, int who, int prio) -> uint64_t {
-      uint64_t Result = ::setpriority(which, who, prio);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_setparam, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, const struct sched_param *param) -> uint64_t {
-      uint64_t Result = ::sched_setparam(pid, param);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_getparam, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, struct sched_param *param) -> uint64_t {
-      uint64_t Result = ::sched_getparam(pid, param);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_setscheduler, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int policy, const struct sched_param *param) -> uint64_t {
-      uint64_t Result = ::sched_setscheduler(pid, policy, param);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_getscheduler, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid) -> uint64_t {
-      uint64_t Result = ::sched_getscheduler(pid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_get_priority_max, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int policy) -> uint64_t {
-      uint64_t Result = ::sched_get_priority_max(policy);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_get_priority_min, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int policy) -> uint64_t {
-      uint64_t Result = ::sched_get_priority_min(policy);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_FLAGS(sched_setaffinity, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY | SyscallFlags::NOSIDEEFFECTS,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, size_t cpusetsize, const unsigned long *mask) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(sched_setaffinity), pid, cpusetsize, mask);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_FLAGS(sched_getaffinity, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, size_t cpusetsize, unsigned char *mask) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(sched_getaffinity), pid, cpusetsize, mask);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_setattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, struct sched_attr *attr, unsigned int flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(sched_setattr), pid, attr, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_getattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, struct sched_attr *attr, unsigned int size, unsigned int flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(sched_getattr), pid, attr, size, flags);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Semaphore.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Semaphore.cpp
deleted file mode 100644
index ea90b97e6c..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Semaphore.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-shared
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-#include "LinuxSyscalls/x32/Syscalls.h"
-
-#include <FEXCore/IR/IR.h>
-#include <FEXHeaderUtils/Syscalls.h>
-
-#include <sys/types.h>
-
-namespace FEX::HLE {
-  void RegisterSemaphore(FEX::HLE::SyscallHandler *Handler) {
-    using namespace FEXCore::IR;
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(semget, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, key_t key, int nsems, int semflg) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(semget), key, nsems, semflg);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Socket.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Socket.cpp
deleted file mode 100644
index 7c6f954994..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Socket.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-shared
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-#include "LinuxSyscalls/x32/Syscalls.h"
-
-#include <FEXCore/IR/IR.h>
-
-#include <stddef.h>
-#include <stdint.h>
-#include <sys/socket.h>
-
-namespace FEX::HLE {
-  void RegisterSocket(FEX::HLE::SyscallHandler *Handler) {
-    using namespace FEXCore::IR;
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(socket, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int domain, int type, int protocol) -> uint64_t {
-      uint64_t Result = ::socket(domain, type, protocol);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(connect, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, const struct sockaddr *addr, socklen_t addrlen) -> uint64_t {
-      uint64_t Result = ::connect(sockfd, addr, addrlen);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(accept4, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) -> uint64_t {
-      uint64_t Result = ::accept4(sockfd, addr, addrlen, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(sendto, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen) -> uint64_t {
-      uint64_t Result = ::sendto(sockfd, buf, len, flags, dest_addr, addrlen);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(recvfrom, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen) -> uint64_t {
-      uint64_t Result = ::recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(shutdown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, int how) -> uint64_t {
-      uint64_t Result = ::shutdown(sockfd, how);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(bind, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, const struct sockaddr *addr, socklen_t addrlen) -> uint64_t {
-      uint64_t Result = ::bind(sockfd, addr, addrlen);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(listen, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, int backlog) -> uint64_t {
-      uint64_t Result = ::listen(sockfd, backlog);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getsockname, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct sockaddr *addr, socklen_t *addrlen) -> uint64_t {
-      uint64_t Result = ::getsockname(sockfd, addr, addrlen);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpeername, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct sockaddr *addr, socklen_t *addrlen) -> uint64_t {
-      uint64_t Result = ::getpeername(sockfd, addr, addrlen);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(socketpair, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int domain, int type, int protocol, int sv[2]) -> uint64_t {
-      uint64_t Result = ::socketpair(domain, type, protocol, sv);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Thread.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Thread.cpp
index 270d868b14..7d752acd41 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Thread.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Thread.cpp
@@ -357,12 +357,6 @@ namespace FEX::HLE {
       FEX_UNREACHABLE;
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::getpid();
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(fork, SyscallFlags::DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
       return ForkGuest(Frame->Thread, Frame, 0, 0, 0, 0, 0, 0);
     });
@@ -371,6 +365,12 @@ namespace FEX::HLE {
       return ForkGuest(Frame->Thread, Frame, CLONE_VFORK, 0, 0, 0, 0, 0);
     });
 
+    REGISTER_SYSCALL_IMPL_FLAGS(getpgrp, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
+      uint64_t Result = ::getpgrp();
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL_FLAGS(clone3, SyscallFlags::DEFAULT, ([](FEXCore::Core::CpuStateFrame *Frame, FEX::HLE::kernel_clone3_args *cl_args, size_t size) -> uint64_t {
       FEX::HLE::clone3_args args{};
       args.Type = TypeOfClone::TYPE_CLONE3;
@@ -404,130 +404,6 @@ namespace FEX::HLE {
       return 0;
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(kill, SyscallFlags::DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int sig) -> uint64_t {
-      uint64_t Result = ::kill(pid, sig);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(tkill, SyscallFlags::DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame, int tid, int sig) -> uint64_t {
-      // Can't actually use tgkill here, kernel rejects tgkill of tgid == 0
-      uint64_t Result = ::syscall(SYSCALL_DEF(tkill), tid, sig);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(tgkill, SyscallFlags::DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame, int tgid, int tid, int sig) -> uint64_t {
-      uint64_t Result = FHU::Syscalls::tgkill(tgid, tid, sig);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::getuid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::getgid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, uid_t uid) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(setuid), uid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, gid_t gid) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(setgid), gid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(geteuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::geteuid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getegid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::getegid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getppid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::getppid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpgrp, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::getpgrp();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setsid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::setsid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setreuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, uid_t ruid, uid_t euid) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(setreuid), ruid, euid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setregid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, gid_t rgid, gid_t egid) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(setregid), rgid, egid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getgroups, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int size, gid_t list[]) -> uint64_t {
-      uint64_t Result = ::getgroups(size, list);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setgroups, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, size_t size, const gid_t *list) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(setgroups), size, list);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setresuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, uid_t ruid, uid_t euid, uid_t suid) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(setresuid), ruid, euid, suid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getresuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, uid_t *ruid, uid_t *euid, uid_t *suid) -> uint64_t {
-      uint64_t Result = ::getresuid(ruid, euid, suid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setresgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, gid_t rgid, gid_t egid, gid_t sgid) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(setresgid), rgid, egid, sgid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getresgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, gid_t *rgid, gid_t *egid, gid_t *sgid) -> uint64_t {
-      uint64_t Result = ::getresgid(rgid, egid, sgid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(personality, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, uint64_t persona) -> uint64_t {
-      uint64_t Result = ::personality(persona);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_FLAGS(prctl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5) -> uint64_t {
       uint64_t Result{};
@@ -611,20 +487,14 @@ namespace FEX::HLE {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(gettid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = FHU::Syscalls::gettid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(set_tid_address, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(set_tid_address, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int *tidptr) -> uint64_t {
       auto Thread = Frame->Thread;
       Thread->ThreadManager.clear_child_tid = tidptr;
       return Thread->ThreadManager.GetTID();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(exit_group, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY | SyscallFlags::NORETURN,
+    REGISTER_SYSCALL_IMPL_FLAGS(exit_group, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY | SyscallFlags::NORETURN,
       [](FEXCore::Core::CpuStateFrame *Frame, int status) -> uint64_t {
 
       // Save telemetry if we're exiting.
@@ -634,64 +504,5 @@ namespace FEX::HLE {
       // This will never be reached
       std::terminate();
     });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(prlimit_64, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int resource, const struct rlimit *new_limit, struct rlimit *old_limit) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(prlimit_64), pid, resource, new_limit, old_limit);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setpgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, pid_t pgid) -> uint64_t {
-      uint64_t Result = ::setpgid(pid, pgid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid) -> uint64_t {
-      uint64_t Result = ::getpgid(pid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setfsuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, uid_t fsuid) -> uint64_t {
-      uint64_t Result = ::setfsuid(fsuid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setfsgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, uid_t fsgid) -> uint64_t {
-      uint64_t Result = ::setfsgid(fsgid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(getsid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid) -> uint64_t {
-      uint64_t Result = ::getsid(pid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(unshare, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int flags) -> uint64_t {
-      uint64_t Result = ::unshare(flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(setns, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int fd, int nstype) -> uint64_t {
-      uint64_t Result = ::setns(fd, nstype);
-      SYSCALL_ERRNO();
-    });
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 16, 0)) {
-      REGISTER_SYSCALL_IMPL_PASS_FLAGS(futex_waitv, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, void *waiters, uint32_t nr_futexes, uint32_t flags, struct timespec *timeout, clockid_t clockid) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(futex_waitv), waiters, nr_futexes, flags, timeout, clockid);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL(futex_waitv, UnimplementedSyscallSafe);
-    }
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Time.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Time.cpp
deleted file mode 100644
index 3a465bfe6f..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Time.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-shared
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-#include "LinuxSyscalls/x32/Syscalls.h"
-
-#include <FEXCore/IR/IR.h>
-
-#include <unistd.h>
-
-namespace FEX::HLE {
-  void RegisterTime(FEX::HLE::SyscallHandler *Handler) {
-    using namespace FEXCore::IR;
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(pause, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::pause();
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Timer.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Timer.cpp
index 6953a95778..47e32a1eed 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Timer.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Timer.cpp
@@ -24,21 +24,15 @@ namespace FEX::HLE {
   void RegisterTimer(FEX::HLE::SyscallHandler *Handler) {
     using namespace FEXCore::IR;
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(alarm, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+    REGISTER_SYSCALL_IMPL_FLAGS(alarm, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, unsigned int seconds) -> uint64_t {
       uint64_t Result = ::alarm(seconds);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(timer_getoverrun, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, kernel_timer_t timerid) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(timer_getoverrun), timerid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_PASS_FLAGS(timer_delete, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, kernel_timer_t timerid) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(timer_delete), timerid);
+    REGISTER_SYSCALL_IMPL_FLAGS(pause, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
+      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
+      uint64_t Result = ::pause();
       SYSCALL_ERRNO();
     });
   }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/FD.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/FD.cpp
index d407223b4b..611875c6fa 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/FD.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/FD.cpp
@@ -253,7 +253,7 @@ namespace FEX::HLE::x32 {
   };
 
   void RegisterFD(FEX::HLE::SyscallHandler *Handler) {
-    REGISTER_SYSCALL_IMPL_X32_PASS(poll, [](FEXCore::Core::CpuStateFrame *Frame, struct pollfd *fds, nfds_t nfds, int timeout) -> uint64_t {
+    REGISTER_SYSCALL_IMPL_X32(poll, [](FEXCore::Core::CpuStateFrame *Frame, struct pollfd *fds, nfds_t nfds, int timeout) -> uint64_t {
       uint64_t Result = ::poll(fds, nfds, timeout);
       SYSCALL_ERRNO();
     });
@@ -281,17 +281,6 @@ namespace FEX::HLE::x32 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(ppoll_time64, ppoll, [](FEXCore::Core::CpuStateFrame *Frame, struct pollfd *fds, nfds_t nfds, struct timespec *timeout_ts, const uint64_t *sigmask, size_t sigsetsize) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(ppoll),
-        fds,
-        nfds,
-        timeout_ts,
-        sigmask,
-        sigsetsize);
-
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X32(_llseek, [](FEXCore::Core::CpuStateFrame *Frame, uint32_t fd, uint32_t offset_high, uint32_t offset_low, loff_t *result, uint32_t whence) -> uint64_t {
       uint64_t Offset = offset_high;
       Offset <<= 32;
@@ -315,21 +304,6 @@ namespace FEX::HLE::x32 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(chown32, chown, [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, uid_t owner, gid_t group) -> uint64_t {
-      uint64_t Result = ::chown(pathname, owner, group);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(fchown32, fchown, [](FEXCore::Core::CpuStateFrame *Frame, int fd, uid_t owner, gid_t group) -> uint64_t {
-      uint64_t Result = ::fchown(fd, owner, group);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(lchown32, lchown, [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, uid_t owner, gid_t group) -> uint64_t {
-      uint64_t Result = ::lchown(pathname, owner, group);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X32(oldstat, [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, oldstat32 *buf) -> uint64_t {
       struct stat host_stat;
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Stat(pathname, &host_stat);
@@ -729,16 +703,6 @@ namespace FEX::HLE::x32 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(timerfd_settime64, timerfd_settime, [](FEXCore::Core::CpuStateFrame *Frame, int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value) -> uint64_t {
-      uint64_t Result = ::timerfd_settime(fd, flags, new_value, old_value);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(timerfd_gettime64, timerfd_gettime, [](FEXCore::Core::CpuStateFrame *Frame, int fd, struct itimerspec *curr_value) -> uint64_t {
-      uint64_t Result = ::timerfd_gettime(fd, curr_value);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X32(timerfd_settime, [](FEXCore::Core::CpuStateFrame *Frame,
       int fd,
       int flags,
@@ -885,14 +849,6 @@ namespace FEX::HLE::x32 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(sendfile64, sendfile, [](FEXCore::Core::CpuStateFrame *Frame, int out_fd, int in_fd, off_t *offset, compat_size_t count) -> uint64_t {
-      // Linux definition for this is a bit confusing
-      // Defines offset as compat_loff_t* but loads loff_t worth of data
-      // count is defined as compat_size_t still
-      uint64_t Result = ::sendfile(out_fd, in_fd, offset, count);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X32(pread_64, [](FEXCore::Core::CpuStateFrame *Frame, int fd, void *buf, uint32_t count, uint32_t offset_low, uint32_t offset_high) -> uint64_t {
       uint64_t Offset = offset_high;
       Offset <<= 32;
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/IO.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/IO.cpp
index df9d936334..000a9d2cbe 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/IO.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/IO.cpp
@@ -40,17 +40,5 @@ namespace FEX::HLE::x32 {
       uint64_t Result = ::syscall(SYSCALL_DEF(io_pgetevents), ctx_id, min_nr, nr, events, timeout_ptr, usig);
       SYSCALL_ERRNO();
     });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS(io_pgetevents_time64,
-      [](FEXCore::Core::CpuStateFrame *Frame,
-        aio_context_t ctx_id,
-        long min_nr,
-        long nr,
-        struct io_event *events,
-        struct timespec *timeout,
-        const struct io_sigset  *usig) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(io_pgetevents), ctx_id, min_nr, nr, events, timeout, usig);
-      SYSCALL_ERRNO();
-    });
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Msg.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Msg.cpp
index 3ba511a7b5..13c4d994b3 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Msg.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Msg.cpp
@@ -45,16 +45,6 @@ namespace FEX::HLE::x32 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(mq_timedsend_time64, mq_timedsend, [](FEXCore::Core::CpuStateFrame *Frame, FEX::HLE::mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mq_timedsend), mqdes, msg_ptr, msg_len, msg_prio, abs_timeout);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(mq_timedreceive_time64, mq_timedreceive, [](FEXCore::Core::CpuStateFrame *Frame, FEX::HLE::mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abs_timeout) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mq_timedreceive), mqdes, msg_ptr, msg_len, msg_prio, abs_timeout);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X32(mq_open, [](FEXCore::Core::CpuStateFrame *Frame, const char *name, int oflag, mode_t mode, compat_ptr<FEX::HLE::x32::mq_attr32> attr) -> uint64_t {
       mq_attr HostAttr{};
       mq_attr *HostAttr_p{};
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Sched.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Sched.cpp
index 359c69f4fd..9a990b5d39 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Sched.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Sched.cpp
@@ -29,10 +29,5 @@ namespace FEX::HLE::x32 {
       }
       SYSCALL_ERRNO();
     });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS(sched_rr_get_interval_time64, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, struct timespec *tp) -> uint64_t {
-      uint64_t Result = ::sched_rr_get_interval(pid, tp);
-      SYSCALL_ERRNO();
-    });
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Semaphore.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Semaphore.cpp
index 579fe305cf..feccb3f971 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Semaphore.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Semaphore.cpp
@@ -385,11 +385,6 @@ namespace FEX::HLE::x32 {
   void RegisterSemaphore(FEX::HLE::SyscallHandler *Handler) {
     REGISTER_SYSCALL_IMPL_X32(ipc, _ipc);
 
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(semtimedop_time64, semtimedop, [](FEXCore::Core::CpuStateFrame *Frame, int semid, struct sembuf *sops, size_t nsops, const struct timespec *timeout) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(semtimedop), semid, sops, nsops, timeout);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X32(semctl, [](FEXCore::Core::CpuStateFrame *Frame, int semid, int semnum, int cmd, semun_32 *semun) -> uint64_t {
       uint64_t Result{};
       bool IPC64 = cmd & 0x100;
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Signals.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Signals.cpp
index 99443f6a1b..d16b094340 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Signals.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Signals.cpp
@@ -213,7 +213,7 @@ namespace FEX::HLE::x32 {
       REGISTER_SYSCALL_IMPL_X32(pidfd_send_signal, UnimplementedSyscallSafe);
     }
 
-    REGISTER_SYSCALL_IMPL_X32_PASS(rt_sigqueueinfo, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int sig, compat_ptr<FEXCore::x86::siginfo_t> info) -> uint64_t {
+    REGISTER_SYSCALL_IMPL_X32(rt_sigqueueinfo, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int sig, compat_ptr<FEXCore::x86::siginfo_t> info) -> uint64_t {
       siginfo_t info64{};
       siginfo_t *info64_p{};
 
@@ -225,7 +225,7 @@ namespace FEX::HLE::x32 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X32_PASS(rt_tgsigqueueinfo, [](FEXCore::Core::CpuStateFrame *Frame, pid_t tgid, pid_t tid, int sig, compat_ptr<FEXCore::x86::siginfo_t> info) -> uint64_t {
+    REGISTER_SYSCALL_IMPL_X32(rt_tgsigqueueinfo, [](FEXCore::Core::CpuStateFrame *Frame, pid_t tgid, pid_t tid, int sig, compat_ptr<FEXCore::x86::siginfo_t> info) -> uint64_t {
       siginfo_t info64{};
       siginfo_t *info64_p{};
 
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Syscalls.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Syscalls.cpp
index 73aa821403..3f349910dd 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Syscalls.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Syscalls.cpp
@@ -40,6 +40,7 @@ namespace FEX::HLE::x32 {
   void RegisterThread(FEX::HLE::SyscallHandler *Handler);
   void RegisterTime(FEX::HLE::SyscallHandler *Handler);
   void RegisterTimer(FEX::HLE::SyscallHandler *Handler);
+  void RegisterGenerated(FEX::HLE::SyscallHandler *Handler);
 
   x32SyscallHandler::x32SyscallHandler(FEXCore::Context::Context *ctx, FEX::HLE::SignalDelegator *_SignalDelegation, fextl::unique_ptr<MemAllocator> Allocator)
     : SyscallHandler{ctx, _SignalDelegation}, AllocHandler{std::move(Allocator)} {
@@ -67,21 +68,13 @@ namespace FEX::HLE::x32 {
     FEX::HLE::RegisterFS(this);
     FEX::HLE::RegisterInfo(this);
     FEX::HLE::RegisterIO(this);
-    FEX::HLE::RegisterIOUring(this);
-    FEX::HLE::RegisterKey(this);
     FEX::HLE::RegisterMemory(this);
-    FEX::HLE::RegisterMsg(this);
-    FEX::HLE::RegisterNamespace(this);
-    FEX::HLE::RegisterSched(this);
-    FEX::HLE::RegisterSemaphore(this);
-    FEX::HLE::RegisterSHM(this);
     FEX::HLE::RegisterSignals(this);
-    FEX::HLE::RegisterSocket(this);
     FEX::HLE::RegisterThread(this);
-    FEX::HLE::RegisterTime(this);
     FEX::HLE::RegisterTimer(this);
     FEX::HLE::RegisterNotImplemented(this);
     FEX::HLE::RegisterStubs(this);
+    FEX::HLE::RegisterGenerated(this);
 
     // 32bit specific
     FEX::HLE::x32::RegisterEpoll(this);
@@ -100,6 +93,7 @@ namespace FEX::HLE::x32 {
     FEX::HLE::x32::RegisterThread(this);
     FEX::HLE::x32::RegisterTime(this);
     FEX::HLE::x32::RegisterTimer(this);
+    FEX::HLE::x32::RegisterGenerated(this);
 
     FEX::HLE::x32::InitializeStaticIoctlHandlers();
 
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Thread.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Thread.cpp
index bc5d9123bf..37919f18a9 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Thread.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Thread.cpp
@@ -213,86 +213,6 @@ namespace FEX::HLE::x32 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(getgroups32, getgroups, [](FEXCore::Core::CpuStateFrame *Frame, int size, gid_t list[]) -> uint64_t {
-      uint64_t Result = ::getgroups(size, list);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(setgroups32, setgroups, [](FEXCore::Core::CpuStateFrame *Frame, size_t size, const gid_t *list) -> uint64_t {
-      uint64_t Result = ::setgroups(size, list);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(getuid32, getuid, [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::getuid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(getgid32, getgid, [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::getgid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(setuid32, setuid, [](FEXCore::Core::CpuStateFrame *Frame, uid_t uid) -> uint64_t {
-      uint64_t Result = ::setuid(uid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(setgid32, setgid, [](FEXCore::Core::CpuStateFrame *Frame, gid_t gid) -> uint64_t {
-      uint64_t Result = ::setgid(gid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(geteuid32, geteuid, [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::geteuid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(getegid32, getegid, [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::getegid();
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(setfsuid32, setfsuid, [](FEXCore::Core::CpuStateFrame *Frame, uid_t fsuid) -> uint64_t {
-      uint64_t Result = ::setfsuid(fsuid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(setfsgid32, setfsgid, [](FEXCore::Core::CpuStateFrame *Frame, uid_t fsgid) -> uint64_t {
-      uint64_t Result = ::setfsgid(fsgid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(setreuid32, setreuid, [](FEXCore::Core::CpuStateFrame *Frame, uid_t ruid, uid_t euid) -> uint64_t {
-      uint64_t Result = ::setreuid(ruid, euid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(setresuid32, setresuid, [](FEXCore::Core::CpuStateFrame *Frame, uid_t ruid, uid_t euid, uid_t suid) -> uint64_t {
-      uint64_t Result = ::setresuid(ruid, euid, suid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(getresuid32, getresuid, [](FEXCore::Core::CpuStateFrame *Frame, uid_t *ruid, uid_t *euid, uid_t *suid) -> uint64_t {
-      uint64_t Result = ::getresuid(ruid, euid, suid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(setresgid32, setresgid, [](FEXCore::Core::CpuStateFrame *Frame, gid_t rgid, gid_t egid, gid_t sgid) -> uint64_t {
-      uint64_t Result = ::setresgid(rgid, egid, sgid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(getresgid32, getresgid, [](FEXCore::Core::CpuStateFrame *Frame, gid_t *rgid, gid_t *egid, gid_t *sgid) -> uint64_t {
-      uint64_t Result = ::getresgid(rgid, egid, sgid);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(setregid32, setregid, [](FEXCore::Core::CpuStateFrame *Frame, gid_t rgid, gid_t egid) -> uint64_t {
-      uint64_t Result = ::setregid(rgid, egid);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X32(sigaltstack, [](FEXCore::Core::CpuStateFrame *Frame, const compat_ptr<stack_t32> ss, compat_ptr<stack_t32> old_ss) -> uint64_t {
       stack_t ss64{};
       stack_t old64{};
@@ -420,16 +340,5 @@ namespace FEX::HLE::x32 {
 
       SYSCALL_ERRNO();
     });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(futex_time64, futex, [](FEXCore::Core::CpuStateFrame *Frame, int *uaddr, int futex_op, int val, const struct timespec *timeout, int *uaddr2, uint32_t val3) -> uint64_t {
-      uint64_t Result = syscall(SYSCALL_DEF(futex),
-        uaddr,
-        futex_op,
-        val,
-        timeout,
-        uaddr2,
-        val3);
-      SYSCALL_ERRNO();
-    });
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Time.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Time.cpp
index 1f6b4c2667..aac4983083 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Time.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Time.cpp
@@ -197,36 +197,6 @@ namespace FEX::HLE::x32 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(clock_gettime64, clock_gettime, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clk_id, timespec *tp) -> uint64_t {
-      uint64_t Result = ::clock_gettime(clk_id, tp);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(clock_adjtime64, clock_adjtime, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clk_id, struct timex *buf) -> uint64_t {
-      uint64_t Result = ::clock_adjtime(clk_id, buf);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(clock_settime64, clock_settime, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clockid, const struct timespec *tp) -> uint64_t {
-      uint64_t Result = ::clock_settime(clockid, tp);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(clock_getres_time64, clock_getres, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clk_id, timespec *tp) -> uint64_t {
-      uint64_t Result = ::clock_getres(clk_id, tp);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(clock_nanosleep_time64, clock_nanosleep, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clockid, int flags, const struct timespec *request, struct timespec *remain) -> uint64_t {
-      uint64_t Result = ::clock_nanosleep(clockid, flags, request, remain);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(utimensat_time64, utimensat, [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, const struct timespec times[2], int flags) -> uint64_t {
-      uint64_t Result = ::utimensat(dirfd, pathname, times, flags);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X32(utimes, [](FEXCore::Core::CpuStateFrame *Frame, const char *filename, const timeval32 times[2]) -> uint64_t {
       uint64_t Result = 0;
       if (times) {
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Timer.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Timer.cpp
index 9acac543c6..642ae43aa2 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Timer.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Timer.cpp
@@ -54,16 +54,6 @@ namespace FEX::HLE::x32 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(timer_settime64, timer_settime, [](FEXCore::Core::CpuStateFrame *Frame, kernel_timer_t timerid, int flags, const struct itimerspec *new_value, struct itimerspec *old_value) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(timer_settime), timerid, flags, new_value, old_value);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(timer_gettime64, timer_gettime, [](FEXCore::Core::CpuStateFrame *Frame, kernel_timer_t timerid, struct itimerspec *curr_value) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(timer_gettime), timerid, curr_value);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X32(getitimer, [](FEXCore::Core::CpuStateFrame *Frame, int which, FEX::HLE::x32::itimerval32 *curr_value) -> uint64_t {
       itimerval val{};
       itimerval *val_p{};
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/FD.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/FD.cpp
index 8c3d64af50..9d89623f8b 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/FD.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/FD.cpp
@@ -29,12 +29,12 @@ tags: LinuxSyscalls|syscalls-x86-64
 
 namespace FEX::HLE::x64 {
   void RegisterFD(FEX::HLE::SyscallHandler *Handler) {
-    REGISTER_SYSCALL_IMPL_X64_PASS(poll, [](FEXCore::Core::CpuStateFrame *Frame, struct pollfd *fds, nfds_t nfds, int timeout) -> uint64_t {
+    REGISTER_SYSCALL_IMPL_X64(poll, [](FEXCore::Core::CpuStateFrame *Frame, struct pollfd *fds, nfds_t nfds, int timeout) -> uint64_t {
       uint64_t Result = ::poll(fds, nfds, timeout);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X64_PASS(select, [](FEXCore::Core::CpuStateFrame *Frame, int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) -> uint64_t {
+    REGISTER_SYSCALL_IMPL_X64(select, [](FEXCore::Core::CpuStateFrame *Frame, int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) -> uint64_t {
       uint64_t Result = ::select(nfds, readfds, writefds, exceptfds, timeout);
       SYSCALL_ERRNO();
     });
@@ -58,21 +58,6 @@ namespace FEX::HLE::x64 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X64_PASS(futimesat, [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, const struct timeval times[2]) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(futimesat), dirfd, pathname, times);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(utimensat, [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, const struct timespec times[2], int flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(utimensat), dirfd, pathname, times, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(pselect6, [](FEXCore::Core::CpuStateFrame *Frame, int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const void *sigmaskpack) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(pselect6), nfds, readfds, writefds, exceptfds, timeout, sigmaskpack);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X64(stat, [](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, FEX::HLE::x64::guest_stat *buf) -> uint64_t {
       struct stat host_stat;
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Stat(pathname, &host_stat);
@@ -100,21 +85,6 @@ namespace FEX::HLE::x64 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X64_PASS(readv, [](FEXCore::Core::CpuStateFrame *Frame, int fd, const struct iovec *iov, int iovcnt) -> uint64_t {
-      uint64_t Result = ::readv(fd, iov, iovcnt);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(writev, [](FEXCore::Core::CpuStateFrame *Frame, int fd, const struct iovec *iov, int iovcnt) -> uint64_t {
-      uint64_t Result = ::writev(fd, iov, iovcnt);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(readahead, [](FEXCore::Core::CpuStateFrame *Frame, int fd, off64_t offset, size_t count) -> uint64_t {
-      uint64_t Result = ::readahead(fd, offset, count);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X64(newfstatat, [](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, FEX::HLE::x64::guest_stat *buf, int flag) -> uint64_t {
       struct stat host_stat;
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.NewFSStatAt(dirfd, pathname, &host_stat, flag);
@@ -124,102 +94,11 @@ namespace FEX::HLE::x64 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X64_PASS(vmsplice, [](FEXCore::Core::CpuStateFrame *Frame, int fd, const struct iovec *iov, unsigned long nr_segs, unsigned int flags) -> uint64_t {
-      uint64_t Result = ::vmsplice(fd, iov, nr_segs, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(preadv, [](FEXCore::Core::CpuStateFrame *Frame,
-      int fd,
-      const struct iovec *iov,
-      uint64_t vlen,
-      uint64_t pos_l,
-      uint64_t pos_h) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(preadv), fd, iov, vlen, pos_l, pos_h);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(pwritev, [](FEXCore::Core::CpuStateFrame *Frame,
-      int fd,
-      const struct iovec *iov,
-      uint64_t vlen,
-      uint64_t pos_l,
-      uint64_t pos_h) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(pwritev), fd, iov, vlen, pos_l, pos_h);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(preadv2, [](FEXCore::Core::CpuStateFrame *Frame,
-      int fd,
-      const struct iovec *iov,
-      uint64_t vlen,
-      uint64_t pos_l,
-      uint64_t pos_h,
-      int flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(preadv2), fd, iov, vlen, pos_l, pos_h, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(pwritev2, [](FEXCore::Core::CpuStateFrame *Frame,
-      int fd,
-      const struct iovec *iov,
-      uint64_t vlen,
-      uint64_t pos_l,
-      uint64_t pos_h,
-      int flags) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(pwritev2), fd, iov, vlen, pos_l, pos_h, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(pread_64, [](FEXCore::Core::CpuStateFrame *Frame, int fd, void *buf, size_t count, off_t offset) -> uint64_t {
-      uint64_t Result = ::pread64(fd, buf, count, offset);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(pwrite_64, [](FEXCore::Core::CpuStateFrame *Frame, int fd, void *buf, size_t count, off_t offset) -> uint64_t {
-      uint64_t Result = ::pwrite64(fd, buf, count, offset);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(process_vm_readv, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, const struct iovec *local_iov, unsigned long liovcnt, const struct iovec *remote_iov, unsigned long riovcnt, unsigned long flags) -> uint64_t {
-      uint64_t Result = ::process_vm_readv(pid, local_iov, liovcnt, remote_iov, riovcnt, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(process_vm_writev, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, const struct iovec *local_iov, unsigned long liovcnt, const struct iovec *remote_iov, unsigned long riovcnt, unsigned long flags) -> uint64_t {
-      uint64_t Result = ::process_vm_writev(pid, local_iov, liovcnt, remote_iov, riovcnt, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(ppoll, [](FEXCore::Core::CpuStateFrame *Frame, struct pollfd *fds, nfds_t nfds, struct timespec *timeout_ts, const uint64_t *sigmask, size_t sigsetsize) -> uint64_t {
-      // glibc wrapper doesn't allow timeout_ts to be modified like the kernel does
-      int Result = ::syscall(SYSCALL_DEF(ppoll), fds, nfds, timeout_ts, sigmask, sigsetsize);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X64(getdents, [](FEXCore::Core::CpuStateFrame *Frame, int fd, void *dirp, uint32_t count) -> uint64_t {
       return GetDentsEmulation<false>(fd, reinterpret_cast<FEX::HLE::x64::linux_dirent*>(dirp), count);
     });
 
-    REGISTER_SYSCALL_IMPL_X64_PASS(getdents64, [](FEXCore::Core::CpuStateFrame *Frame, int fd, void *dirp, uint32_t count) -> uint64_t {
-      uint64_t Result = syscall(SYSCALL_DEF(getdents64),
-        static_cast<uint64_t>(fd),
-        reinterpret_cast<uint64_t>(dirp),
-        static_cast<uint64_t>(count));
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(sendfile, [](FEXCore::Core::CpuStateFrame *Frame, int out_fd, int in_fd, off_t *offset, size_t count) -> uint64_t {
-      uint64_t Result = ::sendfile(out_fd, in_fd, offset, count);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(dup, [](FEXCore::Core::CpuStateFrame *Frame, int oldfd) -> uint64_t {
-      uint64_t Result = ::dup(oldfd);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(dup2, [](FEXCore::Core::CpuStateFrame *Frame, int oldfd, int newfd) -> uint64_t {
+    REGISTER_SYSCALL_IMPL_X64(dup2, [](FEXCore::Core::CpuStateFrame *Frame, int oldfd, int newfd) -> uint64_t {
       uint64_t Result = ::dup2(oldfd, newfd);
       SYSCALL_ERRNO();
     });
@@ -228,32 +107,5 @@ namespace FEX::HLE::x64 {
       uint64_t Result = FEX::HLE::_SyscallHandler->FM.Statfs(path, buf);
       SYSCALL_ERRNO();
     });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(fstatfs, [](FEXCore::Core::CpuStateFrame *Frame, int fd, struct statfs *buf) -> uint64_t {
-      uint64_t Result = ::fstatfs(fd, buf);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(sync_file_range, [](FEXCore::Core::CpuStateFrame *Frame, int fd, off64_t offset, off64_t nbytes, unsigned int flags) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::syscall(SYSCALL_DEF(sync_file_range), fd, offset, nbytes, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(fallocate, [](FEXCore::Core::CpuStateFrame *Frame, int fd, int mode, off_t offset, off_t len) -> uint64_t {
-      uint64_t Result = ::fallocate(fd, mode, offset, len);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(timerfd_settime, [](FEXCore::Core::CpuStateFrame *Frame, int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value) -> uint64_t {
-      // Flags don't need remapped
-      uint64_t Result = ::timerfd_settime(fd, flags, new_value, old_value);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(timerfd_gettime, [](FEXCore::Core::CpuStateFrame *Frame, int fd, struct itimerspec *curr_value) -> uint64_t {
-      uint64_t Result = ::timerfd_gettime(fd, curr_value);
-      SYSCALL_ERRNO();
-    });
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/IO.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/IO.cpp
deleted file mode 100644
index 5859310aa1..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/IO.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-x86-64
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-
-#include <linux/aio_abi.h>
-#include <stdint.h>
-#include <syscall.h>
-#include <unistd.h>
-
-namespace FEXCore::Core {
-  struct CpuStateFrame;
-}
-
-namespace FEX::HLE::x64 {
-  void RegisterIO(FEX::HLE::SyscallHandler *Handler) {
-    REGISTER_SYSCALL_IMPL_X64_PASS(io_getevents, [](FEXCore::Core::CpuStateFrame *Frame, aio_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(io_getevents), ctx_id, min_nr, nr, events, timeout);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(io_pgetevents, [](FEXCore::Core::CpuStateFrame *Frame, aio_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout, const struct io_sigset  *usig) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(io_pgetevents), ctx_id, min_nr, nr, events, timeout, usig);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Info.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Info.cpp
index c746044870..32c2b1b1e1 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Info.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Info.cpp
@@ -17,27 +17,6 @@ tags: LinuxSyscalls|syscalls-x86-64
 namespace FEX::HLE::x64 {
   void RegisterInfo(FEX::HLE::SyscallHandler *Handler) {
     using namespace FEXCore::IR;
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(sysinfo, [](FEXCore::Core::CpuStateFrame *Frame, struct sysinfo *info) -> uint64_t {
-      uint64_t Result = ::sysinfo(info);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(getrusage, [](FEXCore::Core::CpuStateFrame *Frame, int who, struct rusage *usage) -> uint64_t {
-      uint64_t Result = ::getrusage(who, usage);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(getrlimit, [](FEXCore::Core::CpuStateFrame *Frame, int resource, struct rlimit *rlim) -> uint64_t {
-      uint64_t Result = ::getrlimit(resource, rlim);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(setrlimit, [](FEXCore::Core::CpuStateFrame *Frame, int resource, const struct rlimit *rlim) -> uint64_t {
-      uint64_t Result = ::setrlimit(resource, rlim);
-      SYSCALL_ERRNO();
-    });
-
     if (Handler->IsHostKernelVersionAtLeast(6, 6, 0)) {
       REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(map_shadow_stack, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
         [](FEXCore::Core::CpuStateFrame *Frame, uint64_t addr, uint64_t size, uint32_t flags) -> uint64_t {
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Ioctl.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Ioctl.cpp
deleted file mode 100644
index d2dc68bda5..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Ioctl.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-x86-64
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-
-#include <stdint.h>
-#include <sys/ioctl.h>
-
-namespace FEXCore::Core {
-  struct CpuStateFrame;
-}
-
-namespace FEX::HLE::x64 {
-  void RegisterIoctl(FEX::HLE::SyscallHandler *Handler) {
-    REGISTER_SYSCALL_IMPL_X64_PASS(ioctl, [](FEXCore::Core::CpuStateFrame *Frame, int fd, uint64_t request, void *args) -> uint64_t {
-      uint64_t Result = ::ioctl(fd, request, args);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Memory.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Memory.cpp
index 99ac8dfa9e..b61a9a0f87 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Memory.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Memory.cpp
@@ -103,18 +103,6 @@ namespace FEX::HLE::x64 {
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(mlockall, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int flags) -> uint64_t {
-      uint64_t Result = ::mlockall(flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(munlockall, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
-      uint64_t Result = ::munlockall();
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X64_FLAGS(_shmat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
       [](FEXCore::Core::CpuStateFrame *Frame, int shmid, const void *shmaddr, int shmflg) -> uint64_t {
       uint64_t Result = reinterpret_cast<uint64_t>(shmat(shmid, shmaddr, shmflg));
@@ -134,16 +122,5 @@ namespace FEX::HLE::x64 {
       }
       SYSCALL_ERRNO();
     });
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 10, 0)) {
-      REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(process_madvise, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-        [](FEXCore::Core::CpuStateFrame *Frame, int pidfd, const struct iovec *iovec, size_t vlen, int advice, unsigned int flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(process_madvise), pidfd, iovec, vlen, advice, flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL_X64(process_madvise, UnimplementedSyscallSafe);
-    }
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Msg.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Msg.cpp
deleted file mode 100644
index dd17eb70b9..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Msg.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-x86-64
-$end_info$
-*/
-
-#include "LinuxSyscalls/Types.h"
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <syscall.h>
-#include <unistd.h>
-
-namespace FEXCore::Core {
-  struct CpuStateFrame;
-}
-
-namespace FEX::HLE::x64 {
-  void RegisterMsg(FEX::HLE::SyscallHandler *Handler) {
-    REGISTER_SYSCALL_IMPL_X64_PASS(mq_timedsend, [](FEXCore::Core::CpuStateFrame *Frame, FEX::HLE::mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mq_timedsend), mqdes, msg_ptr, msg_len, msg_prio, abs_timeout);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(mq_timedreceive, [](FEXCore::Core::CpuStateFrame *Frame, FEX::HLE::mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abs_timeout) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mq_timedreceive), mqdes, msg_ptr, msg_len, msg_prio, abs_timeout);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(mq_open, [](FEXCore::Core::CpuStateFrame *Frame, const char *name, int oflag, mode_t mode, struct mq_attr *attr) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mq_open), name, oflag, mode, attr);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(mq_notify, [](FEXCore::Core::CpuStateFrame *Frame, FEX::HLE::mqd_t mqdes, const struct sigevent *sevp) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mq_notify), mqdes, sevp);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(mq_getsetattr, [](FEXCore::Core::CpuStateFrame *Frame, FEX::HLE::mqd_t mqdes, struct mq_attr *newattr, struct mq_attr *oldattr) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(mq_getsetattr), mqdes, newattr, oldattr);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Sched.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Sched.cpp
deleted file mode 100644
index d1ef574fe1..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Sched.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-x86-64
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-
-#include <stdint.h>
-#include <sched.h>
-#include <unistd.h>
-
-namespace FEXCore::Core {
-  struct CpuStateFrame;
-}
-
-namespace FEX::HLE::x64 {
-  void RegisterSched(FEX::HLE::SyscallHandler *Handler) {
-    REGISTER_SYSCALL_IMPL_X64_PASS(sched_rr_get_interval, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, struct timespec *tp) -> uint64_t {
-      uint64_t Result = ::sched_rr_get_interval(pid, tp);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Semaphore.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Semaphore.cpp
index 415391d9fc..3acacb4a59 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Semaphore.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Semaphore.cpp
@@ -23,16 +23,6 @@ ARG_TO_STR(FEX::HLE::x64::semun, "%lx")
 
 namespace FEX::HLE::x64 {
   void RegisterSemaphore(FEX::HLE::SyscallHandler *Handler) {
-   REGISTER_SYSCALL_IMPL_X64_PASS(semop, [](FEXCore::Core::CpuStateFrame *Frame, int semid, struct sembuf *sops, size_t nsops) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(semop), semid, sops, nsops);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(semtimedop, [](FEXCore::Core::CpuStateFrame *Frame, int semid, struct sembuf *sops, size_t nsops, const struct timespec *timeout) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(semtimedop), semid, sops, nsops, timeout);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X64(semctl, [](FEXCore::Core::CpuStateFrame *Frame, int semid, int semnum, int cmd, FEX::HLE::x64::semun semun) -> uint64_t {
       uint64_t Result{};
       switch (cmd) {
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Signals.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Signals.cpp
index 4c68ffb50f..85400a7000 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Signals.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Signals.cpp
@@ -31,26 +31,6 @@ namespace FEX::HLE::x64 {
     REGISTER_SYSCALL_IMPL_X64(rt_sigtimedwait, [](FEXCore::Core::CpuStateFrame *Frame, uint64_t *set, siginfo_t *info, const struct timespec* timeout, size_t sigsetsize) -> uint64_t {
       return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSigTimedWait(set, info, timeout, sigsetsize);
     });
-
-    if (Handler->IsHostKernelVersionAtLeast(5, 1, 0)) {
-      REGISTER_SYSCALL_IMPL_X64_PASS(pidfd_send_signal, [](FEXCore::Core::CpuStateFrame *Frame, int pidfd, int sig, siginfo_t *info, unsigned int flags) -> uint64_t {
-        uint64_t Result = ::syscall(SYSCALL_DEF(pidfd_send_signal), pidfd, sig, info, flags);
-        SYSCALL_ERRNO();
-      });
-    }
-    else {
-      REGISTER_SYSCALL_IMPL_X64(pidfd_send_signal, UnimplementedSyscallSafe);
-    }
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(rt_sigqueueinfo, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int sig, siginfo_t *info) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(rt_sigqueueinfo), pid, sig, info);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(rt_tgsigqueueinfo, [](FEXCore::Core::CpuStateFrame *Frame, pid_t tgid, pid_t tid, int sig, siginfo_t *info) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(rt_tgsigqueueinfo), tgid, tid, sig, info);
-      SYSCALL_ERRNO();
-    });
   }
 }
 
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Socket.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Socket.cpp
deleted file mode 100644
index 7de85cae1b..0000000000
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Socket.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-// SPDX-License-Identifier: MIT
-/*
-$info$
-tags: LinuxSyscalls|syscalls-x86-64
-$end_info$
-*/
-
-#include "LinuxSyscalls/Syscalls.h"
-#include "LinuxSyscalls/x64/Syscalls.h"
-
-#include <stdint.h>
-#include <sys/socket.h>
-
-namespace FEXCore::Core {
-  struct CpuStateFrame;
-}
-
-namespace FEX::HLE::x64 {
-  void RegisterSocket(FEX::HLE::SyscallHandler *Handler) {
-    REGISTER_SYSCALL_IMPL_X64_PASS(accept, [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct sockaddr *addr, socklen_t *addrlen) -> uint64_t {
-      uint64_t Result = ::accept(sockfd, addr, addrlen);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(recvmmsg, [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, struct timespec *timeout) -> uint64_t {
-      uint64_t Result = ::recvmmsg(sockfd, msgvec, vlen, flags, timeout);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(sendmmsg, [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct mmsghdr *msgvec, uint32_t vlen, int flags) -> uint64_t {
-      uint64_t Result = ::sendmmsg(sockfd, msgvec, vlen, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(sendmsg, [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, const struct msghdr *msg, int flags) -> uint64_t {
-      uint64_t Result = ::sendmsg(sockfd, msg, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(recvmsg, [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct msghdr *msg, int flags) -> uint64_t {
-      uint64_t Result = ::recvmsg(sockfd, msg, flags);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(setsockopt, [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, int level, int optname, const void *optval, socklen_t optlen) -> uint64_t {
-      uint64_t Result = ::setsockopt(sockfd, level, optname, optval, optlen);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(getsockopt, [](FEXCore::Core::CpuStateFrame *Frame, int sockfd, int level, int optname, void *optval, socklen_t *optlen) -> uint64_t {
-      uint64_t Result = ::getsockopt(sockfd, level, optname, optval, optlen);
-      SYSCALL_ERRNO();
-    });
-  }
-}
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Syscalls.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Syscalls.cpp
index 1b24c4ff5d..1f290293ca 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Syscalls.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Syscalls.cpp
@@ -15,17 +15,13 @@ namespace FEX::HLE::x64 {
   void RegisterEpoll(FEX::HLE::SyscallHandler *Handler);
   void RegisterFD(FEX::HLE::SyscallHandler *Handler);
   void RegisterInfo(FEX::HLE::SyscallHandler *Handler);
-  void RegisterIO(FEX::HLE::SyscallHandler *Handler);
-  void RegisterIoctl(FEX::HLE::SyscallHandler *Handler);
   void RegisterMemory(FEX::HLE::SyscallHandler *Handler);
-  void RegisterMsg(FEX::HLE::SyscallHandler *Handler);
-  void RegisterSched(FEX::HLE::SyscallHandler *Handler);
-  void RegisterSocket(FEX::HLE::SyscallHandler *Handler);
   void RegisterSemaphore(FEX::HLE::SyscallHandler *Handler);
   void RegisterSignals(FEX::HLE::SyscallHandler *Handler);
   void RegisterThread(FEX::HLE::SyscallHandler *Handler);
-  void RegisterTime(FEX::HLE::SyscallHandler *Handler);
   void RegisterNotImplemented(FEX::HLE::SyscallHandler *Handler);
+  void RegisterTime(FEX::HLE::SyscallHandler *Handler);
+  void RegisterGenerated(FEX::HLE::SyscallHandler *Handler);
 
   x64SyscallHandler::x64SyscallHandler(FEXCore::Context::Context *ctx, FEX::HLE::SignalDelegator *_SignalDelegation)
     : SyscallHandler {ctx, _SignalDelegation} {
@@ -54,37 +50,25 @@ namespace FEX::HLE::x64 {
     FEX::HLE::RegisterFS(this);
     FEX::HLE::RegisterInfo(this);
     FEX::HLE::RegisterIO(this);
-    FEX::HLE::RegisterIOUring(this);
-    FEX::HLE::RegisterKey(this);
     FEX::HLE::RegisterMemory(this);
-    FEX::HLE::RegisterMsg(this);
-    FEX::HLE::RegisterNamespace(this);
-    FEX::HLE::RegisterSched(this);
-    FEX::HLE::RegisterSemaphore(this);
-    FEX::HLE::RegisterSHM(this);
     FEX::HLE::RegisterSignals(this);
-    FEX::HLE::RegisterSocket(this);
     FEX::HLE::RegisterThread(this);
-    FEX::HLE::RegisterTime(this);
     FEX::HLE::RegisterTimer(this);
     FEX::HLE::RegisterNotImplemented(this);
     FEX::HLE::RegisterStubs(this);
+    FEX::HLE::RegisterGenerated(this);
 
     // 64bit specific
     FEX::HLE::x64::RegisterEpoll(this);
     FEX::HLE::x64::RegisterFD(this);
     FEX::HLE::x64::RegisterInfo(this);
-    FEX::HLE::x64::RegisterIO(this);
-    FEX::HLE::x64::RegisterIoctl(this);
     FEX::HLE::x64::RegisterMemory(this);
-    FEX::HLE::x64::RegisterMsg(this);
-    FEX::HLE::x64::RegisterSched(this);
-    FEX::HLE::x64::RegisterSocket(this);
     FEX::HLE::x64::RegisterSemaphore(this);
     FEX::HLE::x64::RegisterSignals(this);
     FEX::HLE::x64::RegisterThread(this);
     FEX::HLE::x64::RegisterTime(this);
     FEX::HLE::x64::RegisterNotImplemented(this);
+    FEX::HLE::x64::RegisterGenerated(this);
 
     // x86-64 has a gap of syscalls in the range of [335, 424) where there aren't any
     // These are defined that these must return -ENOSYS
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Thread.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Thread.cpp
index 1947d2da34..a650a36cc8 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Thread.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Thread.cpp
@@ -57,40 +57,6 @@ namespace FEX::HLE::x64 {
       return CloneHandler(Frame, &args);
     }));
 
-    REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(futex, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int *uaddr, int futex_op, int val, const struct timespec *timeout, int *uaddr2, uint32_t val3) -> uint64_t {
-      uint64_t Result = syscall(SYSCALL_DEF(futex),
-        uaddr,
-        futex_op,
-        val,
-        timeout,
-        uaddr2,
-        val3);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_FLAGS(set_robust_list, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, struct robust_list_head *head, size_t len) -> uint64_t {
-      auto Thread = Frame->Thread;
-      Thread->ThreadManager.robust_list_head = reinterpret_cast<uint64_t>(head);
-#ifdef TERMUX_BUILD
-      // Termux/Android doesn't support `set_robust_list` syscall.
-      // The seccomp filter that the OS installs explicitly blocks this syscall from working
-      // glibc uses this syscall for tls and thread data so almost every application uses it
-      // Return success since we have stored the pointer ourselves.
-      return 0;
-#else
-      uint64_t Result = ::syscall(SYSCALL_DEF(set_robust_list), head, len);
-      SYSCALL_ERRNO();
-#endif
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(get_robust_list, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int pid, struct robust_list_head **head, size_t *len_ptr) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(get_robust_list), pid, head, len_ptr);
-      SYSCALL_ERRNO();
-    });
-
     REGISTER_SYSCALL_IMPL_X64(sigaltstack, [](FEXCore::Core::CpuStateFrame *Frame, const stack_t *ss, stack_t *old_ss) -> uint64_t {
       return FEX::HLE::_SyscallHandler->GetSignalDelegator()->RegisterGuestSigAltStack(ss, old_ss);
     });
@@ -156,17 +122,5 @@ namespace FEX::HLE::x64 {
       auto* const* EnvpPtr = envp ? const_cast<char* const*>(Envp.data()) : nullptr;
       return FEX::HLE::ExecveHandler(pathname, ArgsPtr, EnvpPtr, AtArgs);
     }));
-
-    REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(wait4, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int *wstatus, int options, struct rusage *rusage) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(wait4), pid, wstatus, options, rusage);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(waitid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
-      [](FEXCore::Core::CpuStateFrame *Frame, int which, pid_t upid, siginfo_t *infop, int options, struct rusage *rusage) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(waitid), which, upid, infop, options, rusage);
-      SYSCALL_ERRNO();
-    });
   }
 }
diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Time.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Time.cpp
index 4df537c678..9085dcb7cf 100644
--- a/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Time.cpp
+++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/x64/Time.cpp
@@ -21,95 +21,20 @@ tags: LinuxSyscalls|syscalls-x86-64
 
 namespace FEX::HLE::x64 {
   void RegisterTime(FEX::HLE::SyscallHandler *Handler) {
-    REGISTER_SYSCALL_IMPL_X64_PASS(time, [](FEXCore::Core::CpuStateFrame *Frame, time_t *tloc) -> uint64_t {
+    using namespace FEXCore::IR;
+    REGISTER_SYSCALL_IMPL_X64_FLAGS(time, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY, [](FEXCore::Core::CpuStateFrame *Frame, time_t *tloc) -> uint64_t {
       uint64_t Result = ::time(tloc);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X64_PASS(times, [](FEXCore::Core::CpuStateFrame *Frame, struct tms *buf) -> uint64_t {
-      uint64_t Result = ::times(buf);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(utime, [](FEXCore::Core::CpuStateFrame *Frame, char* filename, const struct utimbuf* times) -> uint64_t {
+    REGISTER_SYSCALL_IMPL_X64(utime, [](FEXCore::Core::CpuStateFrame *Frame, char* filename, const struct utimbuf* times) -> uint64_t {
       uint64_t Result = ::utime(filename, times);
       SYSCALL_ERRNO();
     });
 
-    REGISTER_SYSCALL_IMPL_X64_PASS(gettimeofday, [](FEXCore::Core::CpuStateFrame *Frame, struct timeval *tv, struct timezone *tz) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(gettimeofday), tv, tz);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(nanosleep, [](FEXCore::Core::CpuStateFrame *Frame, const struct timespec *req, struct timespec *rem) -> uint64_t {
-      uint64_t Result = ::nanosleep(req, rem);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(clock_gettime, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clk_id, struct timespec *tp) -> uint64_t {
-      uint64_t Result = ::clock_gettime(clk_id, tp);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(clock_getres, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clk_id, struct timespec *tp) -> uint64_t {
-      uint64_t Result = ::clock_getres(clk_id, tp);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(clock_nanosleep, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clockid, int flags, const struct timespec *request, struct timespec *remain) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(clock_nanosleep), clockid, flags, request, remain);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(clock_settime, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clockid, const struct timespec *tp) -> uint64_t {
-      uint64_t Result = ::clock_settime(clockid, tp);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(settimeofday, [](FEXCore::Core::CpuStateFrame *Frame, const struct timeval *tv, const struct timezone *tz) -> uint64_t {
-      uint64_t Result = ::settimeofday(tv, tz);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(utimes, [](FEXCore::Core::CpuStateFrame *Frame, const char *filename, const struct timeval times[2]) -> uint64_t {
+    REGISTER_SYSCALL_IMPL_X64(utimes, [](FEXCore::Core::CpuStateFrame *Frame, const char *filename, const struct timeval times[2]) -> uint64_t {
       uint64_t Result = ::utimes(filename, times);
       SYSCALL_ERRNO();
     });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(getitimer, [](FEXCore::Core::CpuStateFrame *Frame, int which, struct itimerval *curr_value) -> uint64_t {
-      uint64_t Result = ::getitimer(which, curr_value);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(setitimer, [](FEXCore::Core::CpuStateFrame *Frame, int which, const struct itimerval *new_value, struct itimerval *old_value) -> uint64_t {
-      uint64_t Result = ::setitimer(which, new_value, old_value);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(timer_settime, [](FEXCore::Core::CpuStateFrame *Frame, kernel_timer_t timerid, int flags, const struct itimerspec *new_value, struct itimerspec *old_value) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(timer_settime), timerid, flags, new_value, old_value);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(timer_gettime, [](FEXCore::Core::CpuStateFrame *Frame, kernel_timer_t timerid, struct itimerspec *curr_value) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(timer_gettime), timerid, curr_value);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(adjtimex, [](FEXCore::Core::CpuStateFrame *Frame, struct timex *buf) -> uint64_t {
-      uint64_t Result = ::adjtimex(buf);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(clock_adjtime, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clk_id, struct timex *buf) -> uint64_t {
-      uint64_t Result = ::clock_adjtime(clk_id, buf);
-      SYSCALL_ERRNO();
-    });
-
-    REGISTER_SYSCALL_IMPL_X64_PASS(timer_create, [](FEXCore::Core::CpuStateFrame *Frame, clockid_t clockid, struct sigevent *sevp, kernel_timer_t *timerid) -> uint64_t {
-      uint64_t Result = ::syscall(SYSCALL_DEF(timer_create), clockid, sevp, timerid);
-      SYSCALL_ERRNO();
-    });
   }
 }
-
diff --git a/Source/Tools/LinuxEmulation/SyscallDescription.json b/Source/Tools/LinuxEmulation/SyscallDescription.json
new file mode 100644
index 0000000000..a38a29ae93
--- /dev/null
+++ b/Source/Tools/LinuxEmulation/SyscallDescription.json
@@ -0,0 +1,2263 @@
+{
+  "Common": {
+    "read": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "write": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "open": {
+      "CustomHandler": true
+    },
+    "close": {
+      "CustomHandler": true
+    },
+    "stat": {
+      "ArchSpecific": true
+    },
+    "fstat": {
+      "ArchSpecific": true
+    },
+    "lstat": {
+      "ArchSpecific": true
+    },
+    "poll": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "lseek": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mmap": {
+      "CustomHandler": true
+    },
+    "mprotect": {
+      "CustomHandler": true
+    },
+    "munmap": {
+      "CustomHandler": true
+    },
+    "brk": {
+      "CustomHandler": true
+    },
+    "rt_sigaction": {
+      "CustomHandler": true
+    },
+    "rt_sigprocmask": {
+      "CustomHandler": true
+    },
+    "rt_sigreturn": {
+      "CustomHandler": true
+    },
+    "ioctl": {
+      "ArchSpecific": true
+    },
+    "pread_64": {
+      "ArchSpecific": true
+    },
+    "pwrite_64": {
+      "ArchSpecific": true
+    },
+    "readv": {
+      "ArchSpecific": true
+    },
+    "writev": {
+      "ArchSpecific": true
+    },
+    "access": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "pipe": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "select": {
+      "ArchSpecific": true
+    },
+    "sched_yield": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mremap": {
+      "CustomHandler": true
+    },
+    "msync": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mincore": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "madvise": {
+      "CustomHandler": true
+    },
+    "_shmget": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "_shmat": {
+      "ArchSpecific": true
+    },
+    "_shmctl": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "dup": {
+      "ArchSpecific": true
+    },
+    "dup2": {
+      "ArchSpecific": true
+    },
+    "pause": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "nanosleep": {
+      "ArchSpecific": true
+    },
+    "getitimer": {
+      "ArchSpecific": true
+    },
+    "alarm": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "setitimer": {
+      "ArchSpecific": true
+    },
+    "getpid": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sendfile": {
+      "ArchSpecific": true
+    },
+    "socket": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "connect": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "accept": {
+      "ArchSpecific": true
+    },
+    "sendto": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "recvfrom": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sendmsg": {
+      "ArchSpecific": true
+    },
+    "recvmsg": {
+      "ArchSpecific": true
+    },
+    "shutdown": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "bind": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "listen": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getsockname": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getpeername": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "socketpair": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setsockopt": {
+      "ArchSpecific": true
+    },
+    "getsockopt": {
+      "ArchSpecific": true
+    },
+    "clone": {
+      "CustomHandler": true
+    },
+    "fork": {
+      "CustomHandler": true
+    },
+    "vfork": {
+      "CustomHandler": true
+    },
+    "execve": {
+      "CustomHandler": true
+    },
+    "exit": {
+      "CustomHandler": true
+    },
+    "wait4": {
+      "ArchSpecific": true
+    },
+    "kill": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::DEFAULT",
+      "Comment": [
+        "Needs default flags to ensure state synchronization.",
+        "Can cause thread to signal itself and want to ensure everything is synchronized."
+      ]
+    },
+    "uname": {
+      "CustomHandler": true
+    },
+    "semget": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "semop": {
+      "ArchSpecific": true
+    },
+    "semctl": {
+      "ArchSpecific": true
+    },
+    "_shmdt": {
+      "ArchSpecific": true
+    },
+    "msgget": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "msgsnd": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "msgrcv": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "msgctl": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "A quirk of this syscall",
+        "On 32-bit this syscall ONLY supports IPC_64 msqid_ds encoding",
+        "If an application want to use the old style encoding then it needs to use the ipc syscall with MSGCTL command",
+        "ipc syscall supports both IPC_64 and old encoding"
+      ]
+    },
+    "fcntl": {
+      "ArchSpecific": true
+    },
+    "flock": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "fsync": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "fdatasync": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "truncate": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "ftruncate": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getdents": {
+      "ArchSpecific": true
+    },
+    "getcwd": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "chdir": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "fchdir": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "rename": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "mkdir": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "rmdir": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "creat": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "link": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "unlink": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "symlink": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "readlink": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "chmod": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "fchmod": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "chown": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "fchown": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "lchown": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "umask": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "gettimeofday": {
+      "ArchSpecific": true
+    },
+    "getrlimit": {
+      "ArchSpecific": true
+    },
+    "getrusage": {
+      "ArchSpecific": true
+    },
+    "sysinfo": {
+      "ArchSpecific": true
+    },
+    "times": {
+      "ArchSpecific": true
+    },
+    "ptrace": {
+      "CustomHandler": true
+    },
+    "getuid": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "syslog": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getgid": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setuid": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setgid": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "geteuid": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getegid": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setpgid": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getppid": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getpgrp": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "setsid": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setreuid": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setregid": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getgroups": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setgroups": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setresuid": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getresuid": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setresgid": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getresgid": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getpgid": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setfsuid": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setfsgid": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getsid": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "capget": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "capset": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "rt_sigpending": {
+      "CustomHandler": true
+    },
+    "rt_sigtimedwait": {
+      "CustomHandler": true
+    },
+    "rt_sigqueueinfo": {
+      "ArchSpecific": true
+    },
+    "rt_sigsuspend": {
+      "CustomHandler": true
+    },
+    "sigaltstack": {
+      "CustomHandler": true
+    },
+    "utime": {
+      "ArchSpecific": true
+    },
+    "mknod": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "uselib": {
+      "CustomHandler": true
+    },
+    "personality": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "ustat": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Doesn't exist on AArch64, will return -ENOSYS",
+        "Since version 2.28 of GLIBC it has stopped providing a wrapper for this syscall"
+      ]
+    },
+    "statfs": {
+      "CustomHandler": true
+    },
+    "fstatfs": {
+      "ArchSpecific": true
+    },
+    "sysfs": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Doesn't exist on AArch64, will return -ENOSYS"
+      ]
+    },
+    "getpriority": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setpriority": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_setparam": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_getparam": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_setscheduler": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_getscheduler": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_get_priority_max": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_get_priority_min": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_rr_get_interval": {
+      "ArchSpecific": true
+    },
+    "mlock": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "munlock": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mlockall": {
+      "ArchSpecific": true
+    },
+    "munlockall": {
+      "ArchSpecific": true
+    },
+    "vhangup": {
+      "CustomHandler": true
+    },
+    "modify_ldt": {
+      "CustomHandler": true
+    },
+    "pivot_root": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "_sysctl": {
+      "CustomHandler": true
+    },
+    "prctl": {
+      "CustomHandler": true
+    },
+    "arch_prctl": {
+      "CustomHandler": true
+    },
+    "adjtimex": {
+      "ArchSpecific": true
+    },
+    "setrlimit": {
+      "ArchSpecific": true
+    },
+    "chroot": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sync": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "acct": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "settimeofday": {
+      "ArchSpecific": true
+    },
+    "mount": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "umount2": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "swapon": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "swapoff": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "reboot": {
+      "CustomHandler": true
+    },
+    "sethostname": {
+      "CustomHandler": true
+    },
+    "setdomainname": {
+      "CustomHandler": true
+    },
+    "iopl": {
+      "CustomHandler": true
+    },
+    "ioperm": {
+      "CustomHandler": true
+    },
+    "create_module": {
+      "CustomHandler": true
+    },
+    "init_module": {
+      "CustomHandler": true
+    },
+    "delete_module": {
+      "CustomHandler": true
+    },
+    "get_kernel_syms": {
+      "CustomHandler": true
+    },
+    "query_module": {
+      "CustomHandler": true
+    },
+    "quotactl": {
+      "CustomHandler": true
+    },
+    "nfsservctl": {
+      "CustomHandler": true
+    },
+    "getpmsg": {
+      "CustomHandler": true
+    },
+    "putpmsg": {
+      "CustomHandler": true
+    },
+    "afs_syscall": {
+      "CustomHandler": true
+    },
+    "tuxcall": {
+      "CustomHandler": true
+    },
+    "security": {
+      "CustomHandler": true
+    },
+    "gettid": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "readahead": {
+      "ArchSpecific": true
+    },
+    "setxattr": {
+      "CustomHandler": true
+    },
+    "lsetxattr": {
+      "CustomHandler": true
+    },
+    "fsetxattr": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getxattr": {
+      "CustomHandler": true
+    },
+    "lgetxattr": {
+      "CustomHandler": true
+    },
+    "fgetxattr": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "listxattr": {
+      "CustomHandler": true
+    },
+    "llistxattr": {
+      "CustomHandler": true
+    },
+    "flistxattr": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "removexattr": {
+      "CustomHandler": true
+    },
+    "lremovexattr": {
+      "CustomHandler": true
+    },
+    "fremovexattr": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "tkill": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::DEFAULT",
+      "Comment": [
+        "Needs default flags to ensure state synchronization.",
+        "Can cause thread to signal itself and want to ensure everything is synchronized."
+      ]
+    },
+    "time": {
+      "ArchSpecific": true
+    },
+    "futex": {
+      "ArchSpecific": true
+    },
+    "sched_setaffinity": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_getaffinity": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "set_thread_area": {
+      "ArchSpecific": true
+    },
+    "io_setup": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "io_destroy": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "io_getevents": {
+      "ArchSpecific": true
+    },
+    "io_submit": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "io_cancel": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "get_thread_area": {
+      "ArchSpecific": true
+    },
+    "lookup_dcookie": {
+      "CustomHandler": true
+    },
+    "epoll_create": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "epoll_ctl_old": {
+      "CustomHandler": true
+    },
+    "epoll_wait_old": {
+      "CustomHandler": true
+    },
+    "remap_file_pages": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getdents64": {
+      "ArchSpecific": true
+    },
+    "set_tid_address": {
+      "CustomHandler": true
+    },
+    "restart_syscall": {
+      "CustomHandler": true
+    },
+    "semtimedop": {
+      "ArchSpecific": true
+    },
+    "fadvise64": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "timer_create": {
+      "ArchSpecific": true
+    },
+    "timer_settime": {
+      "ArchSpecific": true
+    },
+    "timer_gettime": {
+      "ArchSpecific": true
+    },
+    "timer_getoverrun": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "timer_delete": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "clock_settime": {
+      "ArchSpecific": true
+    },
+    "clock_gettime": {
+      "ArchSpecific": true
+    },
+    "clock_getres": {
+      "ArchSpecific": true
+    },
+    "clock_nanosleep": {
+      "ArchSpecific": true
+    },
+    "exit_group": {
+      "CustomHandler": true
+    },
+    "epoll_wait": {
+      "ArchSpecific": true
+    },
+    "epoll_ctl": {
+      "ArchSpecific": true
+    },
+    "tgkill": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::DEFAULT",
+      "Comment": [
+        "Needs default flags to ensure state synchronization.",
+        "Can cause thread to signal itself and want to ensure everything is synchronized."
+      ]
+    },
+    "utimes": {
+      "ArchSpecific": true
+    },
+    "vserver": {
+      "CustomHandler": true
+    },
+    "mbind": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "set_mempolicy": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "get_mempolicy": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mq_open": {
+      "ArchSpecific": true
+    },
+    "mq_unlink": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mq_timedsend": {
+      "ArchSpecific": true
+    },
+    "mq_timedreceive": {
+      "ArchSpecific": true
+    },
+    "mq_notify": {
+      "ArchSpecific": true
+    },
+    "mq_getsetattr": {
+      "ArchSpecific": true
+    },
+    "kexec_load": {
+      "CustomHandler": true
+    },
+    "waitid": {
+      "ArchSpecific": true
+    },
+    "add_key": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "request_key": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "keyctl": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "ioprio_set": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "ioprio_get": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "inotify_init": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "inotify_add_watch": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "inotify_rm_watch": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "migrate_pages": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "openat": {
+      "CustomHandler": true
+    },
+    "mkdirat": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mknodat": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "fchownat": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "futimesat": {
+      "ArchSpecific": true
+    },
+    "newfstatat": {
+      "ArchSpecific": true
+    },
+    "unlinkat": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "renameat": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "linkat": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "symlinkat": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "readlinkat": {
+      "CustomHandler": true
+    },
+    "fchmodat": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "faccessat": {
+      "CustomHandler": true
+    },
+    "pselect6": {
+      "ArchSpecific": true
+    },
+    "ppoll": {
+      "ArchSpecific": true
+    },
+    "unshare": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "set_robust_list": {
+      "ArchSpecific": true
+    },
+    "get_robust_list": {
+      "ArchSpecific": true
+    },
+    "splice": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "tee": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "sync_file_range": {
+      "ArchSpecific": true
+    },
+    "vmsplice": {
+      "ArchSpecific": true
+    },
+    "move_pages": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "utimensat": {
+      "ArchSpecific": true
+    },
+    "epoll_pwait": {
+      "ArchSpecific": true
+    },
+    "signalfd": {
+      "CustomHandler": true
+    },
+    "timerfd_create": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "eventfd": {
+      "CustomHandler": true
+    },
+    "fallocate": {
+      "ArchSpecific": true
+    },
+    "timerfd_settime": {
+      "ArchSpecific": true
+    },
+    "timerfd_gettime": {
+      "ArchSpecific": true
+    },
+    "accept4": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "signalfd4": {
+      "CustomHandler": true
+    },
+    "eventfd2": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "epoll_create1": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "dup3": {
+      "CustomHandler": true
+    },
+    "pipe2": {
+      "CustomHandler": true
+    },
+    "inotify_init1": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "preadv": {
+      "ArchSpecific": true
+    },
+    "pwritev": {
+      "ArchSpecific": true
+    },
+    "rt_tgsigqueueinfo": {
+      "ArchSpecific": true
+    },
+    "perf_event_open": {
+      "CustomHandler": true
+    },
+    "recvmmsg": {
+      "ArchSpecific": true
+    },
+    "fanotify_init": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "fanotify_mark": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "prlimit_64": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "name_to_handle_at": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "open_by_handle_at": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "clock_adjtime": {
+      "ArchSpecific": true
+    },
+    "syncfs": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sendmmsg": {
+      "ArchSpecific": true
+    },
+    "setns": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getcpu": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Technically used to take three arguments",
+        "Third argument is now ignored."
+      ]
+    },
+    "process_vm_readv": {
+      "ArchSpecific": true
+    },
+    "process_vm_writev": {
+      "ArchSpecific": true
+    },
+    "kcmp": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "finit_module": {
+      "CustomHandler": true
+    },
+    "sched_setattr": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_getattr": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "renameat2": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "seccomp": {
+      "CustomHandler": true
+    },
+    "getrandom": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "memfd_create": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "kexec_file_load": {
+      "CustomHandler": true
+    },
+    "bpf": {
+      "CustomHandler": true
+    },
+    "execveat": {
+      "CustomHandler": true
+    },
+    "userfaultfd": {
+      "CustomHandler": true
+    },
+    "membarrier": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mlock2": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "copy_file_range": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "preadv2": {
+      "ArchSpecific": true
+    },
+    "pwritev2": {
+      "ArchSpecific": true
+    },
+    "pkey_mprotect": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "pkey_alloc": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "pkey_free": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "statx": {
+      "CustomHandler": true
+    },
+    "io_pgetevents": {
+      "ArchSpecific": true
+    },
+    "rseq": {
+      "CustomHandler": true
+    },
+    "pidfd_send_signal": {
+      "ArchSpecific": true
+    },
+    "io_uring_setup": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "io_uring_enter": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "io_uring_register": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "open_tree": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "move_mount": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "fsopen": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "fsconfig": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "fsmount": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "fspick": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "pidfd_open": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.3.0"
+    },
+    "clone3": {
+      "CustomHandler": true
+    },
+    "close_range": {
+      "CustomHandler": true
+    },
+    "openat2": {
+      "CustomHandler": true
+    },
+    "pidfd_getfd": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.8.0"
+    },
+    "faccessat2": {
+      "CustomHandler": true
+    },
+    "process_madvise": {
+      "ArchSpecific": true
+    },
+    "epoll_pwait2": {
+      "ArchSpecific": true
+    },
+    "mount_setattr": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.12.0"
+    },
+    "quotactl_fd": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.14.0"
+    },
+    "landlock_create_ruleset": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.13.0"
+    },
+    "landlock_add_rule": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.13.0"
+    },
+    "landlock_restrict_self": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.13.0"
+    },
+    "memfd_secret": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.14.0"
+    },
+    "process_mrelease": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.15.0"
+    },
+    "futex_waitv": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.16.0"
+    },
+    "set_mempolicy_home_node": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.17.0"
+    }
+  },
+  "x64": {
+    "stat": {
+      "CustomHandler": true
+    },
+    "fstat": {
+      "CustomHandler": true
+    },
+    "lstat": {
+      "CustomHandler": true
+    },
+    "ioctl": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "pread_64": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "pwrite_64": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "readv": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "writev": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "select": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "_shmat": {
+      "CustomHandler": true
+    },
+    "dup": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "dup2": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "nanosleep": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getitimer": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setitimer": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sendfile": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "accept": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sendmsg": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "recvmsg": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setsockopt": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getsockopt": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "wait4": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "semop": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "semctl": {
+      "CustomHandler": true
+    },
+    "_shmdt": {
+      "CustomHandler": true
+    },
+    "fcntl": {
+      "CustomHandler": true
+    },
+    "getdents": {
+      "CustomHandler": true
+    },
+    "gettimeofday": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getrlimit": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "getrusage": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sysinfo": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "times": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "rt_sigqueueinfo": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "utime": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "fstatfs": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sched_rr_get_interval": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mlockall": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "munlockall": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "adjtimex": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "setrlimit": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "settimeofday": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "readahead": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "time": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "futex": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "set_thread_area": {
+      "CustomHandler": true
+    },
+    "io_getevents": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "get_thread_area": {
+      "CustomHandler": true
+    },
+    "getdents64": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "semtimedop": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "timer_create": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "timer_settime": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "timer_gettime": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "clock_settime": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "clock_gettime": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "clock_getres": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "clock_nanosleep": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "epoll_wait": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "epoll_ctl": {
+      "CustomHandler": true
+    },
+    "utimes": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "mq_open": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mq_timedsend": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mq_timedreceive": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mq_notify": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "mq_getsetattr": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "waitid": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "futimesat": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "newfstatat": {
+      "CustomHandler": true
+    },
+    "pselect6": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "ppoll": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "set_robust_list": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "get_robust_list": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sync_file_range": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "vmsplice": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "utimensat": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "epoll_pwait": {
+      "CustomHandler": true
+    },
+    "fallocate": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "timerfd_settime": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "Comment": [
+        "Flags don't need remapped"
+      ]
+    },
+    "timerfd_gettime": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "preadv": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "pwritev": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "rt_tgsigqueueinfo": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "recvmmsg": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "clock_adjtime": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "sendmmsg": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "process_vm_readv": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "process_vm_writev": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "preadv2": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "pwritev2": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "io_pgetevents": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY"
+    },
+    "pidfd_send_signal": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.1.0"
+    },
+    "process_madvise": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "5.10.0"
+    },
+    "epoll_pwait2": {
+      "CustomHandler": true
+    },
+    "cachestat": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "6.5.0"
+    },
+    "fchmodat2": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "MinimumKernel": "6.6.0"
+    },
+    "map_shadow_stack": {
+      "CustomHandler": true
+    }
+  },
+  "x32": {
+    "lchown32": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "lchown"
+    },
+    "getuid32": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "getuid"
+    },
+    "getgid32": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "getgid"
+    },
+    "geteuid32": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "geteuid"
+    },
+    "getegid32": {
+      "ArgCount": 0,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "getegid"
+    },
+    "setreuid32": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "setreuid"
+    },
+    "setregid32": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "setregid"
+    },
+    "getgroups32": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "getgroups"
+    },
+    "setgroups32": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "setgroups"
+    },
+    "fchown32": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "fchown"
+    },
+    "setresuid32": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "setresuid"
+    },
+    "getresuid32": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "getresuid"
+    },
+    "setresgid32": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "setresgid"
+    },
+    "getresgid32": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "getresgid"
+    },
+    "chown32": {
+      "ArgCount": 3,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "chown"
+    },
+    "setuid32": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "setuid"
+    },
+    "setgid32": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "setgid"
+    },
+    "setfsuid32": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "setfsuid"
+    },
+    "setfsgid32": {
+      "ArgCount": 1,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "setfsgid"
+    },
+    "sendfile64":{
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "sendfile",
+      "Comment": [
+        "Linux definition for this is a bit confusing",
+        "Defines offset as compat_loff_t* but loads loff_t worth of data",
+        "count is defined as compat_size_t still"
+      ]
+    },
+    "clock_gettime64": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "clock_gettime"
+    },
+    "clock_settime64": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "clock_settime"
+    },
+    "clock_adjtime64": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "clock_adjtime"
+    },
+    "clock_getres_time64": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "clock_getres"
+    },
+    "clock_nanosleep_time64": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "clock_nanosleep"
+    },
+    "timer_gettime64": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "timer_gettime"
+    },
+    "timer_settime64": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "timer_settime"
+    },
+    "timerfd_gettime64": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "timerfd_gettime"
+    },
+    "timerfd_settime64": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "timerfd_settime"
+    },
+    "utimensat_time64": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "utimensat"
+    },
+    "pselect6_time64": {
+      "CustomHandler": true
+    },
+    "ppoll_time64": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "ppoll"
+    },
+    "io_pgetevents_time64": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "io_pgetevents"
+    },
+    "recvmmsg_time64": {
+      "CustomHandler": true
+    },
+    "mq_timedsend_time64": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "mq_timedsend"
+    },
+    "mq_timedreceive_time64": {
+      "ArgCount": 5,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "mq_timedreceive"
+    },
+    "getdents64": {
+      "CustomHandler": true
+    },
+
+    "semtimedop_time64": {
+      "ArgCount": 4,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "semtimedop"
+    },
+    "rt_sigtimedwait_time64": {
+      "CustomHandler": true
+    },
+    "futex_time64": {
+      "ArgCount": 6,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "futex"
+    },
+    "sched_rr_get_interval_time64": {
+      "ArgCount": 2,
+      "Flags": "SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY",
+      "SyscallRedirect": "sched_rr_get_interval"
+    },
+    "stat": {
+      "CustomHandler": true
+    },
+    "fstat": {
+      "CustomHandler": true
+    },
+    "lstat": {
+      "CustomHandler": true
+    },
+    "ioctl": {
+      "CustomHandler": true
+    },
+    "pread_64": {
+      "CustomHandler": true
+    },
+    "pwrite_64": {
+      "CustomHandler": true
+    },
+    "readv": {
+      "CustomHandler": true
+    },
+    "writev": {
+      "CustomHandler": true
+    },
+    "select": {
+      "CustomHandler": true
+    },
+    "_shmat": {
+      "CustomHandler": true
+    },
+    "dup": {
+      "CustomHandler": true
+    },
+    "dup2": {
+      "CustomHandler": true
+    },
+    "nanosleep": {
+      "CustomHandler": true
+    },
+    "getitimer": {
+      "CustomHandler": true
+    },
+    "setitimer": {
+      "CustomHandler": true
+    },
+    "sendfile": {
+      "CustomHandler": true
+    },
+    "sendmsg": {
+      "CustomHandler": true
+    },
+    "recvmsg": {
+      "CustomHandler": true
+    },
+    "setsockopt": {
+      "CustomHandler": true
+    },
+    "getsockopt": {
+      "CustomHandler": true
+    },
+    "wait4": {
+      "CustomHandler": true
+    },
+    "semctl": {
+      "CustomHandler": true
+    },
+    "_shmdt": {
+      "CustomHandler": true
+    },
+    "fcntl": {
+      "CustomHandler": true
+    },
+    "getdents": {
+      "CustomHandler": true
+    },
+    "gettimeofday": {
+      "CustomHandler": true
+    },
+    "getrlimit": {
+      "CustomHandler": true
+    },
+    "getrusage": {
+      "CustomHandler": true
+    },
+    "sysinfo": {
+      "CustomHandler": true
+    },
+    "times": {
+      "CustomHandler": true
+    },
+    "rt_sigqueueinfo": {
+      "CustomHandler": true
+    },
+    "utime": {
+      "CustomHandler": true
+    },
+    "fstatfs": {
+      "CustomHandler": true
+    },
+    "sched_rr_get_interval": {
+      "CustomHandler": true
+    },
+    "mlockall": {
+      "CustomHandler": true
+    },
+    "munlockall": {
+      "CustomHandler": true
+    },
+    "adjtimex": {
+      "CustomHandler": true
+    },
+    "setrlimit": {
+      "CustomHandler": true
+    },
+    "settimeofday": {
+      "CustomHandler": true
+    },
+    "readahead": {
+      "CustomHandler": true
+    },
+    "time": {
+      "CustomHandler": true,
+      "Comment": [
+        "Doesn't exist on AArch64"
+      ]
+    },
+    "futex": {
+      "CustomHandler": true
+    },
+    "set_thread_area": {
+      "CustomHandler": true
+    },
+    "io_getevents": {
+      "CustomHandler": true
+    },
+    "get_thread_area": {
+      "CustomHandler": true
+    },
+    "timer_create": {
+      "CustomHandler": true
+    },
+    "timer_settime": {
+      "CustomHandler": true
+    },
+    "timer_gettime": {
+      "CustomHandler": true
+    },
+    "clock_settime": {
+      "CustomHandler": true
+    },
+    "clock_gettime": {
+      "CustomHandler": true
+    },
+    "clock_getres": {
+      "CustomHandler": true
+    },
+    "clock_nanosleep": {
+      "CustomHandler": true
+    },
+    "epoll_wait": {
+      "CustomHandler": true
+    },
+    "epoll_ctl": {
+      "CustomHandler": true
+    },
+    "utimes": {
+      "CustomHandler": true
+    },
+    "mq_open": {
+      "CustomHandler": true
+    },
+    "mq_timedsend": {
+      "CustomHandler": true
+    },
+    "mq_timedreceive": {
+      "CustomHandler": true
+    },
+    "mq_notify": {
+      "CustomHandler": true
+    },
+    "mq_getsetattr": {
+      "CustomHandler": true
+    },
+    "waitid": {
+      "CustomHandler": true
+    },
+    "futimesat": {
+      "CustomHandler": true
+    },
+    "pselect6": {
+      "CustomHandler": true
+    },
+    "ppoll": {
+      "CustomHandler": true
+    },
+    "set_robust_list": {
+      "CustomHandler": true
+    },
+    "get_robust_list": {
+      "CustomHandler": true
+    },
+    "sync_file_range": {
+      "CustomHandler": true
+    },
+    "vmsplice": {
+      "CustomHandler": true
+    },
+    "utimensat": {
+      "CustomHandler": true
+    },
+    "epoll_pwait": {
+      "CustomHandler": true
+    },
+    "fallocate": {
+      "CustomHandler": true
+    },
+    "timerfd_settime": {
+      "CustomHandler": true
+    },
+    "timerfd_gettime": {
+      "CustomHandler": true
+    },
+    "preadv": {
+      "CustomHandler": true
+    },
+    "pwritev": {
+      "CustomHandler": true
+    },
+    "rt_tgsigqueueinfo": {
+      "CustomHandler": true
+    },
+    "recvmmsg": {
+      "CustomHandler": true
+    },
+    "clock_adjtime": {
+      "CustomHandler": true
+    },
+    "sendmmsg": {
+      "CustomHandler": true
+    },
+    "process_vm_readv": {
+      "CustomHandler": true
+    },
+    "process_vm_writev": {
+      "CustomHandler": true
+    },
+    "preadv2": {
+      "CustomHandler": true
+    },
+    "pwritev2": {
+      "CustomHandler": true
+    },
+    "io_pgetevents": {
+      "CustomHandler": true
+    },
+    "pidfd_send_signal": {
+      "CustomHandler": true
+    },
+    "process_madvise": {
+      "CustomHandler": true
+    },
+    "epoll_pwait2": {
+      "CustomHandler": true
+    }
+  }
+}
diff --git a/Source/Tools/LinuxEmulation/VDSO_Emulation.cpp b/Source/Tools/LinuxEmulation/VDSO_Emulation.cpp
index 978197368c..21e7f3d6c7 100644
--- a/Source/Tools/LinuxEmulation/VDSO_Emulation.cpp
+++ b/Source/Tools/LinuxEmulation/VDSO_Emulation.cpp
@@ -362,7 +362,7 @@ namespace FEX::VDSO {
   }
 
   void LoadHostVDSO() {
-
+    FEXCore::Allocator::YesIKnowImNotSupposedToUseTheGlibcAllocator glibc;
     void *vdso = dlopen("linux-vdso.so.1", RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
     if (!vdso) {
       vdso = dlopen("linux-gate.so.1", RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);