bump webkit

.buildkite/ci.mjs

@@ -453,7 +453,10 @@ function getPipeline(options) {
       agents: getZigAgent(platform),
       retry: getRetry(),
       cancel_on_build_failing: isMergeQueue(),
-      env: getBuildEnv(platform),
+      env: {
+        ...getBuildEnv(platform),
+        ENABLE_LLVM: "OFF",
+      },
       command: `bun run build:ci --target bun-zig --toolchain ${toolchain}`,
     };
   };
@@ -545,9 +548,9 @@ function getPipeline(options) {
   const buildPlatforms = [
     { os: "darwin", arch: "aarch64", release: "14" },
     { os: "darwin", arch: "x64", release: "14" },
-    { os: "linux", arch: "aarch64", distro: "debian", release: "11" },
-    { os: "linux", arch: "x64", distro: "debian", release: "11" },
-    { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "11" },
+    { os: "linux", arch: "aarch64", distro: "debian", release: "12" },
+    { os: "linux", arch: "x64", distro: "debian", release: "12" },
+    { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "12" },
     { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.20" },
     { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.20" },
     { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.20" },

cmake/targets/BuildBun.cmake

@@ -854,25 +854,60 @@ if(LINUX)
     if(ARCH STREQUAL "aarch64")
       target_link_options(${bun} PUBLIC
         -Wl,--wrap=fcntl64
-        -Wl,--wrap=statx
       )
     endif()
 
     if(ARCH STREQUAL "x64")
       target_link_options(${bun} PUBLIC
+        -Wl,--wrap=__isoc23_sscanf
+        -Wl,--wrap=__isoc23_strtol
+        -Wl,--wrap=__isoc23_strtoul
+        -Wl,--wrap=__isoc23_strtoull
+        -Wl,--wrap=__isoc23_vfscanf
+        -Wl,--wrap=__isoc23_vscanf
+        -Wl,--wrap=__isoc23_vsscanf
+        -Wl,--wrap=__libc_single_threaded
+        -Wl,--wrap=__libc_start_main
+        -Wl,--wrap=_dl_find_object
+        -Wl,--wrap=arc4random_buf
+        -Wl,--wrap=dladdr
+        -Wl,--wrap=dlclose
+        -Wl,--wrap=dlerror
+        -Wl,--wrap=dlopen
+        -Wl,--wrap=dlsym
+        -Wl,--wrap=dlvsym
         -Wl,--wrap=fcntl
         -Wl,--wrap=fcntl64
-        -Wl,--wrap=fstat
-        -Wl,--wrap=fstat64
-        -Wl,--wrap=fstatat
-        -Wl,--wrap=fstatat64
-        -Wl,--wrap=lstat
-        -Wl,--wrap=lstat64
+        -Wl,--wrap=getrandom
         -Wl,--wrap=mknod
         -Wl,--wrap=mknodat
-        -Wl,--wrap=stat
-        -Wl,--wrap=stat64
-        -Wl,--wrap=statx
+        -Wl,--wrap=pthread_attr_getstack
+        -Wl,--wrap=pthread_attr_setguardsize
+        -Wl,--wrap=pthread_attr_setstacksize
+        -Wl,--wrap=pthread_create
+        -Wl,--wrap=pthread_detach
+        -Wl,--wrap=pthread_getattr_np
+        -Wl,--wrap=pthread_getspecific
+        -Wl,--wrap=pthread_join
+        -Wl,--wrap=pthread_key_create
+        -Wl,--wrap=pthread_key_delete
+        -Wl,--wrap=pthread_kill
+        -Wl,--wrap=pthread_mutex_trylock
+        -Wl,--wrap=pthread_mutexattr_destroy
+        -Wl,--wrap=pthread_mutexattr_init
+        -Wl,--wrap=pthread_mutexattr_settype
+        -Wl,--wrap=pthread_once
+        -Wl,--wrap=pthread_rwlock_destroy
+        -Wl,--wrap=pthread_rwlock_init
+        -Wl,--wrap=pthread_rwlock_rdlock
+        -Wl,--wrap=pthread_rwlock_unlock
+        -Wl,--wrap=pthread_rwlock_wrlock
+        -Wl,--wrap=pthread_setspecific
+        -Wl,--wrap=pthread_sigmask
+        -Wl,--wrap=quick_exit
+        -Wl,--wrap=sem_init
+        -Wl,--wrap=sem_post
+        -Wl,--wrap=sem_wait
       )
     endif()
 
@@ -921,7 +956,7 @@ if(LINUX)
     -Wl,-z,combreloc
     -Wl,--no-eh-frame-hdr
     -Wl,--sort-section=name
-    -Wl,--hash-style=gnu
+    -Wl,--hash-style=both
     -Wl,--build-id=sha1  # Better for debugging than default
     -Wl,-Map=${bun}.linker-map
   )

cmake/targets/BuildLibArchive.cmake

@@ -18,7 +18,7 @@ register_cmake_command(
     -DENABLE_INSTALL=OFF
     -DENABLE_TEST=OFF
     -DENABLE_WERROR=OFF
-    -DENABLE_BZIP2=OFF
+    -DENABLE_BZip2=OFF
     -DENABLE_CAT=OFF
     -DENABLE_EXPAT=OFF
     -DENABLE_ICONV=OFF

cmake/tools/SetupLLVM.cmake

@@ -1,14 +1,18 @@
-optionx(ENABLE_LLVM BOOL "If LLVM should be used for compilation" DEFAULT ON)
+
+set(DEFAULT_ENABLE_LLVM ON)
+
+# if target is bun-zig, set ENABLE_LLVM to OFF
+if(TARGET bun-zig)
+  set(DEFAULT_ENABLE_LLVM OFF)
+endif()
+
+optionx(ENABLE_LLVM BOOL "If LLVM should be used for compilation" DEFAULT ${DEFAULT_ENABLE_LLVM})
 
 if(NOT ENABLE_LLVM)
   return()
 endif()
 
-if(CMAKE_HOST_WIN32 OR CMAKE_HOST_APPLE OR EXISTS "/etc/alpine-release")
-  set(DEFAULT_LLVM_VERSION "18.1.8")
-else()
-  set(DEFAULT_LLVM_VERSION "16.0.6")
-endif()
+set(DEFAULT_LLVM_VERSION "18.1.8")
 
 optionx(LLVM_VERSION STRING "The version of LLVM to use" DEFAULT ${DEFAULT_LLVM_VERSION})
 

cmake/tools/SetupWebKit.cmake

@@ -2,7 +2,7 @@ option(WEBKIT_VERSION "The version of WebKit to use")
 option(WEBKIT_LOCAL "If a local version of WebKit should be used instead of downloading")
 
 if(NOT WEBKIT_VERSION)
-  set(WEBKIT_VERSION 8f9ae4f01a047c666ef548864294e01df731d4ea)
+  set(WEBKIT_VERSION 8bbd4ed494f66395f9ae42aed1beb57e998265ca)
 endif()
 
 if(WEBKIT_LOCAL)

scripts/bootstrap.sh

@@ -714,14 +714,7 @@ install_build_essentials() {
 }
 
 llvm_version_exact() {
-	case "$os-$abi" in
-	darwin-* | windows-* | linux-musl)
-		print "18.1.8"
-		;;
-	linux-*)
-		print "16.0.6"
-		;;
-	esac
+	print "18.1.8"
 }
 
 llvm_version() {
@@ -980,8 +973,20 @@ install_chrome_dependencies() {
 }
 
 raise_file_descriptor_limit() {
-	append_to_file_sudo /etc/security/limits.conf '*  soft  nofile  262144'
-	append_to_file_sudo /etc/security/limits.conf '*  hard  nofile  262144'
+	if [ -d /etc/security ]; then
+		append_to_file_sudo /etc/security/limits.conf '*  soft  nofile  262144'
+		append_to_file_sudo /etc/security/limits.conf '*  hard  nofile  262144'
+	fi
+
+	append_to_file_sudo /etc/profile 'ulimit -n 262144'
+
+	if [ -d /etc/systemd ]; then
+		append_to_file_sudo /etc/systemd/user.conf 'DefaultLimitNOFILE=262144'
+	fi
+
+	if [ -d /etc/sysctl.d ]; then
+		append_to_file_sudo /etc/sysctl.d/99-file-max.conf 'fs.file-max=262144'
+	fi
 }
 
 main() {
@@ -994,7 +999,7 @@ main() {
 	install_common_software
 	install_build_essentials
 	install_chrome_dependencies
-	raise_file_descriptor_limit # XXX: temporary
+	raise_file_descriptor_limit
 }
 
 main "$@"

src/bun.js/bindings/Base64Helpers.cpp

@@ -18,13 +18,13 @@ ExceptionOr<String> atob(const String& encodedString)
     if (!encodedString.is8Bit()) {
         const auto span = encodedString.span16();
         size_t expected_length = simdutf::latin1_length_from_utf16(span.size());
-        LChar* ptr;
+        std::span<LChar> ptr;
         WTF::String convertedString = WTF::String::createUninitialized(expected_length, ptr);
         if (UNLIKELY(convertedString.isNull())) {
             return WebCore::Exception { OutOfMemoryError };
         }
 
-        auto result = simdutf::convert_utf16le_to_latin1_with_errors(span.data(), span.size(), reinterpret_cast<char*>(ptr));
+        auto result = simdutf::convert_utf16le_to_latin1_with_errors(span.data(), span.size(), reinterpret_cast<char*>(ptr.data()));
 
         if (result.error) {
             return WebCore::Exception { InvalidCharacterError };
@@ -34,12 +34,12 @@ ExceptionOr<String> atob(const String& encodedString)
 
     const auto span = encodedString.span8();
     size_t result_length = simdutf::maximal_binary_length_from_base64(reinterpret_cast<const char*>(span.data()), encodedString.length());
-    LChar* ptr;
+    std::span<LChar> ptr;
     WTF::String outString = WTF::String::createUninitialized(result_length, ptr);
     if (UNLIKELY(outString.isNull())) {
         return WebCore::Exception { OutOfMemoryError };
     }
-    auto result = simdutf::base64_to_binary(reinterpret_cast<const char*>(span.data()), span.size(), reinterpret_cast<char*>(ptr), simdutf::base64_default);
+    auto result = simdutf::base64_to_binary(reinterpret_cast<const char*>(span.data()), span.size(), reinterpret_cast<char*>(ptr.data()), simdutf::base64_default);
     if (result.error != simdutf::error_code::SUCCESS) {
         return WebCore::Exception { InvalidCharacterError };
     }

src/bun.js/bindings/BunString.cpp

@@ -226,7 +226,7 @@ extern "C" JSC::EncodedJSValue BunString__toJS(JSC::JSGlobalObject* globalObject
 extern "C" BunString BunString__fromUTF16Unitialized(size_t length)
 {
     ASSERT(length > 0);
-    UChar* ptr;
+    std::span<UChar> ptr;
     auto impl = WTF::StringImpl::tryCreateUninitialized(length, ptr);
     if (UNLIKELY(!impl)) {
         return { .tag = BunStringTag::Dead };
@@ -237,7 +237,7 @@ extern "C" BunString BunString__fromUTF16Unitialized(size_t length)
 extern "C" BunString BunString__fromLatin1Unitialized(size_t length)
 {
     ASSERT(length > 0);
-    LChar* ptr;
+    std::span<LChar> ptr;
     auto impl = WTF::StringImpl::tryCreateUninitialized(length, ptr);
     if (UNLIKELY(!impl)) {
         return { .tag = BunStringTag::Dead };
@@ -250,12 +250,12 @@ extern "C" BunString BunString__fromUTF8(const char* bytes, size_t length)
     ASSERT(length > 0);
     if (simdutf::validate_utf8(bytes, length)) {
         size_t u16Length = simdutf::utf16_length_from_utf8(bytes, length);
-        UChar* ptr;
+        std::span<UChar> ptr;
         auto impl = WTF::StringImpl::tryCreateUninitialized(static_cast<unsigned int>(u16Length), ptr);
         if (UNLIKELY(!impl)) {
             return { .tag = BunStringTag::Dead };
         }
-        RELEASE_ASSERT(simdutf::convert_utf8_to_utf16(bytes, length, ptr) == u16Length);
+        RELEASE_ASSERT(simdutf::convert_utf8_to_utf16(bytes, length, ptr.data()) == u16Length);
         impl->ref();
         return { BunStringTag::WTFStringImpl, { .wtf = impl.leakRef() } };
     }
@@ -271,12 +271,12 @@ extern "C" BunString BunString__fromUTF8(const char* bytes, size_t length)
 extern "C" BunString BunString__fromLatin1(const char* bytes, size_t length)
 {
     ASSERT(length > 0);
-    LChar* ptr;
+    std::span<LChar> ptr;
     auto impl = WTF::StringImpl::tryCreateUninitialized(length, ptr);
     if (UNLIKELY(!impl)) {
         return { .tag = BunStringTag::Dead };
     }
-    memcpy(ptr, bytes, length);
+    memcpy(ptr.data(), bytes, length);
 
     return { BunStringTag::WTFStringImpl, { .wtf = impl.leakRef() } };
 }
@@ -286,26 +286,26 @@ extern "C" BunString BunString__fromUTF16ToLatin1(const char16_t* bytes, size_t
     ASSERT(length > 0);
     ASSERT_WITH_MESSAGE(simdutf::validate_utf16le(bytes, length), "This function only accepts ascii UTF16 strings");
     size_t outLength = simdutf::latin1_length_from_utf16(length);
-    LChar* ptr = nullptr;
+    std::span<LChar> ptr;
     auto impl = WTF::StringImpl::tryCreateUninitialized(outLength, ptr);
     if (UNLIKELY(!impl)) {
         return { BunStringTag::Dead };
     }
 
-    size_t latin1_length = simdutf::convert_valid_utf16le_to_latin1(bytes, length, reinterpret_cast<char*>(ptr));
+    size_t latin1_length = simdutf::convert_valid_utf16le_to_latin1(bytes, length, reinterpret_cast<char*>(ptr.data()));
     ASSERT_WITH_MESSAGE(latin1_length == outLength, "Failed to convert UTF16 to Latin1");
     return { BunStringTag::WTFStringImpl, { .wtf = impl.leakRef() } };
 }
 
 extern "C" BunString BunString__fromUTF16(const char16_t* bytes, size_t length)
 {
     ASSERT(length > 0);
-    UChar* ptr;
+    std::span<UChar> ptr;
     auto impl = WTF::StringImpl::tryCreateUninitialized(length, ptr);
     if (UNLIKELY(!impl)) {
         return { .tag = BunStringTag::Dead };
     }
-    memcpy(ptr, bytes, length * sizeof(char16_t));
+    memcpy(ptr.data(), bytes, length * sizeof(char16_t));
     return { BunStringTag::WTFStringImpl, { .wtf = impl.leakRef() } };
 }
 

src/bun.js/bindings/JSBuffer.cpp

@@ -1547,21 +1547,21 @@ static inline JSC::EncodedJSValue jsBufferToString(JSC::VM& vm, JSC::JSGlobalObj
 
     switch (encoding) {
     case WebCore::BufferEncodingType::latin1: {
-        LChar* data = nullptr;
+        std::span<LChar> data;
         auto str = String::createUninitialized(length, data);
-        memcpy(data, reinterpret_cast<const char*>(castedThis->vector()) + offset, length);
+        memcpy(data.data(), reinterpret_cast<const char*>(castedThis->vector()) + offset, length);
         return JSC::JSValue::encode(JSC::jsString(vm, WTFMove(str)));
     }
 
     case WebCore::BufferEncodingType::ucs2:
     case WebCore::BufferEncodingType::utf16le: {
-        UChar* data = nullptr;
+        std::span<UChar> data;
         size_t u16length = length / 2;
         if (u16length == 0) {
             return JSC::JSValue::encode(JSC::jsEmptyString(vm));
         } else {
             auto str = String::createUninitialized(u16length, data);
-            memcpy(reinterpret_cast<void*>(data), reinterpret_cast<const char*>(castedThis->vector()) + offset, u16length * 2);
+            memcpy(reinterpret_cast<void*>(data.data()), reinterpret_cast<const char*>(castedThis->vector()) + offset, u16length * 2);
             return JSC::JSValue::encode(JSC::jsString(vm, str));
         }
 
@@ -1571,9 +1571,9 @@ static inline JSC::EncodedJSValue jsBufferToString(JSC::VM& vm, JSC::JSGlobalObj
     case WebCore::BufferEncodingType::ascii: {
         // ascii: we always know the length
         // so we might as well allocate upfront
-        LChar* data = nullptr;
+        std::span<LChar> data;
         auto str = String::createUninitialized(length, data);
-        Bun__encoding__writeLatin1(reinterpret_cast<const unsigned char*>(castedThis->vector()) + offset, length, data, length, static_cast<uint8_t>(encoding));
+        Bun__encoding__writeLatin1(reinterpret_cast<const unsigned char*>(castedThis->vector()) + offset, length, data.data(), length, static_cast<uint8_t>(encoding));
         return JSC::JSValue::encode(JSC::jsString(vm, WTFMove(str)));
     }
 

src/bun.js/bindings/JSBufferEncodingType.cpp

@@ -31,7 +31,8 @@ using namespace JSC;
 
 String convertEnumerationToString(BufferEncodingType enumerationValue)
 {
-    static const NeverDestroyed<String> values[] = {
+
+    static const std::array<NeverDestroyed<String>, 8> values = {
         MAKE_STATIC_STRING_IMPL("utf8"),
         MAKE_STATIC_STRING_IMPL("ucs2"),
         MAKE_STATIC_STRING_IMPL("utf16le"),
@@ -56,7 +57,7 @@ template<> std::optional<BufferEncodingType> parseEnumeration<BufferEncodingType
     if (UNLIKELY(!arg.isString())) {
         return std::nullopt;
     }
-    return parseEnumeration2(lexicalGlobalObject, asString(arg)->getString(&lexicalGlobalObject));
+    return parseEnumeration2(lexicalGlobalObject, arg.toWTFString(&lexicalGlobalObject));
 }
 
 std::optional<BufferEncodingType> parseEnumeration2(JSGlobalObject& lexicalGlobalObject, WTF::String encoding)

src/bun.js/bindings/JSBundlerPlugin.cpp

@@ -27,8 +27,8 @@
 #include <JavaScriptCore/JSPromise.h>
 namespace Bun {
 
-#define WRAP_BUNDLER_PLUGIN(argName) jsDoubleNumber(bitwise_cast<double>(reinterpret_cast<uintptr_t>(argName)))
-#define UNWRAP_BUNDLER_PLUGIN(callFrame) reinterpret_cast<void*>(bitwise_cast<uintptr_t>(callFrame->argument(0).asDouble()))
+#define WRAP_BUNDLER_PLUGIN(argName) jsDoubleNumber(std::bit_cast<double>(reinterpret_cast<uintptr_t>(argName)))
+#define UNWRAP_BUNDLER_PLUGIN(callFrame) reinterpret_cast<void*>(std::bit_cast<uintptr_t>(callFrame->argument(0).asDouble()))
 
 /// These are callbacks defined in Zig and to be run after their associated JS version is run
 extern "C" void JSBundlerPlugin__addError(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue);

src/bun.js/bindings/JSFFIFunction.cpp

@@ -121,7 +121,7 @@ extern "C" JSC::EncodedJSValue Bun__CreateFFIFunctionValue(Zig::GlobalObject* gl
         // We should only expose the "ptr" field when it's a JSCallback for bun:ffi.
         // Not for internal usages of this function type.
         // We should also consider a separate JSFunction type for our usage to not have this branch in the first place...
-        function->putDirect(vm, JSC::Identifier::fromString(vm, String(MAKE_STATIC_STRING_IMPL("ptr"))), JSC::jsNumber(bitwise_cast<double>(functionPointer)), JSC::PropertyAttribute::ReadOnly | 0);
+        function->putDirect(vm, JSC::Identifier::fromString(vm, String(MAKE_STATIC_STRING_IMPL("ptr"))), JSC::jsNumber(__bit_cast<double>(functionPointer)), JSC::PropertyAttribute::ReadOnly | 0);
 
         return JSC::JSValue::encode(function);
     }

src/bun.js/bindings/NodeHTTP.cpp

@@ -212,10 +212,10 @@ static EncodedJSValue assignHeadersFromUWebSockets(uWS::HttpRequest* request, JS
     for (auto it = request->begin(); it != request->end(); ++it) {
         auto pair = *it;
         StringView nameView = StringView(std::span { reinterpret_cast<const LChar*>(pair.first.data()), pair.first.length() });
-        LChar* data = nullptr;
+        std::span<LChar> data;
         auto value = String::createUninitialized(pair.second.length(), data);
         if (pair.second.length() > 0)
-            memcpy(data, pair.second.data(), pair.second.length());
+            memcpy(data.data(), pair.second.data(), pair.second.length());
 
         HTTPHeaderName name;
         WTF::String nameString;