feat(nix/buildLisp): add ecl

Adds ECL as a second supported implementation, specifically a statically
linked ECL. This is interesting because we can create statically linked
binaries, but has a few drawbacks which doesn't make it generally
useful:

* Loading things is very slow: The statically linked ECL only has byte
  compilation available, so when we do load things or use the REPL it is
  significantly worse than with e. g. SBCL.

* We can't load shared objects via the FFI since ECL's dffi is not
  available when linked statically. This means that as it stands, we
  can't build a statically linked //web/panettone for example.

Since ECL is quite slow anyways, I think these drawbacks are worth it
since the biggest reason for using ECL would be to get a statically
linked binary. If we change our minds, it shouldn't be too hard to
provide ecl-static and ecl-dynamic as separate implementations.

ECL is LGPL and some libraries it uses as part of its runtime are as
well. I've outlined in the ecl-static overlay why this should be of no
concern in the context of depot even though we are statically linking.

Currently everything is building except projects that are using cffi to
load shared libaries which have gotten an appropriate
`badImplementations` entry. To get the rest building the following
changes were made:

* Anywhere a dependency on UIOP is expressed as `bundled "uiop"` we now
  use `bundled "asdf"` for all implementations except SBCL. From my
  testing, SBCL seems to be the only implementation to support using
  `(require 'uiop)` to only load the UIOP package. Where both a
  dependency on ASDF and UIOP exists, we just delete the UIOP one.
  `(require 'asdf)` always causes UIOP to be available.

* Where appropriate only conditionally compile SBCL-specific code and
  if any build the corresponding files for ECL.

* //lisp/klatre: Use the standard condition parse-error for all
  implementations except SBCL in try-parse-integer.

* //3p/lisp/ironclad: disable SBCL assembly optimization hack for all
  other platforms as it may interfere with compilation.

* //3p/lisp/trivial-mimes: prevent call to asdf function by substituting
  it out of the source since it always errors out in ECL and we hardcode
  the correct path elsewhere anyways.

As it stands ECL still suffers from a very weird problem which happens
when compiling postmodern and moptilities:
https://gitlab.com/embeddable-common-lisp/ecl/-/issues/651

Change-Id: I0285924f92ac154126b4c42145073c3fb33702ed
Reviewed-on: https://cl.tvl.fyi/c/depot/+/3297
Tested-by: BuildkiteCI
Reviewed-by: tazjin <mail@tazj.in>
Reviewed-by: eta <tvl@eta.st>
This commit is contained in:
sterni 2021-08-09 02:47:07 +02:00
parent 0285ea7eac
commit 02566cdcfb
31 changed files with 346 additions and 44 deletions

View file

@ -47,4 +47,9 @@ in depot.nix.buildLisp.program {
./src/gemma.lisp
injectFrontend
];
# depends on SBCL
brokenOn = [
"ecl"
];
}

View file

@ -21,7 +21,10 @@ let
deps = [
depot.third_party.lisp.unix-opts
depot.lisp.klatre
(buildLisp.bundled "uiop")
{
default = buildLisp.bundled "asdf";
sbcl = buildLisp.bundled "uiop";
}
lib
];
@ -30,6 +33,10 @@ let
];
main = "🕰.bin:🚂";
brokenOn = [
"ecl" # refuses to create non-ASCII paths even on POSIX…
];
};
in bin // {
inherit lib;

View file

@ -14,4 +14,8 @@ depot.nix.buildLisp.library {
./message.lisp
./client.lisp
];
brokenOn = [
"ecl" # dynamic cffi
];
}

View file

@ -105,7 +105,8 @@ separated by SEP."
"Attempt to parse STR as an integer, returning nil if it is invalid."
(check-type str string)
(handler-case (parse-integer str)
(sb-int:simple-parse-error (_) (declare (ignore _)) nil)))
(#+sbcl sb-int:simple-parse-error
#-sbcl parse-error (_) (declare (ignore _)) nil)))
;;;
;;; Function utilities

View file

@ -8,7 +8,7 @@
let
inherit (builtins) map elemAt match filter;
inherit (pkgs) lib runCommandNoCC makeWrapper writeText writeShellScriptBin sbcl;
inherit (pkgs) lib runCommandNoCC makeWrapper writeText writeShellScriptBin sbcl ecl-static;
#
# Internal helper definitions
@ -16,6 +16,19 @@ let
defaultImplementation = "sbcl";
# Many Common Lisp implementations (like ECL and CCL) will occasionally drop
# you into an interactive debugger even when executing something as a script.
# In nix builds we don't want such a situation: Any error should make the
# script exit non-zero. Luckily the ANSI standard specifies *debugger-hook*
# which is invoked before the debugger letting us just do that.
disableDebugger = writeText "disable-debugger.lisp" ''
(setf *debugger-hook*
(lambda (error hook)
(declare (ignore hook))
(format *error-output* "~%Unhandled error: ~a~%" error)
#+ecl (ext:quit 1)))
'';
# Process a list of arbitrary values which also contains “implementation
# filter sets” which describe conditonal inclusion of elements depending
# on the CL implementation used. Elements are processed in the following
@ -199,6 +212,9 @@ let
# executable which runs 'main' (and exits) where 'main' is available from
# 'deps'. The executable should be created as "$out/bin/${name}", usually
# by dumping the lisp image with the replaced toplevel function replaced.
# - wrapProgram :: boolean
# Whether to wrap the resulting binary / image with a wrapper script setting
# `LD_LIBRARY_PATH`.
# - genTestLisp :: { name, srcs, deps, expression } -> file
# Builds a lisp file which loads the given 'deps' and 'srcs' files and
# then evaluates 'expression'. Depending on whether 'expression' returns
@ -291,6 +307,8 @@ let
:purify t))
'';
wrapProgram = true;
genTestLisp = genTestLispGeneric impls.sbcl;
lispWith = deps:
@ -304,6 +322,141 @@ let
} $@
'';
};
ecl = {
runScript = "${ecl-static}/bin/ecl --load ${disableDebugger} --shell";
faslExt = "fasc";
genLoadLisp = genLoadLispGeneric impls.ecl;
genCompileLisp = { name, srcs, deps }: writeText "ecl-compile.lisp" ''
;; This seems to be required to bring make the 'c' package available
;; early, otherwise ECL tends to fail with a read failure
(ext:install-c-compiler)
;; Load dependencies
${impls.ecl.genLoadLisp deps}
(defun getenv-or-fail (var)
(or (ext:getenv var)
(error (format nil "Missing expected environment variable ~A" var))))
(defun nix-compile-file (srcfile &key native)
"Compile the given srcfile into a compilation unit in :out-dir using
a unique name based on srcfile as the filename which is returned after
compilation. If :native is true, create an native object file,
otherwise a byte-compile fasc file is built and immediately loaded."
(let* ((unique-name (substitute #\_ #\/ srcfile))
(out-file (make-pathname :type (if native "o" "fasc")
:directory (getenv-or-fail "NIX_BUILD_TOP")
:name unique-name)))
(multiple-value-bind (out-truename _warnings-p failure-p)
(compile-file srcfile :system-p native
:load (not native)
:output-file out-file
:verbose t :print t)
(if failure-p (ext:quit 1) out-truename))))
(let* ((out-dir (getenv-or-fail "out"))
(nix-build-dir (getenv-or-fail "NIX_BUILD_TOP"))
(srcs
;; These forms are inserted by the Nix build
'(${lib.concatMapStringsSep "\n" (src: "\"${src}\"") srcs})))
;; First, we'll byte compile loadable FASL files and load them
;; immediately. Since we are using a statically linked ECL, there's
;; no way to load native objects, so we rely on byte compilation
;; for all our loading which is crucial in compilation of course.
(ext:install-bytecodes-compiler)
;; ECL's bytecode FASLs can just be concatenated to create a bundle
;; at least since a recent bugfix which we apply as a patch.
;; See also: https://gitlab.com/embeddable-common-lisp/ecl/-/issues/649
(let ((bundle-out (make-pathname :type "fasc" :name "${name}"
:directory out-dir)))
(with-open-file (fasc-stream bundle-out :direction :output)
(ext:run-program "cat"
(mapcar (lambda (f)
(namestring
(nix-compile-file f :native nil)))
srcs)
:output fasc-stream)))
(ext:install-c-compiler)
;; Build a (natively compiled) static archive (.a) file. We want to
;; use this for (statically) linking an executable later. The bytecode
;; dance is only required because we can't load such archives.
(c:build-static-library
(make-pathname :type "a" :name "${name}" :directory out-dir)
:lisp-files (mapcar (lambda (x)
(nix-compile-file x :native t))
srcs)))
'';
genDumpLisp = { name, main, deps }: writeText "ecl-dump.lisp" ''
(defun getenv-or-fail (var)
(or (ext:getenv var)
(error (format nil "Missing expected environment variable ~A" var))))
${impls.ecl.genLoadLisp deps}
;; makes a 'c' package available that can link executables
(ext:install-c-compiler)
(c:build-program
(make-pathname :name "${name}"
:directory (concatenate 'string
(getenv-or-fail "out")
"/bin"))
:epilogue-code `(progn
;; UIOP doesn't understand ECL, so we need to make it
;; aware that we are a proper executable, causing it
;; to handle argument parsing and such properly. Since
;; this needs to work even when we're not using UIOP,
;; we need to do some compile-time acrobatics.
,(when (find-package 'uiop)
`(setf ,(find-symbol "*IMAGE-DUMPED-P*" :uiop) :executable))
;; Run the actual application
(${main})
;; and exit.
(ext:quit))
;; ECL can't remember these from its own build
:ld-flags '("-static")
:lisp-files
;; The following forms are inserted by the Nix build
'(${
lib.concatMapStrings (dep: ''
"${dep}/${dep.lispName}.a"
'') (allDeps impls.ecl deps)
}))
'';
wrapProgram = false;
genTestLisp = genTestLispGeneric impls.ecl;
lispWith = deps:
let lispDeps = filter (d: !d.lispBinary) (allDeps impls.ecl deps);
in writeShellScriptBin "ecl" ''
exec ${ecl-static}/bin/ecl ${
lib.optionalString (deps != [])
"--load ${writeText "load.lisp" (impls.ecl.genLoadLisp lispDeps)}"
} $@
'';
bundled = name: runCommandNoCC "${name}-cllib" {
passthru = {
lispName = name;
lispNativeDeps = [];
lispDeps = [];
lispBinary = false;
repl = impls.ecl.lispWith [ (impls.ecl.bundled name) ];
};
} ''
mkdir -p "$out"
ln -s "${ecl-static}/lib/ecl-${ecl-static.version}/${name}.${impls.ecl.faslExt}" -t "$out"
ln -s "${ecl-static}/lib/ecl-${ecl-static.version}/lib${name}.a" "$out/${name}.a"
'';
};
};
#
@ -412,7 +565,7 @@ let
lispBinary = true;
tests = testDrv;
};
} ''
} (''
${if ! isNull testDrv
then "echo 'Test ${testDrv} succeeded'"
else ""}
@ -424,9 +577,9 @@ let
deps = ([ selfLib ] ++ lispDeps);
}
}
'' + lib.optionalString impl.wrapProgram ''
wrapProgram $out/bin/${name} --prefix LD_LIBRARY_PATH : "${libPath}"
'');
''));
# 'bundled' creates a "library" which makes a built-in package available,
# such as any of SBCL's sb-* packages or ASDF. By default this is done

View file

@ -2,18 +2,25 @@
# in Common Lisp simple.
{ depot, ... }:
let src = builtins.fetchGit {
url = "https://github.com/sionescu/bordeaux-threads.git";
rev = "499b6d3f0ce635417d6096acf0a671d8bf3f6e5f";
};
let
src = builtins.fetchGit {
url = "https://github.com/sionescu/bordeaux-threads.git";
rev = "499b6d3f0ce635417d6096acf0a671d8bf3f6e5f";
};
getSrc = f: "${src}/src/${f}";
in depot.nix.buildLisp.library {
name = "bordeaux-threads";
deps = [ depot.third_party.lisp.alexandria ];
srcs = map (f: src + ("/src/" + f)) [
srcs = map getSrc [
"pkgdcl.lisp"
"bordeaux-threads.lisp"
"impl-sbcl.lisp"
] ++ [
{
sbcl = getSrc "impl-sbcl.lisp";
ecl = getSrc "impl-ecl.lisp";
}
] ++ map getSrc [
"default-implementations.lisp"
];
}

View file

@ -13,11 +13,14 @@ in buildLisp.library {
babel
trivial-features
(buildLisp.bundled "asdf")
(buildLisp.bundled "uiop")
];
srcs = map (f: src + ("/src/" + f)) [
"cffi-sbcl.lisp"
srcs = [
{
ecl = src + "/src/cffi-ecl.lisp";
sbcl = src + "/src/cffi-sbcl.lisp";
}
] ++ map (f: src + ("/src/" + f)) [
"package.lisp"
"utils.lisp"
"libraries.lisp"

View file

@ -15,7 +15,9 @@ in buildLisp.library {
deps = with depot.third_party.lisp; [
alexandria
bordeaux-threads
(buildLisp.bundled "sb-posix")
{
sbcl = buildLisp.bundled "sb-posix";
}
];
srcs = map (f: src + ("/" + f)) [

View file

@ -37,4 +37,8 @@ in buildLisp.library {
"context.lisp"
"verify-hostname.lisp"
];
brokenOn = [
"ecl" # dynamic cffi
];
}

View file

@ -25,4 +25,8 @@ in depot.nix.buildLisp.library {
"cl-smtp.lisp"
"mime-types.lisp"
];
brokenOn = [
"ecl" # dynamic cffi
];
}

View file

@ -29,7 +29,10 @@ let
deps = with depot.third_party.lisp; [
cl-unicode-base
flexi-streams
(bundled "uiop")
{
ecl = bundled "asdf";
default = bundled "uiop";
}
];
srcs = (map (f: src + ("/build/" + f)) [

View file

@ -15,6 +15,9 @@ in depot.nix.buildLisp.library {
srcs = [
"${src}/closer-mop-packages.lisp"
"${src}/closer-mop-shared.lisp"
"${src}/closer-sbcl.lisp"
{
sbcl = "${src}/closer-sbcl.lisp";
ecl = "${src}/closer-ecl.lisp";
}
];
}

View file

@ -32,4 +32,8 @@ in depot.nix.buildLisp.library {
"encoding.lisp"
"request.lisp"
];
brokenOn = [
"ecl" # dynamic cffi
];
}

View file

@ -23,4 +23,7 @@ in depot.nix.buildLisp.library {
"routes-map-printer.lisp"
];
brokenOn = [
"ecl" # dynamic cffi
];
}

View file

@ -58,4 +58,8 @@ in depot.nix.buildLisp.library {
"acceptor.lisp"
"easy-handlers.lisp"
];
brokenOn = [
"ecl" # dynamic cffi
];
}

View file

@ -10,33 +10,40 @@ let
sha256 = "0k4bib9mbrzalbl9ivkw4a7g4c7bbad1l5jw4pzkifqszy2swkr5";
};
getSrc = f: "${src}/src/${f}";
in depot.nix.buildLisp.library {
name = "ironclad";
deps = with depot.third_party.lisp; [
(bundled "asdf")
(bundled "sb-rotate-byte")
(bundled "sb-posix")
{ sbcl = bundled "sb-rotate-byte"; }
{ sbcl = bundled "sb-posix"; }
alexandria
bordeaux-threads
nibbles
];
srcs = [
"${src}/ironclad.asd"
# TODO(grfn): Figure out how to get this compiling with the assembly
# optimization eventually - see https://cl.tvl.fyi/c/depot/+/1333
(runCommand "package.lisp" {} ''
substitute ${src}/src/package.lisp $out \
--replace \#-ecl-bytecmp "" \
--replace '(pushnew :ironclad-assembly *features*)' ""
'')
] ++ (map (f: src + ("/src/" + f)) [
{
# TODO(grfn): Figure out how to get this compiling with the assembly
# optimization eventually - see https://cl.tvl.fyi/c/depot/+/1333
sbcl = runCommand "package.lisp" {} ''
substitute ${src}/src/package.lisp $out \
--replace \#-ecl-bytecmp "" \
--replace '(pushnew :ironclad-assembly *features*)' ""
'';
default = getSrc "package.lisp";
}
] ++ map getSrc [
"macro-utils.lisp"
] ++ [
{ sbcl = getSrc "opt/sbcl/fndb.lisp"; }
{ sbcl = getSrc "opt/sbcl/cpu-features.lisp"; }
{ sbcl = getSrc "opt/sbcl/x86oid-vm.lisp"; }
"opt/sbcl/fndb.lisp"
"opt/sbcl/cpu-features.lisp"
"opt/sbcl/x86oid-vm.lisp"
{ ecl = getSrc "opt/ecl/c-functions.lisp"; }
] ++ map getSrc [
"common.lisp"
"conditions.lisp"
@ -142,5 +149,5 @@ in depot.nix.buildLisp.library {
"public-key/elgamal.lisp"
"public-key/pkcs1.lisp"
"public-key/rsa.lisp"
]);
];
}

View file

@ -28,4 +28,8 @@ in depot.nix.buildLisp.library {
"binary-2.lisp"
"types.lisp"
];
brokenOn = [
"ecl" # dynamic cffi
];
}

View file

@ -11,6 +11,11 @@ let src = pkgs.fetchFromGitHub {
};
in buildLisp.library {
name = "md5";
deps = [ (buildLisp.bundled "sb-rotate-byte") ];
deps = [
{
sbcl = buildLisp.bundled "sb-rotate-byte";
default = depot.third_party.lisp.flexi-streams;
}
];
srcs = [ (src + "/md5.lisp") ];
}

View file

@ -11,4 +11,8 @@ in depot.nix.buildLisp.library {
name = "moptilities";
deps = [ depot.third_party.lisp.closer-mop ];
srcs = [ "${src}/dev/moptilities.lisp" ];
brokenOn = [
"ecl" # TODO(sterni): https://gitlab.com/embeddable-common-lisp/ecl/-/issues/651
];
}

View file

@ -24,9 +24,10 @@ in depot.nix.buildLisp.library {
"types.lisp"
"vectors.lisp"
"streams.lisp"
"sbcl-opt/fndb.lisp"
"sbcl-opt/nib-tran.lisp"
"sbcl-opt/x86-vm.lisp"
"sbcl-opt/x86-64-vm.lisp"
] ++ [
{ sbcl = "${src}/sbcl-opt/fndb.lisp"; }
{ sbcl = "${src}/sbcl-opt/nib-tran.lisp"; }
{ sbcl = "${src}/sbcl-opt/x86-vm.lisp"; }
{ sbcl = "${src}/sbcl-opt/x86-64-vm.lisp"; }
];
}

View file

@ -83,6 +83,10 @@ let
"table.lisp"
"deftable.lisp"
]);
brokenOn = [
"ecl" # TODO(sterni): https://gitlab.com/embeddable-common-lisp/ecl/-/issues/651
];
};
in postmodern // {

View file

@ -35,4 +35,7 @@ in depot.nix.buildLisp.library {
"policy.lisp"
];
brokenOn = [
"ecl" # dynamic cffi
];
}

View file

@ -7,6 +7,9 @@ let src = builtins.fetchGit {
in depot.nix.buildLisp.library {
name = "trivial-features";
srcs = [
(src + "/src/tf-sbcl.lisp")
{
sbcl = src + "/src/tf-sbcl.lisp";
ecl = src + "/src/tf-ecl.lisp";
}
];
}

View file

@ -19,4 +19,8 @@ in depot.nix.buildLisp.library {
"package.lisp"
"trivial-ldap.lisp"
];
brokenOn = [
"ecl" # dynamic cffi
];
}

View file

@ -10,14 +10,20 @@ let
mime-types = pkgs.runCommand "mime-types.lisp" {} ''
substitute ${src}/mime-types.lisp $out \
--replace /etc/mime.types ${src}/mime.types
--replace /etc/mime.types ${src}/mime.types \
--replace "(asdf:system-source-directory :trivial-mimes)" '"/bogus-dir"'
# We want to prevent an ASDF lookup at build time since this will
# generally fail — we are not using ASDF after all.
'';
in depot.nix.buildLisp.library {
name = "trivial-mimes";
deps = [
(depot.nix.buildLisp.bundled "uiop")
{
sbcl = depot.nix.buildLisp.bundled "uiop";
default = depot.nix.buildLisp.bundled "asdf";
}
];
srcs = [ mime-types ];

View file

@ -19,7 +19,6 @@ in depot.nix.buildLisp.library {
deps = with depot.third_party.lisp; [
split-sequence
cl-ppcre
(bundled "uiop")
(bundled "asdf")
];

View file

@ -33,6 +33,12 @@ in buildLisp.library {
"package.lisp"
"usocket.lisp"
"condition.lisp"
"backend/sbcl.lisp"
] ++ [
{ sbcl = "${src}/backend/sbcl.lisp"; }
# ECL actually has two files, it supports the SBCL backend,
# but usocket also has some ECL specific code
{ ecl = "${src}/backend/sbcl.lisp"; }
{ ecl = "${src}/backend/ecl.lisp"; }
]);
}

View file

@ -66,5 +66,6 @@ in import nixpkgsSrc {
depot.third_party.overlays.tvl
depot.third_party.overlays.haskell
depot.third_party.overlays.emacs
depot.third_party.overlays.ecl-static
];
}

41
third_party/overlays/ecl-static.nix vendored Normal file
View file

@ -0,0 +1,41 @@
{ ... }:
self: super:
{
# Statically linked ECL with statically linked dependencies.
# Works quite well, but solving this properly in a nixpkgs
# context will require figuring out cross compilation (for
# pkgsStatic), so we're gonna use this override for now.
#
# Note that ecl-static does mean that we have things
# statically linked against GMP and ECL which are LGPL.
# I believe this should be alright: The way ppl are gonna
# interact with the distributed binaries (i. e. the binary
# cache) is Nix in the depot monorepo, so the separability
# requirement should be satisfied: Source code or overriding
# would be available as ways to swap out the used GMP in the
# program.
# See https://www.gnu.org/licenses/gpl-faq.en.html#LGPLStaticVsDynamic
ecl-static = (super.pkgsMusl.ecl.override {
inherit (self.pkgsStatic) gmp libffi boehmgc;
}).overrideAttrs (drv: {
# Patches that make .fasc files concatenable again
patches = drv.patches ++ [
(self.fetchpatch {
name = "make-bytecode-fasl-concatenatable-1.patch";
url = "https://gitlab.com/embeddable-common-lisp/ecl/-/commit/fbb75a0fc524e3280d89d8abf3be2ee9924955c8.patch";
sha256 = "0k6cx1bh835rl0j0wbbi5nj0aa2rwbyfyz5q2jw643iqc62l16kv";
})
(self.fetchpatch {
name = "make-bytecode-fasl-concatenatable-2.patch";
url = "https://gitlab.com/embeddable-common-lisp/ecl/-/commit/a8b1c0da43f89800d09c23a27832d0b4c9dcc1e8.patch";
sha256 = "18hl79lss0dxglpa34hszqb6ajvs8rs4b4g1qlrqrvgh1gs667n0";
})
];
configureFlags = drv.configureFlags ++ [
"--disable-shared"
"--with-dffi=no" # will fail at runtime anyways if statically linked
];
});
}

View file

@ -23,7 +23,10 @@ let
name = "clhs-lookup";
deps = [
(buildLisp.bundled "uiop")
{
default = buildLisp.bundled "asdf";
sbcl = buildLisp.bundled "uiop";
}
];
srcs = [

View file

@ -47,4 +47,8 @@ depot.nix.buildLisp.program {
expression = "(fiveam:run!)";
};
brokenOn = [
"ecl" # dependencies use dynamic cffi
];
}