Overhaul Register Capture

src/hx/gc/CapturedState.arm64.cpp

@@ -0,0 +1,114 @@
+#include <hxcpp.h>
+#include "GcRegCapture.h"
+
+constexpr size_t intRegSize{ sizeof(uintptr_t) * 31 };
+
+hx::gc::CapturedState::CapturedState()
+    : stackBase(0)
+    , stackLimit(0)
+    , registers(intRegSize)
+{}
+
+void hx::gc::Capture(CapturedState& state)
+{
+    uintptr_t rX0{};
+    asm("mov %0, x0\n\t" : "=r" (rX0));
+    uintptr_t rX1{};
+    asm("mov %0, x1\n\t" : "=r" (rX1));
+    uintptr_t rX2{};
+    asm("mov %0, x2\n\t" : "=r" (rX2));
+    uintptr_t rX3{};
+    asm("mov %0, x3\n\t" : "=r" (rX3));
+    uintptr_t rX4{};
+    asm("mov %0, x4\n\t" : "=r" (rX4));
+    uintptr_t rX5{};
+    asm("mov %0, x5\n\t" : "=r" (rX5));
+    uintptr_t rX6{};
+    asm("mov %0, x6\n\t" : "=r" (rX6));
+    uintptr_t rX7{};
+    asm("mov %0, x7\n\t" : "=r" (rX7));
+    uintptr_t rX8{};
+    asm("mov %0, x8\n\t" : "=r" (rX8));
+    uintptr_t rX9{};
+    asm("mov %0, x9\n\t" : "=r" (rX9));
+    uintptr_t rX10{};
+    asm("mov %0, x10\n\t" : "=r" (rX10));
+    uintptr_t rX11{};
+    asm("mov %0, x11\n\t" : "=r" (rX11));
+    uintptr_t rX12{};
+    asm("mov %0, x12\n\t" : "=r" (rX12));
+    uintptr_t rX13{};
+    asm("mov %0, x13\n\t" : "=r" (rX13));
+    uintptr_t rX14{};
+    asm("mov %0, x14\n\t" : "=r" (rX14));
+    uintptr_t rX15{};
+    asm("mov %0, x15\n\t" : "=r" (rX15));
+    uintptr_t rX16{};
+    asm("mov %0, x16\n\t" : "=r" (rX16));
+    uintptr_t rX17{};
+    asm("mov %0, x17\n\t" : "=r" (rX17));
+    uintptr_t rX18{};
+    asm("mov %0, x18\n\t" : "=r" (rX18));
+    uintptr_t rX19{};
+    asm("mov %0, x19\n\t" : "=r" (rX19));
+    uintptr_t rX20{};
+    asm("mov %0, x20\n\t" : "=r" (rX20));
+    uintptr_t rX21{};
+    asm("mov %0, x21\n\t" : "=r" (rX21));
+    uintptr_t rX22{};
+    asm("mov %0, x22\n\t" : "=r" (rX22));
+    uintptr_t rX23{};
+    asm("mov %0, x23\n\t" : "=r" (rX23));
+    uintptr_t rX24{};
+    asm("mov %0, x24\n\t" : "=r" (rX24));
+    uintptr_t rX25{};
+    asm("mov %0, x25\n\t" : "=r" (rX25));
+    uintptr_t rX26{};
+    asm("mov %0, x26\n\t" : "=r" (rX26));
+    uintptr_t rX27{};
+    asm("mov %0, x27\n\t" : "=r" (rX27));
+    uintptr_t rX28{};
+    asm("mov %0, x28\n\t" : "=r" (rX28));
+    uintptr_t rX29{};
+    asm("mov %0, x29\n\t" : "=r" (rX29));
+    uintptr_t rX30{};
+    asm("mov %0, x30\n\t" : "=r" (rX30));
+
+    uintptr_t rSp{};
+    asm("mov %0, sp\n\t" : "=r" (rSp));
+
+    state.stackLimit = rSp;
+
+    auto pointers = reinterpret_cast<uintptr_t*>(state.registers.data());
+    pointers[0] = rX0;
+    pointers[1] = rX1;
+    pointers[2] = rX2;
+    pointers[3] = rX3;
+    pointers[4] = rX4;
+    pointers[5] = rX5;
+    pointers[6] = rX6;
+    pointers[7] = rX7;
+    pointers[8] = rX8;
+    pointers[9] = rX9;
+    pointers[10] = rX10;
+    pointers[11] = rX11;
+    pointers[12] = rX12;
+    pointers[13] = rX13;
+    pointers[14] = rX14;
+    pointers[15] = rX15;
+    pointers[16] = rX16;
+    pointers[17] = rX17;
+    pointers[18] = rX18;
+    pointers[19] = rX19;
+    pointers[20] = rX20;
+    pointers[21] = rX21;
+    pointers[22] = rX22;
+    pointers[23] = rX23;
+    pointers[24] = rX24;
+    pointers[25] = rX25;
+    pointers[26] = rX26;
+    pointers[27] = rX27;
+    pointers[28] = rX28;
+    pointers[29] = rX29;
+    pointers[30] = rX30;
+}

src/hx/gc/CapturedState.setjmp.cpp

@@ -0,0 +1,23 @@
+#include <hxcpp.h>
+#include "GcRegCapture.h"
+#include <setjmp.h>
+
+hx::gc::CapturedState::CapturedState()
+    : stackBase(0)
+    , stackLimit(0)
+    , registers(sizeof(jmp_buf))
+{}
+
+void hx::gc::Capture(CapturedState& state)
+{
+    volatile uintptr_t v{};
+    state.stackLimit = reinterpret_cast<uintptr_t>(&v);
+
+    jmp_buf buffer{};
+    if (0 != setjmp(buffer))
+    {
+        hx::CriticalError(HX_CSTRING("Failed to save jump buffer"));
+    }
+
+    std::memcpy(state.registers.data(), buffer, state.registers.size());
+}

src/hx/gc/CapturedState.win32.cpp

@@ -0,0 +1,61 @@
+#include <hxcpp.h>
+#include <Windows.h>
+#include "GcRegCapture.h"
+
+// Strictly speaking we don't need tp capture all of the integer registers
+// But let's just do it for simplicity
+
+#if defined(HXCPP_ARM64)
+constexpr size_t intRegSize{ sizeof(uintptr_t) * 31 };
+constexpr size_t xmmRegSize{ sizeof(ARM64_NT_NEON128) * 32 };
+#elif defined(HXCPP_M64)
+constexpr size_t intRegSize{ sizeof(uintptr_t) * 16 };
+constexpr size_t xmmRegSize{ sizeof(M128A) * 16 };
+#elif defined(HXCPP_M32)
+constexpr size_t intRegSize{ sizeof(uintptr_t) * 8 };
+constexpr size_t xmmRegSize{ sizeof(__m128) * 8 };
+#else
+#error Unsupported Architecture
+#endif
+
+hx::gc::CapturedState::CapturedState()
+    : stackBase(0)
+    , stackLimit(0)
+    , registers(intRegSize + xmmRegSize)
+{}
+
+void hx::gc::Capture(CapturedState& state)
+{
+#if defined(HXCPP_ARM64)
+    ARM64_NT_CONTEXT context{};
+    context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL | CONTEXT_FLOATING_POINT;
+    RtlCaptureContext(reinterpret_cast<PCONTEXT>(&context));
+
+    state.stackLimit = context.Sp;
+
+    std::memcpy(state.registers.data(), &context.X, intRegSize);
+    std::memcpy(state.registers.data() + intRegSize, &context.V, xmmRegSize);
+#elif defined(HXCPP_M64)
+    CONTEXT context{};
+    context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL | CONTEXT_FLOATING_POINT;
+    RtlCaptureContext(&context);
+
+    state.stackLimit = context.Rsp;
+
+    std::memcpy(state.registers.data(), &context.Rax, intRegSize);
+    std::memcpy(state.registers.data() + intRegSize, &context.Xmm0, xmmRegSize);
+#elif defined(HXCPP_M32)
+    CONTEXT context{};
+    context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL | CONTEXT_EXTENDED_REGISTERS;
+    RtlCaptureContext(&context);
+
+    state.stackLimit = context.Esp;
+
+    // ExtendedRegisters seems to be the x87 FXSAVE area
+    // So we can offset 160 bytes into it to get the 8 SSE registers
+    std::memcpy(state.registers.data(), &context.Edi, intRegSize);
+    std::memcpy(state.registers.data() + intRegSize, reinterpret_cast<unsigned char*>(&context.ExtendedRegisters) + 160, xmmRegSize);
+#else
+#error Unsupported Architecture
+#endif
+}

src/hx/gc/CapturedState.x86.cpp

@@ -0,0 +1,113 @@
+#include <hxcpp.h>
+#include <immintrin.h>
+#include "GcRegCapture.h"
+
+#if defined(HXCPP_M32)
+constexpr size_t intRegSize = sizeof(uintptr_t) * 8;
+constexpr size_t xmmRegSize = 16 * 8;
+#elif defined(HXCPP_M64)
+constexpr size_t intRegSize = sizeof(uintptr_t) * 16;
+constexpr size_t xmmRegSize = 16 * 16;
+#else
+#error Unable to determine x86 architecture
+#endif
+
+hx::gc::CapturedState::CapturedState()
+    : stackBase(0)
+    , stackLimit(0)
+    , registers(intRegSize + xmmRegSize)
+{}
+
+void hx::gc::Capture(CapturedState& state)
+{
+#if defined(HXCPP_M32)
+	uintptr_t rEax{};
+	asm("mov %%eax, %0\n\t" : "=r" (rEax));
+	uintptr_t rEbx{};
+	asm("mov %%ebx, %0\n\t" : "=r" (rEbx));
+	uintptr_t rEcx{};
+	asm("mov %%ecx, %0\n\t" : "=r" (rEcx));
+	uintptr_t rEdx{};
+	asm("mov %%edx, %0\n\t" : "=r" (rEdx));
+	uintptr_t rEbp{};
+	asm("mov %%ebp, %0\n\t" : "=r" (rEbp));
+	uintptr_t rEdi{};
+	asm("mov %%edi, %0\n\t" : "=r" (rEdi));
+	uintptr_t rEsi{};
+	asm("mov %%esi, %0\n\t" : "=r" (rEsi));
+	uintptr_t rEsp{};
+	asm("mov %%esp, %0\n\t" : "=r" (rEsp));
+
+	state.stackLimit = rEsp;
+
+	auto pointers = reinterpret_cast<uintptr_t*>(state.registers.data());
+	pointers[0] = rEax;
+	pointers[1] = rEbx;
+	pointers[2] = rEcx;
+	pointers[3] = rEdx;
+	pointers[4] = rEsi;
+	pointers[5] = rEdi;
+	pointers[6] = rEsp;
+	pointers[7] = rEbp;
+#elif defined(HXCPP_M64)
+	uintptr_t rRax{};
+	asm("movq %%rax, %0\n\t" : "=r" (rRax));
+	uintptr_t rRbx{};
+	asm("movq %%rbx, %0\n\t" : "=r" (rRbx));
+	uintptr_t rRcx{};
+	asm("movq %%rcx, %0\n\t" : "=r" (rRcx));
+	uintptr_t rRdx{};
+	asm("movq %%rdx, %0\n\t" : "=r" (rRdx));
+	uintptr_t rRsi{};
+	asm("movq %%rsi, %0\n\t" : "=r" (rRsi));
+	uintptr_t rRdi{};
+	asm("movq %%rdi, %0\n\t" : "=r" (rRdi));
+	uintptr_t rRsp{};
+	asm("movq %%rsp, %0\n\t" : "=r" (rRsp));
+	uintptr_t rRbp{};
+	asm("movq %%rbp, %0\n\t" : "=r" (rRbp));
+	uintptr_t rR8{};
+	asm("movq %%r8, %0\n\t" : "=r" (rR8));
+	uintptr_t rR9{};
+	asm("movq %%r9, %0\n\t" : "=r" (rR9));
+	uintptr_t rR10{};
+	asm("movq %%r10, %0\n\t" : "=r" (rR10));
+	uintptr_t rR11{};
+	asm("movq %%r11, %0\n\t" : "=r" (rR11));
+	uintptr_t rR12{};
+	asm("movq %%r12, %0\n\t" : "=r" (rR12));
+	uintptr_t rR13{};
+	asm("movq %%r13, %0\n\t" : "=r" (rR13));
+	uintptr_t rR14{};
+	asm("movq %%r14, %0\n\t" : "=r" (rR14));
+	uintptr_t rR15{};
+	asm("movq %%r15, %0\n\t" : "=r" (rR15));
+
+	state.stackLimit = rRsp;
+
+	auto pointers = reinterpret_cast<uintptr_t*>(state.registers.data());
+	pointers[ 0] = rRax;
+	pointers[ 1] = rRbx;
+	pointers[ 2] = rRcx;
+	pointers[ 3] = rRdx;
+	pointers[ 4] = rRsi;
+	pointers[ 5] = rRdi;
+	pointers[ 6] = rRsp;
+	pointers[ 7] = rRbp;
+	pointers[ 8] = rR8;
+	pointers[ 9] = rR9;
+	pointers[10] = rR10;
+	pointers[11] = rR11;
+	pointers[12] = rR12;
+	pointers[13] = rR13;
+	pointers[14] = rR14;
+	pointers[15] = rR15;
+#else
+#error Unable to determine x86 architecture
+#endif
+
+	char fxsaveRegion[512] __attribute__((aligned(16)));
+	_fxsave(fxsaveRegion);
+
+	std::memcpy(state.registers.data() + intRegSize, fxsaveRegion + 160, xmmRegSize);
+}

src/hx/gc/GcRegCapture.h

@@ -1,6 +1,8 @@
 #ifndef HX_GC_HELPERS_INCLUDED
 #define HX_GC_HELPERS_INCLUDED
 
+#include <cstdint>
+
 #if defined(HX_WINDOWS) && defined(HXCPP_ARM64)
 // Eg, Microsoft Surface 
 #define HXCPP_CAPTURE_SETJMP
@@ -27,10 +29,26 @@
 
 #endif
 
+#include <vector>
 
 namespace hx
 {
-
+    namespace gc
+    {
+        struct CapturedState
+        {
+            // Base is the address that stack scanning begins and it goes until it reaches the limit value.
+            // I'm avoiding "top" and "bottom" terminology because emscripten has the stack "upside down" in comparison to everything else.
+
+            uintptr_t stackBase;
+            uintptr_t stackLimit;
+            std::vector<uint8_t> registers;
+
+            CapturedState();
+        };
+
+        void Capture(CapturedState& buffer);
+    }
 // Capture Registers
 //
 #ifdef HXCPP_CAPTURE_SETJMP // {