@swiftbrowser/wasm-sdk 0.0.0-stage → 0.9.0

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/LibcShims.h

@@ -0,0 +1,198 @@
+//===--- LibcShims.h - Access to POSIX for Swift's core stdlib --*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  Using the Darwin (or Glibc) module in the core stdlib would create a
+//  circular dependency, so instead we import these declarations as part of
+//  SwiftShims.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_LIBCSHIMS_H
+#define SWIFT_STDLIB_SHIMS_LIBCSHIMS_H
+
+#include "SwiftStdbool.h"
+#include "SwiftStdint.h"
+#include "SwiftStddef.h"
+#include "Visibility.h"
+
+#if __has_feature(nullability)
+#pragma clang assume_nonnull begin
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+// Input/output <stdio.h>
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_size_t _swift_stdlib_fwrite_stdout(const void *ptr, __swift_size_t size,
+                                           __swift_size_t nitems);
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+void _swift_stdlib_fputs_stderr(const char *str);
+
+// General utilities <stdlib.h>
+// Memory management functions
+static inline void _swift_stdlib_free(void *_Nullable ptr) {
+  extern void free(void *_Nullable);
+  free(ptr);
+}
+
+// String handling <string.h>
+SWIFT_READONLY
+static inline __swift_size_t _swift_stdlib_strlen(const char *s) {
+  extern __swift_size_t strlen(const char *);
+  return strlen(s);
+}
+
+SWIFT_READONLY
+static inline __swift_size_t _swift_stdlib_strlen_unsigned(const unsigned char *s) {
+  return _swift_stdlib_strlen((const char *)s);
+}
+
+SWIFT_READONLY
+static inline int _swift_stdlib_memcmp(const void *s1, const void *s2,
+                                       __swift_size_t n) {
+#if defined(__APPLE__)
+  // Darwin defines memcmp with optional pointers, preserve the same type here.
+  extern int memcmp(const void * _Nullable, const void * _Nullable, __swift_size_t);
+// FIXME: Is there a way to identify Glibc specifically?
+#elif (defined(__gnu_linux__) || defined(__ANDROID__)) && !defined(__musl__)
+  extern int memcmp(const void * _Nonnull, const void * _Nonnull, __swift_size_t);
+#else
+  extern int memcmp(const void * _Null_unspecified, const void * _Null_unspecified, __swift_size_t);
+#endif
+  return memcmp(s1, s2, n);
+}
+
+// Casting helper. This code needs to work when included from C or C++.
+// Casting away const with a C-style cast warns in C++. Use a const_cast
+// there.
+#ifdef __cplusplus
+#define CONST_CAST(type, value) const_cast<type>(value)
+#else
+#define CONST_CAST(type, value) (type)value
+#endif
+
+#ifndef _VA_LIST
+typedef __builtin_va_list va_list;
+#define _VA_LIST
+#endif
+
+static inline int _swift_stdlib_vprintf(const char * __restrict fmt, va_list args) {
+    extern int vprintf(const char * __restrict, va_list);
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wformat-nonliteral"
+    return vprintf(fmt, args);
+#pragma clang diagnostic pop
+}
+
+// Non-standard extensions
+#if defined(__APPLE__)
+#define HAS_MALLOC_SIZE 1
+static inline __swift_size_t _swift_stdlib_malloc_size(const void *ptr) {
+  extern __swift_size_t malloc_size(const void *);
+  return malloc_size(ptr);
+}
+#elif defined(__linux__) || defined(__CYGWIN__) || defined(__ANDROID__) \
+   || defined(__HAIKU__) || defined(__FreeBSD__) || defined(__wasi__)
+#define HAS_MALLOC_SIZE 1
+static inline __swift_size_t _swift_stdlib_malloc_size(const void *ptr) {
+#if defined(__ANDROID__)
+#if !defined(__ANDROID_API__) || __ANDROID_API__ >= 17
+  extern __swift_size_t malloc_usable_size(const void * _Nullable ptr);
+#endif
+#else
+  extern __swift_size_t malloc_usable_size(void *ptr);
+#endif
+  return malloc_usable_size(CONST_CAST(void *, ptr));
+}
+#elif defined(_WIN32)
+#define HAS_MALLOC_SIZE 1
+static inline __swift_size_t _swift_stdlib_malloc_size(const void *ptr) {
+  extern __swift_size_t _msize(void *ptr);
+  return _msize(CONST_CAST(void *, ptr));
+}
+#else
+#define HAS_MALLOC_SIZE 0
+
+static inline __swift_size_t _swift_stdlib_malloc_size(const void *ptr) {
+  return 0;
+}
+#endif
+
+static inline __swift_bool _swift_stdlib_has_malloc_size() {
+  return HAS_MALLOC_SIZE != 0;
+}
+
+// Math library functions
+static inline SWIFT_ALWAYS_INLINE
+float _stdlib_remainderf(float _self, float _other) {
+  return __builtin_remainderf(_self, _other);
+}
+  
+static inline SWIFT_ALWAYS_INLINE
+float _stdlib_squareRootf(float _self) {
+#if defined(_WIN32) && (defined(_M_IX86) || defined(__i386__))
+  typedef float __m128 __attribute__((__vector_size__(16), __aligned__(16)));
+  return __builtin_ia32_sqrtss(__extension__ (__m128){ _self, 0, 0, 0 })[0];
+#else
+  return __builtin_sqrtf(_self);
+#endif
+}
+
+static inline SWIFT_ALWAYS_INLINE
+double _stdlib_remainder(double _self, double _other) {
+  return __builtin_remainder(_self, _other);
+}
+
+static inline SWIFT_ALWAYS_INLINE
+double _stdlib_squareRoot(double _self) {
+  return __builtin_sqrt(_self);
+}
+
+#if !defined _WIN32 && (defined __i386__ || defined __x86_64__)
+static inline SWIFT_ALWAYS_INLINE
+long double _stdlib_remainderl(long double _self, long double _other) {
+  return __builtin_remainderl(_self, _other);
+}
+  
+static inline SWIFT_ALWAYS_INLINE
+long double _stdlib_squareRootl(long double _self) {
+  return __builtin_sqrtl(_self);
+}
+#endif
+
+// Apple's math.h does not declare lgamma_r() etc by default, but they're
+// unconditionally exported by libsystem_m.dylib in all OS versions that
+// support Swift development; we simply need to provide declarations here.
+// In the macOS 15.0, iOS 18.0, et al SDKs, math.h unconditionally declares
+// lgamma_r() when building for Swift. Detect those SDKs by checking for a
+// header which was added in those versions. (Redeclaring the function
+// would cause an error where `lgamma_r` is ambiguous between the SDK
+// `_math.lgamma_r` and this `SwiftShims.lgamma_r`.)
+#if defined(__APPLE__) && !__has_include(<_modules/_math_h.h>)
+float lgammaf_r(float x, int *psigngam);
+double lgamma_r(double x, int *psigngam);
+long double lgammal_r(long double x, int *psigngam);
+#endif // defined(__APPLE__) && !__has_include(<_modules/_math_h.h>)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#if __has_feature(nullability)
+#pragma clang assume_nonnull end
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_LIBCSHIMS_H

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/MetadataSections.h

@@ -0,0 +1,100 @@
+//===--- MetadataSections.h -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains the declaration of the MetadataSectionsRange and 
+/// MetadataSections struct, which represent, respectively,  information about  
+/// an image's section, and an image's metadata information (which is composed
+/// of multiple section information).
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_METADATASECTIONS_H
+#define SWIFT_STDLIB_SHIMS_METADATASECTIONS_H
+
+#if defined(__cplusplus) && !defined(__swift__)
+#include <atomic>
+#endif
+
+#include "SwiftStddef.h"
+#include "SwiftStdint.h"
+
+#ifdef __cplusplus
+namespace swift { 
+extern "C" {
+#endif
+
+/// Specifies the address range corresponding to a section.
+typedef struct MetadataSectionRange {
+  __swift_uintptr_t start;
+  __swift_size_t length;
+} MetadataSectionRange;
+
+
+/// Identifies the address space ranges for the Swift metadata required by the
+/// Swift runtime.
+///
+/// \warning If you change the size of this structure by adding fields, it is an
+///   ABI-breaking change on platforms that use it. Make sure to increment
+///   \c CurrentSectionMetadataVersion if you do. To minimize impact, always add
+///   new fields to the \em end of the structure.
+struct MetadataSections {
+  __swift_uintptr_t version;
+
+  /// The base address of the image where this metadata section was defined, as
+  /// reported when the section was registered with the Swift runtime.
+  ///
+  /// The value of this field is equivalent to the value of
+  /// \c SymbolInfo::baseAddress as returned from \c SymbolInfo::lookup() for a
+  /// symbol in the image that contains these sections.
+  ///
+  /// For Mach-O images, set this field to \c __dso_handle (i.e. the Mach header
+  /// for the image.) For ELF images, set it to \c __ehdr_start. For COFF
+  /// images, set this field to \c __ImageBase.
+  ///
+  /// For platforms that have a single statically-linked image or no dynamic
+  /// loader (i.e. no equivalent of \c __dso_handle, \c __ehdr_start, or
+  /// \c __ImageBase), this field is ignored and should be set to \c nullptr.
+  ///
+  /// \sa swift_addNewDSOImage()
+  const void *baseAddress;
+
+  /// Unused.
+  ///
+  /// These pointers (or the space they occupy) can be repurposed without
+  /// causing ABI breakage. Set them to \c nullptr.
+  void *unused0;
+  void *unused1;
+
+  MetadataSectionRange swift5_protocols;
+  MetadataSectionRange swift5_protocol_conformances;
+  MetadataSectionRange swift5_type_metadata;
+  MetadataSectionRange swift5_typeref;
+  MetadataSectionRange swift5_reflstr;
+  MetadataSectionRange swift5_fieldmd;
+  MetadataSectionRange swift5_assocty;
+  MetadataSectionRange swift5_replace;
+  MetadataSectionRange swift5_replac2;
+  MetadataSectionRange swift5_builtin;
+  MetadataSectionRange swift5_capture;
+  MetadataSectionRange swift5_mpenum;
+  MetadataSectionRange swift5_accessible_functions;
+  MetadataSectionRange swift5_runtime_attributes;
+  MetadataSectionRange swift5_tests;
+};
+
+#ifdef __cplusplus
+} //extern "C"
+} // namespace swift
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_METADATASECTIONS_H

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/ObjCShims.h

@@ -0,0 +1,51 @@
+//===--- ObjCShims.h - Access to libobjc for the core stdlib ---------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  Using the ObjectiveC module in the core stdlib would create a
+//  circular dependency, so instead we import these declarations as
+//  part of SwiftShims.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_OBJCSHIMS_H
+#define SWIFT_STDLIB_SHIMS_OBJCSHIMS_H
+
+#include "SwiftStdint.h"
+#include "Visibility.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __OBJC2__
+
+extern void objc_setAssociatedObject(void);
+extern void objc_getAssociatedObject(void);
+int objc_sync_enter(id _Nonnull object);
+int objc_sync_exit(id _Nonnull object);
+
+static void * _Nonnull getSetAssociatedObjectPtr() {
+  return (void *)&objc_setAssociatedObject;
+}
+
+static void * _Nonnull getGetAssociatedObjectPtr() {
+  return (void *)&objc_getAssociatedObject;
+}
+
+#endif // __OBJC2__
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_COREFOUNDATIONSHIMS_H
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/Random.h

@@ -0,0 +1,43 @@
+//===--- Random.h - Wrapper for the OS random number API --------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  A wrapper around the host OS's secure random number generator.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_RANDOM_H
+#define SWIFT_STDLIB_SHIMS_RANDOM_H
+
+#include "SwiftStddef.h"
+#include "Visibility.h"
+
+#if __has_feature(nullability)
+#pragma clang assume_nonnull begin
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIFT_RUNTIME_STDLIB_API
+void swift_stdlib_random(void *buf, __swift_size_t nbytes);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#if __has_feature(nullability)
+#pragma clang assume_nonnull end
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_RANDOM_H
+