diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 87df4ec..9c7c75c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -3,7 +3,7 @@ on: ["push", "pull_request"]
 
 jobs:
   build:
-    name: "Build runtimes"
+    name: "Build Android runtimes"
     runs-on: "ubuntu-latest"
     strategy:
       matrix:
@@ -18,18 +18,37 @@ jobs:
         unzip Precompiled.zip
         echo "$HOME/elixir/bin" >> $GITHUB_PATH
     - uses: actions/checkout@v2
-    - name: Build ${{ matrix.arch }} runtimes
+    - name: Build Android ${{ matrix.arch }} runtimes
       run: |
         mix deps.get
-        ARCH=${{ matrix.arch }} mix package.runtime
-        ARCH=${{ matrix.arch }} mix package.nif
-    - name: Archive runtimes
+        ARCH=${{ matrix.arch }} mix package.android.runtime
+        ARCH=${{ matrix.arch }} mix package.android.nif
+    - name: Archive Android runtimes
       uses: actions/upload-artifact@v2
       with:
         name: ${{ matrix.arch }}-runtime
         path: _build/*.zip
-    - name: ${{ matrix.arch }} release
+    - name: Android ${{ matrix.arch }} release
       uses: softprops/action-gh-release@v1
       if: startsWith(github.ref, 'refs/tags/')
       with:
         files: _build/*.zip
+
+  ios:
+    name: "Build iOS runtime"
+    runs-on: "macos-latest"
+    steps:
+    - run: brew install git elixir carthage coreutils
+    - uses: actions/checkout@v2
+    - name: Build runtime
+      run: mix package.ios.runtime
+    - name: Archive runtimes
+      uses: actions/upload-artifact@v2
+      with:
+        name: iOS-runtime
+        path: _build/liberlang.xcframework
+    - name: iOS release
+      uses: softprops/action-gh-release@v1
+      if: startsWith(github.ref, 'refs/tags/')
+      with:
+        files: _build/liberlang.xcframework
diff --git a/.gitignore b/.gitignore
index a5f82ba..7e19b33 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,5 +3,9 @@
 /erl_crash.dump
 *.so
 *.zip
+*.tar.gz
 *.tmp
-/test_main
\ No newline at end of file
+.DS_Store
+/tmp
+/test_main
+/openssl-1.1.1k
diff --git a/lib/beam.dockerfile b/lib/beam.dockerfile
index f0c6c95..7a3a84c 100644
--- a/lib/beam.dockerfile
+++ b/lib/beam.dockerfile
@@ -9,7 +9,8 @@ ENV FC= CPP= LD= CC=clang AR=ar
 ENV MAKEFLAGS "-j10 -O"
 
 # Setting up openssl
-COPY scripts/install_openssl.sh /work/  
+COPY scripts/install_openssl.sh /work/
+COPY patch /work/patch
 
 # OpenSSL fails to detect this: 
 RUN cp ${NDK_ROOT}/bin/llvm-ar ${NDK_ROOT}/bin/<%= @arch.cpu %>-linux-<%= @arch.android_name %>-ar
@@ -48,4 +49,4 @@ RUN ./otp_build boot -a
 # Build run #2, now creating the arm binaries, appliying the install flags only here...
 ENV INSTALL_PROGRAM "/usr/bin/install -c -s --strip-program=llvm-strip"
 RUN ./otp_build configure <%= config %> LDFLAGS="-z global"
-RUN ./otp_build release -a
\ No newline at end of file
+RUN ./otp_build release -a
diff --git a/lib/mix/tasks/package_android_nif.ex b/lib/mix/tasks/package_android_nif.ex
new file mode 100644
index 0000000..9a8773b
--- /dev/null
+++ b/lib/mix/tasks/package_android_nif.ex
@@ -0,0 +1,51 @@
+defmodule Mix.Tasks.Package.Android.Nif do
+  use Mix.Task
+  require EEx
+
+  def run([]) do
+    for nif <- Runtimes.default_nifs() do
+      for arch <- Runtimes.default_archs() do
+        build(arch, Runtimes.get_nif(nif))
+      end
+    end
+  end
+
+  def run(args) do
+    {git, _tag} =
+      case args do
+        [] -> raise "Need git url parameter"
+        [git] -> {git, nil}
+        [git, tag] -> {git, tag}
+      end
+
+    build("arm64", Runtimes.get_nif(git))
+  end
+
+  defp build(arch, nif) do
+    type = Runtimes.get_arch(arch).android_type
+    target = "_build/#{type}-nif-#{nif.name}.zip"
+
+    if exists?(target) do
+      :ok
+    else
+      image_name = "#{nif.name}-#{arch}"
+
+      Runtimes.docker_build(
+        image_name,
+        Runtimes.generate_nif_dockerfile(arch, nif)
+      )
+
+      Runtimes.run(~w(docker run --rm
+    -w /work/#{nif.basename}/ --entrypoint ./package_nif.sh #{image_name}
+    #{nif.name} > #{target}))
+    end
+  end
+
+  def exists?(file) do
+    case File.stat(file) do
+      {:error, _} -> false
+      {:ok, %File.Stat{size: 0}} -> false
+      _ -> true
+    end
+  end
+end
diff --git a/lib/mix/tasks/package_runtime.ex b/lib/mix/tasks/package_android_runtime.ex
similarity index 96%
rename from lib/mix/tasks/package_runtime.ex
rename to lib/mix/tasks/package_android_runtime.ex
index 7cf7316..cd56bbb 100644
--- a/lib/mix/tasks/package_runtime.ex
+++ b/lib/mix/tasks/package_android_runtime.ex
@@ -1,4 +1,4 @@
-defmodule Mix.Tasks.Package.Runtime do
+defmodule Mix.Tasks.Package.Android.Runtime do
   use Mix.Task
   require EEx
 
diff --git a/lib/mix/tasks/package_ios_nif.ex b/lib/mix/tasks/package_ios_nif.ex
new file mode 100644
index 0000000..d52d06f
--- /dev/null
+++ b/lib/mix/tasks/package_ios_nif.ex
@@ -0,0 +1,112 @@
+defmodule Mix.Tasks.Package.Ios.Nif do
+  alias Mix.Tasks.Package.Ios.Runtime
+  use Mix.Task
+  require EEx
+
+  defdelegate architectures(), to: Runtime
+  defdelegate get_arch(arch), to: Runtime
+  defdelegate get_nif(nif), to: Runtimes
+  defdelegate otp_target(arch), to: Runtime
+
+  def run([nif]) do
+    buildall(Map.keys(architectures()), nif)
+  end
+
+  def elixir_target() do
+    Path.absname("_build/elixir")
+  end
+
+  def build(arch, nif) do
+    nif = get_nif(nif)
+    arch = get_arch(arch)
+
+    # Todo: How to sync cross-compiled erlang version and local erlang version?
+    path =
+      [
+        Path.join(elixir_target(), "bin"),
+        Path.join(System.get_env("HOME"), ".mix"),
+        # Path.join(otp_target(arch), "bootstrap/bin"),
+        System.get_env("PATH")
+      ]
+      |> Enum.join(":")
+
+    # Getting an Elixir version
+    if File.exists?(Path.join(elixir_target(), "bin")) do
+      IO.puts("Elixir already exists...")
+    else
+      Runtimes.run(~w(
+        mkdir #{elixir_target()} &&
+        cd #{elixir_target()} &&
+        wget https://github.com/elixir-lang/elixir/releases/download/v1.11.4/Precompiled.zip &&
+        unzip Precompiled.zip
+        ))
+
+      Runtimes.run("mix do local.hex --force && mix local.rebar --force", PATH: path)
+    end
+
+    {sdkroot, 0} = System.cmd("xcrun", ["-sdk", arch.sdk, "--show-sdk-path"])
+    sdkroot = String.trim(sdkroot)
+    cflags = arch.cflags <> " -isysroot #{sdkroot} -I#{Path.absname("stubs")}"
+    lflags = "-Wl,-syslibroot,#{sdkroot} -lc++"
+
+    env = [
+      PATH: path,
+      ERLANG_PATH: Path.join(otp_target(arch), "release/#{arch.name}/erts-12.0/include"),
+      ERTS_INCLUDE_DIR: Path.join(otp_target(arch), "release/#{arch.name}/erts-12.0/include"),
+      HOST: arch.name,
+      CROSSCOMPILE: "iOS",
+      STATIC_ERLANG_NIF: "yes",
+      CC: "xcrun -sdk #{arch.sdk} cc -arch #{arch.arch}",
+      CFLAGS: cflags,
+      CXX: "xcrun -sdk #{arch.sdk} c++ -arch #{arch.arch}",
+      CXXFLAGS: cflags,
+      LD: "xcrun -sdk #{arch.sdk} ld -arch #{arch.arch}",
+      LDFLAGS: lflags,
+      RANLIB: "xcrun -sdk #{arch.sdk} ranlib",
+      LIBTOOL: "xcrun -sdk #{arch.sdk} libtool",
+      AR: "xcrun -sdk #{arch.sdk} ar",
+      MIX_ENV: "prod",
+      MIX_TARGET: "ios"
+    ]
+
+    # Start the builds
+    nif_dir = "_build/#{arch.name}/#{nif.basename}"
+
+    if !File.exists?(nif_dir) do
+      Runtimes.run(~w(git clone #{nif.repo} #{nif_dir}), env)
+    end
+
+    if nif.tag do
+      Runtimes.run(~w(cd #{nif_dir} && git checkout #{nif.tag}), env)
+    end
+
+    build_nif = Path.absname("scripts/build_nif.sh")
+    Runtimes.run(~w(cd #{nif_dir} && #{build_nif}), env)
+
+    case static_lib_path(arch, nif) do
+      nil -> raise "NIF build failed. Could not locate static lib"
+      lib -> lib
+    end
+  end
+
+  def static_lib_path(arch, nif) do
+    nif_dir = "_build/#{arch.name}/#{nif.basename}"
+
+    # Finding all .a files
+    :filelib.fold_files(
+      String.to_charlist(nif_dir),
+      '.+\\.a$',
+      true,
+      fn name, acc -> [List.to_string(name) | acc] end,
+      []
+    )
+    |> Enum.filter(fn path -> String.contains?(path, "priv") end)
+    |> List.first()
+  end
+
+  defp buildall(targets, nif) do
+    for target <- targets do
+      build(target, nif)
+    end
+  end
+end
diff --git a/lib/mix/tasks/package_ios_runtime.ex b/lib/mix/tasks/package_ios_runtime.ex
new file mode 100644
index 0000000..d9f533b
--- /dev/null
+++ b/lib/mix/tasks/package_ios_runtime.ex
@@ -0,0 +1,252 @@
+defmodule Mix.Tasks.Package.Ios.Runtime do
+  @otp_source "https://github.com/diodechain/otp"
+  @otp_tag "diode/ios"
+
+  alias Mix.Tasks.Package.Ios.Nif
+  use Mix.Task
+  require EEx
+
+  def architectures() do
+    # Not sure if we still need arm-32 at all https://blakespot.com/ios_device_specifications_grid.html
+    %{
+      "ios" => %{
+        arch: "armv7",
+        id: "ios",
+        sdk: "iphoneos",
+        openssl_arch: "ios-xcrun",
+        xcomp: "arm-ios",
+        name: "arm-apple-ios",
+        cflags: "-mios-version-min=7.0.0 -fno-common -Os -D__IOS__=yes"
+      },
+      "ios-arm64" => %{
+        arch: "arm64",
+        id: "ios64",
+        sdk: "iphoneos",
+        openssl_arch: "ios64-xcrun",
+        xcomp: "arm64-ios",
+        name: "aarch64-apple-ios",
+        cflags: "-mios-version-min=7.0.0 -fno-common -Os -D__IOS__=yes"
+      },
+      "iossimulator-x86_64" => %{
+        arch: "x86_64",
+        id: "iossimulator",
+        sdk: "iphonesimulator",
+        openssl_arch: "iossimulator-x86_64-xcrun",
+        xcomp: "x86_64-iossimulator",
+        name: "x86_64-apple-iossimulator",
+        cflags: "-mios-simulator-version-min=7.0.0 -fno-common -Os -D__IOS__=yes"
+      },
+      "iossimulator-arm64" => %{
+        arch: "arm64",
+        id: "iossimulator",
+        sdk: "iphonesimulator",
+        openssl_arch: "iossimulator-arm64-xcrun",
+        xcomp: "arm64-iossimulator",
+        name: "aarch64-apple-iossimulator",
+        cflags: "-mios-simulator-version-min=7.0.0 -fno-common -Os -D__IOS__=yes"
+      }
+    }
+  end
+
+  def get_arch(arch) do
+    Map.fetch!(architectures(), arch)
+  end
+
+  def run([]) do
+    buildall(Map.keys(architectures()), ["https://github.com/elixir-sqlite/exqlite"])
+  end
+
+  def run(nifs) do
+    IO.puts("Validating nifs...")
+    Enum.each(nifs, fn nif -> Runtimes.get_nif(nif) end)
+    buildall(Map.keys(architectures()), nifs)
+  end
+
+  def openssl_target(arch) do
+    Path.absname("_build/#{arch.name}/openssl")
+  end
+
+  def openssl_lib(arch) do
+    Path.join(openssl_target(arch), "lib/libcrypto.a")
+  end
+
+  def otp_target(arch) do
+    Path.absname("_build/#{arch.name}/otp")
+  end
+
+  def runtime_target(arch) do
+    "_build/#{arch.name}/liberlang.a"
+  end
+
+  def build(archid, extra_nifs) do
+    arch = get_arch(archid)
+    File.mkdir_p!("_build/#{arch.name}")
+
+    # Building OpenSSL
+    if File.exists?(openssl_lib(arch)) do
+      IO.puts("OpenSSL (#{arch.id}) already exists...")
+    else
+      Runtimes.run("scripts/install_openssl.sh",
+        ARCH: arch.openssl_arch,
+        OPENSSL_PREFIX: openssl_target(arch)
+      )
+    end
+
+    # Building OTP
+    if File.exists?(runtime_target(arch)) do
+      IO.puts("liberlang.a (#{arch.id}) already exists...")
+    else
+      if !File.exists?(otp_target(arch)) do
+        ensure_otp()
+        Runtimes.run(~w(git clone _build/otp #{otp_target(arch)}))
+      end
+
+      env = [
+        LIBS: openssl_lib(arch),
+        INSTALL_PROGRAM: "/usr/bin/install -c",
+        MAKEFLAGS: "-j10 -O",
+        RELEASE_LIBBEAM: "yes"
+      ]
+
+      if System.get_env("SKIP_CLEAN_BUILD") == nil do
+        nifs = [
+          "#{otp_target(arch)}/lib/asn1/priv/lib/#{arch.name}/asn1rt_nif.a",
+          "#{otp_target(arch)}/lib/crypto/priv/lib/#{arch.name}/crypto.a"
+        ]
+
+        # First round build to generate headers and libs required to build nifs:
+        Runtimes.run(
+          ~w(
+          cd #{otp_target(arch)} && git clean -xdf &&
+          ./otp_build autoconf &&
+          ./otp_build configure
+          --with-ssl=#{openssl_target(arch)}
+          --disable-dynamic-ssl-lib
+          --xcomp-conf=xcomp/erl-xcomp-#{arch.xcomp}.conf
+          --enable-static-nifs=#{Enum.join(nifs, ",")}
+        ),
+          env
+        )
+
+        Runtimes.run(~w(cd #{otp_target(arch)} && ./otp_build boot -a), env)
+        Runtimes.run(~w(cd #{otp_target(arch)} && ./otp_build release -a), env)
+      end
+
+      # Second round
+      # The extra path can only be generated AFTER the nifs are compiled
+      # so this requires two rounds...
+      extra_nifs =
+        Enum.map(extra_nifs, fn nif ->
+          if Nif.static_lib_path(arch, Runtimes.get_nif(nif)) == nil do
+            Nif.build(archid, nif)
+          end
+
+          Nif.static_lib_path(arch, Runtimes.get_nif(nif))
+          |> Path.absname()
+        end)
+
+      nifs = [
+        "#{otp_target(arch)}/lib/asn1/priv/lib/#{arch.name}/asn1rt_nif.a",
+        "#{otp_target(arch)}/lib/crypto/priv/lib/#{arch.name}/crypto.a"
+        | extra_nifs
+      ]
+
+      Runtimes.run(
+        ~w(
+          cd #{otp_target(arch)} && ./otp_build configure
+          --with-ssl=#{openssl_target(arch)}
+          --disable-dynamic-ssl-lib
+          --xcomp-conf=xcomp/erl-xcomp-#{arch.xcomp}.conf
+          --enable-static-nifs=#{Enum.join(nifs, ",")}
+        ),
+        env
+      )
+
+      Runtimes.run(~w(cd #{otp_target(arch)} && ./otp_build boot -a), env)
+      Runtimes.run(~w(cd #{otp_target(arch)} && ./otp_build release -a), env)
+
+      {build_host, 0} = System.cmd("#{otp_target(arch)}/erts/autoconf/config.guess", [])
+      build_host = String.trim(build_host)
+
+      # [erts_version] = Regex.run(~r/erts-[^ ]+/, File.read!("otp/otp_versions.table"))
+      # Locating all built .a files for the target architecture:
+      files =
+        :filelib.fold_files(
+          String.to_charlist(otp_target(arch)),
+          '.+\\.a$',
+          true,
+          fn name, acc -> [List.to_string(name) | acc] end,
+          []
+        )
+        |> Enum.filter(fn name ->
+          !String.contains?(name, build_host) and String.contains?(name, arch.name)
+        end)
+
+      files = files ++ [openssl_lib(arch) | nifs]
+
+      # Creating a new archive
+      repackage_archive(files, runtime_target(arch))
+    end
+  end
+
+  #  Method takes multiple ".a" archive files and extracts their ".o" contents
+  # to then reassemble all of them into a single `target` ".a" archive
+  defp repackage_archive(files, target) do
+    # Removing relative prefix so changing cwd is safe.
+    files = Enum.join(files, " ")
+    Runtimes.run("libtool -static -o #{target} #{files}")
+  end
+
+  defp buildall(targets, nifs) do
+    ensure_otp()
+
+    # targets
+    # |> Enum.map(fn target -> Task.async(fn -> build(target, nifs) end) end)
+    # |> Enum.map(fn task -> Task.await(task, 60_000*60*3) end)
+    for target <- targets do
+      build(target, nifs)
+    end
+
+    {sims, reals} =
+      Enum.map(targets, fn target -> runtime_target(get_arch(target)) end)
+      |> Enum.split_with(fn lib -> String.contains?(lib, "simulator") end)
+
+    libs =
+      (lipo(sims) ++ lipo(reals))
+      |> Enum.map(fn lib -> "-library #{lib}" end)
+
+    framework = "./_build/liberlang.xcframework"
+
+    if File.exists?(framework) do
+      File.rm_rf!(framework)
+    end
+
+    Runtimes.run(
+      "xcodebuild -create-xcframework -output #{framework} " <>
+        Enum.join(libs, " ")
+    )
+  end
+
+  # lipo joins different cpu build of the same target together
+  defp lipo([]), do: []
+  defp lipo([one]), do: [one]
+
+  defp lipo(more) do
+    File.mkdir_p!("tmp")
+    x = System.unique_integer([:positive])
+    tmp = "tmp/#{x}-liberlang.a"
+    if File.exists?(tmp), do: File.rm!(tmp)
+    Runtimes.run("lipo -create #{Enum.join(more, " ")} -output #{tmp}")
+    [tmp]
+  end
+
+  defp ensure_otp() do
+    if !File.exists?("_build/otp") do
+      File.mkdir_p!("_build")
+
+      Runtimes.run(
+        "git clone #{@otp_source} _build/otp && cd _build/otp && git checkout #{@otp_tag}"
+      )
+    end
+  end
+end
diff --git a/lib/mix/tasks/package_nif.ex b/lib/mix/tasks/package_nif.ex
deleted file mode 100644
index e53faae..0000000
--- a/lib/mix/tasks/package_nif.ex
+++ /dev/null
@@ -1,59 +0,0 @@
-defmodule Mix.Tasks.Package.Nif do
-  use Mix.Task
-  require EEx
-
-  def run([]) do
-    Enum.each(Runtimes.default_nifs(), fn nif ->
-      {basename, git} =
-        case nif do
-          git when is_binary(git) -> {basename(git), git}
-          {git, basename} -> {basename, git}
-        end
-
-      Enum.each(Runtimes.default_archs(), fn arch ->
-        build(arch, git, basename)
-      end)
-    end)
-  end
-
-  def run(args) do
-    {git, tag} =
-      case args do
-        [] -> raise "Need git url parameter"
-        [git] -> {git, nil}
-        [git, tag] -> {git, tag}
-      end
-
-    build("arm64", git, basename(git), tag)
-  end
-
-  defp build(arch, git, basename, tag \\ nil) do
-    type = Runtimes.get_arch(arch).android_type
-    target = "_build/#{type}-nif-#{basename}.zip"
-
-    if exists?(target) do
-      :ok
-    else
-      image_name = "#{basename}-#{arch}"
-
-      Runtimes.docker_build(
-        image_name,
-        Runtimes.generate_nif_dockerfile(arch, git, tag)
-      )
-
-      Runtimes.run(~w(docker run --rm
-    -w /work/#{basename(git)}/ --entrypoint ./package_nif.sh #{image_name}
-    #{basename} > #{target}))
-    end
-  end
-
-  def exists?(file) do
-    case File.stat(file) do
-      {:error, _} -> false
-      {:ok, %File.Stat{size: 0}} -> false
-      _ -> true
-    end
-  end
-
-  defp basename(git), do: Path.basename(git, ".git")
-end
diff --git a/lib/runtime.ex b/lib/runtimes.ex
similarity index 69%
rename from lib/runtime.ex
rename to lib/runtimes.ex
index 0edc804..5c356d8 100644
--- a/lib/runtime.ex
+++ b/lib/runtimes.ex
@@ -39,16 +39,16 @@ defmodule Runtimes do
     {beam_dockerfile(args), args}
   end
 
-  def generate_nif_dockerfile(arch, git, tag) do
+  def generate_nif_dockerfile(arch, nif) do
     {parent, args} = generate_beam_dockerfile(arch)
 
     args =
       args ++
-        [parent: parent, repo: git, tag: tag, basename: Path.basename(git, ".git")]
+        [parent: parent, repo: nif.repo, tag: nif.tag, basename: nif.basename]
 
     content = nif_dockerfile(args)
 
-    file = "#{Path.basename(git, ".git")}-#{arch}.dockerfile.tmp"
+    file = "#{nif.basename}-#{arch}.dockerfile.tmp"
     File.write!(file, content)
     file
   end
@@ -56,15 +56,27 @@ defmodule Runtimes do
   EEx.function_from_file(:defp, :nif_dockerfile, "#{__DIR__}/nif.dockerfile", [:assigns])
   EEx.function_from_file(:defp, :beam_dockerfile, "#{__DIR__}/beam.dockerfile", [:assigns])
 
-  def run(args) do
+  def run(args, env \\ []) do
     args = if is_list(args), do: Enum.join(args, " "), else: args
+
+    env =
+      Enum.map(env, fn {key, value} ->
+        case key do
+          atom when is_atom(atom) -> {Atom.to_string(atom), value}
+          _other -> {key, value}
+        end
+      end)
+
     IO.puts("RUN: #{args}")
 
-    {_, 0} =
+    {ret, 0} =
       System.cmd("bash", ["-c", args],
         stderr_to_stdout: true,
-        into: IO.binstream(:stdio, :line)
+        into: IO.binstream(:stdio, :line),
+        env: env
       )
+
+    ret
   end
 
   def docker_build(image, file) do
@@ -89,10 +101,24 @@ defmodule Runtimes do
 
   def default_nifs() do
     [
-      "https://github.com/mmzeeman/esqlite.git",
-      "https://github.com/elixir-sqlite/exqlite.git",
+      "https://github.com/diodechain/esqlite.git",
+      "https://github.com/elixir-sqlite/exqlite",
       {"https://github.com/diodechain/erlang-keccakf1600.git", "keccakf1600"},
       "https://github.com/diodechain/libsecp256k1.git"
     ]
   end
+
+  def get_nif(url) when is_binary(url) do
+    name = Path.basename(url, ".git")
+    get_nif({url, name})
+  end
+
+  def get_nif({url, name}) do
+    %{
+      tag: nil,
+      repo: url,
+      name: name,
+      basename: Path.basename(url, ".git")
+    }
+  end
 end
diff --git a/patch/openssl-ios.conf b/patch/openssl-ios.conf
new file mode 100644
index 0000000..f75539c
--- /dev/null
+++ b/patch/openssl-ios.conf
@@ -0,0 +1,42 @@
+#### iPhoneOS/iOS
+#
+# It takes recent enough Xcode to use following two targets. It shouldn't
+# be a problem by now, but if they don't work, original targets below
+# that depend on manual definition of environment variables should still
+# work...
+#
+my %targets = (
+    "ios-common" => {
+        template         => 1,
+        inherit_from     => [ "darwin-common" ],
+        sys_id           => "iOS",
+        disable          => [ "shared", "async" ],
+    },
+    "ios-xcrun" => {
+        inherit_from     => [ "ios-common", asm("armv4_asm") ],
+        CC               => "xcrun -sdk iphoneos cc",
+        cflags           => add("-arch armv7 -mios-version-min=7.0.0 -fno-common"),
+        perlasm_scheme   => "ios32",
+    },
+    "ios64-xcrun" => {
+        inherit_from     => [ "ios-common", asm("aarch64_asm") ],
+        CC               => "xcrun -sdk iphoneos cc",
+        cflags           => add("-arch arm64 -mios-version-min=7.0.0 -fno-common"),
+        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHAR",
+        perlasm_scheme   => "ios64",
+    },
+    "iossimulator-xcrun" => {
+        inherit_from     => [ "ios-common" ],
+        CC               => "xcrun -sdk iphonesimulator cc",
+    },
+    "iossimulator-x86_64-xcrun" => {
+        inherit_from     => [ "ios-common" ],
+        CC               => "xcrun -sdk iphonesimulator cc",
+        cflags           => add("-arch x86_64 -mios-simulator-version-min=7.0.0 -fno-common"),
+    },
+    "iossimulator-arm64-xcrun" => {
+        inherit_from     => [ "ios-common" ],
+        CC               => "xcrun -sdk iphonesimulator cc",
+        cflags           => add("-arch arm64 -mios-simulator-version-min=7.0.0 -fno-common"),
+    },
+);
diff --git a/run b/run
deleted file mode 100755
index e6122ee..0000000
--- a/run
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash
-make test_main && LD_LIBRARY_PATH="$LD_LIBRARY_PATH:." ./test_main
diff --git a/scripts/build_nif.sh b/scripts/build_nif.sh
index 0be968b..8491e0a 100755
--- a/scripts/build_nif.sh
+++ b/scripts/build_nif.sh
@@ -2,7 +2,7 @@
 
 # mix has priority over `make` for projects like exqlite
 if [ -f "mix.exs" ]; then
-    exec mix do deps.get, release
+    exec mix do deps.get, release --overwrite
 fi
 
 if [ -f "Makefile" ]; then
diff --git a/scripts/install_openssl.sh b/scripts/install_openssl.sh
index b2a1897..298db9c 100755
--- a/scripts/install_openssl.sh
+++ b/scripts/install_openssl.sh
@@ -1,15 +1,23 @@
 #!/bin/bash
 export VSN=1.1.1k
 export VSN_HASH=892a0875b9872acd04a9fde79b1f943075d5ea162415de3047c327df33fbaee5
+
+if [ -z "$OPENSSL_PREFIX" ]; then
 export PREFIX=/usr/local/openssl
+else
+export PREFIX=$OPENSSL_PREFIX
+fi 
 
 # install openssl
 echo "Build and install openssl......"
 mkdir -p $PREFIX/ssl && \
-    wget https://www.openssl.org/source/openssl-$VSN.tar.gz && \
+    mkdir -p _build && \
+    cd _build && \
+    wget -nc https://www.openssl.org/source/openssl-$VSN.tar.gz && \
     [ "$VSN_HASH" = "$(sha256sum openssl-$VSN.tar.gz | cut -d ' ' -f1)" ] && \
     tar xzf openssl-$VSN.tar.gz && \
+    cp ../patch/openssl-ios.conf openssl-$VSN/Configurations/15-ios.conf && \
     cd openssl-$VSN && \
     ./Configure $ARCH --prefix=$PREFIX "$@" && \
-    make depend && make && make install_sw install_ssldirs
+    make clean && make depend && make && make install_sw install_ssldirs
 
diff --git a/stubs/obstack.h b/stubs/obstack.h
new file mode 100644
index 0000000..6c4c8c7
--- /dev/null
+++ b/stubs/obstack.h
@@ -0,0 +1,547 @@
+/* obstack.h - object stack macros
+   Copyright (C) 1988-2021 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 3 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* Summary:
+
+   All the apparent functions defined here are macros. The idea
+   is that you would use these pre-tested macros to solve a
+   very specific set of problems, and they would run fast.
+   Caution: no side-effects in arguments please!! They may be
+   evaluated MANY times!!
+
+   These macros operate a stack of objects.  Each object starts life
+   small, and may grow to maturity.  (Consider building a word syllable
+   by syllable.)  An object can move while it is growing.  Once it has
+   been "finished" it never changes address again.  So the "top of the
+   stack" is typically an immature growing object, while the rest of the
+   stack is of mature, fixed size and fixed address objects.
+
+   These routines grab large chunks of memory, using a function you
+   supply, called 'obstack_chunk_alloc'.  On occasion, they free chunks,
+   by calling 'obstack_chunk_free'.  You must define them and declare
+   them before using any obstack macros.
+
+   Each independent stack is represented by a 'struct obstack'.
+   Each of the obstack macros expects a pointer to such a structure
+   as the first argument.
+
+   One motivation for this package is the problem of growing char strings
+   in symbol tables.  Unless you are "fascist pig with a read-only mind"
+   --Gosper's immortal quote from HAKMEM item 154, out of context--you
+   would not like to put any arbitrary upper limit on the length of your
+   symbols.
+
+   In practice this often means you will build many short symbols and a
+   few long symbols.  At the time you are reading a symbol you don't know
+   how long it is.  One traditional method is to read a symbol into a
+   buffer, realloc()ating the buffer every time you try to read a symbol
+   that is longer than the buffer.  This is beaut, but you still will
+   want to copy the symbol from the buffer to a more permanent
+   symbol-table entry say about half the time.
+
+   With obstacks, you can work differently.  Use one obstack for all symbol
+   names.  As you read a symbol, grow the name in the obstack gradually.
+   When the name is complete, finalize it.  Then, if the symbol exists already,
+   free the newly read name.
+
+   The way we do this is to take a large chunk, allocating memory from
+   low addresses.  When you want to build a symbol in the chunk you just
+   add chars above the current "high water mark" in the chunk.  When you
+   have finished adding chars, because you got to the end of the symbol,
+   you know how long the chars are, and you can create a new object.
+   Mostly the chars will not burst over the highest address of the chunk,
+   because you would typically expect a chunk to be (say) 100 times as
+   long as an average object.
+
+   In case that isn't clear, when we have enough chars to make up
+   the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)
+   so we just point to it where it lies.  No moving of chars is
+   needed and this is the second win: potentially long strings need
+   never be explicitly shuffled. Once an object is formed, it does not
+   change its address during its lifetime.
+
+   When the chars burst over a chunk boundary, we allocate a larger
+   chunk, and then copy the partly formed object from the end of the old
+   chunk to the beginning of the new larger chunk.  We then carry on
+   accreting characters to the end of the object as we normally would.
+
+   A special macro is provided to add a single char at a time to a
+   growing object.  This allows the use of register variables, which
+   break the ordinary 'growth' macro.
+
+   Summary:
+        We allocate large chunks.
+        We carve out one object at a time from the current chunk.
+        Once carved, an object never moves.
+        We are free to append data of any size to the currently
+          growing object.
+        Exactly one object is growing in an obstack at any one time.
+        You can run one obstack per control block.
+        You may have as many control blocks as you dare.
+        Because of the way we do it, you can "unwind" an obstack
+          back to a previous state. (You may remove objects much
+          as you would with a stack.)
+ */
+
+
+/* Don't do the contents of this file more than once.  */
+
+#ifndef _OBSTACK_H
+#define _OBSTACK_H 1
+
+#ifndef _OBSTACK_INTERFACE_VERSION
+# define _OBSTACK_INTERFACE_VERSION 2
+#endif
+
+#include <stddef.h>             /* For size_t and ptrdiff_t.  */
+#include <string.h>             /* For __GNU_LIBRARY__, and memcpy.  */
+
+#if __STDC_VERSION__ < 199901L || defined __HP_cc
+# define __FLEXIBLE_ARRAY_MEMBER 1
+#else
+# define __FLEXIBLE_ARRAY_MEMBER
+#endif
+
+#if _OBSTACK_INTERFACE_VERSION == 1
+/* For binary compatibility with obstack version 1, which used "int"
+   and "long" for these two types.  */
+# define _OBSTACK_SIZE_T unsigned int
+# define _CHUNK_SIZE_T unsigned long
+# define _OBSTACK_CAST(type, expr) ((type) (expr))
+#else
+/* Version 2 with sane types, especially for 64-bit hosts.  */
+# define _OBSTACK_SIZE_T size_t
+# define _CHUNK_SIZE_T size_t
+# define _OBSTACK_CAST(type, expr) (expr)
+#endif
+
+/* If B is the base of an object addressed by P, return the result of
+   aligning P to the next multiple of A + 1.  B and P must be of type
+   char *.  A + 1 must be a power of 2.  */
+
+#define __BPTR_ALIGN(B, P, A) ((B) + (((P) - (B) + (A)) & ~(A)))
+
+/* Similar to __BPTR_ALIGN (B, P, A), except optimize the common case
+   where pointers can be converted to integers, aligned as integers,
+   and converted back again.  If ptrdiff_t is narrower than a
+   pointer (e.g., the AS/400), play it safe and compute the alignment
+   relative to B.  Otherwise, use the faster strategy of computing the
+   alignment relative to 0.  */
+
+#define __PTR_ALIGN(B, P, A)						      \
+  __BPTR_ALIGN (sizeof (ptrdiff_t) < sizeof (void *) ? (B) : (char *) 0,      \
+                P, A)
+
+#ifndef __attribute_pure__
+# define __attribute_pure__ _GL_ATTRIBUTE_PURE
+#endif
+
+/* Not the same as _Noreturn, since it also works with function pointers.  */
+#ifndef __attribute_noreturn__
+# if 2 < __GNUC__ + (8 <= __GNUC_MINOR__) || defined __clang__ || 0x5110 <= __SUNPRO_C
+#  define __attribute_noreturn__ __attribute__ ((__noreturn__))
+# else
+#  define __attribute_noreturn__
+# endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _obstack_chunk           /* Lives at front of each chunk. */
+{
+  char *limit;                  /* 1 past end of this chunk */
+  struct _obstack_chunk *prev;  /* address of prior chunk or NULL */
+  char contents[__FLEXIBLE_ARRAY_MEMBER]; /* objects begin here */
+};
+
+struct obstack          /* control current object in current chunk */
+{
+  _CHUNK_SIZE_T chunk_size;     /* preferred size to allocate chunks in */
+  struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */
+  char *object_base;            /* address of object we are building */
+  char *next_free;              /* where to add next char to current object */
+  char *chunk_limit;            /* address of char after current chunk */
+  union
+  {
+    _OBSTACK_SIZE_T i;
+    void *p;
+  } temp;                       /* Temporary for some macros.  */
+  _OBSTACK_SIZE_T alignment_mask;  /* Mask of alignment for each object. */
+
+  /* These prototypes vary based on 'use_extra_arg'.  */
+  union
+  {
+    void *(*plain) (size_t);
+    void *(*extra) (void *, size_t);
+  } chunkfun;
+  union
+  {
+    void (*plain) (void *);
+    void (*extra) (void *, void *);
+  } freefun;
+
+  void *extra_arg;              /* first arg for chunk alloc/dealloc funcs */
+  unsigned use_extra_arg : 1;     /* chunk alloc/dealloc funcs take extra arg */
+  unsigned maybe_empty_object : 1; /* There is a possibility that the current
+                                      chunk contains a zero-length object.  This
+                                      prevents freeing the chunk if we allocate
+                                      a bigger chunk to replace it. */
+  unsigned alloc_failed : 1;      /* No longer used, as we now call the failed
+                                     handler on error, but retained for binary
+                                     compatibility.  */
+};
+
+/* Declare the external functions we use; they are in obstack.c.  */
+
+extern void _obstack_newchunk (struct obstack *, _OBSTACK_SIZE_T);
+extern void _obstack_free (struct obstack *, void *);
+extern int _obstack_begin (struct obstack *,
+                           _OBSTACK_SIZE_T, _OBSTACK_SIZE_T,
+                           void *(*) (size_t), void (*) (void *));
+extern int _obstack_begin_1 (struct obstack *,
+                             _OBSTACK_SIZE_T, _OBSTACK_SIZE_T,
+                             void *(*) (void *, size_t),
+                             void (*) (void *, void *), void *);
+extern _OBSTACK_SIZE_T _obstack_memory_used (struct obstack *);
+
+
+/* Error handler called when 'obstack_chunk_alloc' failed to allocate
+   more memory.  This can be set to a user defined function which
+   should either abort gracefully or use longjump - but shouldn't
+   return.  The default action is to print a message and abort.  */
+extern __attribute_noreturn__ void (*obstack_alloc_failed_handler) (void);
+
+/* Exit value used when 'print_and_abort' is used.  */
+extern int obstack_exit_failure;
+
+/* Pointer to beginning of object being allocated or to be allocated next.
+   Note that this might not be the final address of the object
+   because a new chunk might be needed to hold the final size.  */
+
+#define obstack_base(h) ((void *) (h)->object_base)
+
+/* Size for allocating ordinary chunks.  */
+
+#define obstack_chunk_size(h) ((h)->chunk_size)
+
+/* Pointer to next byte not yet allocated in current chunk.  */
+
+#define obstack_next_free(h) ((void *) (h)->next_free)
+
+/* Mask specifying low bits that should be clear in address of an object.  */
+
+#define obstack_alignment_mask(h) ((h)->alignment_mask)
+
+/* To prevent prototype warnings provide complete argument list.  */
+#define obstack_init(h)							      \
+  _obstack_begin ((h), 0, 0,						      \
+                  _OBSTACK_CAST (void *(*) (size_t), obstack_chunk_alloc),    \
+                  _OBSTACK_CAST (void (*) (void *), obstack_chunk_free))
+
+#define obstack_begin(h, size)						      \
+  _obstack_begin ((h), (size), 0,					      \
+                  _OBSTACK_CAST (void *(*) (size_t), obstack_chunk_alloc), \
+                  _OBSTACK_CAST (void (*) (void *), obstack_chunk_free))
+
+#define obstack_specify_allocation(h, size, alignment, chunkfun, freefun)     \
+  _obstack_begin ((h), (size), (alignment),				      \
+                  _OBSTACK_CAST (void *(*) (size_t), chunkfun),		      \
+                  _OBSTACK_CAST (void (*) (void *), freefun))
+
+#define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \
+  _obstack_begin_1 ((h), (size), (alignment),				      \
+                    _OBSTACK_CAST (void *(*) (void *, size_t), chunkfun),     \
+                    _OBSTACK_CAST (void (*) (void *, void *), freefun), arg)
+
+#define obstack_chunkfun(h, newchunkfun)				      \
+  ((void) ((h)->chunkfun.extra = (void *(*) (void *, size_t)) (newchunkfun)))
+
+#define obstack_freefun(h, newfreefun)					      \
+  ((void) ((h)->freefun.extra = (void *(*) (void *, void *)) (newfreefun)))
+
+#define obstack_1grow_fast(h, achar) ((void) (*((h)->next_free)++ = (achar)))
+
+#define obstack_blank_fast(h, n) ((void) ((h)->next_free += (n)))
+
+#define obstack_memory_used(h) _obstack_memory_used (h)
+
+#if defined __GNUC__ || defined __clang__
+# if !(defined __GNUC_MINOR__ && __GNUC__ * 1000 + __GNUC_MINOR__ >= 2008 \
+       || defined __clang__)
+#  define __extension__
+# endif
+
+/* For GNU C, if not -traditional,
+   we can define these macros to compute all args only once
+   without using a global variable.
+   Also, we can avoid using the 'temp' slot, to make faster code.  */
+
+# define obstack_object_size(OBSTACK)					      \
+  __extension__								      \
+    ({ struct obstack const *__o = (OBSTACK);				      \
+       (_OBSTACK_SIZE_T) (__o->next_free - __o->object_base); })
+
+/* The local variable is named __o1 to avoid a shadowed variable
+   warning when invoked from other obstack macros.  */
+# define obstack_room(OBSTACK)						      \
+  __extension__								      \
+    ({ struct obstack const *__o1 = (OBSTACK);				      \
+       (_OBSTACK_SIZE_T) (__o1->chunk_limit - __o1->next_free); })
+
+# define obstack_make_room(OBSTACK, length)				      \
+  __extension__								      \
+    ({ struct obstack *__o = (OBSTACK);					      \
+       _OBSTACK_SIZE_T __len = (length);				      \
+       if (obstack_room (__o) < __len)					      \
+         _obstack_newchunk (__o, __len);				      \
+       (void) 0; })
+
+# define obstack_empty_p(OBSTACK)					      \
+  __extension__								      \
+    ({ struct obstack const *__o = (OBSTACK);				      \
+       (__o->chunk->prev == 0						      \
+        && __o->next_free == __PTR_ALIGN ((char *) __o->chunk,		      \
+                                          __o->chunk->contents,		      \
+                                          __o->alignment_mask)); })
+
+# define obstack_grow(OBSTACK, where, length)				      \
+  __extension__								      \
+    ({ struct obstack *__o = (OBSTACK);					      \
+       _OBSTACK_SIZE_T __len = (length);				      \
+       if (obstack_room (__o) < __len)					      \
+         _obstack_newchunk (__o, __len);				      \
+       memcpy (__o->next_free, where, __len);				      \
+       __o->next_free += __len;						      \
+       (void) 0; })
+
+# define obstack_grow0(OBSTACK, where, length)				      \
+  __extension__								      \
+    ({ struct obstack *__o = (OBSTACK);					      \
+       _OBSTACK_SIZE_T __len = (length);				      \
+       if (obstack_room (__o) < __len + 1)				      \
+         _obstack_newchunk (__o, __len + 1);				      \
+       memcpy (__o->next_free, where, __len);				      \
+       __o->next_free += __len;						      \
+       *(__o->next_free)++ = 0;						      \
+       (void) 0; })
+
+# define obstack_1grow(OBSTACK, datum)					      \
+  __extension__								      \
+    ({ struct obstack *__o = (OBSTACK);					      \
+       if (obstack_room (__o) < 1)					      \
+         _obstack_newchunk (__o, 1);					      \
+       obstack_1grow_fast (__o, datum); })
+
+/* These assume that the obstack alignment is good enough for pointers
+   or ints, and that the data added so far to the current object
+   shares that much alignment.  */
+
+# define obstack_ptr_grow(OBSTACK, datum)				      \
+  __extension__								      \
+    ({ struct obstack *__o = (OBSTACK);					      \
+       if (obstack_room (__o) < sizeof (void *))			      \
+         _obstack_newchunk (__o, sizeof (void *));			      \
+       obstack_ptr_grow_fast (__o, datum); })
+
+# define obstack_int_grow(OBSTACK, datum)				      \
+  __extension__								      \
+    ({ struct obstack *__o = (OBSTACK);					      \
+       if (obstack_room (__o) < sizeof (int))				      \
+         _obstack_newchunk (__o, sizeof (int));				      \
+       obstack_int_grow_fast (__o, datum); })
+
+# define obstack_ptr_grow_fast(OBSTACK, aptr)				      \
+  __extension__								      \
+    ({ struct obstack *__o1 = (OBSTACK);				      \
+       void *__p1 = __o1->next_free;					      \
+       *(const void **) __p1 = (aptr);					      \
+       __o1->next_free += sizeof (const void *);			      \
+       (void) 0; })
+
+# define obstack_int_grow_fast(OBSTACK, aint)				      \
+  __extension__								      \
+    ({ struct obstack *__o1 = (OBSTACK);				      \
+       void *__p1 = __o1->next_free;					      \
+       *(int *) __p1 = (aint);						      \
+       __o1->next_free += sizeof (int);					      \
+       (void) 0; })
+
+# define obstack_blank(OBSTACK, length)					      \
+  __extension__								      \
+    ({ struct obstack *__o = (OBSTACK);					      \
+       _OBSTACK_SIZE_T __len = (length);				      \
+       if (obstack_room (__o) < __len)					      \
+         _obstack_newchunk (__o, __len);				      \
+       obstack_blank_fast (__o, __len); })
+
+# define obstack_alloc(OBSTACK, length)					      \
+  __extension__								      \
+    ({ struct obstack *__h = (OBSTACK);					      \
+       obstack_blank (__h, (length));					      \
+       obstack_finish (__h); })
+
+# define obstack_copy(OBSTACK, where, length)				      \
+  __extension__								      \
+    ({ struct obstack *__h = (OBSTACK);					      \
+       obstack_grow (__h, (where), (length));				      \
+       obstack_finish (__h); })
+
+# define obstack_copy0(OBSTACK, where, length)				      \
+  __extension__								      \
+    ({ struct obstack *__h = (OBSTACK);					      \
+       obstack_grow0 (__h, (where), (length));				      \
+       obstack_finish (__h); })
+
+/* The local variable is named __o1 to avoid a shadowed variable
+   warning when invoked from other obstack macros, typically obstack_free.  */
+# define obstack_finish(OBSTACK)					      \
+  __extension__								      \
+    ({ struct obstack *__o1 = (OBSTACK);				      \
+       void *__value = (void *) __o1->object_base;			      \
+       if (__o1->next_free == __value)					      \
+         __o1->maybe_empty_object = 1;					      \
+       __o1->next_free							      \
+         = __PTR_ALIGN (__o1->object_base, __o1->next_free,		      \
+                        __o1->alignment_mask);				      \
+       if ((size_t) (__o1->next_free - (char *) __o1->chunk)		      \
+           > (size_t) (__o1->chunk_limit - (char *) __o1->chunk))	      \
+         __o1->next_free = __o1->chunk_limit;				      \
+       __o1->object_base = __o1->next_free;				      \
+       __value; })
+
+# define obstack_free(OBSTACK, OBJ)					      \
+  __extension__								      \
+    ({ struct obstack *__o = (OBSTACK);					      \
+       void *__obj = (void *) (OBJ);					      \
+       if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit)  \
+         __o->next_free = __o->object_base = (char *) __obj;		      \
+       else								      \
+         _obstack_free (__o, __obj); })
+
+#else /* not __GNUC__ */
+
+# define obstack_object_size(h)						      \
+  ((_OBSTACK_SIZE_T) ((h)->next_free - (h)->object_base))
+
+# define obstack_room(h)						      \
+  ((_OBSTACK_SIZE_T) ((h)->chunk_limit - (h)->next_free))
+
+# define obstack_empty_p(h)						      \
+  ((h)->chunk->prev == 0						      \
+   && (h)->next_free == __PTR_ALIGN ((char *) (h)->chunk,		      \
+                                     (h)->chunk->contents,		      \
+                                     (h)->alignment_mask))
+
+/* Note that the call to _obstack_newchunk is enclosed in (..., 0)
+   so that we can avoid having void expressions
+   in the arms of the conditional expression.
+   Casting the third operand to void was tried before,
+   but some compilers won't accept it.  */
+
+# define obstack_make_room(h, length)					      \
+  ((h)->temp.i = (length),						      \
+   ((obstack_room (h) < (h)->temp.i)					      \
+    ? (_obstack_newchunk (h, (h)->temp.i), 0) : 0),			      \
+   (void) 0)
+
+# define obstack_grow(h, where, length)					      \
+  ((h)->temp.i = (length),						      \
+   ((obstack_room (h) < (h)->temp.i)					      \
+   ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0),			      \
+   memcpy ((h)->next_free, where, (h)->temp.i),				      \
+   (h)->next_free += (h)->temp.i,					      \
+   (void) 0)
+
+# define obstack_grow0(h, where, length)				      \
+  ((h)->temp.i = (length),						      \
+   ((obstack_room (h) < (h)->temp.i + 1)				      \
+   ? (_obstack_newchunk ((h), (h)->temp.i + 1), 0) : 0),		      \
+   memcpy ((h)->next_free, where, (h)->temp.i),				      \
+   (h)->next_free += (h)->temp.i,					      \
+   *((h)->next_free)++ = 0,						      \
+   (void) 0)
+
+# define obstack_1grow(h, datum)					      \
+  (((obstack_room (h) < 1)						      \
+    ? (_obstack_newchunk ((h), 1), 0) : 0),				      \
+   obstack_1grow_fast (h, datum))
+
+# define obstack_ptr_grow(h, datum)					      \
+  (((obstack_room (h) < sizeof (char *))				      \
+    ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0),		      \
+   obstack_ptr_grow_fast (h, datum))
+
+# define obstack_int_grow(h, datum)					      \
+  (((obstack_room (h) < sizeof (int))					      \
+    ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0),			      \
+   obstack_int_grow_fast (h, datum))
+
+# define obstack_ptr_grow_fast(h, aptr)					      \
+  (((const void **) ((h)->next_free += sizeof (void *)))[-1] = (aptr),	      \
+   (void) 0)
+
+# define obstack_int_grow_fast(h, aint)					      \
+  (((int *) ((h)->next_free += sizeof (int)))[-1] = (aint),		      \
+   (void) 0)
+
+# define obstack_blank(h, length)					      \
+  ((h)->temp.i = (length),						      \
+   ((obstack_room (h) < (h)->temp.i)					      \
+   ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0),			      \
+   obstack_blank_fast (h, (h)->temp.i))
+
+# define obstack_alloc(h, length)					      \
+  (obstack_blank ((h), (length)), obstack_finish ((h)))
+
+# define obstack_copy(h, where, length)					      \
+  (obstack_grow ((h), (where), (length)), obstack_finish ((h)))
+
+# define obstack_copy0(h, where, length)				      \
+  (obstack_grow0 ((h), (where), (length)), obstack_finish ((h)))
+
+# define obstack_finish(h)						      \
+  (((h)->next_free == (h)->object_base					      \
+    ? (((h)->maybe_empty_object = 1), 0)				      \
+    : 0),								      \
+   (h)->temp.p = (h)->object_base,					      \
+   (h)->next_free							      \
+     = __PTR_ALIGN ((h)->object_base, (h)->next_free,			      \
+                    (h)->alignment_mask),				      \
+   (((size_t) ((h)->next_free - (char *) (h)->chunk)			      \
+     > (size_t) ((h)->chunk_limit - (char *) (h)->chunk))		      \
+   ? ((h)->next_free = (h)->chunk_limit) : 0),				      \
+   (h)->object_base = (h)->next_free,					      \
+   (h)->temp.p)
+
+# define obstack_free(h, obj)						      \
+  ((h)->temp.p = (void *) (obj),					      \
+   (((h)->temp.p > (void *) (h)->chunk					      \
+     && (h)->temp.p < (void *) (h)->chunk_limit)			      \
+    ? (void) ((h)->next_free = (h)->object_base = (char *) (h)->temp.p)       \
+    : _obstack_free ((h), (h)->temp.p)))
+
+#endif /* not __GNUC__ */
+
+#ifdef __cplusplus
+}       /* C++ */
+#endif
+
+#endif /* _OBSTACK_H */
+
+#include "obstack_printf.c"
\ No newline at end of file
diff --git a/stubs/obstack_printf.c b/stubs/obstack_printf.c
new file mode 100644
index 0000000..7f970a0
--- /dev/null
+++ b/stubs/obstack_printf.c
@@ -0,0 +1,91 @@
+/* Formatted output to obstacks.
+   Copyright (C) 2008-2020 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with this program; if not, see <https://www.gnu.org/licenses/>.  */
+
+/* Specification.  */
+#include <stdio.h>
+
+#include "vasnprintf.h"
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+int
+obstack_vprintf (struct obstack *obs, const char *format, va_list args);
+
+/* Grow an obstack with formatted output.  Return the number of bytes
+   added to OBS.  No trailing nul byte is added, and the object should
+   be closed with obstack_finish before use.
+
+   Upon memory allocation error, call obstack_alloc_failed_handler.
+   Upon other error, return -1.  */
+int
+obstack_printf (struct obstack *obs, const char *format, ...)
+{
+  va_list args;
+  int result;
+
+  va_start (args, format);
+  result = obstack_vprintf (obs, format, args);
+  va_end (args);
+  return result;
+}
+
+/* Grow an obstack with formatted output.  Return the number of bytes
+   added to OBS.  No trailing nul byte is added, and the object should
+   be closed with obstack_finish before use.
+
+   Upon memory allocation error, call obstack_alloc_failed_handler.
+   Upon other error, return -1.  */
+int
+obstack_vprintf (struct obstack *obs, const char *format, va_list args)
+{
+  /* If we are close to the end of the current obstack chunk, use a
+     stack-allocated buffer and copy, to reduce the likelihood of a
+     small-size malloc.  Otherwise, print directly into the
+     obstack.  */
+  enum { CUTOFF = 1024 };
+  char buf[CUTOFF];
+  char *base = obstack_next_free (obs);
+  size_t len = obstack_room (obs);
+  char *str;
+
+  if (len < CUTOFF)
+    {
+      base = buf;
+      len = CUTOFF;
+    }
+  str = vasnprintf (base, &len, format, args);
+  if (!str)
+    {
+      if (errno == ENOMEM)
+        obstack_alloc_failed_handler ();
+      return -1;
+    }
+  if (str == base && str != buf)
+    /* The output was already computed in place, but we need to
+       account for its size.  */
+    obstack_blank_fast (obs, len);
+  else
+    {
+      /* The output exceeded available obstack space or we used buf;
+         copy the resulting string.  */
+      obstack_grow (obs, str, len);
+      if (str != buf)
+        free (str);
+    }
+  return len;
+}
diff --git a/stubs/vasnprintf.h b/stubs/vasnprintf.h
new file mode 100644
index 0000000..53bc930
--- /dev/null
+++ b/stubs/vasnprintf.h
@@ -0,0 +1,67 @@
+/* vsprintf with automatic memory allocation.
+   Copyright (C) 2002-2004, 2007-2020 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with this program; if not, see <https://www.gnu.org/licenses/>.  */
+
+#ifndef _VASNPRINTF_H
+#define _VASNPRINTF_H
+
+/* Get va_list.  */
+#include <stdarg.h>
+
+/* Get size_t.  */
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Write formatted output to a string dynamically allocated with malloc().
+   You can pass a preallocated buffer for the result in RESULTBUF and its
+   size in *LENGTHP; otherwise you pass RESULTBUF = NULL.
+   If successful, return the address of the string (this may be = RESULTBUF
+   if no dynamic memory allocation was necessary) and set *LENGTHP to the
+   number of resulting bytes, excluding the trailing NUL.  Upon error, set
+   errno and return NULL.
+
+   When dynamic memory allocation occurs, the preallocated buffer is left
+   alone (with possibly modified contents).  This makes it possible to use
+   a statically allocated or stack-allocated buffer, like this:
+
+          char buf[100];
+          size_t len = sizeof (buf);
+          char *output = vasnprintf (buf, &len, format, args);
+          if (output == NULL)
+            ... error handling ...;
+          else
+            {
+              ... use the output string ...;
+              if (output != buf)
+                free (output);
+            }
+  */
+#if REPLACE_VASNPRINTF
+# define asnprintf rpl_asnprintf
+# define vasnprintf rpl_vasnprintf
+#endif
+extern char * asnprintf (char *restrict resultbuf, size_t *lengthp,
+                         const char *format, ...);
+extern char * vasnprintf (char *restrict resultbuf, size_t *lengthp,
+                          const char *format, va_list args);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VASNPRINTF_H */