Merge branch 'main' of https://github.com/AsynchronousAI/reasm

Author: AsynchronousAI

.gitignore

@@ -4,7 +4,6 @@ reasm
 .DS_Store
 bench
 sourcemap.json
-*.c
 main.*
 !main.go
 platform.info

compiler/boilerplate.luau

@@ -19,94 +19,12 @@ local stdout_cache: string = ""
 local fflags: number = 0 -- floating-point exception flags (NV,DZ,OF,UF,NX)
 
 -- Utility
---- 32-bit helpers
-local function u32(v: number): number
-    local n = math.floor(v % 0x100000000)
-    if n < 0 then
-        n += 0x100000000
-    end
-    return n
-end
-local function i32(v)
-    local n = u32(v)
-    if n >= 0x80000000 then
-        return n - 0x100000000
-    end
-    return n
-end
-local function f32(v: number): number
-    buffer.writef32(temp, 0, v)
-    return buffer.readf32(temp, 0)
-end
-
 --- Base (can be found in generated code)
-local function idiv_trunc(a: number, b: number): number
-    if b == 0 then error("division by zero") end
-    if a >= 0 then
-        return (a - (a % b)) // b
-    else
-        return -((-a) - ((-a) % b)) // b
-    end
-end
-local function float_to_int(f: number): number
-    buffer.writef32(temp, 0, f)
-    return buffer.readi32(temp, 0)
-end
-local function int_to_float(i: number): number
-    buffer.writei32(temp, 0, i)
-    return buffer.readf32(temp, 0)
-end
-local function float_to_double(f: number): number
-    buffer.writef32(temp, 0, f)
-    buffer.writei32(temp, 4, 0)
-    return buffer.readf64(temp, 0)
-end
 local function two_words_to_double(highWord: number, lowWord: number): number
-    buffer.writei32(temp, 0, u32(lowWord))
-    buffer.writei32(temp, 4, u32(highWord))
+    buffer.writei32(temp, 0, ((math.floor(lowWord % 0x100000000) + 0x100000000) % 0x100000000))
+    buffer.writei32(temp, 4, ((math.floor(highWord % 0x100000000) + 0x100000000) % 0x100000000))
     return buffer.readf64(temp, 0)
 end
-local function hi(addr: number): number
-    return bit32.lshift(bit32.rshift(addr, 12), 12)
-end
-local function lo(addr: number): number
-    return bit32.band(addr, 0xFFF)
-end
-function fclass(x: number): number
-    local result = 0
-
-    if x ~= x then
-        result = bit32.bor(result, bit32.lshift(1, 9)) -- qNaN (cannot distinguish sNaN in Luau)
-    elseif x == math.huge then
-        result = bit32.bor(result, bit32.lshift(1, 7)) -- +Inf
-    elseif x == -math.huge then
-        result = bit32.bor(result, bit32.lshift(1, 0)) -- -Inf
-    elseif x == 0 then
-        if 1/x == -math.huge then
-            result = bit32.bor(result, bit32.lshift(1, 3)) -- -Zero
-        else
-            result = bit32.bor(result, bit32.lshift(1, 4)) -- +Zero
-        end
-    else
-        local absx = math.abs(x)
-        local min_normal = 2.2250738585072014e-308 -- 2^-1022
-        if absx < min_normal then
-            if x > 0 then
-                result = bit32.bor(result, bit32.lshift(1, 5)) -- +Subnormal
-            else
-                result = bit32.bor(result, bit32.lshift(1, 2)) -- -Subnormal
-            end
-        else
-            if x > 0 then
-                result = bit32.bor(result, bit32.lshift(1, 6)) -- +Normal
-            else
-                result = bit32.bor(result, bit32.lshift(1, 1)) -- -Normal
-            end
-        end
-    end
-
-    return result
-end
 function reset_registers(): ()
     r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16 = 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
     r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,r32 = 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
@@ -136,11 +54,13 @@ function format_string(fmt: number, args: {number}): string
         if spec:sub(-1) == "d" then
             local val = args[arg_index]
             arg_index += 1
-            return string.format("%"..fmtSpec, i32(val))
+
+           	local n = --[[u32]] ((math.floor(val % 0x100000000) + 0x100000000) % 0x100000000);
+            return string.format("%"..fmtSpec, --[[i32]] (n >= 0x80000000) and (n - 0x100000000) or n)
         elseif spec:sub(-1) == "X" then
             local val = args[arg_index]
             arg_index += 1
-            return string.format("%"..fmtSpec, u32(val))
+            return string.format("%"..fmtSpec, --[[u32]]((math.floor(val % 0x100000000) + 0x100000000) % 0x100000000))
         elseif spec:sub(-1) == "f" then
             if arg_index % 2 == 1 then
                 arg_index += 1 -- 64-bit varargs are aligned to even a-registers (skip a1/a3/...)
@@ -168,12 +88,6 @@ function format_string(fmt: number, args: {number}): string
 end
 
 
---- Memory
-local function malloc(size: number): number
-    mallocDepth+=size
-    return buffer.len(memory)-mallocDepth
-end
-
 --- Args
 local function get_args(): (number, number, number, number, number, number, number, number)
     return r11, r12, r13, r14, r15, r16, r17, r18
@@ -209,56 +123,14 @@ local function flush_stdout()
         stdout_cache = ""
     end
 end
+local function malloc(size: number): number
+    mallocDepth += size
+    return buffer.len(memory) - mallocDepth
+end
 
 
 -- Functions
-local functions = {
-    ["memcpy"] = function()
-        local dest,src,count = get_args()
-
-        buffer.copy(memory, dest, memory, src, count)
-    end,
-    ["memset"] = function()
-        local dest, value, count = get_args()
-        buffer.fill(memory, dest, bit32.band(value, 0xFF), count)
-    end,
-    ["malloc"] = function()
-        local size = get_args()
-        local dest = malloc(size)
-
-        push_args(dest)
-    end,
-    ["putchar"] = function()
-        local c = get_args()
-        local char = string.char(c)
-        if char == "\n" then
-            flush_stdout()
-        else
-            stdout_cache = stdout_cache .. char
-        end
-    end,
-    ["puts"] = function()
-        local fmt = get_args()
-        local str = read_string(fmt)
-        stdout_cache = stdout_cache .. str
-        flush_stdout()
-    end,
-    ["printf"] = function()
-        local args = {get_args()}
-        local fmt_ptr = args[1]
-        table.remove(args, 1)
-
-        local formatted = format_string(fmt_ptr, args)
-        for i = 1, #formatted do
-            local ch = formatted:sub(i,i)
-            if ch == "\n" then
-                flush_stdout()
-            else
-                stdout_cache = stdout_cache .. ch
-            end
-        end
-    end,
-}
+local functions = {}
 
 local syscalls: {[number]: () -> ()} = {}
 

compiler/compilation.go

@@ -362,16 +362,10 @@ func AfterCompilation(writer *OutputWriter) []byte {
 		push_args = push_args,
 		get_f_args = get_f_args,
 		push_f_args = push_f_args,
-		int_to_float = int_to_float,
-		float_to_int = float_to_int,
-		hi = hi,
-		lo = lo,
 		read_string = read_string,
 		format_string = format_string,
 		malloc = malloc,
-		float_to_double = float_to_double,
 		two_words_to_double = two_words_to_double,
-		fclass = fclass,
 		reset_registers = reset_registers,
 	},
 

compiler/extensions.go

@@ -10,30 +10,38 @@ import (
 //go:embed math.luau
 var math_extension string
 
+//go:embed memory.luau
+var memory_extension string
+
+//go:embed stdio.luau
+var stdio_extension string
+
+//go:embed stdlib.luau
+var stdlib_extension string
+
 var extensions = map[string]string{
-	"math": math_extension,
+	"math":   math_extension,
+	"memory": memory_extension,
+	"stdio":  stdio_extension,
+	"stdlib": stdlib_extension,
 }
 
 func generateExtensions(writer *OutputWriter) string {
 	var sb strings.Builder
-	includesMath := false
+	included := map[string]bool{}
 
 	for _, name := range writer.Options.Imports {
-		if name == "math" {
-			includesMath = true
-		}
 		if ext, ok := extensions[name]; ok {
+			if included[name] {
+				continue
+			}
 			sb.WriteString(ext)
 			sb.WriteString("\n")
+			included[name] = true
 		} else {
 			logrus.Warnf("unknown import: %s", name)
 		}
 	}
 
-	if !includesMath {
-		sb.WriteString(math_extension)
-		sb.WriteString("\n")
-	}
-
 	return sb.String()
 }