ruby_wasm 2.5.1-aarch64-linux-musl

data/lib/ruby_wasm/build/product/openssl.rb

@@ -0,0 +1,93 @@
+require_relative "./product"
+
+module RubyWasm
+  class OpenSSLProduct < AutoconfProduct
+    attr_reader :target
+
+    OPENSSL_VERSION = "3.2.0"
+
+    def initialize(build_dir, target, toolchain)
+      @build_dir = build_dir
+      @target = target
+      super(target, toolchain)
+    end
+
+    def product_build_dir
+      File.join(@build_dir, target.to_s, "openssl-#{OPENSSL_VERSION}")
+    end
+
+    def destdir
+      File.join(product_build_dir, "opt")
+    end
+
+    def install_root
+      File.join(destdir, "usr", "local")
+    end
+
+    def name
+      "openssl-#{OPENSSL_VERSION}-#{target}"
+    end
+
+    def configure_args
+      args = %w[
+        gcc
+        -static
+        -no-asm
+        -no-threads
+        -no-afalgeng
+        -no-ui-console
+        -no-tests
+        -no-sock
+        -no-dgram
+        --libdir=lib
+        -Wl,--allow-undefined
+      ]
+      if @target.triple.start_with?("wasm32-unknown-wasi")
+        args.concat %w[
+                      -D_WASI_EMULATED_SIGNAL
+                      -D_WASI_EMULATED_PROCESS_CLOCKS
+                      -D_WASI_EMULATED_MMAN
+                      -D_WASI_EMULATED_GETPID
+                      -DNO_CHMOD
+                      -DHAVE_FORK=0
+                    ]
+      end
+
+      if @target.pic?
+        args << "-fPIC"
+      end
+
+      args + tools_args
+    end
+
+    def build(executor)
+      return if File.exist?(File.join(install_root, "lib", "libssl.a"))
+
+      executor.mkdir_p File.dirname(product_build_dir)
+      executor.rm_rf product_build_dir
+      executor.mkdir_p product_build_dir
+      tarball_path =
+        File.join(product_build_dir, "openssl-#{OPENSSL_VERSION}.tar.gz")
+      executor.system "curl",
+                      "-o",
+                      tarball_path,
+                      "-L",
+                      "https://www.openssl.org/source/openssl-#{OPENSSL_VERSION}.tar.gz"
+      executor.system "tar",
+                      "xzf",
+                      tarball_path,
+                      "-C",
+                      product_build_dir,
+                      "--strip-components=1"
+
+      executor.system "./Configure", *configure_args, chdir: product_build_dir
+      # Use "install_sw" instead of "install" because it tries to install docs and it's very slow.
+      # OpenSSL build system doesn't have well support for parallel build, so force -j1.
+      executor.system "make",
+                      "-j1",
+                      "install_dev",
+                      "DESTDIR=#{destdir}",
+                      chdir: product_build_dir
+    end
+  end
+end

data/lib/ruby_wasm/build/product/product.rb

@@ -0,0 +1,39 @@
+module RubyWasm
+  class BuildProduct
+    def name
+      raise NotImplementedError, "identifiable product name must be implemented"
+    end
+  end
+
+  class AutoconfProduct < BuildProduct
+    def initialize(target, toolchain)
+      @target = target
+      @toolchain = toolchain
+    end
+    def system_triplet_args
+      args = []
+      case @target.triple
+      when /^wasm32-unknown-wasi/
+        args.concat(%W[--host wasm32-wasi])
+      when "wasm32-unknown-emscripten"
+        args.concat(%W[--host wasm32-emscripten])
+      else
+        raise "unknown target: #{@target.triple}"
+      end
+      args
+    end
+
+    def tools_args
+      args = []
+      args << "CC=#{@toolchain.cc}"
+      args << "LD=#{@toolchain.ld}"
+      args << "AR=#{@toolchain.ar}"
+      args << "RANLIB=#{@toolchain.ranlib}"
+      args
+    end
+
+    def configure_args
+      system_triplet_args + tools_args
+    end
+  end
+end

data/lib/ruby_wasm/build/product/ruby_source.rb

@@ -0,0 +1,103 @@
+require_relative "./product"
+
+module RubyWasm
+  class BuildSource < BuildProduct
+    def initialize(params, build_dir)
+      @params = params
+      @build_dir = build_dir
+    end
+
+    def name
+      @params[:name]
+    end
+
+    def cache_key(digest)
+      digest << @params[:type]
+      case @params[:type]
+      when "github"
+        digest << @params[:rev]
+      when "tarball"
+        digest << @params[:url]
+      when "local"
+        digest << File.mtime(@params[:path]).to_i.to_s
+      else
+        raise "unknown source type: #{@params[:type]}"
+      end
+    end
+
+    def src_dir
+      File.join(@build_dir, "checkouts", @params[:name])
+    end
+
+    def configure_file
+      File.join(src_dir, "configure")
+    end
+
+    def fetch(executor)
+      case @params[:type]
+      when "github"
+        repo_url = "https://github.com/#{@params[:repo]}.git"
+        executor.mkdir_p src_dir
+        executor.system "git", "init", chdir: src_dir
+        executor.system "git",
+                        "remote",
+                        "add",
+                        "origin",
+                        repo_url,
+                        chdir: src_dir
+        executor.system(
+          "git",
+          "fetch",
+          "--depth",
+          "1",
+          "origin",
+          "#{@params[:rev]}:origin/#{@params[:rev]}",
+          chdir: src_dir
+        )
+        executor.system(
+          "git",
+          "checkout",
+          "origin/#{@params[:rev]}",
+          chdir: src_dir
+        )
+      when "tarball"
+        executor.mkdir_p src_dir
+        tarball_path =
+          File.join(File.dirname(src_dir), File.basename(src_dir) + ".tar.gz")
+        executor.system("curl", "-L", "-o", tarball_path, @params[:url])
+        executor.system(
+          "tar",
+          "xf",
+          tarball_path,
+          "-C",
+          src_dir,
+          "--strip-components=1"
+        )
+      when "local"
+        executor.mkdir_p File.dirname(src_dir)
+        executor.ln_s File.expand_path(@params[:path]), src_dir
+      else
+        raise "unknown source type: #{@params[:type]}"
+      end
+      (@params[:patches] || []).each do |patch_path|
+        executor.system "patch", "-p1", "-i", patch_path, chdir: src_dir
+      end
+    end
+
+    def build(executor)
+      fetch(executor) unless File.exist?(src_dir)
+      unless File.exist?(configure_file)
+        executor.system "ruby",
+                        "tool/downloader.rb",
+                        "-d",
+                        "tool",
+                        "-e",
+                        "gnu",
+                        "config.guess",
+                        "config.sub",
+                        chdir: src_dir
+        executor.system "./autogen.sh", chdir: src_dir
+      end
+    end
+  end
+end

data/lib/ruby_wasm/build/product/wasi_vfs.rb

@@ -0,0 +1,45 @@
+require_relative "./product"
+
+module RubyWasm
+  class WasiVfsProduct < BuildProduct
+    WASI_VFS_VERSION = "0.5.0"
+
+    def initialize(build_dir)
+      @build_dir = build_dir
+      @need_fetch_lib = ENV["LIB_WASI_VFS_A"].nil?
+    end
+
+    def lib_product_build_dir
+      File.join(
+        @build_dir,
+        "wasm32-unknown-wasip1",
+        "wasi-vfs-#{WASI_VFS_VERSION}"
+      )
+    end
+
+    def lib_wasi_vfs_a
+      ENV["LIB_WASI_VFS_A"] || File.join(lib_product_build_dir, "libwasi_vfs.a")
+    end
+
+    def name
+      "wasi-vfs-#{WASI_VFS_VERSION}-#{RbConfig::CONFIG["host"]}"
+    end
+
+    def build(executor)
+      return if !@need_fetch_lib || File.exist?(lib_wasi_vfs_a)
+      require "tmpdir"
+      lib_wasi_vfs_url =
+        "https://github.com/kateinoigakukun/wasi-vfs/releases/download/v#{WASI_VFS_VERSION}/libwasi_vfs-wasm32-unknown-unknown.zip"
+      Dir.mktmpdir do |tmpdir|
+        executor.system "curl",
+                        "-L",
+                        lib_wasi_vfs_url,
+                        "-o",
+                        "#{tmpdir}/libwasi_vfs.zip"
+        executor.system "unzip", "#{tmpdir}/libwasi_vfs.zip", "-d", tmpdir
+        executor.mkdir_p File.dirname(lib_wasi_vfs_a)
+        executor.mv File.join(tmpdir, "libwasi_vfs.a"), lib_wasi_vfs_a
+      end
+    end
+  end
+end

data/lib/ruby_wasm/build/product/zlib.rb

@@ -0,0 +1,70 @@
+require_relative "./product"
+
+module RubyWasm
+  class ZlibProduct < AutoconfProduct
+    attr_reader :target
+
+    ZLIB_VERSION = "1.3.1"
+
+    def initialize(build_dir, target, toolchain)
+      @build_dir = build_dir
+      @target = target
+      super(target, toolchain)
+    end
+
+    def product_build_dir
+      File.join(@build_dir, target.to_s, "zlib-#{ZLIB_VERSION}")
+    end
+
+    def destdir
+      File.join(product_build_dir, "opt")
+    end
+
+    def install_root
+      File.join(destdir, "usr", "local")
+    end
+
+    def name
+      "zlib-#{ZLIB_VERSION}-#{target}"
+    end
+
+    def configure_args
+      args = %w[CHOST=linux]
+
+      args + tools_args
+    end
+
+    def build(executor)
+      return if Dir.exist?(install_root)
+
+      executor.mkdir_p File.dirname(product_build_dir)
+      executor.rm_rf product_build_dir
+      executor.mkdir_p product_build_dir
+
+      tarball_path = File.join(product_build_dir, "zlib-#{ZLIB_VERSION}.tar.gz")
+      executor.system "curl",
+                      "-o",
+                      tarball_path,
+                      "-L",
+                      "https://github.com/madler/zlib/releases/download/v#{ZLIB_VERSION}/zlib-#{ZLIB_VERSION}.tar.gz"
+      executor.system "tar",
+                      "xzf",
+                      tarball_path,
+                      "-C",
+                      product_build_dir,
+                      "--strip-components=1"
+
+      configure_args = self.configure_args.dup
+      configure_args << "CFLAGS=-fPIC" if target.pic?
+      executor.system "env",
+                      *configure_args,
+                      "./configure",
+                      "--static",
+                      chdir: product_build_dir
+      executor.system "make",
+                      "install",
+                      "DESTDIR=#{destdir}",
+                      chdir: product_build_dir
+    end
+  end
+end

data/lib/ruby_wasm/build/product.rb

@@ -0,0 +1,8 @@
+require_relative "product/product"
+require_relative "product/ruby_source"
+require_relative "product/baseruby"
+require_relative "product/zlib"
+require_relative "product/libyaml"
+require_relative "product/openssl"
+require_relative "product/wasi_vfs"
+require_relative "product/crossruby"

data/lib/ruby_wasm/build/target.rb

@@ -0,0 +1,24 @@
+module RubyWasm
+  # A build target representation
+  class Target
+    attr_reader :triple
+
+    def initialize(triple, pic: false)
+      @triple = triple
+      @pic = pic
+    end
+
+    def pic?
+      @pic
+    end
+
+    def to_s
+      "#{@triple}#{@pic ? "-pic" : ""}"
+    end
+
+    def cache_key(digest)
+      digest << @triple
+      digest << "pic" if @pic
+    end
+  end
+end

data/lib/ruby_wasm/build/toolchain/wit_bindgen.rb

@@ -0,0 +1,31 @@
+module RubyWasm
+  class WitBindgen
+    attr_reader :bin_path
+
+    def initialize(
+      build_dir:,
+      revision: "251e84b89121751f79ac268629e9285082b2596d"
+    )
+      @build_dir = build_dir
+      @tool_dir = File.join(@build_dir, "toolchain", "wit-bindgen")
+      @bin_path = File.join(@tool_dir, "bin", "wit-bindgen")
+      @revision = revision
+    end
+
+    def install
+      return if File.exist?(@bin_path)
+      RubyWasm::Toolchain.check_executable("cargo")
+      Kernel.system(
+        "cargo",
+        "install",
+        "--git",
+        "https://github.com/bytecodealliance/wit-bindgen",
+        "--rev",
+        @revision,
+        "--root",
+        @tool_dir,
+        "wit-bindgen-cli"
+      )
+    end
+  end
+end

data/lib/ruby_wasm/build/toolchain.rb

@@ -0,0 +1,193 @@
+require_relative "./toolchain/wit_bindgen"
+
+module RubyWasm
+  class Toolchain
+    attr_reader :name
+
+    def initialize
+      @tools = {}
+    end
+
+    def find_tool(name)
+      raise "not implemented"
+    end
+
+    def check_envvar(name)
+      raise "missing environment variable: #{name}" if ENV[name].nil?
+    end
+
+    def self.get(target, build_dir = nil)
+      case target
+      when /^wasm32-unknown-wasi/
+        return RubyWasm::WASISDK.new(build_dir: build_dir)
+      when "wasm32-unknown-emscripten"
+        return RubyWasm::Emscripten.new
+      else
+        raise "unknown target: #{target}"
+      end
+    end
+
+    def self.find_path(command)
+      (ENV["PATH"] || "")
+        .split(File::PATH_SEPARATOR)
+        .each do |path_dir|
+          bin_path = File.join(path_dir, command)
+          return bin_path if File.executable?(bin_path)
+        end
+      nil
+    end
+
+    def self.check_executable(command)
+      tool = find_path(command)
+      raise "missing executable: #{command}" unless tool
+      tool
+    end
+
+    %i[cc ranlib ld ar].each do |name|
+      define_method(name) do
+        @tools_cache ||= {}
+        @tools_cache[name] ||= find_tool(name)
+        @tools_cache[name]
+      end
+    end
+  end
+
+  class WASISDK < Toolchain
+    def initialize(
+      wasi_sdk_path = ENV["WASI_SDK_PATH"],
+      build_dir: nil,
+      version_major: 20,
+      version_minor: 0,
+      binaryen_version: 108
+    )
+      @wasm_opt_path = Toolchain.find_path("wasm-opt")
+      @need_fetch_wasi_sdk = wasi_sdk_path.nil?
+      @need_fetch_binaryen = @wasm_opt_path.nil?
+
+      if @need_fetch_wasi_sdk
+        if build_dir.nil?
+          raise "build_dir is required when WASI_SDK_PATH is not set"
+        end
+        wasi_sdk_path = File.join(build_dir, "toolchain", "wasi-sdk")
+        @version_major = version_major
+        @version_minor = version_minor
+      end
+
+      if @need_fetch_binaryen
+        if build_dir.nil?
+          raise "build_dir is required when wasm-opt not installed in PATH"
+        end
+        @binaryen_path = File.join(build_dir, "toolchain", "binaryen")
+        @binaryen_version = binaryen_version
+        @wasm_opt_path = File.join(@binaryen_path, "bin", "wasm-opt")
+      end
+
+      @tools = {
+        cc: "#{wasi_sdk_path}/bin/clang",
+        ld: "#{wasi_sdk_path}/bin/clang",
+        ar: "#{wasi_sdk_path}/bin/llvm-ar",
+        ranlib: "#{wasi_sdk_path}/bin/llvm-ranlib"
+      }
+      @wasi_sdk_path = wasi_sdk_path
+      @name = "wasi-sdk"
+    end
+
+    def find_tool(name)
+      if !File.exist?(@tools[name]) && !ENV["WASI_SDK_PATH"].nil?
+        raise "missing tool '#{name}' at #{@tools[name]}"
+      end
+      @tools[name]
+    end
+
+    def wasm_opt
+      @wasm_opt_path
+    end
+
+    def wasi_sdk_path
+      @wasi_sdk_path
+    end
+
+    def download_url(version_major, version_minor)
+      version = "#{version_major}.#{version_minor}"
+      assets = [
+        [/x86_64-linux/, "wasi-sdk-#{version}-linux.tar.gz"],
+        [/(arm64e?|x86_64)-darwin/, "wasi-sdk-#{version}-macos.tar.gz"]
+      ]
+      asset = assets.find { |os, _| os =~ RUBY_PLATFORM }&.at(1)
+      if asset.nil?
+        raise "unsupported platform for fetching WASI SDK: #{RUBY_PLATFORM}"
+      end
+      "https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-#{version_major}/#{asset}"
+    end
+
+    def binaryen_download_url(version)
+      assets = [
+        [
+          /x86_64-linux/,
+          "binaryen-version_#{@binaryen_version}-x86_64-linux.tar.gz"
+        ],
+        [
+          /x86_64-darwin/,
+          "binaryen-version_#{@binaryen_version}-x86_64-macos.tar.gz"
+        ],
+        [
+          /arm64e?-darwin/,
+          "binaryen-version_#{@binaryen_version}-arm64-macos.tar.gz"
+        ]
+      ]
+      asset = assets.find { |os, _| os =~ RUBY_PLATFORM }&.at(1)
+      if asset.nil?
+        raise "unsupported platform for fetching Binaryen: #{RUBY_PLATFORM}"
+      end
+      "https://github.com/WebAssembly/binaryen/releases/download/version_#{@binaryen_version}/#{asset}"
+    end
+
+    def install_wasi_sdk
+      return unless @need_fetch_wasi_sdk
+      wasi_sdk_tarball =
+        File.join(File.dirname(@wasi_sdk_path), "wasi-sdk.tar.gz")
+      unless File.exist? wasi_sdk_tarball
+        FileUtils.mkdir_p File.dirname(wasi_sdk_tarball)
+        system "curl -L -o #{wasi_sdk_tarball} #{self.download_url(@version_major, @version_minor)}"
+      end
+      unless File.exist? @wasi_sdk_path
+        FileUtils.mkdir_p @wasi_sdk_path
+        system "tar -C #{@wasi_sdk_path} --strip-component 1 -xzf #{wasi_sdk_tarball}"
+      end
+    end
+
+    def install_binaryen
+      return unless @need_fetch_binaryen
+      binaryen_tarball = File.expand_path("../binaryen.tar.gz", @binaryen_path)
+      unless File.exist? binaryen_tarball
+        FileUtils.mkdir_p File.dirname(binaryen_tarball)
+        system "curl -L -o #{binaryen_tarball} #{self.binaryen_download_url(@binaryen_version)}"
+      end
+
+      unless File.exist? @binaryen_path
+        FileUtils.mkdir_p @binaryen_path
+        system "tar -C #{@binaryen_path} --strip-component 1 -xzf #{binaryen_tarball}"
+      end
+    end
+
+    def install
+      install_wasi_sdk
+      install_binaryen
+    end
+  end
+
+  class Emscripten < Toolchain
+    def initialize
+      @tools = { cc: "emcc", ld: "emcc", ar: "emar", ranlib: "emranlib" }
+      @name = "emscripten"
+    end
+
+    def install
+    end
+
+    def find_tool(name)
+      Toolchain.check_executable(@tools[name])
+      @tools[name]
+    end
+  end
+end

data/lib/ruby_wasm/build.rb

@@ -0,0 +1,92 @@
+require_relative "build/build_params"
+require_relative "build/product"
+require_relative "build/toolchain"
+require_relative "build/executor"
+require_relative "build/target"
+
+class RubyWasm::Build
+  # Source to build from.
+  attr_reader :source
+
+  # Target to build for.
+  attr_reader :target
+
+  # Toolchain for the build.
+  # Defaults to the Toolchain.get for the target.
+  attr_reader :toolchain
+
+  # LibYAML product to build.
+  attr_reader :libyaml
+
+  # zlib product to build.
+  attr_reader :zlib
+
+  # wasi-vfs product used by the crossruby.
+  attr_reader :wasi_vfs
+
+  # BaseRuby product to build.
+  attr_reader :baseruby
+
+  # CrossRuby product to build.
+  attr_reader :crossruby
+
+  def initialize(
+    name,
+    target:,
+    src:,
+    toolchain:,
+    build_dir:,
+    rubies_dir:,
+    wasi_vfs: :default,
+    **options
+  )
+    @target = target
+    @build_dir = build_dir
+    @rubies_dir = rubies_dir
+    @toolchain = (toolchain || RubyWasm::Toolchain.get(target, @build_dir))
+
+    @libyaml = RubyWasm::LibYAMLProduct.new(@build_dir, @target, @toolchain)
+    @zlib = RubyWasm::ZlibProduct.new(@build_dir, @target, @toolchain)
+    @wasi_vfs = wasi_vfs == :default ? RubyWasm::WasiVfsProduct.new(@build_dir) : wasi_vfs
+    @source = RubyWasm::BuildSource.new(src, @build_dir)
+    @baseruby = RubyWasm::BaseRubyProduct.new(@build_dir, @source)
+    @openssl = RubyWasm::OpenSSLProduct.new(@build_dir, @target, @toolchain)
+
+    build_params =
+      RubyWasm::BuildParams.new(
+        name: name,
+        target: target,
+        default_exts: options[:default_exts]
+      )
+
+    @crossruby =
+      RubyWasm::CrossRubyProduct.new(
+        build_params,
+        @build_dir,
+        @rubies_dir,
+        @baseruby,
+        @source,
+        @toolchain
+      )
+
+    @crossruby.with_libyaml @libyaml
+    @crossruby.with_zlib @zlib
+    @crossruby.with_wasi_vfs @wasi_vfs
+    @crossruby.with_openssl @openssl
+  end
+
+  def cache_key(digest)
+    @source.cache_key(digest)
+    @crossruby.cache_key(digest)
+    digest << @build_dir
+    digest << @rubies_dir
+    @target.cache_key(digest)
+    digest << @toolchain.name
+    digest << @libyaml.name
+    digest << @zlib.name
+    digest << @openssl.name
+    if wasi_vfs = @wasi_vfs
+      digest << wasi_vfs.name
+    end
+  end
+end