cpyte 2.1.0__tar.gz → 2.2.0__tar.gz

{cpyte-2.1.0 → cpyte-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 2.1.0
+Version: 2.2.0
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT
@@ -81,3 +81,9 @@ python source/mainpie.py --jit examples/<filename>.cpy
 Cpyte is experimental software. The compiler is continuously tested with fuzzing, and we're still discovering and fixing correctness bugs. While many programs compile and run correctly, I can't make any guarantees about correctness or stability.
 
 If you decide to use Cpyte, always use the latest version — older versions have bugs that are pretty easy to run into.
+
+## Memory Management
+
+Cpyte uses **Boehm GC** (bdw-gc) for automatic garbage collection. Heap-allocated objects (via `new`) are managed automatically — no manual `free` needed.
+
+**Note:** Boehm GC adds a small runtime overhead (~5-10%) compared to manual `malloc/free`. For performance-critical ecosystem projects or embedded use cases, this trade-off may be significant. The GC is required for safety but will slow down programs that do heavy heap allocation.

{cpyte-2.1.0 → cpyte-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cpyte"
-version = "2.1.0"
+version = "2.2.0"
 description = "The Cpyte programming language compiler"
 readme = "readme.md"
 requires-python = ">=3.11"

{cpyte-2.1.0 → cpyte-2.2.0}/readme.md

@@ -69,4 +69,10 @@ python source/mainpie.py --jit examples/<filename>.cpy
 ## Note
 Cpyte is experimental software. The compiler is continuously tested with fuzzing, and we're still discovering and fixing correctness bugs. While many programs compile and run correctly, I can't make any guarantees about correctness or stability.
 
-If you decide to use Cpyte, always use the latest version — older versions have bugs that are pretty easy to run into.
+If you decide to use Cpyte, always use the latest version — older versions have bugs that are pretty easy to run into.
+
+## Memory Management
+
+Cpyte uses **Boehm GC** (bdw-gc) for automatic garbage collection. Heap-allocated objects (via `new`) are managed automatically — no manual `free` needed.
+
+**Note:** Boehm GC adds a small runtime overhead (~5-10%) compared to manual `malloc/free`. For performance-critical ecosystem projects or embedded use cases, this trade-off may be significant. The GC is required for safety but will slow down programs that do heavy heap allocation.

{cpyte-2.1.0 → cpyte-2.2.0}/source/cpyte/bytecoding.py

@@ -131,6 +131,9 @@ class LLVM:
         self.loop_stack = []
         self._malloc_fn = None
         self._free_fn = None
+        self._gc_alloc_fn = None
+        self._gc_mark_fn = None
+        self._gc_root_register_fn = None
         self._strlen_fn = None
         self._memcpy_fn = None
         self.no_userspace = no_userspace
@@ -180,6 +183,24 @@ class LLVM:
             fn = ir.Function(self.module, ir.FunctionType(ret, args), name=name)
             self.functions[name] = fn
 
+        # Boehm GC runtime functions
+        gc_fns = [
+            ('GC_init', _void, []),
+            ('GC_malloc', _i8ptr, [_i64]),
+            ('GC_realloc', _i8ptr, [_i8ptr, _i64]),
+            ('GC_free', _void, [_i8ptr]),
+            ('GC_gcollect', _void, []),
+            ('GC_get_heap_size', _i64, []),
+            ('GC_get_free_bytes', _i64, []),
+            ('GC_disable', _void, []),
+            ('GC_enable', _void, []),
+            ('GC_add_roots', _void, [_i8ptr, _i8ptr]),
+            ('GC_remove_roots', _void, [_i8ptr, _i8ptr]),
+        ]
+        for name, ret, args in gc_fns:
+            fn = ir.Function(self.module, ir.FunctionType(ret, args), name=name)
+            self.functions[name] = fn
+
         # Exception handling globals
         self._exc_buf_ptr = ir.GlobalVariable(self.module, _i8ptr, "_exc_buf_ptr")
         self._exc_buf_ptr.initializer = ir.Constant(_i8ptr, None)
@@ -422,6 +443,10 @@ class LLVM:
 
         if wrapper_builder is not None:
             self.builder = wrapper_builder
+            # Initialize Boehm GC at program start
+            gc_init_fn = self.functions.get('GC_init')
+            if gc_init_fn:
+                self.builder.call(gc_init_fn, [])
             for node in toplevel:
                 self.emit(node)
             self.builder.ret(ir.Constant(ir.IntType(32), 0))
@@ -556,19 +581,21 @@ class LLVM:
         return ptr
 
     def _get_malloc_fn(self):
-        fn = self._malloc_fn
+        # Use Boehm GC allocator instead of malloc
+        fn = self._gc_alloc_fn
         if fn is not None:
             return fn
         for f in self.module.functions:
-            if f.name == 'malloc':
-                self._malloc_fn = f
+            if f.name == 'GC_malloc':
+                self._gc_alloc_fn = f
                 return f
         fnty = ir.FunctionType(_i8ptr, [_i64])
-        fn = ir.Function(self.module, fnty, 'malloc')
-        self._malloc_fn = fn
+        fn = ir.Function(self.module, fnty, 'GC_malloc')
+        self._gc_alloc_fn = fn
         return fn
 
     def _get_free_fn(self):
+        # Boehm GC manages memory - free is a no-op but keep for compatibility
         fn = self._free_fn
         if fn is not None:
             return fn
@@ -813,6 +840,12 @@ class LLVM:
         self.builder = ir.IRBuilder(entry)
         self.builder.position_at_end(entry)
 
+        # Initialize Boehm GC in main function
+        if node.name == 'main':
+            gc_init_fn = self.functions.get('GC_init')
+            if gc_init_fn:
+                self.builder.call(gc_init_fn, [])
+
         old_locals = self.locals
         old_local_types = self.local_types
         self.locals = {}

{cpyte-2.1.0 → cpyte-2.2.0}/source/cpyte/compiling.py

@@ -229,6 +229,7 @@ def run_jit(module, opt_level=3, src_files=None, no_userspace=False, pic=False):
             pass
 
     _map_libc_fn(engine, mod, 'malloc', ctypes.c_size_t, ctypes.c_void_p)
+    _map_libc_fn(engine, mod, 'free', None, None, argtypes=[ctypes.c_void_p])
     _map_libc_fn(engine, mod, 'strlen', ctypes.c_char_p, ctypes.c_int)
     _map_libc_fn(engine, mod, 'memcpy', None, ctypes.c_void_p,
                  argtypes=[ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int])
@@ -251,6 +252,49 @@ def run_jit(module, opt_level=3, src_files=None, no_userspace=False, pic=False):
     except NameError:
         pass
 
+    # Map Boehm GC functions
+    # NOTE: Boehm GC cannot safely scan JIT'd code stacks on ARM64 macOS
+    # because JIT'd frames lack DWARF unwind info. For JIT, GC_malloc
+    # falls back to malloc (no collection needed - process exits immediately).
+    # For AOT, Boehm GC works normally via libgc linkage (-lgc).
+    try:
+        _libgc = ctypes.CDLL('/opt/homebrew/lib/libgc.dylib')
+        _gc_fns = {
+            'GC_init': (None, []),
+            'GC_realloc': (ctypes.c_void_p, [ctypes.c_void_p, ctypes.c_size_t]),
+            'GC_free': (None, [ctypes.c_void_p]),
+            'GC_gcollect': (None, []),
+            'GC_get_heap_size': (ctypes.c_size_t, []),
+            'GC_get_free_bytes': (ctypes.c_size_t, []),
+            'GC_disable': (None, []),
+            'GC_enable': (None, []),
+            'GC_add_roots': (None, [ctypes.c_void_p, ctypes.c_void_p]),
+            'GC_remove_roots': (None, [ctypes.c_void_p, ctypes.c_void_p]),
+        }
+        for gc_name, (gc_restype, gc_argtypes) in _gc_fns.items():
+            try:
+                fn = mod.get_function(gc_name)
+                if gc_argtypes:
+                    cfunctype = ctypes.CFUNCTYPE(gc_restype, *gc_argtypes)
+                else:
+                    cfunctype = ctypes.CFUNCTYPE(gc_restype)
+                cfn = cfunctype(getattr(_libgc, gc_name))
+                _callbacks.append(cfn)
+                engine.add_global_mapping(fn, ctypes.cast(cfn, ctypes.c_void_p).value)
+            except (NameError, AttributeError):
+                pass
+        # For JIT: map GC_malloc to malloc (avoids Boehm stack scanning crashes)
+        try:
+            fn = mod.get_function('GC_malloc')
+            cfunctype = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_size_t)
+            cfn = cfunctype(_libc.malloc)
+            _callbacks.append(cfn)
+            engine.add_global_mapping(fn, ctypes.cast(cfn, ctypes.c_void_p).value)
+        except (NameError, AttributeError):
+            pass
+    except OSError:
+        pass
+
     engine.finalize_object()
     engine.run_static_constructors()
 
@@ -334,7 +378,8 @@ def run_aot(module, output="program.o", opt_level=3, src_files=None, no_userspac
 
     out_name = output.rsplit('.', 1)[0] if '.' in output else output
     r = subprocess.run(
-        ['clang', '-O3', '-o', out_name] + objs + ['-lm'],
+        ['clang', '-O3', '-o', out_name] + objs + ['-lgc', '-lm',
+         '-L/opt/homebrew/opt/bdw-gc/lib', '-I/opt/homebrew/opt/bdw-gc/include'],
         capture_output=True, text=True
     )
     if r.returncode != 0:

{cpyte-2.1.0 → cpyte-2.2.0}/source/cpyte/mainpie.py

@@ -369,7 +369,8 @@ def cmd_build(args, tab_size=4, strict=False, no_userspace=False, pic=False):
         objs.append(runtime_obj)
 
     executable = output or out_base
-    l.link(objs, executable, opt_level=opt, debug=debug, frameworks=frameworks, pic=pic)
+    l.link(objs, executable, libraries=['gc'], library_paths=['/opt/homebrew/opt/bdw-gc/lib'],
+           opt_level=opt, debug=debug, frameworks=frameworks, pic=pic)
     print(f'Wrote {executable}')
 
 

{cpyte-2.1.0 → cpyte-2.2.0}/source/cpyte.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 2.1.0
+Version: 2.2.0
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT
@@ -81,3 +81,9 @@ python source/mainpie.py --jit examples/<filename>.cpy
 Cpyte is experimental software. The compiler is continuously tested with fuzzing, and we're still discovering and fixing correctness bugs. While many programs compile and run correctly, I can't make any guarantees about correctness or stability.
 
 If you decide to use Cpyte, always use the latest version — older versions have bugs that are pretty easy to run into.
+
+## Memory Management
+
+Cpyte uses **Boehm GC** (bdw-gc) for automatic garbage collection. Heap-allocated objects (via `new`) are managed automatically — no manual `free` needed.
+
+**Note:** Boehm GC adds a small runtime overhead (~5-10%) compared to manual `malloc/free`. For performance-critical ecosystem projects or embedded use cases, this trade-off may be significant. The GC is required for safety but will slow down programs that do heavy heap allocation.