Initial ARM64 Windows

.github/workflows/build.yml

@@ -243,20 +243,146 @@ jobs:
             build-type: Debug
             package_json_arch: "x64"
             label: bun-webkit-windows-amd64-debug
+          - runner: windows-11-arm
+            build-type: Release
+            package_json_arch: "arm64"
+            label: bun-webkit-windows-arm64
+          - runner: windows-11-arm
+            build-type: Debug
+            package_json_arch: "arm64"
+            label: bun-webkit-windows-arm64-debug
     runs-on: ${{ matrix.runner }}
     timeout-minutes: 90
     steps:
-      - name: Install Scoop
+      - name: Disable Windows Defender
+        shell: pwsh
         run: |
-          Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-          Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
-          Join-Path (Resolve-Path ~).Path "scoop\shims" >> $Env:GITHUB_PATH
-      - name: Install LLVM and Ninja
+          # Stop Windows Defender services
+          Stop-Service -Name WinDefend -Force -ErrorAction SilentlyContinue
+          Stop-Service -Name WdNisSvc -Force -ErrorAction SilentlyContinue
+
+          # Disable real-time protection via registry
+          Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows Defender\Real-Time Protection" -Name DisableRealtimeMonitoring -Value 1 -Force -ErrorAction SilentlyContinue
+          Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows Defender" -Name DisableAntiSpyware -Value 1 -Force -ErrorAction SilentlyContinue
+          Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows Defender" -Name DisableAntiVirus -Value 1 -Force -ErrorAction SilentlyContinue
+
+          # Disable via PowerShell preferences (belt and suspenders)
+          Set-MpPreference -DisableRealtimeMonitoring $true -Force -ErrorAction SilentlyContinue
+          Set-MpPreference -DisableBehaviorMonitoring $true -Force -ErrorAction SilentlyContinue
+          Set-MpPreference -DisableBlockAtFirstSeen $true -Force -ErrorAction SilentlyContinue
+          Set-MpPreference -DisableIOAVProtection $true -Force -ErrorAction SilentlyContinue
+          Set-MpPreference -DisablePrivacyMode $true -Force -ErrorAction SilentlyContinue
+          Set-MpPreference -DisableScriptScanning $true -Force -ErrorAction SilentlyContinue
+          Set-MpPreference -DisableArchiveScanning $true -Force -ErrorAction SilentlyContinue
+          Set-MpPreference -SignatureDisableUpdateOnStartupWithoutEngine $true -Force -ErrorAction SilentlyContinue
+          Set-MpPreference -DisableIntrusionPreventionSystem $true -Force -ErrorAction SilentlyContinue
+
+          # Add exclusions for the entire system drive as a last resort
+          Add-MpPreference -ExclusionPath "C:\" -Force -ErrorAction SilentlyContinue
+          Add-MpPreference -ExclusionProcess "*" -Force -ErrorAction SilentlyContinue
+
+      - name: Install dependencies for Windows
         run: |
-          scoop install ninja
-          scoop install [email protected]
-          Join-Path (Resolve-Path ~).Path "scoop\apps\llvm\current\bin" >> $Env:GITHUB_PATH
-      - uses: cygwin/cygwin-install-action@006ad0b0946ca6d0a3ea2d4437677fa767392401
+          # Detect architecture
+          $isARM64 = $env:PROCESSOR_ARCHITECTURE -eq "ARM64"
+
+          # Install Scoop if not available
+          if (!(Get-Command scoop -ErrorAction SilentlyContinue)) {
+            Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser -Force
+            Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
+            $env:PATH = "$env:USERPROFILE\scoop\shims;$env:PATH"
+            echo "$env:USERPROFILE\scoop\shims" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          }
+
+          # On ARM64, manually install 7zip to avoid Scoop's extraction issues
+          if ($isARM64) {
+            $7zipUrl = "https://www.7-zip.org/a/7z2501-arm64.exe"
+            $7zipExe = "$env:TEMP\7z-installer.exe"
+            Invoke-WebRequest -Uri $7zipUrl -OutFile $7zipExe
+
+            # Extract manually
+            Start-Process -FilePath $7zipExe -ArgumentList "/S", "/D=C:\Program Files\7-Zip" -Wait
+            echo "C:\Program Files\7-Zip" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+
+            # Tell Scoop to use the external 7zip we just installed
+            scoop config use_external_7zip true
+            scoop config 7zip_path "C:\Program Files\7-Zip\7z.exe"
+          } else {
+            # x64 can use normal Scoop 7zip installation
+            scoop install 7zip
+          }
+
+          # Skip aria2 on ARM64 as it may cause issues
+          if (-not $isARM64) {
+            scoop install aria2
+          }
+
+          # Install tools via Scoop one by one for better error isolation
+          if ($isARM64) {
+            # Use ARM64-specific packages
+            scoop install cmake
+            scoop install ninja
+            scoop install python
+            scoop install perl
+            scoop install make
+
+            # Download and extract LLVM ARM64 directly (Scoop's pre_install fails)
+            Write-Host "Downloading LLVM ARM64..."
+            $llvmVersion = "19.1.4"
+            $llvmUrl = "https://github.com/llvm/llvm-project/releases/download/llvmorg-$llvmVersion/LLVM-$llvmVersion-woa64.exe"
+            $llvmPath = "C:\LLVM"
+
+            # Download LLVM installer
+            $llvmInstaller = "$env:TEMP\llvm-arm64.exe"
+            Invoke-WebRequest -Uri $llvmUrl -OutFile $llvmInstaller
+
+            # Extract with 7zip (faster than installer)
+            Write-Host "Extracting LLVM (this may take a few minutes)..."
+            $extractResult = & "C:\Program Files\7-Zip\7z.exe" x $llvmInstaller -o"$llvmPath" -y 2>&1
+            Write-Host "7zip extraction completed with result: $LASTEXITCODE"
+
+            # Verify extraction worked
+            if (Test-Path "$llvmPath\bin\clang.exe") {
+                Write-Host "LLVM extracted successfully"
+                # Add to PATH
+                echo "$llvmPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+                Write-Host "LLVM ARM64 installed and added to PATH"
+            } else {
+                Write-Host "ERROR: LLVM extraction failed - clang.exe not found"
+                exit 1
+            }
+
+            Write-Host "ARM64 dependency installation completed, continuing..."
+          } else {
+            # Use x64 packages
+            scoop install cmake
+            scoop install ninja
+            scoop install python
+            scoop install perl
+            scoop install llvm
+            scoop install make
+          }
+
+          Write-Host "Starting Ruby installation phase..."
+
+          # Install Ruby manually on ARM64 (Scoop's Ruby fails on ARM64)
+          if ($isARM64) {
+            Write-Host "Skipping Ruby installation on ARM64 - using pre-installed Ruby"
+            # GitHub Actions ARM64 runners come with Ruby pre-installed
+          } else {
+            # x64 can use Scoop's Ruby
+            Write-Host "Installing Ruby via Scoop..."
+            scoop install ruby
+            Write-Host "Ruby installation completed"
+          }
+
+          # Install vcpkg
+          git clone https://github.com/Microsoft/vcpkg.git C:\vcpkg
+          cd C:\vcpkg
+          .\bootstrap-vcpkg.bat
+          $env:VCPKG_ROOT = "C:\vcpkg"
+          echo "VCPKG_ROOT=C:\vcpkg" >> $env:GITHUB_ENV
+
       - uses: actions/checkout@v4
         with:
           sparse-checkout-cone-mode: false
@@ -274,6 +400,14 @@ jobs:
           $env:GITHUB_SHA = "${{ github.sha }}"
           $env:PACKAGE_JSON_ARCH = "${{matrix.package_json_arch}}"
           $env:GITHUB_REPOSITORY = "${{ github.repository }}"
+
+          # Explicitly set architecture to avoid detection issues
+          if ("${{matrix.package_json_arch}}" -eq "arm64") {
+            $env:BUILD_ARM64 = "1"
+          } else {
+            $env:BUILD_ARM64 = "0"
+          }
+
           ./windows-release.ps1
       - uses: actions/upload-artifact@v4
         with:
@@ -440,6 +574,14 @@ jobs:
         with:
           name: bun-webkit-windows-amd64-debug
           path: ${{runner.temp}}/bun-webkit-windows-amd64-debug
+      - uses: actions/download-artifact@v4
+        with:
+          name: bun-webkit-windows-arm64
+          path: ${{runner.temp}}/bun-webkit-windows-arm64
+      - uses: actions/download-artifact@v4
+        with:
+          name: bun-webkit-windows-arm64-debug
+          path: ${{runner.temp}}/bun-webkit-windows-arm64-debug
       - uses: actions/download-artifact@v4
         with:
           name: bun-webkit-linux-amd64-musl
@@ -491,6 +633,8 @@ jobs:
           mv ${{runner.temp}}/bun-webkit-linux-arm64-musl-lto/bun-webkit.tar.gz ./out/bun-webkit-linux-arm64-musl-lto.tar.gz
           mv ${{runner.temp}}/bun-webkit-windows-amd64/bun-webkit.tar.gz ./out/bun-webkit-windows-amd64.tar.gz
           mv ${{runner.temp}}/bun-webkit-windows-amd64-debug/bun-webkit.tar.gz ./out/bun-webkit-windows-amd64-debug.tar.gz
+          mv ${{runner.temp}}/bun-webkit-windows-arm64/bun-webkit.tar.gz ./out/bun-webkit-windows-arm64.tar.gz
+          mv ${{runner.temp}}/bun-webkit-windows-arm64-debug/bun-webkit.tar.gz ./out/bun-webkit-windows-arm64-debug.tar.gz
       - name: Release
         uses: softprops/action-gh-release@v1
         with:
@@ -540,3 +684,5 @@ jobs:
           files: |
             ./out/bun-webkit-windows-amd64.tar.gz
             ./out/bun-webkit-windows-amd64-debug.tar.gz
+            ./out/bun-webkit-windows-arm64.tar.gz
+            ./out/bun-webkit-windows-arm64-debug.tar.gz

Source/JavaScriptCore/assembler/ARM64Assembler.h

@@ -465,7 +465,11 @@ class ARM64Assembler {
                 BranchType m_branchType : 2 { BranchType_JMP };
             } realTypes { };
             struct CopyTypes {
+#if OS(WINDOWS)
+                uint64_t content[5];  // Increased to match RealTypes size (40 bytes) on Windows
+#else
                 uint64_t content[3];
+#endif
             } copyTypes;
             static_assert(sizeof(RealTypes) == sizeof(CopyTypes), "LinkRecord's CopyStruct size equals to RealStruct");
         } data;
@@ -3780,6 +3784,9 @@ class ARM64Assembler {
             linuxPageFlush(current, current + page);
 
         linuxPageFlush(current, end);
+#elif OS(WINDOWS)
+        // On Windows ARM64, use FlushInstructionCache
+        FlushInstructionCache(GetCurrentProcess(), code, size);
 #else
 #error "The cacheFlush support is missing on this platform."
 #endif

Source/JavaScriptCore/assembler/AbstractMacroAssembler.h

@@ -304,7 +304,7 @@ class AbstractMacroAssembler : public AbstractMacroAssemblerBase {
         {
         }
 
-#if OS(WINDOWS)
+#if OS(WINDOWS) && CPU(X86_64)
         template<typename ReturnType, typename... Arguments>
         explicit TrustedImmPtr(ReturnType(SYSV_ABI *value)(Arguments...))
             : m_value(reinterpret_cast<void*>(value))

Source/JavaScriptCore/assembler/MacroAssemblerARM64.cpp

@@ -580,7 +580,9 @@ asm (
 #else
     "ret" "\n"
 #endif
+#if !OS(WINDOWS)
     ".previous" "\n"
+#endif
 );
 
 // And now, the slower version that saves the full width of FP registers:
@@ -833,7 +835,9 @@ asm (
 #else
     "ret" "\n"
 #endif
+#if !OS(WINDOWS)
     ".previous" "\n"
+#endif
 );
 
 void MacroAssembler::probe(Probe::Function function, void* arg, SavedFPWidth savedFPWidth)

Source/JavaScriptCore/interpreter/CallFrame.h

@@ -394,8 +394,8 @@ using JSInstruction = BaseInstruction<JSOpcodeTraits>;
 JS_EXPORT_PRIVATE bool isFromJSCode(void* returnAddress);
 
 #if USE(BUILTIN_FRAME_ADDRESS)
-#if OS(WINDOWS)
-// On Windows, __builtin_frame_address(1) doesn't work, it returns __builtin_frame_address(0)
+#if OS(WINDOWS) && CPU(X86_64)
+// On Windows x86_64, __builtin_frame_address(1) doesn't work, it returns __builtin_frame_address(0)
 // We can't use __builtin_frame_address(0) either, as on Windows it points at the space after
 // function's local variables on the stack instead of before like other platforms.
 // Instead we use _AddressOfReturnAddress(), and clobber rbp so it should be the first parameter
@@ -411,15 +411,29 @@ JS_EXPORT_PRIVATE bool isFromJSCode(void* returnAddress);
         ASSERT(JSC::isFromJSCode(removeCodePtrTag<void*>(__builtin_return_address(0)))); \
         std::bit_cast<JSC::CallFrame*>(*((uintptr_t**) _AddressOfReturnAddress() - 1)); \
     })
-#else // !OS(WINDOWS)
+#elif OS(WINDOWS) && CPU(ARM64)
+// On Windows ARM64, __builtin_frame_address(1) also has issues similar to x86_64
+// Use _AddressOfReturnAddress() and clobber x29 (frame pointer) for ARM64
+#define DECLARE_CALL_FRAME(vm) \
+    ({ \
+        asm volatile( \
+            "" \
+            : /* no outputs */ \
+            : /* no inputs */ \
+            : "x29" /* clobber frame pointer */ \
+        ); \
+        ASSERT(JSC::isFromJSCode(removeCodePtrTag<void*>(__builtin_return_address(0)))); \
+        std::bit_cast<JSC::CallFrame*>(*((uintptr_t**) _AddressOfReturnAddress() - 1)); \
+    })
+#else // !OS(WINDOWS) || (!CPU(X86_64) && !CPU(ARM64))
 // FIXME (see rdar://72897291): Work around a Clang bug where __builtin_return_address()
 // sometimes gives us a signed pointer, and sometimes does not.
 #define DECLARE_CALL_FRAME(vm) \
     ({ \
         ASSERT(JSC::isFromJSCode(removeCodePtrTag<void*>(__builtin_return_address(0)))); \
         std::bit_cast<JSC::CallFrame*>(__builtin_frame_address(1)); \
     })
-#endif // !OS(WINDOWS)
+#endif // !(OS(WINDOWS) && (CPU(X86_64) || CPU(ARM64)))
 #else
 #define DECLARE_CALL_FRAME(vm) ((vm).topCallFrame)
 #endif

Source/JavaScriptCore/jit/ThunkGenerators.cpp

@@ -902,7 +902,7 @@ typedef MathThunkCallingConvention(*MathThunk)(MathThunkCallingConvention);
     } \
     static MathThunk UnaryDoubleOpWrapper(function) = &function##Thunk;
 
-#elif CPU(ARM64)
+#elif CPU(ARM64) && !OS(WINDOWS)
 
 #define defineUnaryDoubleOpWrapper(function) \
     asm( \

Source/JavaScriptCore/offlineasm/arm64.rb

@@ -1399,6 +1399,17 @@ def lowerARM64
             $asm.puts "ldr #{operands[1].arm64Operand(:quad)}, [#{operands[1].arm64Operand(:quad)}, :got_lo12:#{operands[0].asmLabel}]"
             $asm.putStr("#endif")
 
+            # On Windows, use COFF-style addressing
+            $asm.putStr("#elif OS(WINDOWS)")
+
+            # Windows ARM64 uses PC-relative addressing similar to Linux
+            $asm.puts "adrp #{operands[1].arm64Operand(:quad)}, #{operands[0].asmLabel}"
+            $asm.putStr("#if CPU(ADDRESS32)")
+            $asm.puts "add #{operands[1].arm64Operand(:word)}, #{operands[1].arm64Operand(:word)}, :lo12:#{operands[0].asmLabel}"
+            $asm.putStr("#else")
+            $asm.puts "add #{operands[1].arm64Operand(:quad)}, #{operands[1].arm64Operand(:quad)}, :lo12:#{operands[0].asmLabel}"
+            $asm.putStr("#endif")
+
             # Throw a compiler error everywhere else.
             $asm.putStr("#else")
             $asm.putStr("#error Missing globaladdr implementation")

Source/JavaScriptCore/runtime/MachineContext.h

@@ -107,6 +107,8 @@ static inline void*& stackPointerImpl(PlatformRegisters& regs)
     return reinterpret_cast<void*&>((uintptr_t&) regs.Esp);
 #elif CPU(X86_64)
     return reinterpret_cast<void*&>((uintptr_t&) regs.Rsp);
+#elif CPU(ARM64)
+    return reinterpret_cast<void*&>((uintptr_t&) regs.Sp);
 #else
 #error Unknown Architecture
 #endif
@@ -233,6 +235,8 @@ static inline void*& framePointerImpl(PlatformRegisters& regs)
     return reinterpret_cast<void*&>((uintptr_t&) regs.Ebp);
 #elif CPU(X86_64)
     return reinterpret_cast<void*&>((uintptr_t&) regs.Rbp);
+#elif CPU(ARM64)
+    return reinterpret_cast<void*&>((uintptr_t&) regs.Fp);
 #else
 #error Unknown Architecture
 #endif
@@ -361,6 +365,8 @@ static inline void*& instructionPointerImpl(PlatformRegisters& regs)
     return reinterpret_cast<void*&>((uintptr_t&) regs.Eip);
 #elif CPU(X86_64)
     return reinterpret_cast<void*&>((uintptr_t&) regs.Rip);
+#elif CPU(ARM64)
+    return reinterpret_cast<void*&>((uintptr_t&) regs.Pc);
 #else
 #error Unknown Architecture
 #endif
@@ -542,6 +548,8 @@ inline void*& argumentPointer<1>(PlatformRegisters& regs)
     return reinterpret_cast<void*&>((uintptr_t&) regs.Edx);
 #elif CPU(X86_64)
     return reinterpret_cast<void*&>((uintptr_t&) regs.Rdx);
+#elif CPU(ARM64)
+    return reinterpret_cast<void*&>((uintptr_t&) regs.X1);
 #else
 #error Unknown Architecture
 #endif
@@ -571,6 +579,8 @@ inline void* wasmInstancePointer(const PlatformRegisters& regs)
     return reinterpret_cast<void*>((uintptr_t) regs.Ebx);
 #elif CPU(X86_64)
     return reinterpret_cast<void*>((uintptr_t) regs.Rbx);
+#elif CPU(ARM64)
+    return reinterpret_cast<void*>((uintptr_t) regs.X19);
 #else
 #error Unknown Architecture
 #endif
@@ -740,6 +750,9 @@ inline void*& llintInstructionPointer(PlatformRegisters& regs)
 #if CPU(ARM)
     static_assert(LLInt::LLIntPC == ARMRegisters::r8, "Wrong LLInt PC.");
     return reinterpret_cast<void*&>((uintptr_t&) regs.R8);
+#elif CPU(ARM64)
+    static_assert(LLInt::LLIntPC == ARM64Registers::x4, "Wrong LLInt PC.");
+    return reinterpret_cast<void*&>((uintptr_t&) regs.X4);
 #elif CPU(X86)
     static_assert(LLInt::LLIntPC == X86Registers::esi, "Wrong LLInt PC.");
     return reinterpret_cast<void*&>((uintptr_t&) regs.Esi);

Source/WTF/wtf/CodePtr.h

@@ -93,7 +93,7 @@ class CodePtr : public CodePtrBase {
         : m_value(encodeFunc(ptr))
     { }
 
-#if OS(WINDOWS)
+#if OS(WINDOWS) && CPU(X86_64)
     template<typename Out, typename... In>
     constexpr CodePtr(Out(SYSV_ABI *ptr)(In...))
         : m_value(encodeFunc(ptr))

Source/WTF/wtf/FunctionPtr.h

@@ -88,7 +88,7 @@ class FunctionPtr<tag, Out(In...), attr> : public FunctionPtrBase {
         : m_ptr(encode(ptr))
     { }
 
-#if OS(WINDOWS)
+#if OS(WINDOWS) && CPU(X86_64)
     constexpr FunctionPtr(Out(SYSV_ABI *ptr)(In...))
         : m_ptr(encode(ptr))
     { }