Fixing a bug in call_function.asm

Author: rainerzufalldererste

llsc/src/CInstruction.cs

@@ -831,7 +831,6 @@ public override void GetLLInstructions(ref ByteCodeState byteCodeState)
             throw new Exception("Internal Compiler Error!");
 
           byteCodeState.FreeRegister(returnValueRegister, stackSize);
-          byteCodeState.instructions.Add(new LLI_Location_PseudoInstruction(functionPtr, stackSize, byteCodeState));
           byteCodeState.instructions.Add(new LLI_PushRegister((byte)functionPtr.position.registerIndex));
           pushedBytes += 8;
         }

llscript_asm/src/call_func.asm

@@ -148,12 +148,15 @@ sub rax, 8
 mov rbp, rsp
 add rbp, 32
 
+
+
 ; Remaining Params
 remaining_params:
 M_JUMP_TO_DO_CALL_IF_LAST
 
 ; Push all remaining params to the stack.
-mov rbp, qword ptr [rax]
+mov rdi, qword ptr [rax]
+mov qword ptr [rbp], rdi
 
 ; Move to the next param.
 sub rax, 8
@@ -167,8 +170,6 @@ add rbp, 8
 jmp remaining_params
 
 
-; TODO: Do we need to pop the values from the stack as well?
-
 
 do_call:
 ; Let's figure out the return type!
@@ -196,6 +197,7 @@ movsd qword ptr [rsp], xmm0
 mov rax, qword ptr [rsp]
 
 
+
 end_func:
 
 ; Move stack to where we previously stored it.

llscript_exec/project.lua

@@ -39,8 +39,10 @@ filter { }
 filter { "configurations:Debug*" }
   defines { "_DEBUG" }
   symbols "FastLink"
+  links { "msvcrtd.lib", "vcruntimed.lib", "ucrtd.lib" }
 
 filter { "configurations:Release" }
 	defines { "NDEBUG" }
 	optimize "Speed"
   symbols "On"
+  ignoredefaultlibraries { "msvcrt" }

llscript_exec/src/main.c

@@ -1,70 +1,130 @@
-#include <stdio.h>
-#include <malloc.h>
-#include <string.h>
-
-#include <conio.h>
+#include <Windows.h>
+#include <intrin.h>
 
 #include "llshost.h"
 
-int32_t main(const int32_t argc, const char **pArgv)
+__forceinline void SetZero(void *pData, const size_t size)
+{
+  uint8_t *pData8 = (uint8_t *)(pData);
+  size_t i = 0;
+
+  if (size >= sizeof(__m128i))
+    for (; i < size - (sizeof(__m128i) - 1); i += sizeof(__m128i))
+      _mm_storeu_si128((__m128i *)(pData8 + i), _mm_setzero_si128());
+
+  for (; i < size; i++)
+    pData8[i] = 0;
+}
+
+#pragma function(memset)
+extern void *memset(void *pDst, int data, size_t size)
+{
+  size_t i = 0;
+  uint8_t *const pDst8 = (uint8_t *const)pDst;
+  const __m128i data128 = _mm_set1_epi8((char)data);
+
+  if (size >= sizeof(__m128i))
+    for (; i < size - (sizeof(__m128i) - 1); i += sizeof(__m128i))
+      _mm_storeu_si128((__m128i *)(pDst8 + i), data128);
+
+  for (; i < size; i++)
+    pDst8[i] = (uint8_t)data;
+
+  return pDst;
+}
+
+#pragma function(memcpy)
+extern void *memcpy(void *pDst, const void *pSrc, size_t size)
 {
+  size_t i = 0;
+  const uint8_t *const pSrc8 = (const uint8_t *)pSrc;
+  uint8_t *const pDst8 = (uint8_t *)pDst;
+
+  if (size >= sizeof(__m128i))
+    for (; i < size - (sizeof(__m128i) - 1); i += sizeof(__m128i))
+      _mm_storeu_si128((__m128i *)(pDst8 + i), _mm_loadu_si128((const __m128i *)(pSrc8 + i)));
+
+  for (; i < size; i++)
+    pDst8[i] = pSrc8[i];
+
+  return pDst;
+}
+
+#pragma comment (linker, "/ENTRY:entry_point")
+void entry_point()
+{
+  int32_t argc = 0;
+  const wchar_t **pArgv = CommandLineToArgvW(GetCommandLineW(), &argc);
+
+  HANDLE stdOut = GetStdHandle(STD_OUTPUT_HANDLE);
+
   if (argc != 2)
   {
-    puts("Invalid Parameter.\n\nUsage: llscript_exec <Filename>");
-    puts("Build Time: " __TIMESTAMP__);
-    return -1;
+    const char out[] = "Invalid Parameter.\n\nUsage: llscript_exec <Filename>\nBuild Time: " __TIMESTAMP__ "\n";
+    WriteFile(stdOut, out, sizeof(out), NULL, NULL);
+    ExitProcess((UINT)-1);
   }
 
   uint8_t *pByteCode = NULL;
 
   // Read Bytecode from file.
   {
-    FILE *pFile = fopen(pArgv[1], "rb");
+    HANDLE file = CreateFileW(pArgv[1], GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
-    if (pFile == NULL)
+    if (file == NULL || file == INVALID_HANDLE_VALUE)
     {
-      fputs("Failed to open file.", stderr);
-      return -1;
+      const char out[] = "Failed to open file.";
+      WriteFile(stdOut, out, sizeof(out), NULL, NULL);
+      ExitProcess((UINT)-1);
     }
 
-    fseek(pFile, 0, SEEK_END);
-    const int64_t fileSize = _ftelli64(pFile);
-    fseek(pFile, 0, SEEK_SET);
+    LARGE_INTEGER fileSize = { 0 };
+
+    if (FALSE == GetFileSizeEx(file, &fileSize))
+    {
+      const char out[] = "Failed to retrieve file size.";
+      WriteFile(stdOut, out, sizeof(out), NULL, NULL);
+      ExitProcess((UINT)-1);
+    }
 
-    if (fileSize <= 0)
+    if (fileSize.QuadPart <= 0)
     {
-      fputs("Invalid File.", stderr);
-      return -1;
+      const char out[] = "Invalid file size.";
+      WriteFile(stdOut, out, sizeof(out), NULL, NULL);
+      ExitProcess((UINT)-1);
     }
 
-    pByteCode = (uint8_t *)malloc(fileSize);
+    pByteCode = (uint8_t *)VirtualAlloc(NULL, (size_t)fileSize.QuadPart, MEM_COMMIT, PAGE_READWRITE);
 
     if (pByteCode == NULL)
     {
-      fputs("Memory Allocation Failure.", stderr);
-      return -1;
+      const char out[] = "Memory Allocation Failure.";
+      WriteFile(stdOut, out, sizeof(out), NULL, NULL);
+      ExitProcess((UINT)-1);
     }
 
-    if ((size_t)fileSize != fread(pByteCode, 1, (size_t)fileSize, pFile))
+    if (FALSE == ReadFile(file, pByteCode, fileSize.LowPart, NULL, NULL))
     {
-      fputs("Failed to read file.", stderr);
-      return -1;
+      const char out[] = "Failed to read file.";
+      WriteFile(stdOut, out, sizeof(out), NULL, NULL);
+      ExitProcess((UINT)-1);
     }
 
-    fclose(pFile);
+    CloseHandle(file);
   }
 
   llshost_state_t state;
-  memset(&state, 0, sizeof(state));
+  SetZero(&state, sizeof(state));
 
   state.pCode = pByteCode;
 
   static uint8_t stack[LLS_DEFUALT_STACK_SIZE];
-  memset(stack, 0, sizeof(stack));
+  SetZero(stack, sizeof(stack));
   state.pStack = stack;
   state.stackSize = sizeof(stack);
 
   llshost_from_state(&state);
 
-  return 0;
+  ExitProcess((UINT)0);
+  return;
 }

llscript_host/src/llshost.c

@@ -2376,7 +2376,8 @@ void llshost_EvaluateCode(llshost_state_t *pState)
       {
         iregister[target_register] = result;
 #ifdef LLS_DEBUG_MODE
-        printf("\t\t// Return Value: %" PRIu64 " / %" PRIi64 " (0x%" PRIX64 ")\n", result, (int64_t)result, result);
+        if (!silent)
+          printf("\t\t// Return Value: %" PRIu64 " / %" PRIi64 " (0x%" PRIX64 ")\n", result, (int64_t)result, result);
 
         LOG_INSPECT_INTEGER(result, pState);
 #endif
@@ -2385,7 +2386,8 @@ void llshost_EvaluateCode(llshost_state_t *pState)
       {
         fregister[target_register - LLS_IREGISTER_COUNT] = *(double *)&result;
 #ifdef LLS_DEBUG_MODE
-        printf("\t\t// Return Value: %f (0x%" PRIX64 ")\n", *(double *)result, result);
+        if (!silent)
+          printf("\t\t// Return Value: %f (0x%" PRIX64 ")\n", *(double *)result, result);
 #endif
       }
       ASSERT_NO_ELSE;
@@ -2493,7 +2495,10 @@ void llshost_EvaluateCode(llshost_state_t *pState)
           LOG_X64(iregister[1]);
           LOG_INFO_END();
           LOG_END();
-          LOG_INSPECT_INTEGER(iregister[1], pState);
+#ifdef LLS_DEBUG_MODE
+          if (!silent)
+            LOG_INSPECT_INTEGER(iregister[1], pState);
+#endif
 
           HMODULE(*LoadLibraryA)(LPCSTR lpLibFileName) = pState->pLoadLibrary;
 
@@ -2525,7 +2530,10 @@ void llshost_EvaluateCode(llshost_state_t *pState)
           LOG_X64(iregister[2]);
           LOG_INFO_END();
           LOG_END();
-          LOG_INSPECT_INTEGER(iregister[2], pState);
+#ifdef LLS_DEBUG_MODE
+          if (!silent)
+            LOG_INSPECT_INTEGER(iregister[2], pState);
+#endif
 
           FARPROC(*GetProcAddress)(HMODULE hModule, LPCSTR lpProcName) = pState->pGetProcAddress;