defmodule CCPrecompiler do
@moduledoc """
Precompile with existing crosscompiler in the system.
"""
require Logger
@behaviour ElixirMake.Precompiler
# The default configuration for this precompiler module on linux systems.
# It will detect for the following targets
# - x86_64-linux-gnu
# - i686-linux-gnu
# - aarch64-linux-gnu
# - armv7l-linux-gnueabihf
# - riscv64-linux-gnu
# - powerpc64le-linux-gnu
# - s390x-linux-gnu
# by trying to find the corresponding executable, i.e.,
# - x86_64-linux-gnu-gcc
# - i686-linux-gnu-gcc
# - aarch64-linux-gnu-gcc
# - arm-linux-gnueabihf-gcc
# - riscv64-linux-gnu-gcc
# - powerpc64le-linux-gnu-gcc
# - s390x-linux-gnu-gcc
# (this module will only try to find the CC executable, a step further
# will be trying to compile a simple C/C++ program using them)
@default_compilers %{
{:unix, :linux} => %{
"x86_64-linux-gnu" => "x86_64-linux-gnu-",
"i686-linux-gnu" => "i686-linux-gnu-",
"aarch64-linux-gnu" => "aarch64-linux-gnu-",
"armv7l-linux-gnueabihf" => "arm-linux-gnueabihf-",
"riscv64-linux-gnu" => "riscv64-linux-gnu-",
"powerpc64le-linux-gnu" => "powerpc64le-linux-gnu-",
"s390x-linux-gnu" => "s390x-linux-gnu-"
},
{:unix, :darwin} => %{
"x86_64-apple-darwin" => {
"gcc",
"g++",
"<%= cc %> -arch x86_64",
"<%= cxx %> -arch x86_64"
},
"aarch64-apple-darwin" => {
"gcc",
"g++",
"<%= cc %> -arch arm64",
"<%= cxx %> -arch arm64"
}
},
{:win32, :nt} => %{
"x86_64-windows-msvc" => {"cl", "cl"}
}
}
defp default_compilers, do: @default_compilers
defp user_config, do: Mix.Project.config()[:cc_precompiler] || default_compilers()
defp compilers, do: Access.get(user_config(), :compilers, default_compilers())
defp compilers_current_os,
do:
{Access.get(compilers(), :os.type(), %{}), Access.get(default_compilers(), :os.type(), %{})}
defp compilers_current_os_with_override do
{compiler_map1, compiler_map2} = compilers_current_os()
if Map.has_key?(compiler_map1, :include_default_ones) do
include_default_ones = Map.get(compiler_map1, :include_default_ones, false)
compiler_map1 = Map.delete(compiler_map1, :include_default_ones)
if include_default_ones == true do
Map.merge(compiler_map1, compiler_map2, fn _, _, user_override -> user_override end)
else
compiler_map1
end
else
compiler_map1
end
end
defp only_listed_targets, do: Access.get(user_config(), :only_listed_targets, false)
defp exclude_current_target, do: Access.get(user_config(), :exclude_current_target, false)
defp allow_missing_compiler, do: Access.get(user_config(), :allow_missing_compiler, false)
@impl ElixirMake.Precompiler
def current_target do
current_target_from_env = current_target_from_env()
if current_target_from_env do
# overwrite current target triplet from environment variables
{:ok, current_target_from_env}
else
current_target(:os.type())
end
end
defp current_target_from_env do
arch = System.get_env("TARGET_ARCH")
os = System.get_env("TARGET_OS")
abi = System.get_env("TARGET_ABI")
if !Enum.all?([arch, os, abi], &Kernel.is_nil/1) do
"#{arch}-#{os}-#{abi}"
end
end
def current_target({:win32, _}) do
processor_architecture =
String.downcase(String.trim(System.get_env("PROCESSOR_ARCHITECTURE")))
# https://docs.microsoft.com/en-gb/windows/win32/winprog64/wow64-implementation-details?redirectedfrom=MSDN
partial_triplet =
case processor_architecture do
"amd64" ->
"x86_64-windows-"
"ia64" ->
"ia64-windows-"
"arm64" ->
"aarch64-windows-"
"x86" ->
"x86-windows-"
end
{compiler, _} = :erlang.system_info(:c_compiler_used)
case compiler do
:msc ->
{:ok, partial_triplet <> "msvc"}
:gnuc ->
{:ok, partial_triplet <> "gnu"}
other ->
{:ok, partial_triplet <> Atom.to_string(other)}
end
end
def current_target({:unix, _}) do
# get current target triplet from `:erlang.system_info/1`
system_architecture = to_string(:erlang.system_info(:system_architecture))
current = String.split(system_architecture, "-", trim: true)
case length(current) do
4 ->
{:ok, "#{Enum.at(current, 0)}-#{Enum.at(current, 2)}-#{Enum.at(current, 3)}"}
3 ->
case :os.type() do
{:unix, :darwin} ->
# could be something like aarch64-apple-darwin21.0.0
# but we don't really need the last 21.0.0 part
if String.match?(Enum.at(current, 2), ~r/^darwin.*/) do
{:ok, "#{Enum.at(current, 0)}-#{Enum.at(current, 1)}-darwin"}
else
{:ok, system_architecture}
end
_ ->
{:ok, system_architecture}
end
_ ->
{:error, "cannot decide current target"}
end
end
defp only_local do
System.get_env("CC_PRECOMPILER_PRECOMPILE_ONLY_LOCAL") == "true"
end
@impl ElixirMake.Precompiler
def all_supported_targets(:compile) do
# this callback is expected to return a list of string for
# all supported targets by this precompiler. in this
# implementation, we will try to find a few crosscompilers
# available in the system.
# Note that this implementation is mainly used for demonstration
# purpose, therefore the hardcoded compiler names are used in
# DEBIAN/Ubuntu Linux (as I only installed these ones at the
# time of writing this example)
available_targets = find_all_available_targets()
targets =
case {only_local(), only_listed_targets(), current_target()} do
{true, true, {:ok, current}} ->
if Enum.member?(available_targets, current) do
[current]
else
[]
end
{true, _, {:error, err_msg}} ->
Mix.raise(err_msg)
{true, false, {:ok, current}} ->
Enum.uniq([current] ++ available_targets)
{false, true, _} ->
available_targets
{false, false, {:ok, current}} ->
Enum.uniq([current] ++ available_targets)
end
if exclude_current_target() do
case current_target() do
{:ok, current} ->
targets -- [current]
_ ->
targets
end
else
targets
end
end
@impl ElixirMake.Precompiler
def all_supported_targets(:fetch) do
Enum.map(compilers(), fn {os, compilers} ->
Enum.map(Map.keys(compilers), fn key ->
if key == :include_default_ones do
Map.keys(default_compilers()[os])
else
key
end
end)
end)
|> List.flatten()
end
@impl ElixirMake.Precompiler
def unavailable_target(_) do
if only_listed_targets() do
:ignore
else
:compile
end
end
defp find_all_available_targets do
compilers = compilers_current_os_with_override()
compilers
|> Map.keys()
|> Enum.map(&find_available_compilers(&1, Map.get(compilers, &1)))
|> Enum.reject(fn x -> x == nil end)
end
defp find_available_compilers(triplet, prefix) when is_binary(prefix) do
if ensure_executable(["#{prefix}gcc", "#{prefix}g++"]) do
Logger.debug("Found compiler for #{triplet}")
triplet
else
Logger.debug("Compiler not found for #{triplet}")
nil
end
end
defp find_available_compilers(triplet, {cc, cxx}) when is_binary(cc) and is_binary(cxx) do
if ensure_executable([cc, cxx]) do
Logger.debug("Found compiler for #{triplet}")
triplet
else
Logger.debug("Compiler not found for #{triplet}")
nil
end
end
defp find_available_compilers(triplet, {:script, _, _}) do
triplet
end
defp find_available_compilers(triplet, {cc_executable, cxx_executable, _, _})
when is_binary(cc_executable) and is_binary(cxx_executable) do
if ensure_executable([cc_executable, cxx_executable]) do
Logger.debug("Found compiler for #{triplet}")
triplet
else
Logger.debug("Compiler not found for #{triplet}")
nil
end
end
defp find_available_compilers(triplet, invalid) do
Mix.raise(
"Invalid configuration for #{triplet}, expecting a string, 2-tuple or 4-tuple. Got `#{inspect(invalid)}`"
)
end
defp ensure_executable(executable_list) when is_list(executable_list) do
if allow_missing_compiler() do
Enum.any?(executable_list, &System.find_executable/1)
else
Enum.all?(executable_list, &System.find_executable/1)
end
end
@impl ElixirMake.Precompiler
def build_native(args) do
# In this callback we just build the NIF library natively,
# and because this precompiler module is designed for NIF
# libraries that use C/C++ as the main language with Makefile,
# we can just call `ElixirMake.Precompiler.mix_compile(args)`
#
# It's also possible to forward this call to:
#
# `precompile(args, elem(current_target(), 1))`
#
# This could be useful when the precompiler is using a universal
# (cross-)compiler, say zig. in this way, the compiled binaries
# (`mix compile`) will be consistent as the corresponding precompiled
# one (with `mix elixir_make.precompile`)
#
# However, if you'd prefer to having the same behaviour for `mix compile`
# then the following line is okay
ElixirMake.Precompiler.mix_compile(args)
end
@impl ElixirMake.Precompiler
def precompile(args, target) do
# in this callback we compile the NIF library for a given target
config = Mix.Project.config()
app = config[:app]
version = config[:version]
priv_paths = config[:make_precompiler_priv_paths] || ["."]
saved_cc = System.get_env("CC") || ""
saved_cxx = System.get_env("CXX") || ""
saved_cpp = System.get_env("CPP") || ""
Logger.debug("Current compiling target: #{target}")
cc_cxx = get_cc_and_cxx(target)
# remove files in the lists
app_priv = Path.join(Mix.Project.app_path(config), "priv")
case priv_paths do
["."] ->
File.rm_rf!(app_priv)
_ ->
for include <- priv_paths,
file <- Path.wildcard(Path.join(app_priv, include)) do
File.rm_rf(file)
end
end
File.mkdir_p!(app_priv)
case cc_cxx do
{cc, cxx} ->
System.put_env("CC", cc)
System.put_env("CXX", cxx)
System.put_env("CPP", cxx)
System.put_env("CC_PRECOMPILER_CURRENT_TARGET", target)
ElixirMake.Precompiler.mix_compile(args)
{:script, module, custom_args} ->
System.put_env("CC_PRECOMPILER_CURRENT_TARGET", target)
Kernel.apply(module, :compile, [
app,
version,
"#{:erlang.system_info(:nif_version)}",
target,
args,
custom_args
])
end
System.put_env("CC", saved_cc)
System.put_env("CXX", saved_cxx)
System.put_env("CPP", saved_cpp)
:ok
end
defp get_cc_and_cxx(triplet) do
case Access.get(compilers_current_os_with_override(), triplet, nil) do
nil ->
cc = System.get_env("CC")
cxx = System.get_env("CXX")
cpp = System.get_env("CPP")
case {cc, cxx, cpp} do
{nil, _, _} ->
{"gcc", "g++"}
{_, nil, nil} ->
{"gcc", "g++"}
{_, _, nil} ->
{cc, cxx}
{_, nil, _} ->
{cc, cpp}
{_, _, _} ->
{cc, cxx}
end
{cc, cxx} ->
{cc, cxx}
prefix when is_binary(prefix) ->
{"#{prefix}gcc", "#{prefix}g++"}
{:script, script_path, {module, args}} ->
case {script_path, module} do
{"", CCPrecompiler.UniversalBinary} ->
{:script, module, args}
_ ->
Code.require_file(script_path)
{:script, module, args}
end
{cc, cxx, cc_args, cxx_args} ->
{EEx.eval_string(cc_args, cc: cc), EEx.eval_string(cxx_args, cxx: cxx)}
end
end
@impl true
def post_precompile_target(target) do
config = Mix.Project.config()
cc_precompiler_config = config[:cc_precompiler]
cleanup(config, cc_precompiler_config[:cleanup], target)
end
defp cleanup(_, nil, _), do: :ok
defp cleanup(config, make_target, current_precompilation_target) when is_binary(make_target) do
exec =
System.get_env("MAKE") ||
os_specific_executable(Keyword.get(config, :make_executable, :default))
makefile = Keyword.get(config, :make_makefile, :default)
env = Keyword.get(config, :make_env, %{})
env = if is_function(env), do: env.(), else: env
env = default_env(config, env, current_precompilation_target)
# In OTP 19, Erlang's `open_port/2` ignores the current working
# directory when expanding relative paths. This means that `:make_cwd`
# must be an absolute path. This is a different behaviour from earlier
# OTP versions and appears to be a bug. It is being tracked at
# https://bugs.erlang.org/browse/ERL-175.
cwd = Keyword.get(config, :make_cwd, ".") |> Path.expand(File.cwd!())
if String.contains?(cwd, " ") do
IO.warn(
"the absolute path to the makefile for this project contains spaces. Make might " <>
"not work properly if spaces are present in the path. The absolute path is: " <>
inspect(cwd)
)
end
base = exec |> Path.basename() |> Path.rootname()
args = args_for_makefile(base, makefile) ++ [make_target]
case cmd(exec, args, cwd, env) do
0 ->
:ok
exit_status ->
raise_cleanup_error(exec, exit_status)
end
end
defp raise_cleanup_error(exec, exit_status) do
Mix.raise(~s{Could not complete cleanup work with "#{exec}" (exit status: #{exit_status}).\n})
end
# Returns a map of default environment variables
# Defaults may be overwritten.
defp default_env(config, default_env, current_precompilation_target) do
root_dir = :code.root_dir()
erl_interface_dir = Path.join(root_dir, "usr")
erts_dir = Path.join(root_dir, "erts-#{:erlang.system_info(:version)}")
erts_include_dir = Path.join(erts_dir, "include")
erl_ei_lib_dir = Path.join(erl_interface_dir, "lib")
erl_ei_include_dir = Path.join(erl_interface_dir, "include")
Map.merge(
%{
# Don't use Mix.target/0 here for backwards compatibility
"MIX_TARGET" => env("MIX_TARGET", "host"),
"MIX_ENV" => to_string(Mix.env()),
"MIX_BUILD_PATH" => Mix.Project.build_path(config),
"MIX_APP_PATH" => Mix.Project.app_path(config),
"MIX_COMPILE_PATH" => Mix.Project.compile_path(config),
"MIX_CONSOLIDATION_PATH" => Mix.Project.consolidation_path(config),
"MIX_DEPS_PATH" => Mix.Project.deps_path(config),
"MIX_MANIFEST_PATH" => Mix.Project.manifest_path(config),
# Rebar naming
"ERL_EI_LIBDIR" => env("ERL_EI_LIBDIR", erl_ei_lib_dir),
"ERL_EI_INCLUDE_DIR" => env("ERL_EI_INCLUDE_DIR", erl_ei_include_dir),
# erlang.mk naming
"ERTS_INCLUDE_DIR" => env("ERTS_INCLUDE_DIR", erts_include_dir),
"ERL_INTERFACE_LIB_DIR" => env("ERL_INTERFACE_LIB_DIR", erl_ei_lib_dir),
"ERL_INTERFACE_INCLUDE_DIR" => env("ERL_INTERFACE_INCLUDE_DIR", erl_ei_include_dir),
# Disable default erlang values
"BINDIR" => nil,
"ROOTDIR" => nil,
"PROGNAME" => nil,
"EMU" => nil,
# cc_precompiler
"CC_PRECOMPILER_CURRENT_TARGET" => current_precompilation_target
},
default_env
)
end
defp os_specific_executable(exec) when is_binary(exec) do
exec
end
defp os_specific_executable(:default) do
case :os.type() do
{:win32, _} ->
cond do
System.find_executable("nmake") -> "nmake"
System.find_executable("make") -> "make"
true -> "nmake"
end
{:unix, type} when type in [:freebsd, :openbsd, :netbsd] ->
"gmake"
_ ->
"make"
end
end
# Returns a list of command-line args to pass to make (or nmake/gmake) in
# order to specify the makefile to use.
defp args_for_makefile("nmake", :default), do: ["/F", "Makefile.win"]
defp args_for_makefile("nmake", makefile), do: ["/F", makefile]
defp args_for_makefile(_, :default), do: []
defp args_for_makefile(_, makefile), do: ["-f", makefile]
# Runs `exec [args]` in `cwd` and prints the stdout and stderr in real time,
# as soon as `exec` prints them (using `IO.Stream`).
defp cmd(exec, args, cwd, env) do
opts = [
into: IO.stream(:stdio, :line),
stderr_to_stdout: true,
cd: cwd,
env: env
]
{%IO.Stream{}, status} = System.cmd(find_executable(exec), args, opts)
status
end
defp find_executable(exec) do
System.find_executable(exec) ||
Mix.raise("""
"#{exec}" not found in the path. If you have set the MAKE environment variable,
please make sure it is correct.
""")
end
defp env(var, default) do
System.get_env(var) || default
end
end
