diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000000..885642638e4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,55 @@ +#************************************************************************** +#* * +#* OCaml * +#* Derived from the work of: * +#* Damien Doligez, projet Gallium, INRIA * +#* * +#* Copyright 2015 Institut National de Recherche en Informatique et * +#* en Automatique. * +#* * +#* All rights reserved. This file is distributed under the terms of * +#* the GNU Lesser General Public License version 2.1, with the * +#* special exception on linking described in the file LICENSE. * +#* * +#************************************************************************** + +*.o +*.a +*.so +*.obj +*.lib +*.dll +*.la +*.cm[ioxat] +*.cmx[as] +*.cmti +*.annot +*.exe +*.exe.manifest +.DS_Store +*.out +*.out.dSYM +*.swp +_ocamltest +_ocamltestd +*.odoc +.merlin + +_build/ +_build0/ +_build1/ +_build2/ +.rsync-output +.rsync-output-compare +_compare/ +_runtest/ +_stage2_configure/ +autom4te.cache + +Makefile +config.log +config.status +configure +configure_opts +ocaml-stage1-config.status +ocaml-stage2-config.status diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 00000000000..6982237e9f0 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,23 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "Build & install Flambda backend", + "type": "shell", + "command": "opam exec --switch=4.11.1 make install", + "group": "build", + "problemMatcher": [ + "$ocamlc" + ] + } + + { + "type": "dune", + "problemMatcher": [ + "$ocamlc" + ], + "group": "build", + "label": "dune: build /dune" + } + ] +} diff --git a/Makefile.in b/Makefile.in new file mode 100644 index 00000000000..379a7c1b8b5 --- /dev/null +++ b/Makefile.in @@ -0,0 +1,388 @@ +#************************************************************************** +#* * +#* The Flambda backend project for OCaml * +#* * +#* Copyright 2020--2021 Jane Street Group LLC * +#* * +#************************************************************************** + +# CR mshinwell: Find out how to get something like "set -eu" in effect. +prefix=@prefix@ +stage0_prefix=@stage0_prefix@ +stage1_prefix=@stage1_prefix@ +stage2_prefix=@stage2_prefix@ +middle_end=@middle_end@ +dune=@dune@ + +# The Flambda backend compiler build proceeds, from cold, in three stages. +# We call these (in order) stage0, stage1 and stage2. They are documented +# below. + +.DEFAULT_GOAL := stage2 + +# Building stage0 is the same as an upstream compiler build with make. This is +# done in an rsynced tree to avoid polluting the ocaml/ subdirectory (see +# below for more details). We need to make sure the separate tree is in +# sync with the ocaml/ directory first, in case files were added or removed. +# +# We use the -i option to rsync in order to short-circuit a null build with +# make, since it seems faster. +# +# CR-someday mshinwell: We should replace this with a coldstart using dune. +.PHONY: stage0 +stage0: _build0/config.status + rm -f .rsync-output + rsync -i -a --filter=':- $$(pwd)/ocaml/.gitignore' \ + $$(pwd)/ocaml/ $$(pwd)/_build0 \ + | grep -v '/$$' \ + | tee .rsync-output + if [ -s .rsync-output ] || ! [ -d @stage0_prefix@ ]; then \ + (cd _build0 && \ + $(MAKE) world.opt && \ + $(MAKE) ocamlnat && \ + $(MAKE) install); \ + fi + +# stage1 builds the Flambda backend compiler using the stage0 compiler. +# +# At the end, we have a working Flambda backend compiler, equivalent to having +# done "make ocamlopt" upstream. For testing with a broken middle or backend, +# e.g. if the stdlib doesn't compile, you can stop here and run +# _build1/default/flambda_backend_main.exe. +# +# At this point we don't yet have a standard library and a set of otherlibs +# whose .cmx files are compatible with this new compiler. Neither are the +# Flambda backend compiler, or the compilerlibs that form it, built with the +# Flambda backend compiler itself. These steps comprise stage2. +# +# This code should use build contexts instead of --build-dir. +.PHONY: stage1 +stage1: ocaml-stage1-config.status stage0 \ + ocaml/otherlibs/dynlink/natdynlinkops2 + cp ocaml-stage1-config.status ocaml/config.status + (cd ocaml && ./config.status) + PATH=$(stage0_prefix)/bin:$$PATH \ + $(dune) build --profile=release --build-dir=_build1 @install + (cd _build1/install/default/bin && \ + rm -f ocamllex && \ + ln -s ocamllex.opt ocamllex) + +# CR mshinwell: We should add targets that don't use --profile=release, for +# speed, and also ensuring that warnings are errors. We should also consider +# adding a new Dune profile that is like "release" but has warnings as errors. + +# stage2 rebuilds the whole compiler system with the Flambda backend compiler +# itself, including the stdlib, otherlibs, compilerlibs, etc. The result is +# equivalent to having done "make world.opt && make ocamlnat" upstream. +.PHONY: stage2 +stage2: ocaml-stage2-config.status stage1 + cp ocaml-stage2-config.status ocaml/config.status + (cd ocaml && ./config.status) + PATH=$(stage1_prefix)/bin:$$PATH \ + $(dune) build --profile=release --build-dir=_build2 @install + +# This target is like a polling version of upstream "make ocamlopt" (based +# on the stage1 target, above). +# It is likely to be what's most often wanted for day-to-day development of +# features, especially large ones that take a long time to get to compile, +# in the middle end and backend. +.PHONY: hacking +hacking: ocaml-stage1-config.status stage0 \ + ocaml/otherlibs/dynlink/natdynlinkops2 + cp ocaml-stage1-config.status ocaml/config.status + (cd ocaml && ./config.status) + PATH=$(stage0_prefix)/bin:$$PATH \ + $(dune) build -w --profile=release --build-dir=_build1 @install + +# The stage0 configure step configures the tree to build pretty much the +# bare minimum that we need for building stage1. +# Currently the middle end for stage0 will match the selected middle end +# for the Flambda backend compiler. +_build0/config.status: ocaml/configure.ac + rm -rf _build0 + mkdir _build0 + rsync -a $$(pwd)/ocaml/ $$(pwd)/_build0 + (cd _build0 && \ + cat ../configure_opts | xargs -0 ./configure -C \ + --prefix=@stage0_prefix@ \ + --disable-ocamldoc \ + --disable-ocamltest \ + --disable-debug-runtime \ + --disable-instrumented-runtime \ + --disable-debugger) + +# stage1 has already been configured by running the configure script. +# It is configured according to any options requested by the user, including +# selection of the middle end, but the prefix is set to a temporary build +# directory. + +# This configures stage2 to have the same configure options as stage1 +# except that the prefix is set to the ultimate installation directory. +# We save the config.status file (which is executable) for fast reconfiguration +# of the ocaml/ subdirectory during the dune builds for stage1 and stage2. +# The stage2 configure can be run by make in parallel with that for stage0. +# We add --enable-ocamltest so that the config.status generated here can be +# immediately reused for the "compare" target (see below). +ocaml-stage2-config.status: ocaml/configure.ac + rm -rf _stage2_configure + mkdir _stage2_configure + rsync -a --filter=':- $$(pwd)/ocaml/.gitignore' \ + $$(pwd)/ocaml/ $$(pwd)/_stage2_configure + (cd _stage2_configure && \ + cat ../configure_opts | xargs -0 ./configure -C \ + --prefix=$(prefix) \ + --enable-ocamltest \ + --disable-ocamldoc && \ + cp config.status ../ocaml-stage2-config.status) + +# We need to augment dune's substitutions so this part isn't so +# difficult. We use /bin/echo to avoid builtin variants of "echo" +# which don't accept "-n". Unfortunately if there are no +# NATDYNLINKOPS, we need to provide a harmless option, otherwise dune +# will provide '' on the command line to ocamlopt which causes an +# error. +# CR mshinwell: This should be moved into the upstream dune build system. +ocaml/otherlibs/dynlink/natdynlinkops2: ocaml-stage1-config.status + cp ocaml-stage1-config.status ocaml/config.status + (cd ocaml && ./config.status) + cat ocaml/Makefile.config \ + | sed 's/^NATDYNLINKOPTS=$$/NATDYNLINKOPTS=-g/' \ + | grep '^NATDYNLINKOPTS=' \ + | sed 's/^[^=]*=\(.*\)/-ccopt\n"\1"/' \ + > ocaml/otherlibs/dynlink/natdynlinkops + /bin/echo -n $$(cat ocaml/Makefile.config \ + | sed 's/^NATDYNLINKOPTS=$$/NATDYNLINKOPTS=-bin-annot/' \ + | grep '^NATDYNLINKOPTS=' \ + | sed 's/^[^=]*=\(.*\)/\1/') \ + > ocaml/otherlibs/dynlink/natdynlinkops2 + if [ "$$(cat ocaml/otherlibs/dynlink/natdynlinkops2)" \ + != "-bin-annot" ]; \ + then \ + /bin/echo -n "-ccopt" > ocaml/otherlibs/dynlink/natdynlinkops1; \ + else \ + /bin/echo -n "-bin-annot" > ocaml/otherlibs/dynlink/natdynlinkops1; \ + fi + +# Most of the installation tree is correctly set up by dune, but we need to +# copy it to the final destination, and rearrange a few things to match +# upstream. +.PHONY: install +install: stage2 + mkdir -p $(prefix) + rsync --copy-links -r $(stage2_prefix)/bin $(prefix) + rsync --copy-links -r $(stage2_prefix)/lib $(prefix) + rm -f $(prefix)/bin/ocamllex + ln -s $(prefix)/bin/ocamllex.opt $(prefix)/bin/ocamllex + rm -f $(prefix)/bin/flambda_backend.main* + rm -rf $(prefix)/lib/ocaml-variants + rm -rf $(prefix)/lib/stublibs + rm -f $(prefix)/lib/ocaml/META + rm -f $(prefix)/lib/ocaml/dune-package + rm -f $(prefix)/lib/ocaml/compiler-libs/*.cmo + rm -rf $(prefix)/lib/flambda_backend + for file in topdirs opttopdirs; do \ + for ext in cmi mli cmt cmti; do \ + cp -f $(prefix)/lib/ocaml/compiler-libs/$${file}.$$ext \ + $(prefix)/lib/ocaml; \ + done; \ + done + +# This target only runs the dune-based tests, not the upstream testsuite. +# stage2 needs to have been built first. +.PHONY: runtest +runtest: + # It's a shame that dune needs the stage1 compiler on the path here. + # Ideally that would be inaccessible within tests (to prevent mistakes + # such as running "ocamlopt" rather than one of the stage2 binaries). + PATH=$(stage1_prefix)/bin:$$PATH \ + $(dune) runtest --profile=release --build-dir=_build2 + +# The following horror will be removed when work to allow the testsuite to +# run on an installed tree (led by David Allsopp) is completed. +# stage2 needs to have been built first. +.PHONY: runtest-upstream +runtest-upstream: + rm -rf _runtest + mkdir _runtest + cp -a ocaml/testsuite _runtest/testsuite + (cd _runtest && ln -s ../ocaml/Makefile.tools Makefile.tools) + (cd _runtest && ln -s ../ocaml/Makefile.build_config Makefile.build_config) + (cd _runtest && ln -s ../ocaml/Makefile.config_if_required Makefile.config_if_required) + (cd _runtest && ln -s ../ocaml/Makefile.config Makefile.config) + cp _build2/install/default/bin/* _runtest/ + # There seems to be an assumption that ocamlc/ocamlopt/ocamllex are + # bytecode... + cp -f _build2/install/default/bin/ocamlc.byte _runtest/ocamlc + cp -f _build2/install/default/bin/ocamlopt.byte _runtest/ocamlopt + mkdir _runtest/lex + mv _runtest/ocamllex.byte _runtest/lex/ocamllex + mkdir _runtest/yacc + mv _runtest/ocamlyacc _runtest/yacc/ + (cd _runtest && ln -s ../_build2/default/ocaml/runtime runtime) + (cd _runtest && ln -s ../_build2/install/default/lib/ocaml stdlib) + # compilerlibs + mkdir _runtest/compilerlibs + cp _build2/install/default/lib/ocaml/compiler-libs/*.cma \ + _runtest/compilerlibs + cp _build2/install/default/lib/ocaml/compiler-libs/*.a \ + _runtest/compilerlibs + cp _build2/install/default/lib/ocaml/compiler-libs/*.cmxa \ + _runtest/compilerlibs + mkdir _runtest/toplevel + cp _build2/default/ocaml/toplevel/.ocamltoplevel.objs/byte/*.cm* \ + _runtest/toplevel/ + # Various directories are put on the -I paths by tools/Makefile; + # utils/ is one such, so we just dump the .cm* files in there for + # various things. + mkdir _runtest/utils + cp _build2/install/default/lib/ocaml/compiler-libs/*.cmi \ + _runtest/utils + cp _build2/install/default/lib/ocaml/compiler-libs/*.cmo \ + _runtest/utils + cp _build2/install/default/lib/ocaml/compiler-libs/*.cmx \ + _runtest/utils + cp _build2/install/default/lib/ocaml/*.cmi _runtest/utils + cp _build2/install/default/lib/ocaml/*.cma _runtest/utils + cp _build2/install/default/lib/ocaml/*.a _runtest/utils + cp _build2/install/default/lib/ocaml/*.cmxa _runtest/utils + cp _build2/default/ocaml/.ocamlcommon.objs/native/config.o \ + _runtest/utils + # Needed for tests/warnings + cp ocaml/utils/warnings.ml _runtest/utils + # Suppress linker errors about -I directories not existing. + for dir in asmcomp bytecomp driver file_formats lambda middle_end \ + parsing typing; do ln -s utils _runtest/$$dir; done + # dynlink + mkdir -p _runtest/otherlibs/dynlink + cp _build2/install/default/lib/ocaml/dynlink* \ + _runtest/otherlibs/dynlink + # str + mkdir -p _runtest/otherlibs/str + cp _build2/install/default/lib/ocaml/stublibs/dllstr_stubs.so \ + _runtest/otherlibs/str + cp _build2/install/default/lib/ocaml/str*.cmi \ + _runtest/otherlibs/str + cp _build2/install/default/lib/ocaml/libstr*.a \ + _runtest/otherlibs/str + cp _build2/install/default/lib/ocaml/str*.cma \ + _runtest/otherlibs/str + cp _build2/install/default/lib/ocaml/str*.cmxa \ + _runtest/otherlibs/str + cp _build2/install/default/lib/ocaml/str*.a \ + _runtest/otherlibs/str + cp _build2/install/default/lib/ocaml/str*.cmx \ + _runtest/otherlibs/str + # unix + mkdir -p _runtest/otherlibs/unix + cp _build2/install/default/lib/ocaml/stublibs/dllunix_stubs.so \ + _runtest/otherlibs/unix + cp _build2/install/default/lib/ocaml/unix*.cmi \ + _runtest/otherlibs/unix + cp _build2/install/default/lib/ocaml/libunix*.a \ + _runtest/otherlibs/unix + cp _build2/install/default/lib/ocaml/unix*.cma \ + _runtest/otherlibs/unix + cp _build2/install/default/lib/ocaml/unix*.cmxa \ + _runtest/otherlibs/unix + cp _build2/install/default/lib/ocaml/unix*.a \ + _runtest/otherlibs/unix + cp _build2/install/default/lib/ocaml/unix*.cmx \ + _runtest/otherlibs/unix + # systhreads + mkdir -p _runtest/otherlibs/systhreads + cp _build2/install/default/lib/ocaml/stublibs/dllthreads_stubs.so \ + _runtest/otherlibs/systhreads + cp _build2/install/default/lib/ocaml/threads/*.cmi \ + _runtest/otherlibs/systhreads + cp _build2/install/default/lib/ocaml/threads/*.cma \ + _runtest/otherlibs/systhreads + cp _build2/install/default/lib/ocaml/threads/*.a \ + _runtest/otherlibs/systhreads + cp _build2/install/default/lib/ocaml/threads/*.cmxa \ + _runtest/otherlibs/systhreads + cp _build2/install/default/lib/ocaml/threads/*.cmx \ + _runtest/otherlibs/systhreads + # ocamldebug + mkdir _runtest/debugger + mv _runtest/ocamldebug _runtest/debugger + cp _build2/default/ocaml/debugger/.main.eobjs/byte/*.cm* \ + _runtest/debugger + # The ast_invariants test needs VERSION to be present. In fact ideally + # we should have all the source files in _runtest too for this test, + # but for the moment we accept it being a weaker check. We're not + # working on parts of the compiler that deal with the AST anyway in + # this repo. + touch _runtest/VERSION + # tools + mkdir _runtest/tools + cp _build2/default/ocaml/tools/ocamlmklib_byte.bc \ + _runtest/tools/ocamlmklib + cp _build2/default/ocaml/tools/ocamlobjinfo_byte.bc \ + _runtest/tools/ocamlobjinfo + # ocamltest itself + mkdir _runtest/ocamltest + # This is deliberately run with the stage0 compiler in case the new + # one is broken. As such, we use the stage1 build dir, not that from + # stage2. + # This might be causing a spurious rebuild of the runtime + PATH=$(stage0_prefix)/bin:$$PATH \ + $(dune) build --profile=release --build-dir=_build1 \ + ocaml/tools/cmpbyt.bc + PATH=$(stage0_prefix)/bin:$$PATH \ + $(dune) build --profile=release --build-dir=_build1 \ + ocaml/ocamltest/ocamltest.byte + cp _build1/default/ocaml/tools/cmpbyt.bc _runtest/tools/cmpbyt + # We should build the native ocamltest too. + cp _build1/default/ocaml/ocamltest/ocamltest.byte \ + _runtest/ocamltest/ocamltest + (export OCAMLSRCDIR=$$(pwd)/_runtest; cd _runtest/testsuite \ + && if $$(which parallel > /dev/null 2>&1); \ + then make parallel; \ + else make all; \ + fi) + +# Compare the Flambda backend installation tree against the upstream one. +# "make install" needs to have been done first. +# +# We can't use the stage0 installation directory to compare against because +# it won't have been configured with the correct options. Instead we build +# a fresh upstream compiler using the same configure options as the user +# originally specified when they configured the Flambda backend tree. +.PHONY: compare +compare: _compare/config.status + rm -f .rsync-output-compare + rsync -i -a --filter=':- $$(pwd)/ocaml/.gitignore' \ + $$(pwd)/ocaml/ $$(pwd)/_compare \ + | grep -v '/$$' \ + | tee .rsync-output-compare + if [ -s .rsync-output-compare ] || ! [ -d _compare/_install ]; then \ + (cd _compare && \ + $(MAKE) world.opt && \ + $(MAKE) ocamlnat && \ + $(MAKE) install); \ + fi + ./scripts/compare.sh $$(pwd)/_compare/_install $(prefix) \ + @stage0_prefix@/bin/ocamlobjinfo.opt + +# CR mshinwell: Why does the ocamltest build complain about +# Ocaml_directories being missing? +_compare/config.status: ocaml/configure.ac + rm -rf _compare + mkdir _compare + rsync -a --filter=':- $$(pwd)/ocaml/.gitignore' \ + $$(pwd)/ocaml/ $$(pwd)/_compare + (cd _compare && \ + cat ../configure_opts | xargs -0 ./configure -C \ + --prefix=$$(pwd)/_install \ + --disable-stdlib-manpages \ + --disable-ocamltest \ + --disable-ocamldoc) + +# For Github Actions checks +.PHONY: ci +ci: + $(MAKE) stage2 + $(MAKE) install + $(MAKE) runtest + $(MAKE) runtest-upstream + diff --git a/autoconf-aux/ax_subdirs_configure.m4 b/autoconf-aux/ax_subdirs_configure.m4 new file mode 100644 index 00000000000..b4ec96962c2 --- /dev/null +++ b/autoconf-aux/ax_subdirs_configure.m4 @@ -0,0 +1,337 @@ +# =========================================================================== +# https://www.gnu.org/software/autoconf-archive/ax_subdirs_configure.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_SUBDIRS_CONFIGURE( [subdirs], [mandatory arguments], [possibly merged arguments], [replacement arguments], [forbidden arguments]) +# +# DESCRIPTION +# +# AX_SUBDIRS_CONFIGURE attempts to be the equivalent of AC_CONFIG_SUBDIRS +# with customizable options for configure scripts. +# +# Run the configure script for each directory from the comma-separated m4 +# list 'subdirs'. This macro can be used multiple times. All arguments of +# this macro must be comma-separated lists. +# +# All command line arguments from the parent configure script will be +# given to the subdirectory configure script after the following +# modifications (in that order): +# +# 1. The arguments from the 'mandatory arguments' list shall always be +# appended to the argument list. +# +# 2. The arguments from the 'possibly merged arguments' list shall be +# added if not present in the arguments of the parent configure script or +# merged with the existing argument otherwise. +# +# 3. The arguments from the 'replacement arguments' list shall be added if +# not present in the arguments of the parent configure script or replace +# the existing argument otherwise. +# +# 4. The arguments from the 'forbidden arguments' list shall always be +# removed from the argument list. +# +# The lists 'mandatory arguments' and 'forbidden arguments' can hold any +# kind of argument. The 'possibly merged arguments' and 'replacement +# arguments' expect their arguments to be of the form --option-name=value. +# +# This macro aims to remain as close as possible to the AC_CONFIG_SUBDIRS +# macro. It corrects the paths for '--cache-file' and '--srcdir' and adds +# '--disable-option-checking' and '--silent' if necessary. +# +# This macro also sets the output variable subdirs_extra to the list of +# directories recorded with AX_SUBDIRS_CONFIGURE. This variable can be +# used in Makefile rules or substituted in configured files. +# +# This macro shall do nothing more than managing the arguments of the +# configure script. Just like when using AC_CONFIG_SUBDIRS, it is up to +# the user to check any requirements or define and substitute any required +# variable for the remainder of the project. +# +# Configure scripts recorded with AX_SUBDIRS_CONFIGURE may be executed +# before configure scripts recorded with AC_CONFIG_SUBDIRS. +# +# Without additional arguments, the behaviour of AX_SUBDIRS_CONFIGURE +# should be identical to the behaviour of AC_CONFIG_SUBDIRS, apart from +# the contents of the variables subdirs and subdirs_extra (except that +# AX_SUBDIRS_CONFIGURE expects a comma-separated m4 list): +# +# AC_CONFIG_SUBDIRS([something]) +# AX_SUBDIRS_CONFIGURE([something]) +# +# This macro may be called multiple times. +# +# Usage example: +# +# Let us assume our project has 4 dependencies, namely A, B, C and D. Here +# are some characteristics of our project and its dependencies: +# +# - A does not require any special option. +# +# - we want to build B with an optional feature which can be enabled with +# its configure script's option '--enable-special-feature'. +# +# - B's configure script is strange and has an option '--with-B=build'. +# After close inspection of its documentation, we don't want B to receive +# this option. +# +# - C and D both need B. +# +# - Just like our project, C and D can build B themselves with the option +# '--with-B=build'. +# +# - We want C and D to use the B we build instead of building it +# themselves. +# +# Our top-level configure script will be called as follows: +# +# $ --with-A=build --with-B=build --with-C=build \ +# --with-D=build --some-option +# +# Thus we have to make sure that: +# +# - neither B, C or D receive the option '--with-B=build' +# +# - C and D know where to find the headers and libraries of B. +# +# Under those conditions, we can use the AC_CONFIG_SUBDIRS macro for A, +# but need to use AX_SUBDIRS_CONFIGURE for B, C and D: +# +# - B must receive '--enable-special-feature' but cannot receive +# '--with-B=build' +# +# - C and D cannot receive '--with-B=build' (or else it would be built +# thrice) and need to be told where to find B (since we are building it, +# it would probably not be available in standard paths). +# +# Here is a configure.ac snippet that solves our problem: +# +# AC_CONFIG_SUBDIRS([dependencies/A]) +# AX_SUBDIRS_CONFIGURE( +# [dependencies/B], [--enable-special-feature], [], [], +# [--with-B=build]) +# AX_SUBDIRS_CONFIGURE( +# [[dependencies/C],[dependencies/D]], +# [], +# [[CPPFLAGS=-I${ac_top_srcdir}/dependencies/B -I${ac_top_builddir}/dependencies/B], +# [LDFLAGS=-L${ac_abs_top_builddir}/dependencies/B/.libs]], +# [--with-B=system], +# []) +# +# If using automake, the following can be added to the Makefile.am (we use +# both $(subdirs) and $(subdirs_extra) since our example above used both +# AC_CONFIG_SUBDIRS and AX_SUBDIRS_CONFIGURE): +# +# SUBDIRS = $(subdirs) $(subdirs_extra) +# +# LICENSE +# +# Copyright (c) 2017 Harenome Ranaivoarivony-Razanajato +# +# 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 3 of the License, 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. +# +# Under Section 7 of GPL version 3, you are granted additional permissions +# described in the Autoconf Configure Script Exception, version 3.0, as +# published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see . + +#serial 5 + +AC_DEFUN([AX_SUBDIRS_CONFIGURE], +[ + dnl Calls to AC_CONFIG_SUBDIRS perform preliminary steps and build a list + dnl '$subdirs' which is used later by _AC_OUTPUT_SUBDIRS (used by AC_OUTPUT) + dnl to actually run the configure scripts. + dnl This macro performs similar preliminary steps but uses + dnl AC_CONFIG_COMMANDS_PRE to delay the final tasks instead of building an + dnl intermediary list and relying on another macro. + dnl + dnl Since each configure script can get different options, a special variable + dnl named 'ax_sub_configure_args_' is constructed for each + dnl subdirectory. + + # Various preliminary checks. + AC_REQUIRE([AC_DISABLE_OPTION_CHECKING]) + AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) + AS_LITERAL_IF([$1], [], + [AC_DIAGNOSE([syntax], [$0: you should use literals])]) + + m4_foreach(subdir_path, [$1], + [ + ax_dir="subdir_path" + + dnl Build the argument list in a similar fashion to AC_CONFIG_SUBDIRS. + dnl A few arguments found in the final call to the configure script are not + dnl added here because they rely on variables that may not yet be available + dnl (see below the part that is similar to _AC_OUTPUT_SUBDIRS). + # Do not complain, so a configure script can configure whichever parts of a + # large source tree are present. + if test -d "$srcdir/$ax_dir"; then + _AC_SRCDIRS(["$ax_dir"]) + # Remove --cache-file, --srcdir, and --disable-option-checking arguments + # so they do not pile up. + ax_args= + ax_prev= + eval "set x $ac_configure_args" + shift + for ax_arg; do + if test -n "$ax_prev"; then + ax_prev= + continue + fi + case $ax_arg in + -cache-file | --cache-file | --cache-fil | --cache-fi | --cache-f \ + | --cache- | --cache | --cach | --cac | --ca | --c) + ax_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \ + | --c=*) + ;; + --config-cache | -C) + ;; + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ax_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + ;; + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ax_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* \ + | --p=*) + ;; + --disable-option-checking) + ;; + *) case $ax_arg in + *\'*) ax_arg=$(AS_ECHO(["$ax_arg"]) | sed "s/'/'\\\\\\\\''/g");; + esac + AS_VAR_APPEND([ax_args], [" '$ax_arg'"]) ;; + esac + done + # Always prepend --disable-option-checking to silence warnings, since + # different subdirs can have different --enable and --with options. + ax_args="--disable-option-checking $ax_args" + # Options that must be added as they are provided. + m4_ifnblank([$2], [m4_foreach(opt, [$2], [AS_VAR_APPEND(ax_args, " 'opt'") + ])]) + # New options that may need to be merged with existing options. + m4_ifnblank([$3], [m4_foreach(opt, [$3], + [ax_candidate="opt" + ax_candidate_flag="${ax_candidate%%=*}" + ax_candidate_content="${ax_candidate#*=}" + if test "x$ax_candidate" != "x" -a "x$ax_candidate_flag" != "x"; then + if echo "$ax_args" | grep -- "${ax_candidate_flag}=" >/dev/null 2>&1; then + [ax_args=$(echo $ax_args | sed "s,\(${ax_candidate_flag}=[^']*\),\1 ${ax_candidate_content},")] + else + AS_VAR_APPEND(ax_args, " 'opt'") + fi + fi + ])]) + # New options that must replace existing options. + m4_ifnblank([$4], [m4_foreach(opt, [$4], + [ax_candidate="opt" + ax_candidate_flag="${ax_candidate%%=*}" + ax_candidate_content="${ax_candidate#*=}" + if test "x$ax_candidate" != "x" -a "x$ax_candidate_flag" != "x"; then + if echo "$ax_args" | grep -- "${ax_candidate_flag}=" >/dev/null 2>&1; then + [ax_args=$(echo $ax_args | sed "s,${ax_candidate_flag}=[^']*,${ax_candidate},")] + else + AS_VAR_APPEND(ax_args, " 'opt'") + fi + fi + ])]) + # Options that must be removed. + m4_ifnblank([$5], [m4_foreach(opt, [$5], [ax_args=$(echo $ax_args | sed "s,'opt',,") + ])]) + AS_VAR_APPEND([ax_args], [" '--srcdir=$ac_srcdir'"]) + + # Add the subdirectory to the list of target subdirectories. + ax_subconfigures="$ax_subconfigures $ax_dir" + # Save the argument list for this subdirectory. + dnl $1 is a path to some subdirectory: m4_bpatsubsts() is used to convert + dnl $1 into a valid shell variable name. + dnl For instance, "ax_sub_configure_args_path/to/subdir" becomes + dnl "ax_sub_configure_args_path_to_subdir". + ax_var=$(printf "$ax_dir" | tr -c "0-9a-zA-Z_" "_") + eval "ax_sub_configure_args_$ax_var=\"$ax_args\"" + eval "ax_sub_configure_$ax_var=\"yes\"" + else + AC_MSG_WARN([could not find source tree for $ax_dir]) + fi + + dnl Add some more arguments to the argument list and then actually run the + dnl configure script. This is mostly what happens in _AC_OUTPUT_SUBDIRS + dnl except it does not iterate over an intermediary list. + AC_CONFIG_COMMANDS_PRE( + dnl This very line cannot be quoted! m4_foreach has some work here. + ax_dir="subdir_path" + [ + # Convert the path to the subdirectory into a shell variable name. + ax_var=$(printf "$ax_dir" | tr -c "0-9a-zA-Z_" "_") + ax_configure_ax_var=$(eval "echo \"\$ax_sub_configure_$ax_var\"") + if test "$no_recursion" != "yes" -a "x$ax_configure_ax_var" = "xyes"; then + AC_SUBST([subdirs_extra], ["$subdirs_extra $ax_dir"]) + ax_msg="=== configuring in $ax_dir ($(pwd)/$ax_dir)" + _AS_ECHO_LOG([$ax_msg]) + _AS_ECHO([$ax_msg]) + AS_MKDIR_P(["$ax_dir"]) + _AC_SRCDIRS(["$ax_dir"]) + + ax_popdir=$(pwd) + cd "$ax_dir" + + # Check for guested configure; otherwise get Cygnus style configure. + if test -f "$ac_srcdir/configure.gnu"; then + ax_sub_configure=$ac_srcdir/configure.gnu + elif test -f "$ac_srcdir/configure"; then + ax_sub_configure=$ac_srcdir/configure + elif test -f "$ac_srcdir/configure.in"; then + # This should be Cygnus configure. + ax_sub_configure=$ac_aux_dir/configure + else + AC_MSG_WARN([no configuration information is in $ax_dir]) + ax_sub_configure= + fi + + if test -n "$ax_sub_configure"; then + # Get the configure arguments for the current configure. + eval "ax_sub_configure_args=\"\$ax_sub_configure_args_${ax_var}\"" + + # Always prepend --prefix to ensure using the same prefix + # in subdir configurations. + ax_arg="--prefix=$prefix" + case $ax_arg in + *\'*) ax_arg=$(AS_ECHO(["$ax_arg"]) | sed "s/'/'\\\\\\\\''/g");; + esac + ax_sub_configure_args="'$ax_arg' $ax_sub_configure_args" + if test "$silent" = yes; then + ax_sub_configure_args="--silent $ax_sub_configure_args" + fi + # Make the cache file name correct relative to the subdirectory. + case $cache_file in + [[\\/]]* | ?:[[\\/]]* ) + ax_sub_cache_file=$cache_file ;; + *) # Relative name. + ax_sub_cache_file=$ac_top_build_prefix$cache_file ;; + esac + + AC_MSG_NOTICE([running $SHELL $ax_sub_configure $ax_sub_configure_args --cache-file=$ac_sub_cache_file]) + eval "\$SHELL \"$ax_sub_configure\" $ax_sub_configure_args --cache-file=\"$ax_sub_cache_file\"" \ + || AC_MSG_ERROR([$ax_sub_configure failed for $ax_dir]) + fi + + cd "$ax_popdir" + fi + ]) + ]) +]) diff --git a/autoconf-aux/install-sh b/autoconf-aux/install-sh new file mode 100755 index 00000000000..59990a10492 --- /dev/null +++ b/autoconf-aux/install-sh @@ -0,0 +1,508 @@ +#!/bin/sh +# install - install a program, script, or datafile + +scriptversion=2014-09-12.12; # UTC + +# This originates from X11R5 (mit/util/scripts/install.sh), which was +# later released in X11R6 (xc/config/util/install.sh) with the +# following copyright and license. +# +# Copyright (C) 1994 X Consortium +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- +# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# Except as contained in this notice, the name of the X Consortium shall not +# be used in advertising or otherwise to promote the sale, use or other deal- +# ings in this Software without prior written authorization from the X Consor- +# tium. +# +# +# FSF changes to this file are in the public domain. +# +# Calling this script install-sh is preferred over install.sh, to prevent +# 'make' implicit rules from creating a file called install from it +# when there is no Makefile. +# +# This script is compatible with the BSD install script, but was written +# from scratch. + +tab=' ' +nl=' +' +IFS=" $tab$nl" + +# Set DOITPROG to "echo" to test this script. + +doit=${DOITPROG-} +doit_exec=${doit:-exec} + +# Put in absolute file names if you don't have them in your path; +# or use environment vars. + +chgrpprog=${CHGRPPROG-chgrp} +chmodprog=${CHMODPROG-chmod} +chownprog=${CHOWNPROG-chown} +cmpprog=${CMPPROG-cmp} +cpprog=${CPPROG-cp} +mkdirprog=${MKDIRPROG-mkdir} +mvprog=${MVPROG-mv} +rmprog=${RMPROG-rm} +stripprog=${STRIPPROG-strip} + +posix_mkdir= + +# Desired mode of installed file. +mode=0755 + +chgrpcmd= +chmodcmd=$chmodprog +chowncmd= +mvcmd=$mvprog +rmcmd="$rmprog -f" +stripcmd= + +src= +dst= +dir_arg= +dst_arg= + +copy_on_change=false +is_target_a_directory=possibly + +usage="\ +Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE + or: $0 [OPTION]... SRCFILES... DIRECTORY + or: $0 [OPTION]... -t DIRECTORY SRCFILES... + or: $0 [OPTION]... -d DIRECTORIES... + +In the 1st form, copy SRCFILE to DSTFILE. +In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. +In the 4th, create DIRECTORIES. + +Options: + --help display this help and exit. + --version display version info and exit. + + -c (ignored) + -C install only if different (preserve the last data modification time) + -d create directories instead of installing files. + -g GROUP $chgrpprog installed files to GROUP. + -m MODE $chmodprog installed files to MODE. + -o USER $chownprog installed files to USER. + -s $stripprog installed files. + -t DIRECTORY install into DIRECTORY. + -T report an error if DSTFILE is a directory. + +Environment variables override the default commands: + CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG + RMPROG STRIPPROG +" + +while test $# -ne 0; do + case $1 in + -c) ;; + + -C) copy_on_change=true;; + + -d) dir_arg=true;; + + -g) chgrpcmd="$chgrpprog $2" + shift;; + + --help) echo "$usage"; exit $?;; + + -m) mode=$2 + case $mode in + *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*) + echo "$0: invalid mode: $mode" >&2 + exit 1;; + esac + shift;; + + -o) chowncmd="$chownprog $2" + shift;; + + -s) stripcmd=$stripprog;; + + -t) + is_target_a_directory=always + dst_arg=$2 + # Protect names problematic for 'test' and other utilities. + case $dst_arg in + -* | [=\(\)!]) dst_arg=./$dst_arg;; + esac + shift;; + + -T) is_target_a_directory=never;; + + --version) echo "$0 $scriptversion"; exit $?;; + + --) shift + break;; + + -*) echo "$0: invalid option: $1" >&2 + exit 1;; + + *) break;; + esac + shift +done + +# We allow the use of options -d and -T together, by making -d +# take the precedence; this is for compatibility with GNU install. + +if test -n "$dir_arg"; then + if test -n "$dst_arg"; then + echo "$0: target directory not allowed when installing a directory." >&2 + exit 1 + fi +fi + +if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then + # When -d is used, all remaining arguments are directories to create. + # When -t is used, the destination is already specified. + # Otherwise, the last argument is the destination. Remove it from $@. + for arg + do + if test -n "$dst_arg"; then + # $@ is not empty: it contains at least $arg. + set fnord "$@" "$dst_arg" + shift # fnord + fi + shift # arg + dst_arg=$arg + # Protect names problematic for 'test' and other utilities. + case $dst_arg in + -* | [=\(\)!]) dst_arg=./$dst_arg;; + esac + done +fi + +if test $# -eq 0; then + if test -z "$dir_arg"; then + echo "$0: no input file specified." >&2 + exit 1 + fi + # It's OK to call 'install-sh -d' without argument. + # This can happen when creating conditional directories. + exit 0 +fi + +if test -z "$dir_arg"; then + if test $# -gt 1 || test "$is_target_a_directory" = always; then + if test ! -d "$dst_arg"; then + echo "$0: $dst_arg: Is not a directory." >&2 + exit 1 + fi + fi +fi + +if test -z "$dir_arg"; then + do_exit='(exit $ret); exit $ret' + trap "ret=129; $do_exit" 1 + trap "ret=130; $do_exit" 2 + trap "ret=141; $do_exit" 13 + trap "ret=143; $do_exit" 15 + + # Set umask so as not to create temps with too-generous modes. + # However, 'strip' requires both read and write access to temps. + case $mode in + # Optimize common cases. + *644) cp_umask=133;; + *755) cp_umask=22;; + + *[0-7]) + if test -z "$stripcmd"; then + u_plus_rw= + else + u_plus_rw='% 200' + fi + cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; + *) + if test -z "$stripcmd"; then + u_plus_rw= + else + u_plus_rw=,u+rw + fi + cp_umask=$mode$u_plus_rw;; + esac +fi + +for src +do + # Protect names problematic for 'test' and other utilities. + case $src in + -* | [=\(\)!]) src=./$src;; + esac + + if test -n "$dir_arg"; then + dst=$src + dstdir=$dst + test -d "$dstdir" + dstdir_status=$? + else + + # Waiting for this to be detected by the "$cpprog $src $dsttmp" command + # might cause directories to be created, which would be especially bad + # if $src (and thus $dsttmp) contains '*'. + if test ! -f "$src" && test ! -d "$src"; then + echo "$0: $src does not exist." >&2 + exit 1 + fi + + if test -z "$dst_arg"; then + echo "$0: no destination specified." >&2 + exit 1 + fi + dst=$dst_arg + + # If destination is a directory, append the input filename; won't work + # if double slashes aren't ignored. + if test -d "$dst"; then + if test "$is_target_a_directory" = never; then + echo "$0: $dst_arg: Is a directory" >&2 + exit 1 + fi + dstdir=$dst + dst=$dstdir/`basename "$src"` + dstdir_status=0 + else + dstdir=`dirname "$dst"` + test -d "$dstdir" + dstdir_status=$? + fi + fi + + obsolete_mkdir_used=false + + if test $dstdir_status != 0; then + case $posix_mkdir in + '') + # Create intermediate dirs using mode 755 as modified by the umask. + # This is like FreeBSD 'install' as of 1997-10-28. + umask=`umask` + case $stripcmd.$umask in + # Optimize common cases. + *[2367][2367]) mkdir_umask=$umask;; + .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; + + *[0-7]) + mkdir_umask=`expr $umask + 22 \ + - $umask % 100 % 40 + $umask % 20 \ + - $umask % 10 % 4 + $umask % 2 + `;; + *) mkdir_umask=$umask,go-w;; + esac + + # With -d, create the new directory with the user-specified mode. + # Otherwise, rely on $mkdir_umask. + if test -n "$dir_arg"; then + mkdir_mode=-m$mode + else + mkdir_mode= + fi + + posix_mkdir=false + case $umask in + *[123567][0-7][0-7]) + # POSIX mkdir -p sets u+wx bits regardless of umask, which + # is incompatible with FreeBSD 'install' when (umask & 300) != 0. + ;; + *) + # $RANDOM is not portable (e.g. dash); use it when possible to + # lower collision chance + tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ + trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0 + + # As "mkdir -p" follows symlinks and we work in /tmp possibly; so + # create the $tmpdir first (and fail if unsuccessful) to make sure + # that nobody tries to guess the $tmpdir name. + if (umask $mkdir_umask && + $mkdirprog $mkdir_mode "$tmpdir" && + exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1 + then + if test -z "$dir_arg" || { + # Check for POSIX incompatibilities with -m. + # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or + # other-writable bit of parent directory when it shouldn't. + # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. + test_tmpdir="$tmpdir/a" + ls_ld_tmpdir=`ls -ld "$test_tmpdir"` + case $ls_ld_tmpdir in + d????-?r-*) different_mode=700;; + d????-?--*) different_mode=755;; + *) false;; + esac && + $mkdirprog -m$different_mode -p -- "$test_tmpdir" && { + ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"` + test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" + } + } + then posix_mkdir=: + fi + rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" + else + # Remove any dirs left behind by ancient mkdir implementations. + rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null + fi + trap '' 0;; + esac;; + esac + + if + $posix_mkdir && ( + umask $mkdir_umask && + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" + ) + then : + else + + # The umask is ridiculous, or mkdir does not conform to POSIX, + # or it failed possibly due to a race condition. Create the + # directory the slow way, step by step, checking for races as we go. + + case $dstdir in + /*) prefix='/';; + [-=\(\)!]*) prefix='./';; + *) prefix='';; + esac + + oIFS=$IFS + IFS=/ + set -f + set fnord $dstdir + shift + set +f + IFS=$oIFS + + prefixes= + + for d + do + test X"$d" = X && continue + + prefix=$prefix$d + if test -d "$prefix"; then + prefixes= + else + if $posix_mkdir; then + (umask=$mkdir_umask && + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break + # Don't fail if two instances are running concurrently. + test -d "$prefix" || exit 1 + else + case $prefix in + *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; + *) qprefix=$prefix;; + esac + prefixes="$prefixes '$qprefix'" + fi + fi + prefix=$prefix/ + done + + if test -n "$prefixes"; then + # Don't fail if two instances are running concurrently. + (umask $mkdir_umask && + eval "\$doit_exec \$mkdirprog $prefixes") || + test -d "$dstdir" || exit 1 + obsolete_mkdir_used=true + fi + fi + fi + + if test -n "$dir_arg"; then + { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && + { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && + { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || + test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 + else + + # Make a couple of temp file names in the proper directory. + dsttmp=$dstdir/_inst.$$_ + rmtmp=$dstdir/_rm.$$_ + + # Trap to clean up those temp files at exit. + trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 + + # Copy the file name to the temp name. + (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && + + # and set any options; do chmod last to preserve setuid bits. + # + # If any of these fail, we abort the whole thing. If we want to + # ignore errors from any of these, just make sure not to ignore + # errors from the above "$doit $cpprog $src $dsttmp" command. + # + { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && + { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && + { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && + { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && + + # If -C, don't bother to copy if it wouldn't change the file. + if $copy_on_change && + old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && + new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && + set -f && + set X $old && old=:$2:$4:$5:$6 && + set X $new && new=:$2:$4:$5:$6 && + set +f && + test "$old" = "$new" && + $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 + then + rm -f "$dsttmp" + else + # Rename the file to the real destination. + $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || + + # The rename failed, perhaps because mv can't rename something else + # to itself, or perhaps because mv is so ancient that it does not + # support -f. + { + # Now remove or move aside any old file at destination location. + # We try this two ways since rm can't unlink itself on some + # systems and the destination file might be busy for other + # reasons. In this case, the final cleanup might fail but the new + # file should still install successfully. + { + test ! -f "$dst" || + $doit $rmcmd -f "$dst" 2>/dev/null || + { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && + { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } + } || + { echo "$0: cannot unlink or rename $dst" >&2 + (exit 1); exit 1 + } + } && + + # Now rename the file to the real destination. + $doit $mvcmd "$dsttmp" "$dst" + } + fi || exit 1 + + trap '' 0 + fi +done + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/configure.ac b/configure.ac new file mode 100644 index 00000000000..55727aec484 --- /dev/null +++ b/configure.ac @@ -0,0 +1,87 @@ +AC_PREREQ([2.69]) +AC_INIT([The Flambda backend for OCaml], + 4.11.1+dev0-2020-08-18, + [mshinwell@janestreet.com], + [flambda_backend], + [http://github.com/ocaml-flambda/flambda_backend]) + +AC_MSG_NOTICE([Configuring Flambda backend version AC_PACKAGE_VERSION]) + +m4_include([autoconf-aux/ax_subdirs_configure.m4]) + +AC_CONFIG_AUX_DIR([autoconf-aux]) + +AC_PATH_PROG([dune], [dune], []) + +AC_ARG_WITH([dune], + [AS_HELP_STRING([--with-dune], + [Path to dune executable (otherwise PATH is searched)])], + [dune=$with_dune]) + +dnl Bug here somewhere -- if dune is on the path and an invalid --with-dune is +dnl specified, then we should stop. + +AS_IF([test x"$dune" = "x"], + [AC_MSG_ERROR([dune not found on PATH; install, or use --with-dune])]) + +AC_MSG_NOTICE([Using dune executable: $dune]) + +AC_ARG_ENABLE([middle-end], + [AS_HELP_STRING([--enable-middle-end], + [Select which middle end to use: closure or flambda])], + [AS_CASE([$enable_middle_end], + [closure], [middle_end=closure middle_end_arg=--disable-flambda], + [flambda], [middle_end=flambda middle_end_arg=--enable-flambda], + [*], [AC_MSG_ERROR([Bad middle end (not closure or flambda)])])], + [AC_MSG_ERROR([--enable-middle-end=closure|flambda must be provided])]) + +stage0_prefix=$ac_abs_confdir/_build0/_install +stage1_prefix=$ac_abs_confdir/_build1/install/default +stage2_prefix=$ac_abs_confdir/_build2/install/default + +AC_SUBST([prefix]) +AC_SUBST([middle_end]) +AC_SUBST([stage0_prefix]) +AC_SUBST([stage1_prefix]) +AC_SUBST([stage2_prefix]) +AC_SUBST([dune]) + +# Don't error on options that this configure script doesn't understand but +# the ocaml/ one does. +AC_DISABLE_OPTION_CHECKING + +# The "real" --prefix will still be on the command line, but our new one here +# will take priority. +# This should match configure_args_for_ocaml, below. +AX_SUBDIRS_CONFIGURE([ocaml], + [$middle_end_arg,-C,--disable-ocamldoc], + [], + [--prefix=$stage1_prefix], + []) + +temp=$(mktemp) + +echo "$middle_end_arg" > $temp +echo "--disable-ocamldoc" >> $temp + +# The following trick ensures that if one of the arguments to configure +# contains a space, the argument is not incorrectly split on such space. +eval 'for option in '$ac_configure_args'; do echo $option; done' \ + | grep -v '^--prefix=' \ + | grep -v '^--enable-middle-end=' \ + | grep -v '^--with-dune=' \ + >> $temp + +# We prefer nulls to newlines as delimiters as it makes it easier to +# use xargs across platforms (macOS doesn't support xargs -d'\n' for +# example). +cat $temp | tr '\n' '\0' > configure_opts + +rm -f $temp + +AC_CONFIG_FILES([Makefile]) +AC_OUTPUT + +# We need a copy of config.status that is, for certain, the correct one +# for the stage1 build. +cp ocaml/config.status ocaml-stage1-config.status diff --git a/dune b/dune new file mode 100644 index 00000000000..6957a46a77e --- /dev/null +++ b/dune @@ -0,0 +1,955 @@ +;************************************************************************** +;* * +;* The Flambda backend project for OCaml * +;* * +;* Mark Shinwell, Jane Street Europe * +;* * +;* Copyright 2020 Jane Street Group LLC * +;* * +;************************************************************************** + +; Since upstream has the middle end code inside ocamloptcomp, we do the +; same for the moment. + +(copy_files backend/*.ml{,i}) +(copy_files backend/debug/*.ml{,i}) + +(copy_files# driver/optcompile.ml{,i}) +(copy_files# driver/flambda_backend_main.ml{,i}) +(copy_files# driver/optmaindriver.ml{,i}) + +(copy_files file_formats/cmx_format.mli) +(copy_files file_formats/linear_format.ml{,i}) + +(copy_files middle_end/*.ml{,i}) +(copy_files middle_end/closure/*.ml{,i}) +(copy_files middle_end/flambda/*.ml{,i}) +(copy_files middle_end/flambda/base_types/*.ml{,i}) + +(copy_files ocaml/driver/opterrors.ml{,i}) +(copy_files ocaml/file_formats/cmxs_format.mli) + +(library + (name ocamloptcomp) + (wrapped false) ; for compatibility with existing code + (modes byte native) + ; We should change the code so this "-open" can be removed. + ; Likewise fix occurrences of warning 9. + (flags (:standard -principal -nostdlib -w -9)) + (modules_without_implementation + backend_intf + cmx_format + cmxs_format + inlining_decision_intf + simplify_boxed_integer_ops_intf + x86_ast) + (modules + ;; To match the Makefiles, ocamloptcomp needs to include ocamlmiddleend. + + ;; file_formats/ + cmx_format cmxs_format + + ;; middle_end/ + backend_intf backend_var backend_var clambda clambda_primitives + compilation_unit compilenv convert_primitives internal_variable_names + linkage_name printclambda printclambda_primitives semantics_of_primitives + symbol variable + + ;; middle_end/closure/ + closure closure_middle_end + + ;; middle_end/flambda/base_types/ + closure_element closure_id closure_origin export_id id_types mutable_variable + set_of_closures_id set_of_closures_origin static_exception tag + var_within_closure + + ;; middle_end/flambda/ + alias_analysis allocated_const augment_specialised_args build_export_info + closure_conversion closure_conversion_aux closure_offsets effect_analysis + export_info export_info_for_pack extract_projections find_recursive_functions + flambda flambda_invariants flambda_iterators flambda_middle_end + flambda_to_clambda flambda_utils freshening import_approx inconstant_idents + initialize_symbol_to_let_symbol inline_and_simplify inline_and_simplify_aux + inlining_cost inlining_decision inlining_decision_intf inlining_stats + inlining_stats_types inlining_transforms invariant_params lift_code + lift_constants lift_let_to_initialize_symbol parameter pass_wrapper + projection ref_to_variables remove_free_vars_equal_to_args + remove_unused_arguments remove_unused_closure_vars + remove_unused_program_constructs share_constants simple_value_approx + simplify_boxed_integer_ops simplify_boxed_integer_ops_intf simplify_common + simplify_primitives traverse_for_exported_symbols un_anf unbox_closures + unbox_free_vars_of_closures unbox_specialised_args + + ;; asmcomp/ + afl_instrument arch asmgen asmlibrarian asmlink asmpackager branch_relaxation + branch_relaxation_intf cmm_helpers cmm cmmgen cmmgen_state coloring comballoc + CSE CSEgen deadcode emit emitaux interf interval linear linearize linscan + liveness mach printcmm printlinear printmach proc reg reload reloadgen + schedgen scheduling selectgen selection spill split + strmatch x86_ast x86_dsl x86_gas x86_masm x86_proc + + ;; file_formats/ + linear_format + + ;; asmcomp/debug/ + reg_availability_set compute_ranges_intf available_regs reg_with_debug_info + compute_ranges + + ;; driver/ + opterrors optcompile optmaindriver + + ; The driver should be in here too, but is not at present. This might + ; be tricky because it has a different name... + ) + (libraries ocamlcommon stdlib)) + +(executable + (name flambda_backend_main) + (modes byte) + (flags (:standard -principal -nostdlib + -cclib "-I ocaml/runtime" -cclib "-L ocaml/runtime" -cclib -lcamlrun)) + (link_deps (file ocaml/stdlib/camlheader) (file ocaml/runtime/libcamlrun.a)) + (libraries + flambda_backend_driver + ocamloptcomp + ocamlcommon + stdlib) + (modules flambda_backend_main)) + +(rule + (targets flambda_backend_main_native.ml) + (action (copy driver/flambda_backend_main.ml %{targets}))) + +(executable + (name flambda_backend_main_native) + (modes native) + (flags (:standard -principal -nostdlib)) + (libraries + flambda_backend_driver + ocamloptcomp + ocamlcommon + stdlib + runtime_native) + (modules flambda_backend_main_native)) + +(install + (files + (flambda_backend_main.bc as ocamlopt.byte) + (flambda_backend_main_native.exe as ocamlopt) + (flambda_backend_main_native.exe as ocamlopt.opt) + ) + (section bin) + (package ocaml)) + +(install + (files + (ocamloptcomp.a as compiler-libs/ocamloptcomp.a) + (ocamloptcomp.cmxa as compiler-libs/ocamloptcomp.cmxa) + (ocamloptcomp.cma as compiler-libs/ocamloptcomp.cma) + ) + (section lib) + (package ocaml)) + +(install + (section lib) + (package ocaml) + (files + (cmx_format.mli as compiler-libs/cmx_format.mli) + (cmxs_format.mli as compiler-libs/cmxs_format.mli) + (backend_intf.mli as compiler-libs/backend_intf.mli) + (backend_var.mli as compiler-libs/backend_var.mli) + (clambda.mli as compiler-libs/clambda.mli) + (clambda_primitives.mli as compiler-libs/clambda_primitives.mli) + (compilation_unit.mli as compiler-libs/compilation_unit.mli) + (compilenv.mli as compiler-libs/compilenv.mli) + (convert_primitives.mli as compiler-libs/convert_primitives.mli) + (internal_variable_names.mli as compiler-libs/internal_variable_names.mli) + (linkage_name.mli as compiler-libs/linkage_name.mli) + (printclambda.mli as compiler-libs/printclambda.mli) + (printclambda_primitives.mli as compiler-libs/printclambda_primitives.mli) + (semantics_of_primitives.mli as compiler-libs/semantics_of_primitives.mli) + (symbol.mli as compiler-libs/symbol.mli) + (variable.mli as compiler-libs/variable.mli) + (closure.mli as compiler-libs/closure.mli) + (closure_middle_end.mli as compiler-libs/closure_middle_end.mli) + (closure_element.mli as compiler-libs/closure_element.mli) + (closure_id.mli as compiler-libs/closure_id.mli) + (closure_origin.mli as compiler-libs/closure_origin.mli) + (export_id.mli as compiler-libs/export_id.mli) + (id_types.mli as compiler-libs/id_types.mli) + (mutable_variable.mli as compiler-libs/mutable_variable.mli) + (set_of_closures_id.mli as compiler-libs/set_of_closures_id.mli) + (set_of_closures_origin.mli as compiler-libs/set_of_closures_origin.mli) + (static_exception.mli as compiler-libs/static_exception.mli) + (tag.mli as compiler-libs/tag.mli) + (var_within_closure.mli as compiler-libs/var_within_closure.mli) + (alias_analysis.mli as compiler-libs/alias_analysis.mli) + (allocated_const.mli as compiler-libs/allocated_const.mli) + (augment_specialised_args.mli as compiler-libs/augment_specialised_args.mli) + (build_export_info.mli as compiler-libs/build_export_info.mli) + (closure_conversion.mli as compiler-libs/closure_conversion.mli) + (closure_conversion_aux.mli as compiler-libs/closure_conversion_aux.mli) + (closure_offsets.mli as compiler-libs/closure_offsets.mli) + (effect_analysis.mli as compiler-libs/effect_analysis.mli) + (export_info.mli as compiler-libs/export_info.mli) + (export_info_for_pack.mli as compiler-libs/export_info_for_pack.mli) + (extract_projections.mli as compiler-libs/extract_projections.mli) + (find_recursive_functions.mli as compiler-libs/find_recursive_functions.mli) + (flambda.mli as compiler-libs/flambda.mli) + (flambda_invariants.mli as compiler-libs/flambda_invariants.mli) + (flambda_iterators.mli as compiler-libs/flambda_iterators.mli) + (flambda_middle_end.mli as compiler-libs/flambda_middle_end.mli) + (flambda_to_clambda.mli as compiler-libs/flambda_to_clambda.mli) + (flambda_utils.mli as compiler-libs/flambda_utils.mli) + (freshening.mli as compiler-libs/freshening.mli) + (import_approx.mli as compiler-libs/import_approx.mli) + (inconstant_idents.mli as compiler-libs/inconstant_idents.mli) + (initialize_symbol_to_let_symbol.mli as compiler-libs/initialize_symbol_to_let_symbol.mli) + (inline_and_simplify.mli as compiler-libs/inline_and_simplify.mli) + (inline_and_simplify_aux.mli as compiler-libs/inline_and_simplify_aux.mli) + (inlining_cost.mli as compiler-libs/inlining_cost.mli) + (inlining_decision.mli as compiler-libs/inlining_decision.mli) + (inlining_decision_intf.mli as compiler-libs/inlining_decision_intf.mli) + (inlining_stats.mli as compiler-libs/inlining_stats.mli) + (inlining_stats_types.mli as compiler-libs/inlining_stats_types.mli) + (inlining_transforms.mli as compiler-libs/inlining_transforms.mli) + (invariant_params.mli as compiler-libs/invariant_params.mli) + (lift_code.mli as compiler-libs/lift_code.mli) + (lift_constants.mli as compiler-libs/lift_constants.mli) + (lift_let_to_initialize_symbol.mli as compiler-libs/lift_let_to_initialize_symbol.mli) + (parameter.mli as compiler-libs/parameter.mli) + (pass_wrapper.mli as compiler-libs/pass_wrapper.mli) + (projection.mli as compiler-libs/projection.mli) + (ref_to_variables.mli as compiler-libs/ref_to_variables.mli) + (remove_free_vars_equal_to_args.mli as compiler-libs/remove_free_vars_equal_to_args.mli) + (remove_unused_arguments.mli as compiler-libs/remove_unused_arguments.mli) + (remove_unused_closure_vars.mli as compiler-libs/remove_unused_closure_vars.mli) + (remove_unused_program_constructs.mli as compiler-libs/remove_unused_program_constructs.mli) + (share_constants.mli as compiler-libs/share_constants.mli) + (simple_value_approx.mli as compiler-libs/simple_value_approx.mli) + (simplify_boxed_integer_ops.mli as compiler-libs/simplify_boxed_integer_ops.mli) + (simplify_boxed_integer_ops_intf.mli as compiler-libs/simplify_boxed_integer_ops_intf.mli) + (simplify_common.mli as compiler-libs/simplify_common.mli) + (simplify_primitives.mli as compiler-libs/simplify_primitives.mli) + (traverse_for_exported_symbols.mli as compiler-libs/traverse_for_exported_symbols.mli) + (un_anf.mli as compiler-libs/un_anf.mli) + (unbox_closures.mli as compiler-libs/unbox_closures.mli) + (unbox_free_vars_of_closures.mli as compiler-libs/unbox_free_vars_of_closures.mli) + (unbox_specialised_args.mli as compiler-libs/unbox_specialised_args.mli) + (afl_instrument.mli as compiler-libs/afl_instrument.mli) + (asmgen.mli as compiler-libs/asmgen.mli) + (asmlibrarian.mli as compiler-libs/asmlibrarian.mli) + (asmlink.mli as compiler-libs/asmlink.mli) + (asmpackager.mli as compiler-libs/asmpackager.mli) + (branch_relaxation.mli as compiler-libs/branch_relaxation.mli) + (cmm_helpers.mli as compiler-libs/cmm_helpers.mli) + (cmm.mli as compiler-libs/cmm.mli) + (cmmgen.mli as compiler-libs/cmmgen.mli) + (cmmgen_state.mli as compiler-libs/cmmgen_state.mli) + (coloring.mli as compiler-libs/coloring.mli) + (comballoc.mli as compiler-libs/comballoc.mli) + (CSEgen.mli as compiler-libs/CSEgen.mli) + (deadcode.mli as compiler-libs/deadcode.mli) + (emit.mli as compiler-libs/emit.mli) + (emitaux.mli as compiler-libs/emitaux.mli) + (interf.mli as compiler-libs/interf.mli) + (interval.mli as compiler-libs/interval.mli) + (linear.mli as compiler-libs/linear.mli) + (linearize.mli as compiler-libs/linearize.mli) + (linscan.mli as compiler-libs/linscan.mli) + (liveness.mli as compiler-libs/liveness.mli) + (mach.mli as compiler-libs/mach.mli) + (printcmm.mli as compiler-libs/printcmm.mli) + (printlinear.mli as compiler-libs/printlinear.mli) + (printmach.mli as compiler-libs/printmach.mli) + (proc.mli as compiler-libs/proc.mli) + (reg.mli as compiler-libs/reg.mli) + (reload.mli as compiler-libs/reload.mli) + (reloadgen.mli as compiler-libs/reloadgen.mli) + (schedgen.mli as compiler-libs/schedgen.mli) + (scheduling.mli as compiler-libs/scheduling.mli) + (selectgen.mli as compiler-libs/selectgen.mli) + (selection.mli as compiler-libs/selection.mli) + (spill.mli as compiler-libs/spill.mli) + (split.mli as compiler-libs/split.mli) + (strmatch.mli as compiler-libs/strmatch.mli) + (x86_ast.mli as compiler-libs/x86_ast.mli) + (x86_dsl.mli as compiler-libs/x86_dsl.mli) + (x86_gas.mli as compiler-libs/x86_gas.mli) + (x86_masm.mli as compiler-libs/x86_masm.mli) + (x86_proc.mli as compiler-libs/x86_proc.mli) + (linear_format.mli as compiler-libs/linear_format.mli) + (reg_availability_set.mli as compiler-libs/reg_availability_set.mli) + (available_regs.mli as compiler-libs/available_regs.mli) + (reg_with_debug_info.mli as compiler-libs/reg_with_debug_info.mli) + (compute_ranges.mli as compiler-libs/compute_ranges.mli) + (opterrors.mli as compiler-libs/opterrors.mli) + (optcompile.mli as compiler-libs/optcompile.mli) + (optmaindriver.mli as compiler-libs/optmaindriver.mli) + + (.ocamloptcomp.objs/byte/linear_format.cmi as compiler-libs/linear_format.cmi) + (.ocamloptcomp.objs/byte/linear_format.cmo as compiler-libs/linear_format.cmo) + (.ocamloptcomp.objs/byte/linear_format.cmt as compiler-libs/linear_format.cmt) + (.ocamloptcomp.objs/byte/linear_format.cmti as compiler-libs/linear_format.cmti) + (.ocamloptcomp.objs/native/linear_format.cmx as compiler-libs/linear_format.cmx) + + (.ocamloptcomp.objs/byte/afl_instrument.cmi as compiler-libs/afl_instrument.cmi) + (.ocamloptcomp.objs/byte/afl_instrument.cmo as compiler-libs/afl_instrument.cmo) + (.ocamloptcomp.objs/byte/afl_instrument.cmt as compiler-libs/afl_instrument.cmt) + (.ocamloptcomp.objs/byte/afl_instrument.cmti as compiler-libs/afl_instrument.cmti) + (.ocamloptcomp.objs/byte/arch.cmi as compiler-libs/arch.cmi) + (.ocamloptcomp.objs/byte/arch.cmo as compiler-libs/arch.cmo) + (.ocamloptcomp.objs/byte/arch.cmt as compiler-libs/arch.cmt) + (.ocamloptcomp.objs/byte/asmgen.cmi as compiler-libs/asmgen.cmi) + (.ocamloptcomp.objs/byte/asmgen.cmo as compiler-libs/asmgen.cmo) + (.ocamloptcomp.objs/byte/asmgen.cmt as compiler-libs/asmgen.cmt) + (.ocamloptcomp.objs/byte/asmgen.cmti as compiler-libs/asmgen.cmti) + (.ocamloptcomp.objs/byte/asmlibrarian.cmi as compiler-libs/asmlibrarian.cmi) + (.ocamloptcomp.objs/byte/asmlibrarian.cmo as compiler-libs/asmlibrarian.cmo) + (.ocamloptcomp.objs/byte/asmlibrarian.cmt as compiler-libs/asmlibrarian.cmt) + (.ocamloptcomp.objs/byte/asmlibrarian.cmti as compiler-libs/asmlibrarian.cmti) + (.ocamloptcomp.objs/byte/asmlink.cmi as compiler-libs/asmlink.cmi) + (.ocamloptcomp.objs/byte/asmlink.cmo as compiler-libs/asmlink.cmo) + (.ocamloptcomp.objs/byte/asmlink.cmt as compiler-libs/asmlink.cmt) + (.ocamloptcomp.objs/byte/asmlink.cmti as compiler-libs/asmlink.cmti) + (.ocamloptcomp.objs/byte/asmpackager.cmi as compiler-libs/asmpackager.cmi) + (.ocamloptcomp.objs/byte/asmpackager.cmo as compiler-libs/asmpackager.cmo) + (.ocamloptcomp.objs/byte/asmpackager.cmt as compiler-libs/asmpackager.cmt) + (.ocamloptcomp.objs/byte/asmpackager.cmti as compiler-libs/asmpackager.cmti) + (.ocamloptcomp.objs/byte/available_regs.cmi as compiler-libs/available_regs.cmi) + (.ocamloptcomp.objs/byte/available_regs.cmo as compiler-libs/available_regs.cmo) + (.ocamloptcomp.objs/byte/available_regs.cmt as compiler-libs/available_regs.cmt) + (.ocamloptcomp.objs/byte/available_regs.cmti as compiler-libs/available_regs.cmti) + (.ocamloptcomp.objs/byte/branch_relaxation.cmi as compiler-libs/branch_relaxation.cmi) + (.ocamloptcomp.objs/byte/branch_relaxation.cmo as compiler-libs/branch_relaxation.cmo) + (.ocamloptcomp.objs/byte/branch_relaxation.cmt as compiler-libs/branch_relaxation.cmt) + (.ocamloptcomp.objs/byte/branch_relaxation.cmti as compiler-libs/branch_relaxation.cmti) + (.ocamloptcomp.objs/byte/branch_relaxation_intf.cmi as compiler-libs/branch_relaxation_intf.cmi) + (.ocamloptcomp.objs/byte/branch_relaxation_intf.cmo as compiler-libs/branch_relaxation_intf.cmo) + (.ocamloptcomp.objs/byte/branch_relaxation_intf.cmt as compiler-libs/branch_relaxation_intf.cmt) + (.ocamloptcomp.objs/byte/cSE.cmi as compiler-libs/CSE.cmi) + (.ocamloptcomp.objs/byte/cSE.cmo as compiler-libs/CSE.cmo) + (.ocamloptcomp.objs/byte/cSE.cmt as compiler-libs/CSE.cmt) + (.ocamloptcomp.objs/byte/cSEgen.cmi as compiler-libs/CSEgen.cmi) + (.ocamloptcomp.objs/byte/cSEgen.cmo as compiler-libs/CSEgen.cmo) + (.ocamloptcomp.objs/byte/cSEgen.cmt as compiler-libs/CSEgen.cmt) + (.ocamloptcomp.objs/byte/cSEgen.cmti as compiler-libs/CSEgen.cmti) + (.ocamloptcomp.objs/byte/cmm.cmi as compiler-libs/cmm.cmi) + (.ocamloptcomp.objs/byte/cmm.cmo as compiler-libs/cmm.cmo) + (.ocamloptcomp.objs/byte/cmm.cmt as compiler-libs/cmm.cmt) + (.ocamloptcomp.objs/byte/cmm.cmti as compiler-libs/cmm.cmti) + (.ocamloptcomp.objs/byte/cmm_helpers.cmi as compiler-libs/cmm_helpers.cmi) + (.ocamloptcomp.objs/byte/cmm_helpers.cmo as compiler-libs/cmm_helpers.cmo) + (.ocamloptcomp.objs/byte/cmm_helpers.cmt as compiler-libs/cmm_helpers.cmt) + (.ocamloptcomp.objs/byte/cmm_helpers.cmti as compiler-libs/cmm_helpers.cmti) + (.ocamloptcomp.objs/byte/cmmgen.cmi as compiler-libs/cmmgen.cmi) + (.ocamloptcomp.objs/byte/cmmgen.cmo as compiler-libs/cmmgen.cmo) + (.ocamloptcomp.objs/byte/cmmgen.cmt as compiler-libs/cmmgen.cmt) + (.ocamloptcomp.objs/byte/cmmgen.cmti as compiler-libs/cmmgen.cmti) + (.ocamloptcomp.objs/byte/cmmgen_state.cmi as compiler-libs/cmmgen_state.cmi) + (.ocamloptcomp.objs/byte/cmmgen_state.cmo as compiler-libs/cmmgen_state.cmo) + (.ocamloptcomp.objs/byte/cmmgen_state.cmt as compiler-libs/cmmgen_state.cmt) + (.ocamloptcomp.objs/byte/cmmgen_state.cmti as compiler-libs/cmmgen_state.cmti) + (.ocamloptcomp.objs/byte/coloring.cmi as compiler-libs/coloring.cmi) + (.ocamloptcomp.objs/byte/coloring.cmo as compiler-libs/coloring.cmo) + (.ocamloptcomp.objs/byte/coloring.cmt as compiler-libs/coloring.cmt) + (.ocamloptcomp.objs/byte/coloring.cmti as compiler-libs/coloring.cmti) + (.ocamloptcomp.objs/byte/comballoc.cmi as compiler-libs/comballoc.cmi) + (.ocamloptcomp.objs/byte/comballoc.cmo as compiler-libs/comballoc.cmo) + (.ocamloptcomp.objs/byte/comballoc.cmt as compiler-libs/comballoc.cmt) + (.ocamloptcomp.objs/byte/comballoc.cmti as compiler-libs/comballoc.cmti) + (.ocamloptcomp.objs/byte/compute_ranges.cmi as compiler-libs/compute_ranges.cmi) + (.ocamloptcomp.objs/byte/compute_ranges.cmo as compiler-libs/compute_ranges.cmo) + (.ocamloptcomp.objs/byte/compute_ranges.cmt as compiler-libs/compute_ranges.cmt) + (.ocamloptcomp.objs/byte/compute_ranges.cmti as compiler-libs/compute_ranges.cmti) + (.ocamloptcomp.objs/byte/compute_ranges_intf.cmi as compiler-libs/compute_ranges_intf.cmi) + (.ocamloptcomp.objs/byte/compute_ranges_intf.cmo as compiler-libs/compute_ranges_intf.cmo) + (.ocamloptcomp.objs/byte/compute_ranges_intf.cmt as compiler-libs/compute_ranges_intf.cmt) + (.ocamloptcomp.objs/byte/deadcode.cmi as compiler-libs/deadcode.cmi) + (.ocamloptcomp.objs/byte/deadcode.cmo as compiler-libs/deadcode.cmo) + (.ocamloptcomp.objs/byte/deadcode.cmt as compiler-libs/deadcode.cmt) + (.ocamloptcomp.objs/byte/deadcode.cmti as compiler-libs/deadcode.cmti) + (.ocamloptcomp.objs/byte/emit.cmi as compiler-libs/emit.cmi) + (.ocamloptcomp.objs/byte/emit.cmo as compiler-libs/emit.cmo) + (.ocamloptcomp.objs/byte/emit.cmt as compiler-libs/emit.cmt) + (.ocamloptcomp.objs/byte/emit.cmti as compiler-libs/emit.cmti) + (.ocamloptcomp.objs/byte/emitaux.cmi as compiler-libs/emitaux.cmi) + (.ocamloptcomp.objs/byte/emitaux.cmo as compiler-libs/emitaux.cmo) + (.ocamloptcomp.objs/byte/emitaux.cmt as compiler-libs/emitaux.cmt) + (.ocamloptcomp.objs/byte/emitaux.cmti as compiler-libs/emitaux.cmti) + (.ocamloptcomp.objs/byte/interf.cmi as compiler-libs/interf.cmi) + (.ocamloptcomp.objs/byte/interf.cmo as compiler-libs/interf.cmo) + (.ocamloptcomp.objs/byte/interf.cmt as compiler-libs/interf.cmt) + (.ocamloptcomp.objs/byte/interf.cmti as compiler-libs/interf.cmti) + (.ocamloptcomp.objs/byte/interval.cmi as compiler-libs/interval.cmi) + (.ocamloptcomp.objs/byte/interval.cmo as compiler-libs/interval.cmo) + (.ocamloptcomp.objs/byte/interval.cmt as compiler-libs/interval.cmt) + (.ocamloptcomp.objs/byte/interval.cmti as compiler-libs/interval.cmti) + (.ocamloptcomp.objs/byte/linear.cmi as compiler-libs/linear.cmi) + (.ocamloptcomp.objs/byte/linear.cmo as compiler-libs/linear.cmo) + (.ocamloptcomp.objs/byte/linear.cmt as compiler-libs/linear.cmt) + (.ocamloptcomp.objs/byte/linear.cmti as compiler-libs/linear.cmti) + (.ocamloptcomp.objs/byte/linearize.cmi as compiler-libs/linearize.cmi) + (.ocamloptcomp.objs/byte/linearize.cmo as compiler-libs/linearize.cmo) + (.ocamloptcomp.objs/byte/linearize.cmt as compiler-libs/linearize.cmt) + (.ocamloptcomp.objs/byte/linearize.cmti as compiler-libs/linearize.cmti) + (.ocamloptcomp.objs/byte/linscan.cmi as compiler-libs/linscan.cmi) + (.ocamloptcomp.objs/byte/linscan.cmo as compiler-libs/linscan.cmo) + (.ocamloptcomp.objs/byte/linscan.cmt as compiler-libs/linscan.cmt) + (.ocamloptcomp.objs/byte/linscan.cmti as compiler-libs/linscan.cmti) + (.ocamloptcomp.objs/byte/liveness.cmi as compiler-libs/liveness.cmi) + (.ocamloptcomp.objs/byte/liveness.cmo as compiler-libs/liveness.cmo) + (.ocamloptcomp.objs/byte/liveness.cmt as compiler-libs/liveness.cmt) + (.ocamloptcomp.objs/byte/liveness.cmti as compiler-libs/liveness.cmti) + (.ocamloptcomp.objs/byte/mach.cmi as compiler-libs/mach.cmi) + (.ocamloptcomp.objs/byte/mach.cmo as compiler-libs/mach.cmo) + (.ocamloptcomp.objs/byte/mach.cmt as compiler-libs/mach.cmt) + (.ocamloptcomp.objs/byte/mach.cmti as compiler-libs/mach.cmti) + (.ocamloptcomp.objs/byte/optcompile.cmi as compiler-libs/optcompile.cmi) + (.ocamloptcomp.objs/byte/optcompile.cmo as compiler-libs/optcompile.cmo) + (.ocamloptcomp.objs/byte/optcompile.cmt as compiler-libs/optcompile.cmt) + (.ocamloptcomp.objs/byte/optcompile.cmti as compiler-libs/optcompile.cmti) + (.ocamloptcomp.objs/byte/optmaindriver.cmi as compiler-libs/optmaindriver.cmi) + (.ocamloptcomp.objs/byte/optmaindriver.cmo as compiler-libs/optmaindriver.cmo) + (.ocamloptcomp.objs/byte/optmaindriver.cmt as compiler-libs/optmaindriver.cmt) + (.ocamloptcomp.objs/byte/optmaindriver.cmti as compiler-libs/optmaindriver.cmti) + (.ocamloptcomp.objs/byte/opterrors.cmi as compiler-libs/opterrors.cmi) + (.ocamloptcomp.objs/byte/opterrors.cmo as compiler-libs/opterrors.cmo) + (.ocamloptcomp.objs/byte/opterrors.cmt as compiler-libs/opterrors.cmt) + (.ocamloptcomp.objs/byte/opterrors.cmti as compiler-libs/opterrors.cmti) + (.ocamloptcomp.objs/byte/printcmm.cmi as compiler-libs/printcmm.cmi) + (.ocamloptcomp.objs/byte/printcmm.cmo as compiler-libs/printcmm.cmo) + (.ocamloptcomp.objs/byte/printcmm.cmt as compiler-libs/printcmm.cmt) + (.ocamloptcomp.objs/byte/printcmm.cmti as compiler-libs/printcmm.cmti) + (.ocamloptcomp.objs/byte/printlinear.cmi as compiler-libs/printlinear.cmi) + (.ocamloptcomp.objs/byte/printlinear.cmo as compiler-libs/printlinear.cmo) + (.ocamloptcomp.objs/byte/printlinear.cmt as compiler-libs/printlinear.cmt) + (.ocamloptcomp.objs/byte/printlinear.cmti as compiler-libs/printlinear.cmti) + (.ocamloptcomp.objs/byte/printmach.cmi as compiler-libs/printmach.cmi) + (.ocamloptcomp.objs/byte/printmach.cmo as compiler-libs/printmach.cmo) + (.ocamloptcomp.objs/byte/printmach.cmt as compiler-libs/printmach.cmt) + (.ocamloptcomp.objs/byte/printmach.cmti as compiler-libs/printmach.cmti) + (.ocamloptcomp.objs/byte/proc.cmi as compiler-libs/proc.cmi) + (.ocamloptcomp.objs/byte/proc.cmo as compiler-libs/proc.cmo) + (.ocamloptcomp.objs/byte/proc.cmt as compiler-libs/proc.cmt) + (.ocamloptcomp.objs/byte/proc.cmti as compiler-libs/proc.cmti) + (.ocamloptcomp.objs/byte/reg.cmi as compiler-libs/reg.cmi) + (.ocamloptcomp.objs/byte/reg.cmo as compiler-libs/reg.cmo) + (.ocamloptcomp.objs/byte/reg.cmt as compiler-libs/reg.cmt) + (.ocamloptcomp.objs/byte/reg.cmti as compiler-libs/reg.cmti) + (.ocamloptcomp.objs/byte/reg_availability_set.cmi as compiler-libs/reg_availability_set.cmi) + (.ocamloptcomp.objs/byte/reg_availability_set.cmo as compiler-libs/reg_availability_set.cmo) + (.ocamloptcomp.objs/byte/reg_availability_set.cmt as compiler-libs/reg_availability_set.cmt) + (.ocamloptcomp.objs/byte/reg_availability_set.cmti as compiler-libs/reg_availability_set.cmti) + (.ocamloptcomp.objs/byte/reg_with_debug_info.cmi as compiler-libs/reg_with_debug_info.cmi) + (.ocamloptcomp.objs/byte/reg_with_debug_info.cmo as compiler-libs/reg_with_debug_info.cmo) + (.ocamloptcomp.objs/byte/reg_with_debug_info.cmt as compiler-libs/reg_with_debug_info.cmt) + (.ocamloptcomp.objs/byte/reg_with_debug_info.cmti as compiler-libs/reg_with_debug_info.cmti) + (.ocamloptcomp.objs/byte/reload.cmi as compiler-libs/reload.cmi) + (.ocamloptcomp.objs/byte/reload.cmo as compiler-libs/reload.cmo) + (.ocamloptcomp.objs/byte/reload.cmt as compiler-libs/reload.cmt) + (.ocamloptcomp.objs/byte/reload.cmti as compiler-libs/reload.cmti) + (.ocamloptcomp.objs/byte/reloadgen.cmi as compiler-libs/reloadgen.cmi) + (.ocamloptcomp.objs/byte/reloadgen.cmo as compiler-libs/reloadgen.cmo) + (.ocamloptcomp.objs/byte/reloadgen.cmt as compiler-libs/reloadgen.cmt) + (.ocamloptcomp.objs/byte/reloadgen.cmti as compiler-libs/reloadgen.cmti) + (.ocamloptcomp.objs/byte/schedgen.cmi as compiler-libs/schedgen.cmi) + (.ocamloptcomp.objs/byte/schedgen.cmo as compiler-libs/schedgen.cmo) + (.ocamloptcomp.objs/byte/schedgen.cmt as compiler-libs/schedgen.cmt) + (.ocamloptcomp.objs/byte/schedgen.cmti as compiler-libs/schedgen.cmti) + (.ocamloptcomp.objs/byte/scheduling.cmi as compiler-libs/scheduling.cmi) + (.ocamloptcomp.objs/byte/scheduling.cmo as compiler-libs/scheduling.cmo) + (.ocamloptcomp.objs/byte/scheduling.cmt as compiler-libs/scheduling.cmt) + (.ocamloptcomp.objs/byte/scheduling.cmti as compiler-libs/scheduling.cmti) + (.ocamloptcomp.objs/byte/selectgen.cmi as compiler-libs/selectgen.cmi) + (.ocamloptcomp.objs/byte/selectgen.cmo as compiler-libs/selectgen.cmo) + (.ocamloptcomp.objs/byte/selectgen.cmt as compiler-libs/selectgen.cmt) + (.ocamloptcomp.objs/byte/selectgen.cmti as compiler-libs/selectgen.cmti) + (.ocamloptcomp.objs/byte/selection.cmi as compiler-libs/selection.cmi) + (.ocamloptcomp.objs/byte/selection.cmo as compiler-libs/selection.cmo) + (.ocamloptcomp.objs/byte/selection.cmt as compiler-libs/selection.cmt) + (.ocamloptcomp.objs/byte/selection.cmti as compiler-libs/selection.cmti) + (.ocamloptcomp.objs/byte/spill.cmi as compiler-libs/spill.cmi) + (.ocamloptcomp.objs/byte/spill.cmo as compiler-libs/spill.cmo) + (.ocamloptcomp.objs/byte/spill.cmt as compiler-libs/spill.cmt) + (.ocamloptcomp.objs/byte/spill.cmti as compiler-libs/spill.cmti) + (.ocamloptcomp.objs/byte/split.cmi as compiler-libs/split.cmi) + (.ocamloptcomp.objs/byte/split.cmo as compiler-libs/split.cmo) + (.ocamloptcomp.objs/byte/split.cmt as compiler-libs/split.cmt) + (.ocamloptcomp.objs/byte/split.cmti as compiler-libs/split.cmti) + (.ocamloptcomp.objs/byte/strmatch.cmi as compiler-libs/strmatch.cmi) + (.ocamloptcomp.objs/byte/strmatch.cmo as compiler-libs/strmatch.cmo) + (.ocamloptcomp.objs/byte/strmatch.cmt as compiler-libs/strmatch.cmt) + (.ocamloptcomp.objs/byte/strmatch.cmti as compiler-libs/strmatch.cmti) + (.ocamloptcomp.objs/byte/x86_ast.cmi as compiler-libs/x86_ast.cmi) + (.ocamloptcomp.objs/byte/x86_ast.cmti as compiler-libs/x86_ast.cmti) + (.ocamloptcomp.objs/byte/x86_dsl.cmi as compiler-libs/x86_dsl.cmi) + (.ocamloptcomp.objs/byte/x86_dsl.cmo as compiler-libs/x86_dsl.cmo) + (.ocamloptcomp.objs/byte/x86_dsl.cmt as compiler-libs/x86_dsl.cmt) + (.ocamloptcomp.objs/byte/x86_dsl.cmti as compiler-libs/x86_dsl.cmti) + (.ocamloptcomp.objs/byte/x86_gas.cmi as compiler-libs/x86_gas.cmi) + (.ocamloptcomp.objs/byte/x86_gas.cmo as compiler-libs/x86_gas.cmo) + (.ocamloptcomp.objs/byte/x86_gas.cmt as compiler-libs/x86_gas.cmt) + (.ocamloptcomp.objs/byte/x86_gas.cmti as compiler-libs/x86_gas.cmti) + (.ocamloptcomp.objs/byte/x86_masm.cmi as compiler-libs/x86_masm.cmi) + (.ocamloptcomp.objs/byte/x86_masm.cmo as compiler-libs/x86_masm.cmo) + (.ocamloptcomp.objs/byte/x86_masm.cmt as compiler-libs/x86_masm.cmt) + (.ocamloptcomp.objs/byte/x86_masm.cmti as compiler-libs/x86_masm.cmti) + (.ocamloptcomp.objs/byte/x86_proc.cmi as compiler-libs/x86_proc.cmi) + (.ocamloptcomp.objs/byte/x86_proc.cmo as compiler-libs/x86_proc.cmo) + (.ocamloptcomp.objs/byte/x86_proc.cmt as compiler-libs/x86_proc.cmt) + (.ocamloptcomp.objs/byte/x86_proc.cmti as compiler-libs/x86_proc.cmti) + (.ocamloptcomp.objs/native/afl_instrument.cmx as compiler-libs/afl_instrument.cmx) + (.ocamloptcomp.objs/native/arch.cmx as compiler-libs/arch.cmx) + (.ocamloptcomp.objs/native/asmgen.cmx as compiler-libs/asmgen.cmx) + (.ocamloptcomp.objs/native/asmlibrarian.cmx as compiler-libs/asmlibrarian.cmx) + (.ocamloptcomp.objs/native/asmlink.cmx as compiler-libs/asmlink.cmx) + (.ocamloptcomp.objs/native/asmpackager.cmx as compiler-libs/asmpackager.cmx) + (.ocamloptcomp.objs/native/available_regs.cmx as compiler-libs/available_regs.cmx) + (.ocamloptcomp.objs/native/branch_relaxation.cmx as compiler-libs/branch_relaxation.cmx) + (.ocamloptcomp.objs/native/branch_relaxation_intf.cmx as compiler-libs/branch_relaxation_intf.cmx) + (.ocamloptcomp.objs/native/cSE.cmx as compiler-libs/CSE.cmx) + (.ocamloptcomp.objs/native/cSEgen.cmx as compiler-libs/CSEgen.cmx) + (.ocamloptcomp.objs/native/cmm.cmx as compiler-libs/cmm.cmx) + (.ocamloptcomp.objs/native/cmm_helpers.cmx as compiler-libs/cmm_helpers.cmx) + (.ocamloptcomp.objs/native/cmmgen.cmx as compiler-libs/cmmgen.cmx) + (.ocamloptcomp.objs/native/cmmgen_state.cmx as compiler-libs/cmmgen_state.cmx) + (.ocamloptcomp.objs/native/coloring.cmx as compiler-libs/coloring.cmx) + (.ocamloptcomp.objs/native/comballoc.cmx as compiler-libs/comballoc.cmx) + (.ocamloptcomp.objs/native/compute_ranges.cmx as compiler-libs/compute_ranges.cmx) + (.ocamloptcomp.objs/native/compute_ranges_intf.cmx as compiler-libs/compute_ranges_intf.cmx) + (.ocamloptcomp.objs/native/deadcode.cmx as compiler-libs/deadcode.cmx) + (.ocamloptcomp.objs/native/emit.cmx as compiler-libs/emit.cmx) + (.ocamloptcomp.objs/native/emitaux.cmx as compiler-libs/emitaux.cmx) + (.ocamloptcomp.objs/native/interf.cmx as compiler-libs/interf.cmx) + (.ocamloptcomp.objs/native/interval.cmx as compiler-libs/interval.cmx) + (.ocamloptcomp.objs/native/linear.cmx as compiler-libs/linear.cmx) + (.ocamloptcomp.objs/native/linearize.cmx as compiler-libs/linearize.cmx) + (.ocamloptcomp.objs/native/linscan.cmx as compiler-libs/linscan.cmx) + (.ocamloptcomp.objs/native/liveness.cmx as compiler-libs/liveness.cmx) + (.ocamloptcomp.objs/native/mach.cmx as compiler-libs/mach.cmx) + (.ocamloptcomp.objs/native/optcompile.cmx as compiler-libs/optcompile.cmx) + (.ocamloptcomp.objs/native/opterrors.cmx as compiler-libs/opterrors.cmx) + (.ocamloptcomp.objs/native/printcmm.cmx as compiler-libs/printcmm.cmx) + (.ocamloptcomp.objs/native/printlinear.cmx as compiler-libs/printlinear.cmx) + (.ocamloptcomp.objs/native/printmach.cmx as compiler-libs/printmach.cmx) + (.ocamloptcomp.objs/native/proc.cmx as compiler-libs/proc.cmx) + (.ocamloptcomp.objs/native/reg.cmx as compiler-libs/reg.cmx) + (.ocamloptcomp.objs/native/reg_availability_set.cmx as compiler-libs/reg_availability_set.cmx) + (.ocamloptcomp.objs/native/reg_with_debug_info.cmx as compiler-libs/reg_with_debug_info.cmx) + (.ocamloptcomp.objs/native/reload.cmx as compiler-libs/reload.cmx) + (.ocamloptcomp.objs/native/reloadgen.cmx as compiler-libs/reloadgen.cmx) + (.ocamloptcomp.objs/native/schedgen.cmx as compiler-libs/schedgen.cmx) + (.ocamloptcomp.objs/native/scheduling.cmx as compiler-libs/scheduling.cmx) + (.ocamloptcomp.objs/native/selectgen.cmx as compiler-libs/selectgen.cmx) + (.ocamloptcomp.objs/native/selection.cmx as compiler-libs/selection.cmx) + (.ocamloptcomp.objs/native/spill.cmx as compiler-libs/spill.cmx) + (.ocamloptcomp.objs/native/split.cmx as compiler-libs/split.cmx) + (.ocamloptcomp.objs/native/strmatch.cmx as compiler-libs/strmatch.cmx) + (.ocamloptcomp.objs/native/x86_dsl.cmx as compiler-libs/x86_dsl.cmx) + (.ocamloptcomp.objs/native/x86_gas.cmx as compiler-libs/x86_gas.cmx) + (.ocamloptcomp.objs/native/x86_masm.cmx as compiler-libs/x86_masm.cmx) + (.ocamloptcomp.objs/native/x86_proc.cmx as compiler-libs/x86_proc.cmx) + )) + +(install + (section lib) + (package ocaml) + (files + ; These are the ocamlmiddleend ones + (.ocamloptcomp.objs/byte/alias_analysis.cmi as compiler-libs/alias_analysis.cmi) + (.ocamloptcomp.objs/byte/alias_analysis.cmo as compiler-libs/alias_analysis.cmo) + (.ocamloptcomp.objs/byte/alias_analysis.cmt as compiler-libs/alias_analysis.cmt) + (.ocamloptcomp.objs/byte/alias_analysis.cmti as compiler-libs/alias_analysis.cmti) + (.ocamloptcomp.objs/byte/allocated_const.cmi as compiler-libs/allocated_const.cmi) + (.ocamloptcomp.objs/byte/allocated_const.cmo as compiler-libs/allocated_const.cmo) + (.ocamloptcomp.objs/byte/allocated_const.cmt as compiler-libs/allocated_const.cmt) + (.ocamloptcomp.objs/byte/allocated_const.cmti as compiler-libs/allocated_const.cmti) + (.ocamloptcomp.objs/byte/augment_specialised_args.cmi as compiler-libs/augment_specialised_args.cmi) + (.ocamloptcomp.objs/byte/augment_specialised_args.cmo as compiler-libs/augment_specialised_args.cmo) + (.ocamloptcomp.objs/byte/augment_specialised_args.cmt as compiler-libs/augment_specialised_args.cmt) + (.ocamloptcomp.objs/byte/augment_specialised_args.cmti as compiler-libs/augment_specialised_args.cmti) + (.ocamloptcomp.objs/byte/backend_intf.cmi as compiler-libs/backend_intf.cmi) + (.ocamloptcomp.objs/byte/backend_intf.cmti as compiler-libs/backend_intf.cmti) + (.ocamloptcomp.objs/byte/backend_var.cmi as compiler-libs/backend_var.cmi) + (.ocamloptcomp.objs/byte/backend_var.cmo as compiler-libs/backend_var.cmo) + (.ocamloptcomp.objs/byte/backend_var.cmt as compiler-libs/backend_var.cmt) + (.ocamloptcomp.objs/byte/backend_var.cmti as compiler-libs/backend_var.cmti) + (.ocamloptcomp.objs/byte/build_export_info.cmi as compiler-libs/build_export_info.cmi) + (.ocamloptcomp.objs/byte/build_export_info.cmo as compiler-libs/build_export_info.cmo) + (.ocamloptcomp.objs/byte/build_export_info.cmt as compiler-libs/build_export_info.cmt) + (.ocamloptcomp.objs/byte/build_export_info.cmti as compiler-libs/build_export_info.cmti) + (.ocamloptcomp.objs/byte/clambda.cmi as compiler-libs/clambda.cmi) + (.ocamloptcomp.objs/byte/clambda.cmo as compiler-libs/clambda.cmo) + (.ocamloptcomp.objs/byte/clambda.cmt as compiler-libs/clambda.cmt) + (.ocamloptcomp.objs/byte/clambda.cmti as compiler-libs/clambda.cmti) + (.ocamloptcomp.objs/byte/clambda_primitives.cmi as compiler-libs/clambda_primitives.cmi) + (.ocamloptcomp.objs/byte/clambda_primitives.cmo as compiler-libs/clambda_primitives.cmo) + (.ocamloptcomp.objs/byte/clambda_primitives.cmt as compiler-libs/clambda_primitives.cmt) + (.ocamloptcomp.objs/byte/clambda_primitives.cmti as compiler-libs/clambda_primitives.cmti) + (.ocamloptcomp.objs/byte/closure.cmi as compiler-libs/closure.cmi) + (.ocamloptcomp.objs/byte/closure.cmo as compiler-libs/closure.cmo) + (.ocamloptcomp.objs/byte/closure.cmt as compiler-libs/closure.cmt) + (.ocamloptcomp.objs/byte/closure.cmti as compiler-libs/closure.cmti) + (.ocamloptcomp.objs/byte/closure_conversion.cmi as compiler-libs/closure_conversion.cmi) + (.ocamloptcomp.objs/byte/closure_conversion.cmo as compiler-libs/closure_conversion.cmo) + (.ocamloptcomp.objs/byte/closure_conversion.cmt as compiler-libs/closure_conversion.cmt) + (.ocamloptcomp.objs/byte/closure_conversion.cmti as compiler-libs/closure_conversion.cmti) + (.ocamloptcomp.objs/byte/closure_conversion_aux.cmi as compiler-libs/closure_conversion_aux.cmi) + (.ocamloptcomp.objs/byte/closure_conversion_aux.cmo as compiler-libs/closure_conversion_aux.cmo) + (.ocamloptcomp.objs/byte/closure_conversion_aux.cmt as compiler-libs/closure_conversion_aux.cmt) + (.ocamloptcomp.objs/byte/closure_conversion_aux.cmti as compiler-libs/closure_conversion_aux.cmti) + (.ocamloptcomp.objs/byte/closure_element.cmi as compiler-libs/closure_element.cmi) + (.ocamloptcomp.objs/byte/closure_element.cmo as compiler-libs/closure_element.cmo) + (.ocamloptcomp.objs/byte/closure_element.cmt as compiler-libs/closure_element.cmt) + (.ocamloptcomp.objs/byte/closure_element.cmti as compiler-libs/closure_element.cmti) + (.ocamloptcomp.objs/byte/closure_id.cmi as compiler-libs/closure_id.cmi) + (.ocamloptcomp.objs/byte/closure_id.cmo as compiler-libs/closure_id.cmo) + (.ocamloptcomp.objs/byte/closure_id.cmt as compiler-libs/closure_id.cmt) + (.ocamloptcomp.objs/byte/closure_id.cmti as compiler-libs/closure_id.cmti) + (.ocamloptcomp.objs/byte/closure_middle_end.cmi as compiler-libs/closure_middle_end.cmi) + (.ocamloptcomp.objs/byte/closure_middle_end.cmo as compiler-libs/closure_middle_end.cmo) + (.ocamloptcomp.objs/byte/closure_middle_end.cmt as compiler-libs/closure_middle_end.cmt) + (.ocamloptcomp.objs/byte/closure_middle_end.cmti as compiler-libs/closure_middle_end.cmti) + (.ocamloptcomp.objs/byte/closure_offsets.cmi as compiler-libs/closure_offsets.cmi) + (.ocamloptcomp.objs/byte/closure_offsets.cmo as compiler-libs/closure_offsets.cmo) + (.ocamloptcomp.objs/byte/closure_offsets.cmt as compiler-libs/closure_offsets.cmt) + (.ocamloptcomp.objs/byte/closure_offsets.cmti as compiler-libs/closure_offsets.cmti) + (.ocamloptcomp.objs/byte/closure_origin.cmi as compiler-libs/closure_origin.cmi) + (.ocamloptcomp.objs/byte/closure_origin.cmo as compiler-libs/closure_origin.cmo) + (.ocamloptcomp.objs/byte/closure_origin.cmt as compiler-libs/closure_origin.cmt) + (.ocamloptcomp.objs/byte/closure_origin.cmti as compiler-libs/closure_origin.cmti) + (.ocamloptcomp.objs/byte/cmx_format.cmi as compiler-libs/cmx_format.cmi) + (.ocamloptcomp.objs/byte/cmx_format.cmti as compiler-libs/cmx_format.cmti) + (.ocamloptcomp.objs/byte/cmxs_format.cmi as compiler-libs/cmxs_format.cmi) + (.ocamloptcomp.objs/byte/cmxs_format.cmti as compiler-libs/cmxs_format.cmti) + (.ocamloptcomp.objs/byte/compilation_unit.cmi as compiler-libs/compilation_unit.cmi) + (.ocamloptcomp.objs/byte/compilation_unit.cmo as compiler-libs/compilation_unit.cmo) + (.ocamloptcomp.objs/byte/compilation_unit.cmt as compiler-libs/compilation_unit.cmt) + (.ocamloptcomp.objs/byte/compilation_unit.cmti as compiler-libs/compilation_unit.cmti) + (.ocamloptcomp.objs/byte/compilenv.cmi as compiler-libs/compilenv.cmi) + (.ocamloptcomp.objs/byte/compilenv.cmo as compiler-libs/compilenv.cmo) + (.ocamloptcomp.objs/byte/compilenv.cmt as compiler-libs/compilenv.cmt) + (.ocamloptcomp.objs/byte/compilenv.cmti as compiler-libs/compilenv.cmti) + (.ocamloptcomp.objs/byte/convert_primitives.cmi as compiler-libs/convert_primitives.cmi) + (.ocamloptcomp.objs/byte/convert_primitives.cmo as compiler-libs/convert_primitives.cmo) + (.ocamloptcomp.objs/byte/convert_primitives.cmt as compiler-libs/convert_primitives.cmt) + (.ocamloptcomp.objs/byte/convert_primitives.cmti as compiler-libs/convert_primitives.cmti) + (.ocamloptcomp.objs/byte/effect_analysis.cmi as compiler-libs/effect_analysis.cmi) + (.ocamloptcomp.objs/byte/effect_analysis.cmo as compiler-libs/effect_analysis.cmo) + (.ocamloptcomp.objs/byte/effect_analysis.cmt as compiler-libs/effect_analysis.cmt) + (.ocamloptcomp.objs/byte/effect_analysis.cmti as compiler-libs/effect_analysis.cmti) + (.ocamloptcomp.objs/byte/export_id.cmi as compiler-libs/export_id.cmi) + (.ocamloptcomp.objs/byte/export_id.cmo as compiler-libs/export_id.cmo) + (.ocamloptcomp.objs/byte/export_id.cmt as compiler-libs/export_id.cmt) + (.ocamloptcomp.objs/byte/export_id.cmti as compiler-libs/export_id.cmti) + (.ocamloptcomp.objs/byte/export_info.cmi as compiler-libs/export_info.cmi) + (.ocamloptcomp.objs/byte/export_info.cmo as compiler-libs/export_info.cmo) + (.ocamloptcomp.objs/byte/export_info.cmt as compiler-libs/export_info.cmt) + (.ocamloptcomp.objs/byte/export_info.cmti as compiler-libs/export_info.cmti) + (.ocamloptcomp.objs/byte/export_info_for_pack.cmi as compiler-libs/export_info_for_pack.cmi) + (.ocamloptcomp.objs/byte/export_info_for_pack.cmo as compiler-libs/export_info_for_pack.cmo) + (.ocamloptcomp.objs/byte/export_info_for_pack.cmt as compiler-libs/export_info_for_pack.cmt) + (.ocamloptcomp.objs/byte/export_info_for_pack.cmti as compiler-libs/export_info_for_pack.cmti) + (.ocamloptcomp.objs/byte/extract_projections.cmi as compiler-libs/extract_projections.cmi) + (.ocamloptcomp.objs/byte/extract_projections.cmo as compiler-libs/extract_projections.cmo) + (.ocamloptcomp.objs/byte/extract_projections.cmt as compiler-libs/extract_projections.cmt) + (.ocamloptcomp.objs/byte/extract_projections.cmti as compiler-libs/extract_projections.cmti) + (.ocamloptcomp.objs/byte/find_recursive_functions.cmi as compiler-libs/find_recursive_functions.cmi) + (.ocamloptcomp.objs/byte/find_recursive_functions.cmo as compiler-libs/find_recursive_functions.cmo) + (.ocamloptcomp.objs/byte/find_recursive_functions.cmt as compiler-libs/find_recursive_functions.cmt) + (.ocamloptcomp.objs/byte/find_recursive_functions.cmti as compiler-libs/find_recursive_functions.cmti) + (.ocamloptcomp.objs/byte/flambda.cmi as compiler-libs/flambda.cmi) + (.ocamloptcomp.objs/byte/flambda.cmo as compiler-libs/flambda.cmo) + (.ocamloptcomp.objs/byte/flambda.cmt as compiler-libs/flambda.cmt) + (.ocamloptcomp.objs/byte/flambda.cmti as compiler-libs/flambda.cmti) + (.ocamloptcomp.objs/byte/flambda_invariants.cmi as compiler-libs/flambda_invariants.cmi) + (.ocamloptcomp.objs/byte/flambda_invariants.cmo as compiler-libs/flambda_invariants.cmo) + (.ocamloptcomp.objs/byte/flambda_invariants.cmt as compiler-libs/flambda_invariants.cmt) + (.ocamloptcomp.objs/byte/flambda_invariants.cmti as compiler-libs/flambda_invariants.cmti) + (.ocamloptcomp.objs/byte/flambda_iterators.cmi as compiler-libs/flambda_iterators.cmi) + (.ocamloptcomp.objs/byte/flambda_iterators.cmo as compiler-libs/flambda_iterators.cmo) + (.ocamloptcomp.objs/byte/flambda_iterators.cmt as compiler-libs/flambda_iterators.cmt) + (.ocamloptcomp.objs/byte/flambda_iterators.cmti as compiler-libs/flambda_iterators.cmti) + (.ocamloptcomp.objs/byte/flambda_middle_end.cmi as compiler-libs/flambda_middle_end.cmi) + (.ocamloptcomp.objs/byte/flambda_middle_end.cmo as compiler-libs/flambda_middle_end.cmo) + (.ocamloptcomp.objs/byte/flambda_middle_end.cmt as compiler-libs/flambda_middle_end.cmt) + (.ocamloptcomp.objs/byte/flambda_middle_end.cmti as compiler-libs/flambda_middle_end.cmti) + (.ocamloptcomp.objs/byte/flambda_to_clambda.cmi as compiler-libs/flambda_to_clambda.cmi) + (.ocamloptcomp.objs/byte/flambda_to_clambda.cmo as compiler-libs/flambda_to_clambda.cmo) + (.ocamloptcomp.objs/byte/flambda_to_clambda.cmt as compiler-libs/flambda_to_clambda.cmt) + (.ocamloptcomp.objs/byte/flambda_to_clambda.cmti as compiler-libs/flambda_to_clambda.cmti) + (.ocamloptcomp.objs/byte/flambda_utils.cmi as compiler-libs/flambda_utils.cmi) + (.ocamloptcomp.objs/byte/flambda_utils.cmo as compiler-libs/flambda_utils.cmo) + (.ocamloptcomp.objs/byte/flambda_utils.cmt as compiler-libs/flambda_utils.cmt) + (.ocamloptcomp.objs/byte/flambda_utils.cmti as compiler-libs/flambda_utils.cmti) + (.ocamloptcomp.objs/byte/freshening.cmi as compiler-libs/freshening.cmi) + (.ocamloptcomp.objs/byte/freshening.cmo as compiler-libs/freshening.cmo) + (.ocamloptcomp.objs/byte/freshening.cmt as compiler-libs/freshening.cmt) + (.ocamloptcomp.objs/byte/freshening.cmti as compiler-libs/freshening.cmti) + (.ocamloptcomp.objs/byte/id_types.cmi as compiler-libs/id_types.cmi) + (.ocamloptcomp.objs/byte/id_types.cmo as compiler-libs/id_types.cmo) + (.ocamloptcomp.objs/byte/id_types.cmt as compiler-libs/id_types.cmt) + (.ocamloptcomp.objs/byte/id_types.cmti as compiler-libs/id_types.cmti) + (.ocamloptcomp.objs/byte/import_approx.cmi as compiler-libs/import_approx.cmi) + (.ocamloptcomp.objs/byte/import_approx.cmo as compiler-libs/import_approx.cmo) + (.ocamloptcomp.objs/byte/import_approx.cmt as compiler-libs/import_approx.cmt) + (.ocamloptcomp.objs/byte/import_approx.cmti as compiler-libs/import_approx.cmti) + (.ocamloptcomp.objs/byte/inconstant_idents.cmi as compiler-libs/inconstant_idents.cmi) + (.ocamloptcomp.objs/byte/inconstant_idents.cmo as compiler-libs/inconstant_idents.cmo) + (.ocamloptcomp.objs/byte/inconstant_idents.cmt as compiler-libs/inconstant_idents.cmt) + (.ocamloptcomp.objs/byte/inconstant_idents.cmti as compiler-libs/inconstant_idents.cmti) + (.ocamloptcomp.objs/byte/initialize_symbol_to_let_symbol.cmi as compiler-libs/initialize_symbol_to_let_symbol.cmi) + (.ocamloptcomp.objs/byte/initialize_symbol_to_let_symbol.cmo as compiler-libs/initialize_symbol_to_let_symbol.cmo) + (.ocamloptcomp.objs/byte/initialize_symbol_to_let_symbol.cmt as compiler-libs/initialize_symbol_to_let_symbol.cmt) + (.ocamloptcomp.objs/byte/initialize_symbol_to_let_symbol.cmti as compiler-libs/initialize_symbol_to_let_symbol.cmti) + (.ocamloptcomp.objs/byte/inline_and_simplify.cmi as compiler-libs/inline_and_simplify.cmi) + (.ocamloptcomp.objs/byte/inline_and_simplify.cmo as compiler-libs/inline_and_simplify.cmo) + (.ocamloptcomp.objs/byte/inline_and_simplify.cmt as compiler-libs/inline_and_simplify.cmt) + (.ocamloptcomp.objs/byte/inline_and_simplify.cmti as compiler-libs/inline_and_simplify.cmti) + (.ocamloptcomp.objs/byte/inline_and_simplify_aux.cmi as compiler-libs/inline_and_simplify_aux.cmi) + (.ocamloptcomp.objs/byte/inline_and_simplify_aux.cmo as compiler-libs/inline_and_simplify_aux.cmo) + (.ocamloptcomp.objs/byte/inline_and_simplify_aux.cmt as compiler-libs/inline_and_simplify_aux.cmt) + (.ocamloptcomp.objs/byte/inline_and_simplify_aux.cmti as compiler-libs/inline_and_simplify_aux.cmti) + (.ocamloptcomp.objs/byte/inlining_cost.cmi as compiler-libs/inlining_cost.cmi) + (.ocamloptcomp.objs/byte/inlining_cost.cmo as compiler-libs/inlining_cost.cmo) + (.ocamloptcomp.objs/byte/inlining_cost.cmt as compiler-libs/inlining_cost.cmt) + (.ocamloptcomp.objs/byte/inlining_cost.cmti as compiler-libs/inlining_cost.cmti) + (.ocamloptcomp.objs/byte/inlining_decision.cmi as compiler-libs/inlining_decision.cmi) + (.ocamloptcomp.objs/byte/inlining_decision.cmo as compiler-libs/inlining_decision.cmo) + (.ocamloptcomp.objs/byte/inlining_decision.cmt as compiler-libs/inlining_decision.cmt) + (.ocamloptcomp.objs/byte/inlining_decision.cmti as compiler-libs/inlining_decision.cmti) + (.ocamloptcomp.objs/byte/inlining_decision_intf.cmi as compiler-libs/inlining_decision_intf.cmi) + (.ocamloptcomp.objs/byte/inlining_decision_intf.cmti as compiler-libs/inlining_decision_intf.cmti) + (.ocamloptcomp.objs/byte/inlining_stats.cmi as compiler-libs/inlining_stats.cmi) + (.ocamloptcomp.objs/byte/inlining_stats.cmo as compiler-libs/inlining_stats.cmo) + (.ocamloptcomp.objs/byte/inlining_stats.cmt as compiler-libs/inlining_stats.cmt) + (.ocamloptcomp.objs/byte/inlining_stats.cmti as compiler-libs/inlining_stats.cmti) + (.ocamloptcomp.objs/byte/inlining_stats_types.cmi as compiler-libs/inlining_stats_types.cmi) + (.ocamloptcomp.objs/byte/inlining_stats_types.cmo as compiler-libs/inlining_stats_types.cmo) + (.ocamloptcomp.objs/byte/inlining_stats_types.cmt as compiler-libs/inlining_stats_types.cmt) + (.ocamloptcomp.objs/byte/inlining_stats_types.cmti as compiler-libs/inlining_stats_types.cmti) + (.ocamloptcomp.objs/byte/inlining_transforms.cmi as compiler-libs/inlining_transforms.cmi) + (.ocamloptcomp.objs/byte/inlining_transforms.cmo as compiler-libs/inlining_transforms.cmo) + (.ocamloptcomp.objs/byte/inlining_transforms.cmt as compiler-libs/inlining_transforms.cmt) + (.ocamloptcomp.objs/byte/inlining_transforms.cmti as compiler-libs/inlining_transforms.cmti) + (.ocamloptcomp.objs/byte/internal_variable_names.cmi as compiler-libs/internal_variable_names.cmi) + (.ocamloptcomp.objs/byte/internal_variable_names.cmo as compiler-libs/internal_variable_names.cmo) + (.ocamloptcomp.objs/byte/internal_variable_names.cmt as compiler-libs/internal_variable_names.cmt) + (.ocamloptcomp.objs/byte/internal_variable_names.cmti as compiler-libs/internal_variable_names.cmti) + (.ocamloptcomp.objs/byte/invariant_params.cmi as compiler-libs/invariant_params.cmi) + (.ocamloptcomp.objs/byte/invariant_params.cmo as compiler-libs/invariant_params.cmo) + (.ocamloptcomp.objs/byte/invariant_params.cmt as compiler-libs/invariant_params.cmt) + (.ocamloptcomp.objs/byte/invariant_params.cmti as compiler-libs/invariant_params.cmti) + (.ocamloptcomp.objs/byte/lift_code.cmi as compiler-libs/lift_code.cmi) + (.ocamloptcomp.objs/byte/lift_code.cmo as compiler-libs/lift_code.cmo) + (.ocamloptcomp.objs/byte/lift_code.cmt as compiler-libs/lift_code.cmt) + (.ocamloptcomp.objs/byte/lift_code.cmti as compiler-libs/lift_code.cmti) + (.ocamloptcomp.objs/byte/lift_constants.cmi as compiler-libs/lift_constants.cmi) + (.ocamloptcomp.objs/byte/lift_constants.cmo as compiler-libs/lift_constants.cmo) + (.ocamloptcomp.objs/byte/lift_constants.cmt as compiler-libs/lift_constants.cmt) + (.ocamloptcomp.objs/byte/lift_constants.cmti as compiler-libs/lift_constants.cmti) + (.ocamloptcomp.objs/byte/lift_let_to_initialize_symbol.cmi as compiler-libs/lift_let_to_initialize_symbol.cmi) + (.ocamloptcomp.objs/byte/lift_let_to_initialize_symbol.cmo as compiler-libs/lift_let_to_initialize_symbol.cmo) + (.ocamloptcomp.objs/byte/lift_let_to_initialize_symbol.cmt as compiler-libs/lift_let_to_initialize_symbol.cmt) + (.ocamloptcomp.objs/byte/lift_let_to_initialize_symbol.cmti as compiler-libs/lift_let_to_initialize_symbol.cmti) + (.ocamloptcomp.objs/byte/linkage_name.cmi as compiler-libs/linkage_name.cmi) + (.ocamloptcomp.objs/byte/linkage_name.cmo as compiler-libs/linkage_name.cmo) + (.ocamloptcomp.objs/byte/linkage_name.cmt as compiler-libs/linkage_name.cmt) + (.ocamloptcomp.objs/byte/linkage_name.cmti as compiler-libs/linkage_name.cmti) + (.ocamloptcomp.objs/byte/mutable_variable.cmi as compiler-libs/mutable_variable.cmi) + (.ocamloptcomp.objs/byte/mutable_variable.cmo as compiler-libs/mutable_variable.cmo) + (.ocamloptcomp.objs/byte/mutable_variable.cmt as compiler-libs/mutable_variable.cmt) + (.ocamloptcomp.objs/byte/mutable_variable.cmti as compiler-libs/mutable_variable.cmti) + (.ocamloptcomp.objs/byte/parameter.cmi as compiler-libs/parameter.cmi) + (.ocamloptcomp.objs/byte/parameter.cmo as compiler-libs/parameter.cmo) + (.ocamloptcomp.objs/byte/parameter.cmt as compiler-libs/parameter.cmt) + (.ocamloptcomp.objs/byte/parameter.cmti as compiler-libs/parameter.cmti) + (.ocamloptcomp.objs/byte/pass_wrapper.cmi as compiler-libs/pass_wrapper.cmi) + (.ocamloptcomp.objs/byte/pass_wrapper.cmo as compiler-libs/pass_wrapper.cmo) + (.ocamloptcomp.objs/byte/pass_wrapper.cmt as compiler-libs/pass_wrapper.cmt) + (.ocamloptcomp.objs/byte/pass_wrapper.cmti as compiler-libs/pass_wrapper.cmti) + (.ocamloptcomp.objs/byte/printclambda.cmi as compiler-libs/printclambda.cmi) + (.ocamloptcomp.objs/byte/printclambda.cmo as compiler-libs/printclambda.cmo) + (.ocamloptcomp.objs/byte/printclambda.cmt as compiler-libs/printclambda.cmt) + (.ocamloptcomp.objs/byte/printclambda.cmti as compiler-libs/printclambda.cmti) + (.ocamloptcomp.objs/byte/printclambda_primitives.cmi as compiler-libs/printclambda_primitives.cmi) + (.ocamloptcomp.objs/byte/printclambda_primitives.cmo as compiler-libs/printclambda_primitives.cmo) + (.ocamloptcomp.objs/byte/printclambda_primitives.cmt as compiler-libs/printclambda_primitives.cmt) + (.ocamloptcomp.objs/byte/printclambda_primitives.cmti as compiler-libs/printclambda_primitives.cmti) + (.ocamloptcomp.objs/byte/projection.cmi as compiler-libs/projection.cmi) + (.ocamloptcomp.objs/byte/projection.cmo as compiler-libs/projection.cmo) + (.ocamloptcomp.objs/byte/projection.cmt as compiler-libs/projection.cmt) + (.ocamloptcomp.objs/byte/projection.cmti as compiler-libs/projection.cmti) + (.ocamloptcomp.objs/byte/ref_to_variables.cmi as compiler-libs/ref_to_variables.cmi) + (.ocamloptcomp.objs/byte/ref_to_variables.cmo as compiler-libs/ref_to_variables.cmo) + (.ocamloptcomp.objs/byte/ref_to_variables.cmt as compiler-libs/ref_to_variables.cmt) + (.ocamloptcomp.objs/byte/ref_to_variables.cmti as compiler-libs/ref_to_variables.cmti) + (.ocamloptcomp.objs/byte/remove_free_vars_equal_to_args.cmi as compiler-libs/remove_free_vars_equal_to_args.cmi) + (.ocamloptcomp.objs/byte/remove_free_vars_equal_to_args.cmo as compiler-libs/remove_free_vars_equal_to_args.cmo) + (.ocamloptcomp.objs/byte/remove_free_vars_equal_to_args.cmt as compiler-libs/remove_free_vars_equal_to_args.cmt) + (.ocamloptcomp.objs/byte/remove_free_vars_equal_to_args.cmti as compiler-libs/remove_free_vars_equal_to_args.cmti) + (.ocamloptcomp.objs/byte/remove_unused_arguments.cmi as compiler-libs/remove_unused_arguments.cmi) + (.ocamloptcomp.objs/byte/remove_unused_arguments.cmo as compiler-libs/remove_unused_arguments.cmo) + (.ocamloptcomp.objs/byte/remove_unused_arguments.cmt as compiler-libs/remove_unused_arguments.cmt) + (.ocamloptcomp.objs/byte/remove_unused_arguments.cmti as compiler-libs/remove_unused_arguments.cmti) + (.ocamloptcomp.objs/byte/remove_unused_closure_vars.cmi as compiler-libs/remove_unused_closure_vars.cmi) + (.ocamloptcomp.objs/byte/remove_unused_closure_vars.cmo as compiler-libs/remove_unused_closure_vars.cmo) + (.ocamloptcomp.objs/byte/remove_unused_closure_vars.cmt as compiler-libs/remove_unused_closure_vars.cmt) + (.ocamloptcomp.objs/byte/remove_unused_closure_vars.cmti as compiler-libs/remove_unused_closure_vars.cmti) + (.ocamloptcomp.objs/byte/remove_unused_program_constructs.cmi as compiler-libs/remove_unused_program_constructs.cmi) + (.ocamloptcomp.objs/byte/remove_unused_program_constructs.cmo as compiler-libs/remove_unused_program_constructs.cmo) + (.ocamloptcomp.objs/byte/remove_unused_program_constructs.cmt as compiler-libs/remove_unused_program_constructs.cmt) + (.ocamloptcomp.objs/byte/remove_unused_program_constructs.cmti as compiler-libs/remove_unused_program_constructs.cmti) + (.ocamloptcomp.objs/byte/semantics_of_primitives.cmi as compiler-libs/semantics_of_primitives.cmi) + (.ocamloptcomp.objs/byte/semantics_of_primitives.cmo as compiler-libs/semantics_of_primitives.cmo) + (.ocamloptcomp.objs/byte/semantics_of_primitives.cmt as compiler-libs/semantics_of_primitives.cmt) + (.ocamloptcomp.objs/byte/semantics_of_primitives.cmti as compiler-libs/semantics_of_primitives.cmti) + (.ocamloptcomp.objs/byte/set_of_closures_id.cmi as compiler-libs/set_of_closures_id.cmi) + (.ocamloptcomp.objs/byte/set_of_closures_id.cmo as compiler-libs/set_of_closures_id.cmo) + (.ocamloptcomp.objs/byte/set_of_closures_id.cmt as compiler-libs/set_of_closures_id.cmt) + (.ocamloptcomp.objs/byte/set_of_closures_id.cmti as compiler-libs/set_of_closures_id.cmti) + (.ocamloptcomp.objs/byte/set_of_closures_origin.cmi as compiler-libs/set_of_closures_origin.cmi) + (.ocamloptcomp.objs/byte/set_of_closures_origin.cmo as compiler-libs/set_of_closures_origin.cmo) + (.ocamloptcomp.objs/byte/set_of_closures_origin.cmt as compiler-libs/set_of_closures_origin.cmt) + (.ocamloptcomp.objs/byte/set_of_closures_origin.cmti as compiler-libs/set_of_closures_origin.cmti) + (.ocamloptcomp.objs/byte/share_constants.cmi as compiler-libs/share_constants.cmi) + (.ocamloptcomp.objs/byte/share_constants.cmo as compiler-libs/share_constants.cmo) + (.ocamloptcomp.objs/byte/share_constants.cmt as compiler-libs/share_constants.cmt) + (.ocamloptcomp.objs/byte/share_constants.cmti as compiler-libs/share_constants.cmti) + (.ocamloptcomp.objs/byte/simple_value_approx.cmi as compiler-libs/simple_value_approx.cmi) + (.ocamloptcomp.objs/byte/simple_value_approx.cmo as compiler-libs/simple_value_approx.cmo) + (.ocamloptcomp.objs/byte/simple_value_approx.cmt as compiler-libs/simple_value_approx.cmt) + (.ocamloptcomp.objs/byte/simple_value_approx.cmti as compiler-libs/simple_value_approx.cmti) + (.ocamloptcomp.objs/byte/simplify_boxed_integer_ops.cmi as compiler-libs/simplify_boxed_integer_ops.cmi) + (.ocamloptcomp.objs/byte/simplify_boxed_integer_ops.cmo as compiler-libs/simplify_boxed_integer_ops.cmo) + (.ocamloptcomp.objs/byte/simplify_boxed_integer_ops.cmt as compiler-libs/simplify_boxed_integer_ops.cmt) + (.ocamloptcomp.objs/byte/simplify_boxed_integer_ops.cmti as compiler-libs/simplify_boxed_integer_ops.cmti) + (.ocamloptcomp.objs/byte/simplify_boxed_integer_ops_intf.cmi as compiler-libs/simplify_boxed_integer_ops_intf.cmi) + (.ocamloptcomp.objs/byte/simplify_boxed_integer_ops_intf.cmti as compiler-libs/simplify_boxed_integer_ops_intf.cmti) + (.ocamloptcomp.objs/byte/simplify_common.cmi as compiler-libs/simplify_common.cmi) + (.ocamloptcomp.objs/byte/simplify_common.cmo as compiler-libs/simplify_common.cmo) + (.ocamloptcomp.objs/byte/simplify_common.cmt as compiler-libs/simplify_common.cmt) + (.ocamloptcomp.objs/byte/simplify_common.cmti as compiler-libs/simplify_common.cmti) + (.ocamloptcomp.objs/byte/simplify_primitives.cmi as compiler-libs/simplify_primitives.cmi) + (.ocamloptcomp.objs/byte/simplify_primitives.cmo as compiler-libs/simplify_primitives.cmo) + (.ocamloptcomp.objs/byte/simplify_primitives.cmt as compiler-libs/simplify_primitives.cmt) + (.ocamloptcomp.objs/byte/simplify_primitives.cmti as compiler-libs/simplify_primitives.cmti) + (.ocamloptcomp.objs/byte/static_exception.cmi as compiler-libs/static_exception.cmi) + (.ocamloptcomp.objs/byte/static_exception.cmo as compiler-libs/static_exception.cmo) + (.ocamloptcomp.objs/byte/static_exception.cmt as compiler-libs/static_exception.cmt) + (.ocamloptcomp.objs/byte/static_exception.cmti as compiler-libs/static_exception.cmti) + (.ocamloptcomp.objs/byte/symbol.cmi as compiler-libs/symbol.cmi) + (.ocamloptcomp.objs/byte/symbol.cmo as compiler-libs/symbol.cmo) + (.ocamloptcomp.objs/byte/symbol.cmt as compiler-libs/symbol.cmt) + (.ocamloptcomp.objs/byte/symbol.cmti as compiler-libs/symbol.cmti) + (.ocamloptcomp.objs/byte/tag.cmi as compiler-libs/tag.cmi) + (.ocamloptcomp.objs/byte/tag.cmo as compiler-libs/tag.cmo) + (.ocamloptcomp.objs/byte/tag.cmt as compiler-libs/tag.cmt) + (.ocamloptcomp.objs/byte/tag.cmti as compiler-libs/tag.cmti) + (.ocamloptcomp.objs/byte/traverse_for_exported_symbols.cmi as compiler-libs/traverse_for_exported_symbols.cmi) + (.ocamloptcomp.objs/byte/traverse_for_exported_symbols.cmo as compiler-libs/traverse_for_exported_symbols.cmo) + (.ocamloptcomp.objs/byte/traverse_for_exported_symbols.cmt as compiler-libs/traverse_for_exported_symbols.cmt) + (.ocamloptcomp.objs/byte/traverse_for_exported_symbols.cmti as compiler-libs/traverse_for_exported_symbols.cmti) + (.ocamloptcomp.objs/byte/un_anf.cmi as compiler-libs/un_anf.cmi) + (.ocamloptcomp.objs/byte/un_anf.cmo as compiler-libs/un_anf.cmo) + (.ocamloptcomp.objs/byte/un_anf.cmt as compiler-libs/un_anf.cmt) + (.ocamloptcomp.objs/byte/un_anf.cmti as compiler-libs/un_anf.cmti) + (.ocamloptcomp.objs/byte/unbox_closures.cmi as compiler-libs/unbox_closures.cmi) + (.ocamloptcomp.objs/byte/unbox_closures.cmo as compiler-libs/unbox_closures.cmo) + (.ocamloptcomp.objs/byte/unbox_closures.cmt as compiler-libs/unbox_closures.cmt) + (.ocamloptcomp.objs/byte/unbox_closures.cmti as compiler-libs/unbox_closures.cmti) + (.ocamloptcomp.objs/byte/unbox_free_vars_of_closures.cmi as compiler-libs/unbox_free_vars_of_closures.cmi) + (.ocamloptcomp.objs/byte/unbox_free_vars_of_closures.cmo as compiler-libs/unbox_free_vars_of_closures.cmo) + (.ocamloptcomp.objs/byte/unbox_free_vars_of_closures.cmt as compiler-libs/unbox_free_vars_of_closures.cmt) + (.ocamloptcomp.objs/byte/unbox_free_vars_of_closures.cmti as compiler-libs/unbox_free_vars_of_closures.cmti) + (.ocamloptcomp.objs/byte/unbox_specialised_args.cmi as compiler-libs/unbox_specialised_args.cmi) + (.ocamloptcomp.objs/byte/unbox_specialised_args.cmo as compiler-libs/unbox_specialised_args.cmo) + (.ocamloptcomp.objs/byte/unbox_specialised_args.cmt as compiler-libs/unbox_specialised_args.cmt) + (.ocamloptcomp.objs/byte/unbox_specialised_args.cmti as compiler-libs/unbox_specialised_args.cmti) + (.ocamloptcomp.objs/byte/var_within_closure.cmi as compiler-libs/var_within_closure.cmi) + (.ocamloptcomp.objs/byte/var_within_closure.cmo as compiler-libs/var_within_closure.cmo) + (.ocamloptcomp.objs/byte/var_within_closure.cmt as compiler-libs/var_within_closure.cmt) + (.ocamloptcomp.objs/byte/var_within_closure.cmti as compiler-libs/var_within_closure.cmti) + (.ocamloptcomp.objs/byte/variable.cmi as compiler-libs/variable.cmi) + (.ocamloptcomp.objs/byte/variable.cmo as compiler-libs/variable.cmo) + (.ocamloptcomp.objs/byte/variable.cmt as compiler-libs/variable.cmt) + (.ocamloptcomp.objs/byte/variable.cmti as compiler-libs/variable.cmti) + (.ocamloptcomp.objs/native/alias_analysis.cmx as compiler-libs/alias_analysis.cmx) + (.ocamloptcomp.objs/native/allocated_const.cmx as compiler-libs/allocated_const.cmx) + (.ocamloptcomp.objs/native/augment_specialised_args.cmx as compiler-libs/augment_specialised_args.cmx) + (.ocamloptcomp.objs/native/backend_var.cmx as compiler-libs/backend_var.cmx) + (.ocamloptcomp.objs/native/build_export_info.cmx as compiler-libs/build_export_info.cmx) + (.ocamloptcomp.objs/native/clambda.cmx as compiler-libs/clambda.cmx) + (.ocamloptcomp.objs/native/clambda_primitives.cmx as compiler-libs/clambda_primitives.cmx) + (.ocamloptcomp.objs/native/closure.cmx as compiler-libs/closure.cmx) + (.ocamloptcomp.objs/native/closure_conversion.cmx as compiler-libs/closure_conversion.cmx) + (.ocamloptcomp.objs/native/closure_conversion_aux.cmx as compiler-libs/closure_conversion_aux.cmx) + (.ocamloptcomp.objs/native/closure_element.cmx as compiler-libs/closure_element.cmx) + (.ocamloptcomp.objs/native/closure_id.cmx as compiler-libs/closure_id.cmx) + (.ocamloptcomp.objs/native/closure_middle_end.cmx as compiler-libs/closure_middle_end.cmx) + (.ocamloptcomp.objs/native/closure_offsets.cmx as compiler-libs/closure_offsets.cmx) + (.ocamloptcomp.objs/native/closure_origin.cmx as compiler-libs/closure_origin.cmx) + (.ocamloptcomp.objs/native/compilation_unit.cmx as compiler-libs/compilation_unit.cmx) + (.ocamloptcomp.objs/native/compilenv.cmx as compiler-libs/compilenv.cmx) + (.ocamloptcomp.objs/native/convert_primitives.cmx as compiler-libs/convert_primitives.cmx) + (.ocamloptcomp.objs/native/effect_analysis.cmx as compiler-libs/effect_analysis.cmx) + (.ocamloptcomp.objs/native/export_id.cmx as compiler-libs/export_id.cmx) + (.ocamloptcomp.objs/native/export_info.cmx as compiler-libs/export_info.cmx) + (.ocamloptcomp.objs/native/export_info_for_pack.cmx as compiler-libs/export_info_for_pack.cmx) + (.ocamloptcomp.objs/native/extract_projections.cmx as compiler-libs/extract_projections.cmx) + (.ocamloptcomp.objs/native/find_recursive_functions.cmx as compiler-libs/find_recursive_functions.cmx) + (.ocamloptcomp.objs/native/flambda.cmx as compiler-libs/flambda.cmx) + (.ocamloptcomp.objs/native/flambda_invariants.cmx as compiler-libs/flambda_invariants.cmx) + (.ocamloptcomp.objs/native/flambda_iterators.cmx as compiler-libs/flambda_iterators.cmx) + (.ocamloptcomp.objs/native/flambda_middle_end.cmx as compiler-libs/flambda_middle_end.cmx) + (.ocamloptcomp.objs/native/flambda_to_clambda.cmx as compiler-libs/flambda_to_clambda.cmx) + (.ocamloptcomp.objs/native/flambda_utils.cmx as compiler-libs/flambda_utils.cmx) + (.ocamloptcomp.objs/native/freshening.cmx as compiler-libs/freshening.cmx) + (.ocamloptcomp.objs/native/id_types.cmx as compiler-libs/id_types.cmx) + (.ocamloptcomp.objs/native/import_approx.cmx as compiler-libs/import_approx.cmx) + (.ocamloptcomp.objs/native/inconstant_idents.cmx as compiler-libs/inconstant_idents.cmx) + (.ocamloptcomp.objs/native/initialize_symbol_to_let_symbol.cmx as compiler-libs/initialize_symbol_to_let_symbol.cmx) + (.ocamloptcomp.objs/native/inline_and_simplify.cmx as compiler-libs/inline_and_simplify.cmx) + (.ocamloptcomp.objs/native/inline_and_simplify_aux.cmx as compiler-libs/inline_and_simplify_aux.cmx) + (.ocamloptcomp.objs/native/inlining_cost.cmx as compiler-libs/inlining_cost.cmx) + (.ocamloptcomp.objs/native/inlining_decision.cmx as compiler-libs/inlining_decision.cmx) + (.ocamloptcomp.objs/native/inlining_stats.cmx as compiler-libs/inlining_stats.cmx) + (.ocamloptcomp.objs/native/inlining_stats_types.cmx as compiler-libs/inlining_stats_types.cmx) + (.ocamloptcomp.objs/native/inlining_transforms.cmx as compiler-libs/inlining_transforms.cmx) + (.ocamloptcomp.objs/native/internal_variable_names.cmx as compiler-libs/internal_variable_names.cmx) + (.ocamloptcomp.objs/native/invariant_params.cmx as compiler-libs/invariant_params.cmx) + (.ocamloptcomp.objs/native/lift_code.cmx as compiler-libs/lift_code.cmx) + (.ocamloptcomp.objs/native/lift_constants.cmx as compiler-libs/lift_constants.cmx) + (.ocamloptcomp.objs/native/lift_let_to_initialize_symbol.cmx as compiler-libs/lift_let_to_initialize_symbol.cmx) + (.ocamloptcomp.objs/native/linkage_name.cmx as compiler-libs/linkage_name.cmx) + (.ocamloptcomp.objs/native/mutable_variable.cmx as compiler-libs/mutable_variable.cmx) + (.ocamloptcomp.objs/native/parameter.cmx as compiler-libs/parameter.cmx) + (.ocamloptcomp.objs/native/pass_wrapper.cmx as compiler-libs/pass_wrapper.cmx) + (.ocamloptcomp.objs/native/printclambda.cmx as compiler-libs/printclambda.cmx) + (.ocamloptcomp.objs/native/printclambda_primitives.cmx as compiler-libs/printclambda_primitives.cmx) + (.ocamloptcomp.objs/native/projection.cmx as compiler-libs/projection.cmx) + (.ocamloptcomp.objs/native/ref_to_variables.cmx as compiler-libs/ref_to_variables.cmx) + (.ocamloptcomp.objs/native/remove_free_vars_equal_to_args.cmx as compiler-libs/remove_free_vars_equal_to_args.cmx) + (.ocamloptcomp.objs/native/remove_unused_arguments.cmx as compiler-libs/remove_unused_arguments.cmx) + (.ocamloptcomp.objs/native/remove_unused_closure_vars.cmx as compiler-libs/remove_unused_closure_vars.cmx) + (.ocamloptcomp.objs/native/remove_unused_program_constructs.cmx as compiler-libs/remove_unused_program_constructs.cmx) + (.ocamloptcomp.objs/native/semantics_of_primitives.cmx as compiler-libs/semantics_of_primitives.cmx) + (.ocamloptcomp.objs/native/set_of_closures_id.cmx as compiler-libs/set_of_closures_id.cmx) + (.ocamloptcomp.objs/native/set_of_closures_origin.cmx as compiler-libs/set_of_closures_origin.cmx) + (.ocamloptcomp.objs/native/share_constants.cmx as compiler-libs/share_constants.cmx) + (.ocamloptcomp.objs/native/simple_value_approx.cmx as compiler-libs/simple_value_approx.cmx) + (.ocamloptcomp.objs/native/simplify_boxed_integer_ops.cmx as compiler-libs/simplify_boxed_integer_ops.cmx) + (.ocamloptcomp.objs/native/simplify_common.cmx as compiler-libs/simplify_common.cmx) + (.ocamloptcomp.objs/native/simplify_primitives.cmx as compiler-libs/simplify_primitives.cmx) + (.ocamloptcomp.objs/native/static_exception.cmx as compiler-libs/static_exception.cmx) + (.ocamloptcomp.objs/native/symbol.cmx as compiler-libs/symbol.cmx) + (.ocamloptcomp.objs/native/tag.cmx as compiler-libs/tag.cmx) + (.ocamloptcomp.objs/native/traverse_for_exported_symbols.cmx as compiler-libs/traverse_for_exported_symbols.cmx) + (.ocamloptcomp.objs/native/un_anf.cmx as compiler-libs/un_anf.cmx) + (.ocamloptcomp.objs/native/unbox_closures.cmx as compiler-libs/unbox_closures.cmx) + (.ocamloptcomp.objs/native/unbox_free_vars_of_closures.cmx as compiler-libs/unbox_free_vars_of_closures.cmx) + (.ocamloptcomp.objs/native/unbox_specialised_args.cmx as compiler-libs/unbox_specialised_args.cmx) + (.ocamloptcomp.objs/native/var_within_closure.cmx as compiler-libs/var_within_closure.cmx) + (.ocamloptcomp.objs/native/variable.cmx as compiler-libs/variable.cmx) + )) diff --git a/dune-project b/dune-project new file mode 100644 index 00000000000..9213d0edaa8 --- /dev/null +++ b/dune-project @@ -0,0 +1,13 @@ +(lang dune 2.8) +(wrapped_executables false) +(using experimental_building_ocaml_compiler_with_dune 0.1) + +(cram enable) + +(package + (name flambda_backend) +) + +(package + (name ocaml) +) diff --git a/flambda_backend.opam b/flambda_backend.opam new file mode 100644 index 00000000000..bd110b291e3 --- /dev/null +++ b/flambda_backend.opam @@ -0,0 +1,28 @@ +opam-version: "2.0" +version: "4.11.2+trunk" +synopsis: "Flambda backend -- this OPAM file has not yet been sorted out" +depends: [ + "ocaml" {= "4.11.2" & post} + "base-unix" {post} + "base-bigarray" {post} + "base-threads" {post} +] +conflict-class: "ocaml-core-compiler" +flags: compiler +setenv: CAML_LD_LIBRARY_PATH = "%{lib}%/stublibs" +build: [ + ["./configure" "--prefix=%{prefix}%"] + [make "-j%{jobs}%"] +] +install: [make "install"] +maintainer: "caml-list@inria.fr" +homepage: "https://github.com/ocaml/ocaml/" +bug-reports: "https://github.com/ocaml/ocaml/issues" +authors: [ + "Xavier Leroy" + "Damien Doligez" + "Alain Frisch" + "Jacques Garrigue" + "Didier Rémy" + "Jérôme Vouillon" +] diff --git a/native_toplevel/dune b/native_toplevel/dune index f4e514490c0..620c2208f86 100644 --- a/native_toplevel/dune +++ b/native_toplevel/dune @@ -19,7 +19,6 @@ (modes native) (wrapped false) (flags (:standard -principal -nostdlib -w -9)) - (library_flags -linkall) (libraries stdlib ocamlcommon ocamlbytecomp ocamloptcomp dynlink_internal) (modules genprintval_native opttoploop opttopdirs opttopmain)) @@ -29,6 +28,23 @@ (deps %{project_root}/ocaml/toplevel/genprintval.ml) (action (copy %{deps} %{targets}))) +(executable + (name opttopstart) + (modes native) + (flags (:standard -principal -nostdlib)) + (libraries + ocamlopttoplevel + stdlib + runtime_native) + (modules opttopstart)) + +(install + (files + (opttopstart.exe as ocamlnat) + ) + (section bin) + (package ocaml)) + (install (files (ocamlopttoplevel.a as compiler-libs/ocamlopttoplevel.a)