cpyte 4.2.4__tar.gz → 4.2.6__tar.gz

{cpyte-4.2.4/source/cpyte.egg-info → cpyte-4.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 4.2.4
+Version: 4.2.6
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT

{cpyte-4.2.4 → cpyte-4.2.6}/source/cpyte/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.2.4"
+__version__ = "4.2.6"
 
 # ---------------------------------------------------------------------------
 # Public library API.

{cpyte-4.2.4 → cpyte-4.2.6}/source/cpyte/compiling.py

@@ -469,7 +469,18 @@ def _find_llvm_cc():
         if exe:
             try:
                 r = subprocess.run(
-                    [exe, "-S", "-emit-llvm", "-O0", "-target", triple, "-o", "-", "-xc", "-"],
+                    [
+                        exe,
+                        "-S",
+                        "-emit-llvm",
+                        "-O0",
+                        "-target",
+                        triple,
+                        "-o",
+                        "-",
+                        "-xc",
+                        "-",
+                    ],
                     input="int __x = 0;",
                     capture_output=True,
                     text=True,
@@ -545,6 +556,26 @@ def _load_libc():
 
 
 _libc = _load_libc()
+
+
+def _load_optional_lib(*names):
+    for _n in names:
+        if not _n:
+            continue
+        try:
+            return ctypes.CDLL(_n)
+        except OSError:
+            continue
+    return None
+
+
+_libm = _load_optional_lib(
+    ctypes.util.find_library("m"), "libm.so.6", "/usr/lib/libm.so", "libm.dylib"
+)
+_libgcc = _load_optional_lib(
+    ctypes.util.find_library("gcc_s"), "libgcc_s.so.1", "/usr/lib/libgcc_s.so.1"
+)
+_process_libs = tuple(lib for lib in (_libc, _libm, _libgcc) if lib is not None)
 _libc.strlen.argtypes = [ctypes.c_char_p]
 _libc.strlen.restype = ctypes.c_int
 _libc.memcpy.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int]
@@ -1496,9 +1527,12 @@ def run_jit(
     try:
         fn = mod.get_function("strcmp")
         engine.add_global_mapping(fn, _libc_addr("strcmp"))
+        _explicit_mapped.add("strcmp")
     except NameError:
         pass
 
+    _map_process_libc(engine, mod)
+
     engine.finalize_object()
     if _use_windows_gnu():
         externs = sorted(
@@ -1579,6 +1613,9 @@ def _libc_addr(name):
     return ctypes.cast(getattr(_libc, name), ctypes.c_void_p).value
 
 
+_explicit_mapped = set()
+
+
 def _map_libc_fn(engine, mod, name, argtype, restype, argtypes=None):
     """Map an external libc symbol in the JIT module to its raw native address.
 
@@ -1591,6 +1628,49 @@ def _map_libc_fn(engine, mod, name, argtype, restype, argtypes=None):
     except NameError:
         return
     engine.add_global_mapping(fn, _libc_addr(name))
+    _explicit_mapped.add(name)
+
+
+def _map_process_libc(engine, mod):
+    """Resolve every external C symbol the runtime/bignum helpers reference.
+
+    RuntimeDyld's in-process symbol lookup is unreliable on Linux: llvmlite
+    returns a NULL address for libc functions (printf, fputs, putchar, ...),
+    and MCJIT leaves an unresolved external at address 0. A runtime helper
+    such as print_int (whose C body calls printf) then jumps to NULL and the
+    process SIGSEGVs before producing any output. Map each external
+    declaration we can find in the loaded C runtime / libm / process image to
+    its real address. LLVM intrinsics (``llvm.*``) are lowered by the backend
+    and are deliberately skipped.
+    """
+    libs = list(_process_libs)
+    try:
+        libs.append(ctypes.CDLL(None))
+    except OSError:
+        pass
+    mapped = set()
+    for fn in mod.functions:
+        if not fn.is_declaration:
+            continue
+        name = fn.name
+        if name.startswith("llvm.") or name in mapped or name in _explicit_mapped:
+            continue
+        for lib in libs:
+            try:
+                sym = getattr(lib, name)
+            except AttributeError:
+                continue
+            try:
+                addr = ctypes.cast(sym, ctypes.c_void_p).value
+            except (TypeError, ValueError):
+                continue
+            if addr:
+                mapped.add(name)
+                try:
+                    engine.add_global_mapping(fn, addr)
+                except Exception:
+                    pass
+                break
 
 
 def run_aot(

{cpyte-4.2.4 → cpyte-4.2.6}/source/cpyte/gc_runtime.c

@@ -115,16 +115,19 @@ typedef struct {
 
 /* Thread-local storage for TLAB.
  *
- * Windows and Linux use native TLS (`__declspec(thread)` / `__thread`).
- * macOS must NOT: the JIT path compiles this file to LLVM IR and emits a
- * Mach-O object via llvmlite's MCJIT, which cannot encode the TLVP
- * relocation that `__thread` lowers to (ARM64_RELOC_TLVP_LOAD_PAGEOFF12).
- * On Apple we back the per-thread TLAB with a pthread key instead, so the
- * emitted object is TLS-free and each thread still gets its own buffer. */
+ * Native TLS (`__declspec(thread)` / `__thread`) is avoided on every POSIX
+ * platform: the JIT path compiles this file to LLVM IR and emits a native
+ * object via llvmlite's MCJIT, and the compiler lowers native TLS to a
+ * `thread_local` LLVM global, which RuntimeDyld refuses to allocate
+ * (`LLVM ERROR: allocation of TLS not implemented`; on macOS arm64 it would
+ * also require the TLVP relocation ARM64_RELOC_TLVP_LOAD_PAGEOFF12). We back
+ * the per-thread TLAB with a pthread key instead, so the emitted object is
+ * TLS-free and each thread still gets its own buffer. Windows keeps native
+ * TLS (no POSIX threads available). */
 #ifdef _WIN32
 __declspec(thread) static tlab_t tlab = {NULL, NULL, NULL};
 #  define TLAB_GET() (&tlab)
-#elif defined(__APPLE__)
+#else
 static pthread_key_t  tlab_key;
 static pthread_once_t tlab_key_once = PTHREAD_ONCE_INIT;
 static void tlab_key_create(void) { pthread_key_create(&tlab_key, NULL); }
@@ -138,22 +141,19 @@ static tlab_t* tlab_get(void) {
     return tl;
 }
 #  define TLAB_GET() tlab_get()
-#else
-static __thread tlab_t tlab = {NULL, NULL, NULL};
-#  define TLAB_GET() (&tlab)
 #endif
 
 static void* tlab_alloc(size_t size) {
     /* Round up to pointer alignment */
     size = (size + sizeof(void*) - 1) & ~(sizeof(void*) - 1);
-    
+
     if (TLAB_GET()->start == NULL || TLAB_GET()->current + size > TLAB_GET()->end) {
         /* TLAB exhausted or not initialized: allocate new block from global heap */
         size_t block_size = (size > TLAB_SIZE) ? size : TLAB_SIZE;
-        
+
         gc_lock_init();
         CPY_MUTEX_LOCK(&gc_lock_);
-        
+
         /* Allocate the TLAB block through the normal GC path */
         cpyte_obj_t* hdr = (cpyte_obj_t*)calloc(1, sizeof(cpyte_obj_t) + block_size);
         if (hdr == NULL) {
@@ -163,14 +163,14 @@ static void* tlab_alloc(size_t size) {
         hdr->size = block_size;
         ugc_register(&gc, &hdr->base);
         obj_track(hdr);
-        
+
         CPY_MUTEX_UNLOCK(&gc_lock_);
-        
+
         TLAB_GET()->start = PAYLOAD(hdr);
         TLAB_GET()->end = TLAB_GET()->start + block_size;
         TLAB_GET()->current = TLAB_GET()->start;
     }
-    
+
     /* Bump-pointer allocation (lock-free) */
     void *ptr = TLAB_GET()->current;
     TLAB_GET()->current += size;
@@ -386,7 +386,7 @@ void gc_init(void) {
             if (v > 0) gc_threshold = v;
         }
     }
-    
+
     /* Initialize TLAB for the current thread */
     TLAB_GET()->start = NULL;
     TLAB_GET()->end = NULL;
@@ -406,7 +406,7 @@ void* gc_malloc(size_t size) {
             return ptr;
         }
     }
-    
+
     /* Fallback to global allocation for large objects or TLAB failure */
     gc_lock_init();
     CPY_MUTEX_LOCK(&gc_lock_);
@@ -540,7 +540,7 @@ void gc_shutdown(void) {
         }
         obj_table[i] = NULL;
     }
-    
+
     /* Reset TLAB for current thread */
     TLAB_GET()->start = NULL;
     TLAB_GET()->end = NULL;

{cpyte-4.2.4 → cpyte-4.2.6/source/cpyte.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 4.2.4
+Version: 4.2.6
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT