Update Files

Kha/Backends/Kinc-hxcpp/khacpp/src/hx/gc/GcCommon.cpp

@@ -0,0 +1,182 @@
+#include <hxcpp.h>
+
+#include <map>
+#include <vector>
+#include <set>
+#include <stdlib.h>
+
+#if defined(HXCPP_CAPTURE_x64) && !defined(__GNUC__)
+#include <windows.h>
+#endif
+
+
+#ifdef _WIN32
+
+#define GC_WIN32_THREADS
+#include <time.h>
+
+#endif
+
+#ifdef HXCPP_TELEMETRY
+extern void __hxt_new_string(void* result, int size);
+#endif
+
+
+
+
+namespace hx
+{
+#if defined(HX_MACOS) || defined(HX_WINDOWS) || defined(HX_LINUX) || defined(KORE_CONSOLE)
+int sgMinimumWorkingMemory       = 20*1024*1024;
+int sgMinimumFreeSpace           = 10*1024*1024;
+#else
+int sgMinimumWorkingMemory       = 8*1024*1024;
+int sgMinimumFreeSpace           = 4*1024*1024;
+#endif
+// Once you use more than the minimum, this kicks in...
+int sgTargetFreeSpacePercentage  = 100;
+
+
+
+
+
+
+// Called internally before and GC operations
+void CommonInitAlloc()
+{
+   #if !defined(HX_WINRT) && !defined(__SNC__) && !defined(__ORBIS__) && !defined(KORE_CONSOLE)
+   const char *minimumWorking = getenv("HXCPP_MINIMUM_WORKING_MEMORY");
+   if (minimumWorking)
+   {
+      int mem =  atoi(minimumWorking);
+      if (mem>0)
+         sgMinimumWorkingMemory = mem;
+   }
+
+   const char *minimumFreeSpace = getenv("HXCPP_MINIMUM_FREE_SPACE");
+   if (minimumFreeSpace)
+   {
+      int mem =  atoi(minimumFreeSpace);
+      if (mem>0)
+         sgMinimumFreeSpace = mem;
+   }
+
+
+   const char *targetFree = getenv("HXCPP_TARGET_FREE_SPACE");
+   if (targetFree)
+   {
+      int percent =  atoi(targetFree);
+      if (percent>0)
+         sgTargetFreeSpacePercentage = percent;
+   }
+   #endif
+}
+
+} // end namespace hx
+
+
+
+void *String::operator new( size_t inSize )
+{
+   return hx::InternalNew(inSize,false);
+}
+
+
+void __hxcpp_collect(bool inMajor)
+{
+   hx::InternalCollect(inMajor,inMajor);
+}
+
+
+void __hxcpp_gc_compact()
+{
+   int mem = hx::InternalCollect(true,true);
+   while(true)
+   {
+      int compact = hx::InternalCollect(true,true);
+      if (compact>=mem-16384)
+         break;
+      mem = compact;
+   }
+}
+
+namespace hx
+{
+
+void GCAddFinalizer(hx::Object *v, finalizer f)
+{
+   if (v)
+   {
+      throw Dynamic(HX_CSTRING("Add finalizer error"));
+   }
+}
+
+HX_CHAR *NewString(int inLen)
+{
+   char *result =  (char *)hx::InternalNew( (inLen+1)*sizeof(char), false );
+   result[inLen] = '\0';
+#ifdef HXCPP_TELEMETRY
+   __hxt_new_string(result, inLen+1);
+#endif
+   return result;
+
+}
+
+void *NewGCBytes(void *inData,int inSize)
+{
+   void *result =  hx::InternalNew(inSize,false);
+   if (inData)
+   {
+      memcpy(result,inData,inSize);
+   }
+   return result;
+}
+
+
+void *NewGCPrivate(void *inData,int inSize)
+{
+   void *result =  InternalNew(inSize,false);
+   if (inData)
+   {
+      memcpy(result,inData,inSize);
+   }
+   return result;
+}
+
+
+
+} // end namespace hx
+
+
+
+
+void __hxcpp_enable(bool inEnable)
+{
+   hx::InternalEnableGC(inEnable);
+}
+
+void  __hxcpp_set_minimum_working_memory(int inBytes)
+{
+   hx::sgMinimumWorkingMemory = inBytes;
+}
+
+void  __hxcpp_set_minimum_free_space(int inBytes)
+{
+   hx::sgMinimumFreeSpace = inBytes;
+}
+
+void  __hxcpp_set_target_free_space_percentage(int inPercentage)
+{
+   hx::sgTargetFreeSpacePercentage = inPercentage;
+}
+
+bool __hxcpp_is_const_string(const ::String &inString)
+{
+   #ifdef HXCPP_ALIGN_ALLOC
+   // Unaligned must be native const
+   if ( ((size_t)inString.__s) & 0x3 )
+      return true;
+   #endif
+   return ((unsigned int *)inString.raw_ptr())[-1] & HX_GC_CONST_ALLOC_BIT;
+}
+

Kha/Backends/Kinc-hxcpp/khacpp/src/hx/gc/GcRegCapture.cpp

@@ -0,0 +1,160 @@
+#include "hxcpp.h"
+#include "GcRegCapture.h"
+
+#ifdef HXCPP_CAPTURE_SETJMP // {
+
+// Nothing
+
+#elif defined(HXCPP_CAPTURE_x86) // }  {
+
+#pragma optimize( "", off )
+
+
+namespace hx {
+
+void CaptureX86(RegisterCaptureBuffer &outBuffer)
+{
+   void *regEsi;
+   void *regEdi;
+   void *regEbx;
+   #ifdef __GNUC__
+   asm ("mov %%esi, %0\n\t" : "=r" (regEsi) );
+   asm ("mov %%edi, %0\n\t" : "=r" (regEdi) );
+   asm ("mov %%ebx, %0\n\t" : "=r" (regEbx) );
+   #else
+   __asm {
+      mov regEsi, esi
+      mov regEdi, edi
+      mov regEbx, ebx
+   }
+   #endif
+   outBuffer.esi = regEsi;
+   outBuffer.edi = regEdi;
+   outBuffer.ebx = regEbx;
+}
+
+} // end namespace hx
+
+#elif defined(HXCPP_CAPTURE_x64) // } {
+
+#if !defined(__GNUC__)
+#include <windows.h>
+#endif
+
+namespace hx {
+
+void CaptureX64(RegisterCaptureBuffer &outBuffer)
+{
+   #if !defined(__GNUC__)
+      CONTEXT context;
+
+      context.ContextFlags = CONTEXT_INTEGER;
+      RtlCaptureContext(&context);
+
+      outBuffer.rbx = (void *)context.Rbx;
+      outBuffer.rbp = (void *)context.Rbp;
+      outBuffer.rdi = (void *)context.Rdi;
+      outBuffer.r12 = (void *)context.R12;
+      outBuffer.r13 = (void *)context.R13;
+      outBuffer.r14 = (void *)context.R14;
+      outBuffer.r15 = (void *)context.R15;
+      memcpy(outBuffer.xmm, &context.Xmm0, sizeof(outBuffer.xmm));
+   #else
+      void *regBx;
+      void *regBp;
+      void *regDi;
+      void *reg12;
+      void *reg13;
+      void *reg14;
+      void *reg15;
+      asm ("movq %%rbx, %0\n\t" : "=r" (regBx) );
+      asm ("movq %%rbp, %0\n\t" : "=r" (regBp) );
+      asm ("movq %%rdi, %0\n\t" : "=r" (regDi) );
+      asm ("movq %%r12, %0\n\t" : "=r" (reg12) );
+      asm ("movq %%r13, %0\n\t" : "=r" (reg13) );
+      asm ("movq %%r14, %0\n\t" : "=r" (reg14) );
+      asm ("movq %%r15, %0\n\t" : "=r" (reg15) );
+      outBuffer.rbx = regBx;
+      outBuffer.rbp = regBp;
+      outBuffer.r12 = reg12;
+      outBuffer.r13 = reg13;
+      outBuffer.r14 = reg14;
+      outBuffer.r15 = reg15;
+   #endif
+}
+
+} // end namespace hx
+
+
+#elif defined(HXCPP_CAPTURE_ARM64) // } {
+
+namespace hx {
+
+void CaptureArm64(RegisterCaptureBuffer &outBuffer)
+{
+   void *regX19;
+   void *regX20;
+   void *regX21;
+   void *regX22;
+   void *regX23;
+   void *regX24;
+   void *regX25;
+   void *regX26;
+   void *regX27;
+   void *regX28;
+   asm ("mov %0, x19\n\t" : "=r" (regX19) );
+   asm ("mov %0, x20\n\t" : "=r" (regX20) );
+   asm ("mov %0, x21\n\t" : "=r" (regX21) );
+   asm ("mov %0, x22\n\t" : "=r" (regX22) );
+   asm ("mov %0, x23\n\t" : "=r" (regX23) );
+   asm ("mov %0, x24\n\t" : "=r" (regX24) );
+   asm ("mov %0, x25\n\t" : "=r" (regX25) );
+   asm ("mov %0, x26\n\t" : "=r" (regX26) );
+   asm ("mov %0, x27\n\t" : "=r" (regX27) );
+   asm ("mov %0, x28\n\t" : "=r" (regX28) );
+   outBuffer.x19 = regX19;
+   outBuffer.x20 = regX20;
+   outBuffer.x21 = regX21;
+   outBuffer.x22 = regX22;
+   outBuffer.x23 = regX23;
+   outBuffer.x24 = regX24;
+   outBuffer.x25 = regX25;
+   outBuffer.x26 = regX26;
+   outBuffer.x27 = regX27;
+   outBuffer.x28 = regX28;
+}
+
+} // end namespace
+
+#else // }  {
+
+#include <string.h>
+
+namespace hx {
+
+// Put this function here so we can be reasonablly sure that "this" register and
+// the 4 registers that may be used to pass args are on the stack.
+int RegisterCapture::Capture(int *inTopOfStack,int **inBuf,int &outSize,int inMaxSize, int *inBottom)
+{
+	int size = ( (char *)inTopOfStack - (char *)inBottom )/sizeof(void *);
+	if (size>inMaxSize)
+		size = inMaxSize;
+	outSize = size;
+	if (size>0)
+	   memcpy(inBuf,inBottom,size*sizeof(void*));
+	return 1;
+}
+
+
+RegisterCapture *gRegisterCaptureInstance = 0;
+RegisterCapture *RegisterCapture::Instance()
+{
+	if (!gRegisterCaptureInstance)
+		gRegisterCaptureInstance = new RegisterCapture();
+	return gRegisterCaptureInstance;
+}
+
+} // end namespace hx
+
+#endif // }
+

Kha/Backends/Kinc-hxcpp/khacpp/src/hx/gc/GcRegCapture.h

@@ -0,0 +1,140 @@
+#ifndef HX_GC_HELPERS_INCLUDED
+#define HX_GC_HELPERS_INCLUDED
+
+#if defined(HX_WINDOWS) && defined(HXCPP_ARM64)
+// Eg, Microsoft Surface 
+#define HXCPP_CAPTURE_SETJMP
+#endif
+
+#ifdef HXCPP_CAPTURE_SETJMP
+   #include <setjmp.h>
+#else
+
+   #if (defined(HX_WINDOWS) || (defined(HX_LINUX) && defined(__i386__))) && !defined(HXCPP_M64)
+      #define HXCPP_CAPTURE_x86
+   #endif
+
+   #if ((defined(HX_MACOS) && defined(__x86_64)) || (defined(HX_WINDOWS) && !defined(HX_WINRT)) || defined(_XBOX_ONE) || (defined(HX_LINUX) && defined(__x86_64__)) || defined(KORE_PS4) || defined(KORE_PS5) || defined(KORE_XBOX_ONE) || defined(KORE_XBOX_SCARLETT)) && defined(HXCPP_M64)
+      #define HXCPP_CAPTURE_x64
+   #endif
+
+   #if defined(HXCPP_ARM64)
+      //#define HXCPP_CAPTURE_ARM64
+      // Awlays use setjmp on arm64
+      #include <setjmp.h>
+      #define HXCPP_CAPTURE_SETJMP
+   #endif
+
+#endif
+
+
+namespace hx
+{
+
+// Capture Registers
+//
+#ifdef HXCPP_CAPTURE_SETJMP // {
+
+typedef jmp_buf RegisterCaptureBuffer;
+
+#define CAPTURE_REGS \
+   setjmp(mRegisterBuf);
+
+#define CAPTURE_REG_START (int *)(&mRegisterBuf)
+#define CAPTURE_REG_END (int *)(&mRegisterBuf+1)
+
+#elif defined(HXCPP_CAPTURE_x86) // } {
+
+struct RegisterCaptureBuffer
+{
+   void *ebx;
+   void *edi;
+   void *esi;
+};
+
+void CaptureX86(RegisterCaptureBuffer &outBuffer);
+
+#define CAPTURE_REGS \
+   hx::CaptureX86(mRegisterBuf);
+
+#define CAPTURE_REG_START (int *)(&mRegisterBuf)
+#define CAPTURE_REG_END (int *)(&mRegisterBuf+1)
+
+#elif defined(HXCPP_CAPTURE_x64) // }  {
+
+
+struct RegisterCaptureBuffer
+{
+   void *rbx;
+   void *rbp;
+   void *rdi;
+   void *r12;
+   void *r13;
+   void *r14;
+   void *r15;
+
+   void *xmm[16*2];
+};
+
+void CaptureX64(RegisterCaptureBuffer &outBuffer);
+
+#define CAPTURE_REGS \
+   hx::CaptureX64(mRegisterBuf);
+
+#define CAPTURE_REG_START (int *)(&mRegisterBuf)
+#define CAPTURE_REG_END (int *)(&mRegisterBuf+1)
+
+
+#elif defined(HXCPP_CAPTURE_ARM64) // }  {
+
+
+struct RegisterCaptureBuffer
+{
+   void *x19;
+   void *x20;
+   void *x21;
+   void *x22;
+   void *x23;
+   void *x24;
+   void *x25;
+   void *x26;
+   void *x27;
+   void *x28;
+};
+
+void CaptureArm64(RegisterCaptureBuffer &outBuffer);
+
+#define CAPTURE_REGS \
+   hx::CaptureArm64(mRegisterBuf);
+
+#define CAPTURE_REG_START (int *)(&mRegisterBuf)
+#define CAPTURE_REG_END (int *)(&mRegisterBuf+1)
+
+
+#else //  }  default capture... {
+
+
+class RegisterCapture
+{
+public:
+	virtual int Capture(int *inTopOfStack,int **inBuf,int &outSize,int inMaxSize,int *inDummy);
+   static RegisterCapture *Instance();
+};
+
+typedef int *RegisterCaptureBuffer[20];
+
+#define CAPTURE_REGS \
+   hx::RegisterCapture::Instance()->Capture(mTopOfStack, \
+                mRegisterBuf,mRegisterBufSize,20,mBottomOfStack); \
+
+#define CAPTURE_REG_START (int *)mRegisterBuf
+#define CAPTURE_REG_END (int *)(mRegisterBuf+mRegisterBufSize)
+
+#endif // }
+
+
+
+}
+
+
+#endif