shellsim-c-toolchain 0.1.25__py3-none-any.whl

shellsim_c_toolchain/__init__.py

@@ -0,0 +1,75 @@
+"""Install the separately distributed C-to-Wasm compiler into a shellsim guest."""
+
+from __future__ import annotations
+
+import hashlib
+import shlex
+from importlib.resources import files
+from importlib.resources.abc import Traversable
+from typing import Protocol
+
+_TREE_SHA256 = {
+    "tcc": "6d9aec3bf180d260f9285f6bd63f2aff550f65baf39f62a493ac126f0ec4d203",
+    "wasi-sysroot": "c8db6acd30553b74e149cf9bf23387107e7587761cc930933026000af3a03e63",
+}
+
+
+class _RunResult(Protocol):
+    def check_returncode(self) -> None: ...
+
+
+class _GuestMachine(Protocol):
+    def write_file(self, path: str, data: bytes, *, mode: int = 0o644) -> None: ...
+
+    def run(self, source: str, stdin: bytes = b"") -> _RunResult: ...
+
+
+def _tree_files(root: Traversable) -> tuple[tuple[str, bytes], ...]:
+    pending = [("", root)]
+    contents = []
+    while pending:
+        prefix, directory = pending.pop()
+        for entry in sorted(directory.iterdir(), key=lambda child: child.name, reverse=True):
+            path = f"{prefix}{entry.name}"
+            if entry.is_dir():
+                pending.append((f"{path}/", entry))
+            else:
+                contents.append((path, entry.read_bytes()))
+    return tuple(sorted(contents))
+
+
+def _verified_assets() -> tuple[tuple[str, tuple[tuple[str, bytes], ...]], ...]:
+    assets = files("shellsim_c_toolchain").joinpath("_assets")
+    bundles = []
+    for name, expected_digest in _TREE_SHA256.items():
+        contents = _tree_files(assets.joinpath(name))
+        digest = hashlib.sha256()
+        for path, payload in contents:
+            digest.update(path.encode() + b"\0" + payload + b"\0")
+        if digest.hexdigest() != expected_digest:
+            raise ValueError(f"bundled C toolchain asset digest mismatch: {name}")
+        bundles.append((name, contents))
+    return tuple(bundles)
+
+
+def install_c_toolchain(guest: _GuestMachine) -> None:
+    """Install ``cc`` and the WASI C sysroot without granting host execution.
+
+    The pinned files come from this distribution, never an ambient host path. The host stages
+    each file directly in the bounded guest VFS.
+    """
+
+    bundles = _verified_assets()
+    guest.run("test ! -e /tcc && test ! -e /wasi-sysroot").check_returncode()
+    directories = {f"/{name}" for name, _ in bundles}
+    for name, contents in bundles:
+        for path, _ in contents:
+            components = path.split("/")[:-1]
+            for depth in range(1, len(components) + 1):
+                directories.add(f"/{name}/{'/'.join(components[:depth])}")
+    guest.run("mkdir -p " + " ".join(shlex.quote(path) for path in sorted(directories))).check_returncode()
+    for name, contents in bundles:
+        for path, payload in contents:
+            mode = 0o755 if name == "tcc" and path == "tcc-shellsim.wasm" else 0o644
+            guest.write_file(f"/{name}/{path}", payload, mode=mode)
+    guest.run("rm /usr/bin/cc; ln -s /tcc/tcc-shellsim.wasm /usr/bin/cc").check_returncode()

shellsim_c_toolchain/_assets/tcc/SHELLSIM-LIBC-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shellsim contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

shellsim_c_toolchain/_assets/tcc/include/float.h

@@ -0,0 +1,75 @@
+#ifndef _FLOAT_H_
+#define _FLOAT_H_
+
+#define FLT_RADIX 2
+
+/* IEEE float */
+#define FLT_MANT_DIG 24
+#define FLT_DIG 6
+#define FLT_ROUNDS 1
+#define FLT_EPSILON 1.19209290e-07F
+#define FLT_MIN_EXP (-125)
+#define FLT_MIN 1.17549435e-38F
+#define FLT_MIN_10_EXP (-37)
+#define FLT_MAX_EXP 128
+#define FLT_MAX 3.40282347e+38F
+#define FLT_MAX_10_EXP 38
+
+/* IEEE double */
+#define DBL_MANT_DIG 53
+#define DBL_DIG 15
+#define DBL_EPSILON 2.2204460492503131e-16
+#define DBL_MIN_EXP (-1021)
+#define DBL_MIN 2.2250738585072014e-308
+#define DBL_MIN_10_EXP (-307)
+#define DBL_MAX_EXP 1024
+#define DBL_MAX 1.7976931348623157e+308
+#define DBL_MAX_10_EXP 308
+
+/* horrible intel long double */
+#if defined __i386__ || defined __x86_64__
+
+#define LDBL_MANT_DIG 64
+#define LDBL_DIG 18
+#define LDBL_EPSILON 1.08420217248550443401e-19L
+#define LDBL_MIN_EXP (-16381)
+#define LDBL_MIN 3.36210314311209350626e-4932L
+#define LDBL_MIN_10_EXP (-4931)
+#define LDBL_MAX_EXP 16384
+#define LDBL_MAX 1.18973149535723176502e+4932L
+#define LDBL_MAX_10_EXP 4932
+#define DECIMAL_DIG 21
+
+#elif defined __aarch64__ || defined __riscv
+/*
+ * Use values from:
+ * gcc -dM -E -xc /dev/null | grep LDBL | sed -e "s/__//g"
+ */
+#define LDBL_MANT_DIG 113
+#define LDBL_DIG 33
+#define LDBL_EPSILON 1.92592994438723585305597794258492732e-34L
+#define LDBL_MIN_EXP (-16381)
+#define LDBL_MIN 3.36210314311209350626267781732175260e-4932L
+#define LDBL_MIN_10_EXP (-4931)
+#define LDBL_MAX_EXP 16384
+#define LDBL_MAX 1.18973149535723176508575932662800702e+4932L
+#define LDBL_MAX_10_EXP 4932
+#define DECIMAL_DIG 36
+
+#else
+
+/* same as IEEE double */
+#define LDBL_MANT_DIG 53
+#define LDBL_DIG 15
+#define LDBL_EPSILON 2.2204460492503131e-16L
+#define LDBL_MIN_EXP (-1021)
+#define LDBL_MIN 2.2250738585072014e-308L
+#define LDBL_MIN_10_EXP (-307)
+#define LDBL_MAX_EXP 1024
+#define LDBL_MAX 1.7976931348623157e+308L
+#define LDBL_MAX_10_EXP 308
+#define DECIMAL_DIG 17
+
+#endif
+
+#endif /* _FLOAT_H_ */

shellsim_c_toolchain/_assets/tcc/include/stdalign.h

@@ -0,0 +1,16 @@
+#ifndef _STDALIGN_H
+#define _STDALIGN_H
+
+#if __STDC_VERSION__ < 201112L && (defined(__GNUC__) || defined(__TINYC__))
+# define _Alignas(t) __attribute__((__aligned__(t)))
+# define _Alignof(t) __alignof__(t)
+#endif
+
+#define alignas _Alignas
+#define alignof _Alignof
+
+#define __alignas_is_defined 1
+#define __alignof_is_defined 1
+
+#endif /* _STDALIGN_H */
+

shellsim_c_toolchain/_assets/tcc/include/stdarg.h

@@ -0,0 +1,14 @@
+#ifndef _STDARG_H
+#define _STDARG_H
+
+typedef __builtin_va_list va_list;
+#define va_start __builtin_va_start
+#define va_arg __builtin_va_arg
+#define va_copy __builtin_va_copy
+#define va_end __builtin_va_end
+
+/* fix a buggy dependency on GCC in libio.h */
+typedef va_list __gnuc_va_list;
+#define _VA_LIST_DEFINED
+
+#endif /* _STDARG_H */

shellsim_c_toolchain/_assets/tcc/include/stdatomic.h

@@ -0,0 +1,171 @@
+/* This file is derived from clang's stdatomic.h */
+
+/*===---- stdatomic.h - Standard header for atomic types and operations -----===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef _STDATOMIC_H
+#define _STDATOMIC_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#define __ATOMIC_RELAXED 0
+#define __ATOMIC_CONSUME 1
+#define __ATOMIC_ACQUIRE 2
+#define __ATOMIC_RELEASE 3
+#define __ATOMIC_ACQ_REL 4
+#define __ATOMIC_SEQ_CST 5
+
+/* Memory ordering */
+typedef enum {
+    memory_order_relaxed = __ATOMIC_RELAXED,
+    memory_order_consume = __ATOMIC_CONSUME,
+    memory_order_acquire = __ATOMIC_ACQUIRE,
+    memory_order_release = __ATOMIC_RELEASE,
+    memory_order_acq_rel = __ATOMIC_ACQ_REL,
+    memory_order_seq_cst = __ATOMIC_SEQ_CST,
+} memory_order;
+
+/* Atomic typedefs */
+typedef _Atomic(_Bool) atomic_bool;
+typedef _Atomic(char) atomic_char;
+typedef _Atomic(signed char) atomic_schar;
+typedef _Atomic(unsigned char) atomic_uchar;
+typedef _Atomic(short) atomic_short;
+typedef _Atomic(unsigned short) atomic_ushort;
+typedef _Atomic(int) atomic_int;
+typedef _Atomic(unsigned int) atomic_uint;
+typedef _Atomic(long) atomic_long;
+typedef _Atomic(unsigned long) atomic_ulong;
+typedef _Atomic(long long) atomic_llong;
+typedef _Atomic(unsigned long long) atomic_ullong;
+typedef _Atomic(uint_least16_t) atomic_char16_t;
+typedef _Atomic(uint_least32_t) atomic_char32_t;
+typedef _Atomic(wchar_t) atomic_wchar_t;
+typedef _Atomic(int_least8_t) atomic_int_least8_t;
+typedef _Atomic(uint_least8_t) atomic_uint_least8_t;
+typedef _Atomic(int_least16_t) atomic_int_least16_t;
+typedef _Atomic(uint_least16_t) atomic_uint_least16_t;
+typedef _Atomic(int_least32_t) atomic_int_least32_t;
+typedef _Atomic(uint_least32_t) atomic_uint_least32_t;
+typedef _Atomic(int_least64_t) atomic_int_least64_t;
+typedef _Atomic(uint_least64_t) atomic_uint_least64_t;
+typedef _Atomic(int_fast8_t) atomic_int_fast8_t;
+typedef _Atomic(uint_fast8_t) atomic_uint_fast8_t;
+typedef _Atomic(int_fast16_t) atomic_int_fast16_t;
+typedef _Atomic(uint_fast16_t) atomic_uint_fast16_t;
+typedef _Atomic(int_fast32_t) atomic_int_fast32_t;
+typedef _Atomic(uint_fast32_t) atomic_uint_fast32_t;
+typedef _Atomic(int_fast64_t) atomic_int_fast64_t;
+typedef _Atomic(uint_fast64_t) atomic_uint_fast64_t;
+typedef _Atomic(intptr_t) atomic_intptr_t;
+typedef _Atomic(uintptr_t) atomic_uintptr_t;
+typedef _Atomic(size_t) atomic_size_t;
+typedef _Atomic(ptrdiff_t) atomic_ptrdiff_t;
+typedef _Atomic(intmax_t) atomic_intmax_t;
+typedef _Atomic(uintmax_t) atomic_uintmax_t;
+
+/* Atomic flag */
+typedef struct {
+    atomic_bool value;
+} atomic_flag;
+
+#define ATOMIC_FLAG_INIT {0}
+#define ATOMIC_VAR_INIT(value) (value)
+
+/* Generic routines */
+#define atomic_init(object, desired)                                      \
+    atomic_store_explicit(object, desired, __ATOMIC_RELAXED)
+
+#define __atomic_store_n(ptr, val, order)                                 \
+    (*(ptr) = (val), __atomic_store((ptr), &(typeof(*(ptr))){val}, (order)))
+#define atomic_store_explicit(object, desired, order)                     \
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ (*ptr) tmp = (desired);                                 \
+       __atomic_store (ptr, &tmp, (order));                               \
+    })
+#define atomic_store(object, desired)                                     \
+     atomic_store_explicit (object, desired, __ATOMIC_SEQ_CST)
+
+#define __atomic_load_n(ptr, order)                                       \
+    ({ typeof(*(ptr)) __val;                                              \
+       __atomic_load((ptr), &__val, (order));                             \
+       __val; })
+#define atomic_load_explicit(object, order)                               \
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ ((void)0,*ptr) tmp;                                             \
+       __atomic_load (ptr, &tmp, (order));                                \
+       tmp;                                                               \
+    })
+#define atomic_load(object) atomic_load_explicit (object, __ATOMIC_SEQ_CST)
+
+#define atomic_exchange_explicit(object, desired, order)                  \
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ (*ptr) val = (desired);                                 \
+       __typeof__ (*ptr) tmp;                                             \
+       __atomic_exchange (ptr, &val, &tmp, (order));                      \
+       tmp;                                                               \
+    })
+#define atomic_exchange(object, desired)                                  \
+  atomic_exchange_explicit (object, desired, __ATOMIC_SEQ_CST)
+#define __atomic_compare_exchange_n(ptr, expected, desired, weak, success, failure) \
+    ({ typeof(*(ptr)) __desired = (desired);                              \
+       __atomic_compare_exchange((ptr), (expected), &__desired,          \
+         (weak), (success), (failure)); })
+#define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ (*ptr) tmp = desired;                                   \
+       __atomic_compare_exchange(ptr, expected, &tmp, 0, success, failure); \
+    })
+#define atomic_compare_exchange_strong(object, expected, desired)         \
+    atomic_compare_exchange_strong_explicit (object, expected, desired,   \
+                                             __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
+#define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ (*ptr) tmp = desired;                                   \
+       __atomic_compare_exchange(ptr, expected, &tmp, 1, success, failure); \
+    })
+#define atomic_compare_exchange_weak(object, expected, desired)           \
+    atomic_compare_exchange_weak_explicit (object, expected, desired,     \
+                                           __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
+
+#define atomic_fetch_add(object, operand) \
+    __atomic_fetch_add(object, operand, __ATOMIC_SEQ_CST)
+#define atomic_fetch_add_explicit __atomic_fetch_add
+
+#define atomic_fetch_sub(object, operand) \
+    __atomic_fetch_sub(object, operand, __ATOMIC_SEQ_CST)
+#define atomic_fetch_sub_explicit __atomic_fetch_sub
+
+#define atomic_fetch_or(object, operand) \
+    __atomic_fetch_or(object, operand, __ATOMIC_SEQ_CST)
+#define atomic_fetch_or_explicit __atomic_fetch_or
+
+#define atomic_fetch_xor(object, operand) \
+    __atomic_fetch_xor(object, operand, __ATOMIC_SEQ_CST)
+#define atomic_fetch_xor_explicit __atomic_fetch_xor
+
+#define atomic_fetch_and(object, operand) \
+    __atomic_fetch_and(object, operand, __ATOMIC_SEQ_CST)
+#define atomic_fetch_and_explicit __atomic_fetch_and
+
+extern void atomic_thread_fence (memory_order);
+#define __atomic_thread_fence(order) atomic_thread_fence (order)
+extern void atomic_signal_fence (memory_order);
+#define __atomic_signal_fence(order) atomic_signal_fence(order)
+#define atomic_signal_fence(order) __atomic_signal_fence  (order)
+extern bool __atomic_is_lock_free(size_t size, void *ptr);
+#define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ))
+
+extern bool atomic_flag_test_and_set(void *object);
+extern bool atomic_flag_test_and_set_explicit(void *object, memory_order order);
+extern void atomic_flag_clear(void *object);
+extern void atomic_flag_clear_explicit(void *object, memory_order order);
+#endif /* _STDATOMIC_H */

shellsim_c_toolchain/_assets/tcc/include/stdbool.h

@@ -0,0 +1,11 @@
+#ifndef _STDBOOL_H
+#define _STDBOOL_H
+
+/* ISOC99 boolean */
+
+#define bool	_Bool
+#define true	1
+#define false	0
+#define __bool_true_false_are_defined 1
+
+#endif /* _STDBOOL_H */

shellsim_c_toolchain/_assets/tcc/include/stddef.h

@@ -0,0 +1,39 @@
+#ifndef _STDDEF_H
+#define _STDDEF_H
+
+typedef __SIZE_TYPE__ size_t;
+typedef __PTRDIFF_TYPE__ ssize_t;
+typedef __WCHAR_TYPE__ wchar_t;
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+typedef __PTRDIFF_TYPE__ intptr_t;
+typedef __SIZE_TYPE__ uintptr_t;
+
+#if __STDC_VERSION__ >= 201112L
+typedef union { long long __ll; long double __ld; } max_align_t;
+#endif
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#undef offsetof
+#define offsetof(type, field) __builtin_offsetof(type, field)
+
+void *alloca(size_t size);
+
+#endif
+
+/* Older glibc require a wint_t from <stddef.h> (when requested
+   by __need_wint_t, as otherwise stddef.h isn't allowed to
+   define this type).   Note that this must be outside the normal
+   _STDDEF_H guard, so that it works even when we've included the file
+   already (without requiring wint_t).  Some other libs define _WINT_T
+   if they've already provided that type, so we can use that as guard.
+   TCC defines __WINT_TYPE__ for us.  */
+#if defined (__need_wint_t)
+#ifndef _WINT_T
+#define _WINT_T
+typedef __WINT_TYPE__ wint_t;
+#endif
+#undef __need_wint_t
+#endif

shellsim_c_toolchain/_assets/tcc/include/stdnoreturn.h

@@ -0,0 +1,7 @@
+#ifndef _STDNORETURN_H
+#define _STDNORETURN_H
+
+/* ISOC11 noreturn */
+#define noreturn _Noreturn
+
+#endif /* _STDNORETURN_H */