From d735a3df5fe48734e29c68e4bbb1e00acee4014d Mon Sep 17 00:00:00 2001 From: Sebastien Bourdeauducq Date: Thu, 14 Feb 2019 15:29:42 +0800 Subject: [PATCH] initial commit (based on artiq 322861225e) --- artiq/artiq-board.nix | 61 ++++++ artiq/artiq-dev.nix | 35 +++ artiq/conda-board.nix | 57 +++++ artiq/conda-build.nix | 65 ++++++ artiq/default.nix | 18 ++ artiq/fetch-llvm-clang.nix | 22 ++ artiq/fetchcargo.nix | 35 +++ artiq/pkgs/artiq-src.nix | 7 + artiq/pkgs/artiq.nix | 79 +++++++ artiq/pkgs/binutils-or1k.nix | 34 +++ artiq/pkgs/llvm-or1k.nix | 45 ++++ artiq/pkgs/llvmlite.nix | 25 +++ artiq/pkgs/openocd.nix | 72 +++++++ artiq/pkgs/python3Packages.nix | 107 ++++++++++ artiq/pkgs/rust/binaryBuild.nix | 117 ++++++++++ artiq/pkgs/rust/bootstrap.nix | 42 ++++ artiq/pkgs/rust/default.nix | 88 ++++++++ .../patches/disable-test-inherit-env.patch | 10 + .../rust/patches/net-tcp-disable-tests.patch | 104 +++++++++ .../patches/stdsimd-disable-doctest.patch | 20 ++ artiq/pkgs/rust/print-hashes.sh | 38 ++++ artiq/pkgs/rust/rust-src.nix | 11 + artiq/pkgs/rust/rustc.nix | 199 ++++++++++++++++++ artiq/shell-dev.nix | 6 + artiq/shell.nix | 7 + main.nix | 56 +++++ 26 files changed, 1360 insertions(+) create mode 100644 artiq/artiq-board.nix create mode 100644 artiq/artiq-dev.nix create mode 100644 artiq/conda-board.nix create mode 100644 artiq/conda-build.nix create mode 100644 artiq/default.nix create mode 100644 artiq/fetch-llvm-clang.nix create mode 100644 artiq/fetchcargo.nix create mode 100644 artiq/pkgs/artiq-src.nix create mode 100644 artiq/pkgs/artiq.nix create mode 100644 artiq/pkgs/binutils-or1k.nix create mode 100644 artiq/pkgs/llvm-or1k.nix create mode 100644 artiq/pkgs/llvmlite.nix create mode 100644 artiq/pkgs/openocd.nix create mode 100644 artiq/pkgs/python3Packages.nix create mode 100644 artiq/pkgs/rust/binaryBuild.nix create mode 100644 artiq/pkgs/rust/bootstrap.nix create mode 100644 artiq/pkgs/rust/default.nix create mode 100644 artiq/pkgs/rust/patches/disable-test-inherit-env.patch create mode 100644 artiq/pkgs/rust/patches/net-tcp-disable-tests.patch create mode 100644 artiq/pkgs/rust/patches/stdsimd-disable-doctest.patch create mode 100755 artiq/pkgs/rust/print-hashes.sh create mode 100644 artiq/pkgs/rust/rust-src.nix create mode 100644 artiq/pkgs/rust/rustc.nix create mode 100644 artiq/shell-dev.nix create mode 100644 artiq/shell.nix create mode 100644 main.nix diff --git a/artiq/artiq-board.nix b/artiq/artiq-board.nix new file mode 100644 index 0000000..c535154 --- /dev/null +++ b/artiq/artiq-board.nix @@ -0,0 +1,61 @@ +# Install Vivado in /opt and add to /etc/nixos/configuration.nix: +# nix.sandboxPaths = ["/opt"]; + +{ pkgs ? import {}}: +{ target, variant, buildCommand ? "python -m artiq.gateware.targets.${target} -V ${variant}" }: + +let + artiqPkgs = import ./default.nix { inherit pkgs; }; + fetchcargo = import ./fetchcargo.nix { + inherit (pkgs) stdenv cacert git cargo cargo-vendor; + }; + artiqSrc = import ./pkgs/artiq-src.nix { fetchgit = pkgs.fetchgit; }; + cargoDeps = fetchcargo rec { + name = "artiq-firmware-cargo-deps"; + src = "${artiqSrc}/artiq/firmware"; + sha256 = "1xzjn9i4rkd9124v2gbdplsgsvp1hlx7czdgc58n316vsnrkbr86"; + }; + + cargoVendored = pkgs.stdenv.mkDerivation { + name = "artiq-firmware-cargo-vendored"; + src = cargoDeps; + phases = [ "unpackPhase" "installPhase" ]; + installPhase = + '' + mkdir -p $out/registry + cat << EOF > $out/config + [source.crates-io] + registry = "https://github.com/rust-lang/crates.io-index" + replace-with = "vendored-sources" + + [source."https://github.com/m-labs/libfringe"] + git = "https://github.com/m-labs/libfringe" + rev = "b8a6d8f" + replace-with = "vendored-sources" + + [source.vendored-sources] + directory = "$out/registry" + EOF + cp -R * $out/registry + ''; + }; + + buildenv = import ./artiq-dev.nix { inherit pkgs; }; + +in pkgs.stdenv.mkDerivation { + name = "artiq-board-${target}-${variant}"; + src = null; + phases = [ "buildPhase" "installPhase" ]; + buildPhase = + '' + ${buildenv}/bin/artiq-dev -c "CARGO_HOME=${cargoVendored} ${buildCommand}" + ''; + installPhase = + '' + TARGET_DIR=$out/${pkgs.python3Packages.python.sitePackages}/artiq/binaries/${target}-${variant} + mkdir -p $TARGET_DIR + cp artiq_${target}/${variant}/gateware/top.bit $TARGET_DIR + cp artiq_${target}/${variant}/software/bootloader/bootloader.bin $TARGET_DIR + cp artiq_${target}/${variant}/software/runtime/runtime.{elf,fbi} $TARGET_DIR + ''; +} diff --git a/artiq/artiq-dev.nix b/artiq/artiq-dev.nix new file mode 100644 index 0000000..33e888d --- /dev/null +++ b/artiq/artiq-dev.nix @@ -0,0 +1,35 @@ +{ pkgs ? import {}}: + +let + artiqpkgs = import ./default.nix { inherit pkgs; }; +in + pkgs.buildFHSUserEnv { + name = "artiq-dev"; + targetPkgs = pkgs: ( + with pkgs; [ + ncurses5 + gnumake + zlib + libuuid + xorg.libSM + xorg.libICE + xorg.libXrender + xorg.libX11 + xorg.libXext + xorg.libXtst + xorg.libXi + (python3.withPackages(ps: with ps; [ jinja2 numpy artiqpkgs.migen artiqpkgs.microscope artiqpkgs.misoc artiqpkgs.jesd204b artiqpkgs.artiq ])) + git + cargo + ] ++ + (with artiqpkgs; [ + rustc + binutils-or1k + llvm-or1k + openocd + ]) + ); + profile = '' + export TARGET_AR=${artiqpkgs.binutils-or1k}/bin/or1k-linux-ar + ''; + } diff --git a/artiq/conda-board.nix b/artiq/conda-board.nix new file mode 100644 index 0000000..08c9fc1 --- /dev/null +++ b/artiq/conda-board.nix @@ -0,0 +1,57 @@ +{ pkgs ? import {}}: +{ artiqSrc, boardBinaries, target, variant }: + +with pkgs; + +let + fakeCondaSource = runCommand "fake-conda-source-${target}-${variant}" { } + '' + cp --no-preserve=mode,ownership -R ${artiqSrc} $out + mkdir $out/fake-conda; + + cat << EOF > $out/fake-conda/meta.yaml + package: + name: artiq-board-${target}-${variant} + version: {{ environ["GIT_DESCRIBE_TAG"] }} + + source: + git_url: .. + + build: + noarch: python + number: {{ environ["GIT_DESCRIBE_NUMBER"] }} + string: {{ environ["GIT_DESCRIBE_NUMBER"] }}+git{{ environ["GIT_FULL_HASH"][:8] }} + ignore_prefix_files: True + + outputs: + - name: artiq-board-${target}-${variant} + noarch: python + files: + - site-packages + requirements: + run: + - artiq + ignore_prefix_files: True + + about: + home: https://m-labs.hk/artiq + license: LGPL + summary: 'Bitstream, BIOS and firmware for the ${target}-${variant} board variant' + EOF + + cat << EOF > $out/fake-conda/build.sh + #!/bin/bash + set -e + SOC_PREFIX=\$PREFIX/site-packages/artiq/binaries/${target}-${variant} + mkdir -p \$SOC_PREFIX + cp ${boardBinaries}/${pkgs.python3Packages.python.sitePackages}/artiq/binaries/${target}-${variant}/* \$SOC_PREFIX + EOF + chmod 755 $out/fake-conda/build.sh + ''; + conda-board = import ./conda-build.nix { inherit pkgs; } { + name = "conda-artiq-board-${target}-${variant}"; + src = fakeCondaSource; + recipe = "fake-conda"; + }; +in + conda-board diff --git a/artiq/conda-build.nix b/artiq/conda-build.nix new file mode 100644 index 0000000..22dd9eb --- /dev/null +++ b/artiq/conda-build.nix @@ -0,0 +1,65 @@ +# We need to pass the whole source to conda for the git variables to work. +# recipe must be a string pointing to a path within the source. + +{ pkgs ? import {}}: +{ name, src, recipe }: + +with pkgs; + +let + condaDeps = [ stdenv.cc xorg.libSM xorg.libICE xorg.libXrender libselinux ]; + # Use the full Anaconda distribution, which already contains conda-build and its many dependencies, + # so we don't have to manually deal with them. + condaInstaller = fetchurl { + url = "https://repo.anaconda.com/archive/Anaconda3-2018.12-Linux-x86_64.sh"; + sha256 = "006fgyz75ihd00qzbr1cny97xf1mwnzibbqyhskghraqgs2x068h"; + }; + condaSrcChmod = runCommand "conda-src-chmod" { } "mkdir $out; cp ${condaInstaller} $out/conda-installer.sh; chmod +x $out/conda-installer.sh"; + condaInstallerEnv = buildFHSUserEnv { + name = "conda-installer-env"; + targetPkgs = pkgs: ([ condaSrcChmod ] ++ condaDeps); + }; + + # Git depends on libiconv + condaIconv = fetchurl { + url = "https://anaconda.org/conda-forge/libiconv/1.15/download/linux-64/libiconv-1.15-h14c3975_1004.tar.bz2"; + sha256 = "167j8jpr6mnyrzwp18dr52xr3xjsf39q452ag247ijlmp092v8ns"; + }; + condaGit = fetchurl { + url = "https://anaconda.org/conda-forge/git/2.20.1/download/linux-64/git-2.20.1-pl526hc122a05_1001.tar.bz2"; + sha256 = "03s01xq2jj7zbx7jfzz6agy40jj7xkq6dwar3lw1z5j2rbmh8h0h"; + }; + condaInstalled = runCommand "conda-installed" { } + '' + ${condaInstallerEnv}/bin/conda-installer-env -c "${condaSrcChmod}/conda-installer.sh -p $out -b" + ${condaInstallerEnv}/bin/conda-installer-env -c "$out/bin/conda install ${condaIconv}" + ${condaInstallerEnv}/bin/conda-installer-env -c "$out/bin/conda install ${condaGit}" + ''; + condaBuilderEnv = buildFHSUserEnv { + name = "conda-builder-env"; + targetPkgs = pkgs: [ condaInstalled ] ++ condaDeps; + }; + +in stdenv.mkDerivation { + inherit name src; + buildInputs = [ condaBuilderEnv ]; + buildCommand = + '' + HOME=`pwd` + # Build requirements make conda-build fail when disconnected from the internet, e.g. in the nix sandbox. + # Just ignore them - python and setuptools are installed anyway. + cat << EOF > clobber.yaml + requirements: + build: + + build: + script_env: + - PYTHON + EOF + mkdir $out + ${condaBuilderEnv}/bin/conda-builder-env -c "PYTHON=python conda build --clobber-file clobber.yaml --no-anaconda-upload --no-test --output-folder $out $src/${recipe}" + + mkdir -p $out/nix-support + echo file conda $out/noarch/*.tar.bz2 >> $out/nix-support/hydra-build-products + ''; +} diff --git a/artiq/default.nix b/artiq/default.nix new file mode 100644 index 0000000..5b27187 --- /dev/null +++ b/artiq/default.nix @@ -0,0 +1,18 @@ +{ pkgs ? import {}}: +with pkgs; +let + # this code was copied from nipxkgs rev. ffafe9 (nixcloud team) and slightly modified + rust = callPackage ./pkgs/rust + (stdenv.lib.optionalAttrs (stdenv.cc.isGNU && stdenv.hostPlatform.isi686) { + stdenv = overrideCC stdenv gcc6; # with gcc-7: undefined reference to `__divmoddi4' + }); + llvm-src = callPackage ./fetch-llvm-clang.nix {}; +in rec { + inherit (rust) rustc; + inherit (callPackage ./pkgs/python3Packages.nix {}) migen microscope misoc jesd204b; + binutils-or1k = callPackage ./pkgs/binutils-or1k.nix {}; + llvm-or1k = callPackage ./pkgs/llvm-or1k.nix { inherit llvm-src; }; + llvmlite = callPackage ./pkgs/llvmlite.nix { inherit llvm-or1k; }; + artiq = callPackage ./pkgs/artiq.nix { inherit binutils-or1k; inherit llvm-or1k; inherit llvmlite; }; + openocd = callPackage ./pkgs/openocd.nix {}; +} diff --git a/artiq/fetch-llvm-clang.nix b/artiq/fetch-llvm-clang.nix new file mode 100644 index 0000000..686aef9 --- /dev/null +++ b/artiq/fetch-llvm-clang.nix @@ -0,0 +1,22 @@ +{ runCommand, fetchFromGitHub, git }: + +let +llvm-src = fetchFromGitHub { + rev = "527aa86b578da5dfb9cf4510b71f0f46a11249f7"; + owner = "m-labs"; + repo = "llvm-or1k"; + sha256 = "0lmcg9xj66pf4mb6racipw67vm8kwm84dl861hyqnywd61kvhrwa"; +}; +clang-src = fetchFromGitHub { + rev = "9e996136d52ed506ed8f57ef8b13b0f0f735e6a3"; + owner = "m-labs"; + repo = "clang-or1k"; + sha256 = "0w5f450i76y162aswi2c7jip8x3arzljaxhbqp8qfdffm0rdbjp4"; +}; +in +runCommand "llvm_or1k_src" {}'' +mkdir -p $out +mkdir -p $out/tools/clang +cp -r ${llvm-src}/* $out/ +cp -r ${clang-src}/* $out/tools/clang +'' diff --git a/artiq/fetchcargo.nix b/artiq/fetchcargo.nix new file mode 100644 index 0000000..6195a72 --- /dev/null +++ b/artiq/fetchcargo.nix @@ -0,0 +1,35 @@ +{ stdenv, cacert, git, cargo, cargo-vendor }: +{ name, src, sha256 }: +stdenv.mkDerivation { + name = "${name}-vendor"; + nativeBuildInputs = [ cacert git cargo cargo-vendor ]; + inherit src; + + phases = "unpackPhase patchPhase installPhase"; + + installPhase = '' + if [[ ! -f Cargo.lock ]]; then + echo + echo "ERROR: The Cargo.lock file doesn't exist" + echo + echo "Cargo.lock is needed to make sure that cargoSha256 doesn't change" + echo "when the registry is updated." + echo + + exit 1 + fi + + export CARGO_HOME=$(mktemp -d cargo-home.XXX) + + cargo vendor + + cp -ar vendor $out + ''; + + outputHashAlgo = "sha256"; + outputHashMode = "recursive"; + outputHash = sha256; + + impureEnvVars = stdenv.lib.fetchers.proxyImpureEnvVars; + preferLocalBuild = true; +} diff --git a/artiq/pkgs/artiq-src.nix b/artiq/pkgs/artiq-src.nix new file mode 100644 index 0000000..8b49e0b --- /dev/null +++ b/artiq/pkgs/artiq-src.nix @@ -0,0 +1,7 @@ +{ pkgs ? import {}}: +pkgs.fetchgit { + url = "https://github.com/m-labs/artiq"; + rev = import ./artiq-rev.nix; + sha256 = import ./artiq-hash.nix; + deepClone = true; +} diff --git a/artiq/pkgs/artiq.nix b/artiq/pkgs/artiq.nix new file mode 100644 index 0000000..419d9d1 --- /dev/null +++ b/artiq/pkgs/artiq.nix @@ -0,0 +1,79 @@ +{ stdenv, git, fetchFromGitHub, fetchgit, python3Packages, qt5Full, binutils-or1k, llvm-or1k, llvmlite, python3 }: + +let + +levenshtein = python3Packages.buildPythonPackage rec { + name = "levenshtein"; + src = fetchFromGitHub { + owner = "ztane"; + repo = "python-Levenshtein"; + rev = "854e61a05bb8b750e990add96df412cd5448b75e"; + sha256 = "1yf21kg1g2ivm5a4dx1jra9k0c33np54d0hk5ymnfyc4f6pg386q"; + }; + doCheck = false; +}; + +pythonparser = python3Packages.buildPythonPackage rec { + name = "pythonparser"; + src = fetchFromGitHub { + owner = "m-labs"; + repo = "pythonparser"; + rev = "5b391fe86f43bb9f4f96c5bc0532e2a112db2936"; + sha256 = "1gw1fk4y2l6bwq0fg2a9dfc1rvq8cv492dyil96amjdhsxvnx35b"; + }; + propagatedBuildInputs = with python3Packages; [ regex ]; +}; + +asyncserial = python3Packages.buildPythonPackage rec { + name = "asyncserial"; + src = fetchFromGitHub { + owner = "m-labs"; + repo = "asyncserial"; + rev = "d95bc1d6c791b0e9785935d2f62f628eb5cdf98d"; + sha256 = "0yzkka9jk3612v8gx748x6ziwykq5lr7zmr9wzkcls0v2yilqx9k"; + }; + propagatedBuildInputs = with python3Packages; [ pyserial ]; + doCheck = false; +}; + +quamash = python3Packages.buildPythonPackage rec { + name = "quamash"; + src = fetchFromGitHub { + owner = "harvimt"; + repo = "quamash"; + rev = "e513b30f137415c5e098602fa383e45debab85e7"; + sha256 = "117rp9r4lz0kfz4dmmpa35hp6nhbh6b4xq0jmgvqm68g9hwdxmqa"; + }; + propagatedBuildInputs = with python3Packages; [ pyqt5 ]; + doCheck = false; +}; + +pyqtgraph-qt5 = python3Packages.buildPythonPackage rec { + name = "pyqtgraph_qt5-${version}"; + version = "0.10.0"; + doCheck = false; + src = fetchFromGitHub { + owner = "pyqtgraph"; + repo = "pyqtgraph"; + rev = "1426e334e1d20542400d77c72c132b04c6d17ddb"; + sha256 = "1079haxyr316jf0wpirxdj0ry6j8mr16cqr0dyyrd5cnxwl7zssh"; + }; + propagatedBuildInputs = with python3Packages; [ scipy numpy pyqt5 pyopengl ]; +}; + +in + +python3Packages.buildPythonPackage rec { + name = "artiq"; + src = import ./artiq-src.nix { inherit fetchgit; }; + buildInputs = [ git ]; + propagatedBuildInputs = with python3Packages; [ binutils-or1k llvm-or1k llvmlite levenshtein pyqtgraph-qt5 aiohttp pygit2 pythonparser numpy dateutil quamash scipy prettytable pyserial asyncserial h5py cython regex qt5Full pyqt5 ]; + checkPhase = "python -m unittest discover -v artiq.test"; + meta = with stdenv.lib; { + description = "A leading-edge control system for quantum information experiments"; + homepage = https://m-labs/artiq; + license = licenses.lgpl3; + #maintainers = [ maintainers.sb0 ]; + platforms = [ "x86_64-linux" ]; + }; +} diff --git a/artiq/pkgs/binutils-or1k.nix b/artiq/pkgs/binutils-or1k.nix new file mode 100644 index 0000000..f9fa99a --- /dev/null +++ b/artiq/pkgs/binutils-or1k.nix @@ -0,0 +1,34 @@ +{ stdenv, buildPackages +, fetchurl, zlib +}: + +stdenv.mkDerivation rec { + basename = "binutils"; + platform = "or1k"; + version = "2.30"; + name = "${basename}_${platform}-${version}"; + src = fetchurl { + url = "https://ftp.gnu.org/gnu/binutils/binutils-${version}.tar.bz2"; + sha256 = "028cklfqaab24glva1ks2aqa1zxa6w6xmc8q34zs1sb7h22dxspg"; + }; + configureFlags = + [ "--enable-shared" "--enable-deterministic-archives" "--target=or1k-linux"]; + outputs = [ "out" "info" "man" ]; + depsBuildBuild = [ buildPackages.stdenv.cc ]; + buildInputs = [ zlib ]; + enableParallelBuilding = true; + meta = { + description = "Tools for manipulating binaries (linker, assembler, etc.)"; + longDescription = '' + The GNU Binutils are a collection of binary tools. The main + ones are `ld' (the GNU linker) and `as' (the GNU assembler). + They also include the BFD (Binary File Descriptor) library, + `gprof', `nm', `strip', etc. + ''; + homepage = http://www.gnu.org/software/binutils/; + license = stdenv.lib.licenses.gpl3Plus; + /* Give binutils a lower priority than gcc-wrapper to prevent a + collision due to the ld/as wrappers/symlinks in the latter. */ + priority = "10"; + }; +} diff --git a/artiq/pkgs/llvm-or1k.nix b/artiq/pkgs/llvm-or1k.nix new file mode 100644 index 0000000..8b41124 --- /dev/null +++ b/artiq/pkgs/llvm-or1k.nix @@ -0,0 +1,45 @@ +{ stdenv +, git +, llvm-src +, perl, groff, cmake, libxml2, python, libffi, valgrind +, ... +}: + +stdenv.mkDerivation rec { + name = "llvm_or1k"; + src = llvm-src; + + buildInputs = [ perl groff cmake libxml2 python libffi ] ++ stdenv.lib.optional stdenv.isLinux valgrind; + + preBuild = '' + NIX_BUILD_CORES=4 + makeFlagsArray=(-j''$NIX_BUILD_CORES) + mkdir -p $out/ + ''; + + cmakeFlags = with stdenv; [ + "-DCMAKE_BUILD_TYPE=Release" + "-DLLVM_BUILD_LLVM_DYLIB=ON" + "-DLLVM_LINK_LLVM_DYLIB=ON" + "-DLLVM_TARGETS_TO_BUILD=X86" + "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=OR1K" + "-DLLVM_ENABLE_ASSERTIONS=OFF" + "-DLLVM_INSTALL_UTILS=ON" + "-DLLVM_INCLUDE_TESTS=OFF" + "-DLLVM_INCLUDE_DOCS=OFF" + "-DLLVM_INCLUDE_EXAMPLES=OFF" + "-DCLANG_ENABLE_ARCMT=OFF" + "-DCLANG_ENABLE_STATIC_ANALYZER=OFF" + "-DCLANG_INCLUDE_TESTS=OFF" + "-DCLANG_INCLUDE_DOCS=OFF" + ]; + + enableParallelBuilding = true; + meta = { + description = "Collection of modular and reusable compiler and toolchain technologies"; + homepage = http://llvm.org/; + license = stdenv.lib.licenses.bsd3; + #maintainers = with stdenv.lib.maintainers; [ sb0 ]; + platforms = stdenv.lib.platforms.all; + }; +} diff --git a/artiq/pkgs/llvmlite.nix b/artiq/pkgs/llvmlite.nix new file mode 100644 index 0000000..9c7ef6e --- /dev/null +++ b/artiq/pkgs/llvmlite.nix @@ -0,0 +1,25 @@ +{ stdenv, fetchFromGitHub, llvm-or1k, makeWrapper, python3, ncurses, zlib, python3Packages }: +stdenv.mkDerivation rec { + name = "llvmlite"; + src = fetchFromGitHub { + rev = "1d167be4eec5d6c32498952be8b3ac17dd30df8d"; + owner = "m-labs"; + repo = "llvmlite"; + sha256 = "0ranbjhcz2v3crmdbw1sxdwqwqbbm7dd53d8qaqb69ma9fkxy8x7"; + }; + + buildInputs = [ makeWrapper python3 ncurses zlib llvm-or1k python3Packages.setuptools ]; + + installPhase = '' + LLVM_CONFIG=${llvm-or1k}/bin/llvm-config + python3 setup.py install --prefix=$out + ''; + + meta = with stdenv.lib; { + description = "A lightweight LLVM python binding for writing JIT compilers"; + homepage = "http://llvmlite.pydata.org/"; + #maintainers = with maintainers; [ sb0 ]; + license = licenses.bsd2; + platforms = platforms.unix; + }; +} diff --git a/artiq/pkgs/openocd.nix b/artiq/pkgs/openocd.nix new file mode 100644 index 0000000..df6588a --- /dev/null +++ b/artiq/pkgs/openocd.nix @@ -0,0 +1,72 @@ +{ stdenv, fetchFromGitHub, autoreconfHook, libftdi, libusb1, pkgconfig, hidapi }: + +stdenv.mkDerivation rec { + name = "openocd-mlabs-${version}"; + version = "0.10.0"; + + src = fetchFromGitHub { + owner = "m-labs"; + repo = "openocd"; + fetchSubmodules = true; + rev = "c383a57adcff332b2c5cf8d55a84626285b42c2c"; + sha256 = "0xlj9cs72acx3zqagvr7f1c0v6lnqhl8fgrlhgmhmvk5n9knk492"; + }; + bscan_spi_bitstreams = fetchFromGitHub { + owner = "quartiq"; + repo = "bscan_spi_bitstreams"; + rev = "a628956da7dc794e6e3c95b31ff9ce3af58bc763"; + sha256 = "1cydbym3wv9jwxh6lw9im1mjzr7w8rzzx95bxkjschmzjq4h13vk"; + }; + + nativeBuildInputs = [ pkgconfig ]; + buildInputs = [ autoreconfHook libftdi libusb1 hidapi ]; + + configureFlags = [ + "--enable-jtag_vpi" + "--enable-usb_blaster_libftdi" + "--enable-amtjtagaccel" + "--enable-gw16012" + "--enable-presto_libftdi" + "--enable-openjtag_ftdi" + "--enable-oocd_trace" + "--enable-buspirate" + "--enable-sysfsgpio" + "--enable-remote-bitbang" + ]; + + NIX_CFLAGS_COMPILE = [ + "-Wno-implicit-fallthrough" + "-Wno-format-truncation" + "-Wno-format-overflow" + ]; + + postInstall = '' + mkdir -p "$out/etc/udev/rules.d" + rules="$out/share/openocd/contrib/60-openocd.rules" + if [ ! -f "$rules" ]; then + echo "$rules is missing, must update the Nix file." + exit 1 + fi + ln -s "$rules" "$out/etc/udev/rules.d/" + + mkdir -p "$out/share/bscan-spi-bitstreams" + cp ${bscan_spi_bitstreams}/*.bit "$out/share/bscan-spi-bitstreams" + ''; + + meta = with stdenv.lib; { + description = "Free and Open On-Chip Debugging, In-System Programming and Boundary-Scan Testing"; + longDescription = '' + OpenOCD provides on-chip programming and debugging support with a layered + architecture of JTAG interface and TAP support, debug target support + (e.g. ARM, MIPS), and flash chip drivers (e.g. CFI, NAND, etc.). Several + network interfaces are available for interactiving with OpenOCD: HTTP, + telnet, TCL, and GDB. The GDB server enables OpenOCD to function as a + "remote target" for source-level debugging of embedded systems using the + GNU GDB program. + ''; + homepage = http://openocd.sourceforge.net/; + license = licenses.gpl2Plus; + #maintainers = with maintainers; [ sb0 ]; + platforms = platforms.linux; + }; +} diff --git a/artiq/pkgs/python3Packages.nix b/artiq/pkgs/python3Packages.nix new file mode 100644 index 0000000..898bd97 --- /dev/null +++ b/artiq/pkgs/python3Packages.nix @@ -0,0 +1,107 @@ +{ pkgs, stdenv, fetchFromGitHub, python, python3Packages }: + +rec { + asyncserial = python3Packages.buildPythonPackage rec { + name = "asyncserial"; + + src = fetchFromGitHub { + owner = "m-labs"; + repo = "asyncserial"; + rev = "d95bc1d6c791b0e9785935d2f62f628eb5cdf98d"; + sha256 = "0yzkka9jk3612v8gx748x6ziwykq5lr7zmr9wzkcls0v2yilqx9k"; + fetchSubmodules = true; + }; + + propagatedBuildInputs = with python3Packages; [ pyserial ] ++ (with pkgs; [ ]); + + meta = with stdenv.lib; { + description = "asyncio support for pyserial"; + homepage = "https://m-labs.hk"; + license = licenses.bsd2; + platforms = platforms.unix; + }; + }; + misoc = python3Packages.buildPythonPackage rec { + name = "misoc"; + + src = fetchFromGitHub { + owner = "m-labs"; + repo = "misoc"; + rev = "8e033c2cb77f78c95d2b2e08125324891d07fa34"; + sha256 = "0pv1akhvr85iswqmhzcqh9gfnyha11k68qmhqizma8fdccvvzm4y"; + fetchSubmodules = true; + }; + + # TODO: fix misoc bitrot and re-enable tests + doCheck = false; + + propagatedBuildInputs = with python3Packages; [ pyserial jinja2 numpy asyncserial migen ]; + + meta = with stdenv.lib; { + description = "A high performance and small footprint system-on-chip based on Migen"; + homepage = "https://m-labs.hk/migen"; + license = licenses.bsd2; + platforms = platforms.unix; + }; + }; + migen = python3Packages.buildPythonPackage rec { + name = "migen"; + + src = fetchFromGitHub { + owner = "m-labs"; + repo = "migen"; + rev = "afe4405becdbc76539f0195c319367187012b05e"; + sha256 = "1f288a7ll1d1gjmml716wsjf1jyq9y903i2312bxb8pwrg7fwgvz"; + }; + + # TODO: fix migen platform issues and re-enable tests + doCheck = false; + + propagatedBuildInputs = with python3Packages; [ colorama sphinx sphinx_rtd_theme ] ++ (with pkgs; [ verilator ]); + + meta = with stdenv.lib; { + description = "A Python toolbox for building complex digital hardware"; + homepage = "https://m-labs.hk/migen"; + license = licenses.bsd2; + platforms = platforms.unix; + }; + }; + microscope = python3Packages.buildPythonPackage rec { + name = "microscope"; + + src = fetchFromGitHub { + owner = "m-labs"; + repo = "microscope"; + rev = "02cffc360ec5a234c589de6cb9616b057ed22253"; + sha256 = "09yvgk16xfv5r5cf55vcg0f14wam42w53r4snlalcyw5gkm0rlhq"; + }; + + propagatedBuildInputs = with python3Packages; [ pyserial prettytable msgpack-python migen ]; + + meta = with stdenv.lib; { + description = "Finding the bacteria in rotting FPGA designs"; + homepage = "https://m-labs.hk/migen"; + license = licenses.bsd2; + platforms = platforms.unix; + }; + }; + jesd204b = python3Packages.buildPythonPackage rec { + name = "jesd204b"; + + src = fetchFromGitHub { + owner = "m-labs"; + repo = "jesd204b"; + rev = "2fd6391c0a9197580d60f7d8a146191dc7337b03"; + sha256 = "1lhw8f0dp42xx4g6d7hyhqhrnd6i5ll4a1wcg265rqz3600i4009"; + }; + + propagatedBuildInputs = with python3Packages; [ migen misoc ]; + + meta = with stdenv.lib; { + description = "JESD204B core for Migen/MiSoC"; + homepage = "https://m-labs.hk/migen"; + license = licenses.bsd2; + platforms = platforms.unix; + }; + }; +} diff --git a/artiq/pkgs/rust/binaryBuild.nix b/artiq/pkgs/rust/binaryBuild.nix new file mode 100644 index 0000000..872c4bd --- /dev/null +++ b/artiq/pkgs/rust/binaryBuild.nix @@ -0,0 +1,117 @@ +{ stdenv, makeWrapper, bash, buildRustPackage, curl, darwin +, version +, src +, platform +, versionType +}: + +let + inherit (stdenv.lib) optionalString; + inherit (darwin.apple_sdk.frameworks) Security; + + bootstrapping = versionType == "bootstrap"; + + installComponents + = "rustc,rust-std-${platform}" + + (optionalString bootstrapping ",cargo") + ; +in + +rec { + inherit buildRustPackage; + + rustc = stdenv.mkDerivation rec { + name = "rustc-${versionType}-${version}"; + + inherit version; + inherit src; + + meta = with stdenv.lib; { + homepage = http://www.rust-lang.org/; + description = "A safe, concurrent, practical language"; + #maintainers = with maintainers; [ sb0 ]; + license = [ licenses.mit licenses.asl20 ]; + }; + + buildInputs = [ bash ] ++ stdenv.lib.optional stdenv.isDarwin Security; + + postPatch = '' + patchShebangs . + ''; + + installPhase = '' + ./install.sh --prefix=$out \ + --components=${installComponents} + + ${optionalString (stdenv.isLinux && bootstrapping) '' + patchelf \ + --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \ + "$out/bin/rustc" + patchelf \ + --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \ + "$out/bin/rustdoc" + patchelf \ + --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \ + "$out/bin/cargo" + ''} + + ${optionalString (stdenv.isDarwin && bootstrapping) '' + install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$out/bin/rustc" + install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$out/bin/rustdoc" + install_name_tool -change /usr/lib/libiconv.2.dylib '${darwin.libiconv}/lib/libiconv.2.dylib' "$out/bin/cargo" + install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$out/bin/cargo" + install_name_tool -change /usr/lib/libcurl.4.dylib '${stdenv.lib.getLib curl}/lib/libcurl.4.dylib' "$out/bin/cargo" + for f in $out/lib/lib*.dylib; do + install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$f" + done + ''} + + # Do NOT, I repeat, DO NOT use `wrapProgram` on $out/bin/rustc + # (or similar) here. It causes strange effects where rustc loads + # the wrong libraries in a bootstrap-build causing failures that + # are very hard to track down. For details, see + # https://github.com/rust-lang/rust/issues/34722#issuecomment-232164943 + ''; + }; + + cargo = stdenv.mkDerivation rec { + name = "cargo-${versionType}-${version}"; + + inherit version; + inherit src; + + meta = with stdenv.lib; { + homepage = http://www.rust-lang.org/; + description = "A safe, concurrent, practical language"; + #maintainers = with maintainers; [ sb0 ]; + license = [ licenses.mit licenses.asl20 ]; + }; + + buildInputs = [ makeWrapper bash ] ++ stdenv.lib.optional stdenv.isDarwin Security; + + postPatch = '' + patchShebangs . + ''; + + installPhase = '' + patchShebangs ./install.sh + ./install.sh --prefix=$out \ + --components=cargo + + ${optionalString (stdenv.isLinux && bootstrapping) '' + patchelf \ + --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \ + "$out/bin/cargo" + ''} + + ${optionalString (stdenv.isDarwin && bootstrapping) '' + install_name_tool -change /usr/lib/libiconv.2.dylib '${darwin.libiconv}/lib/libiconv.2.dylib' "$out/bin/cargo" + install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$out/bin/cargo" + install_name_tool -change /usr/lib/libcurl.4.dylib '${stdenv.lib.getLib curl}/lib/libcurl.4.dylib' "$out/bin/cargo" + ''} + + wrapProgram "$out/bin/cargo" \ + --suffix PATH : "${rustc}/bin" + ''; + }; +} diff --git a/artiq/pkgs/rust/bootstrap.nix b/artiq/pkgs/rust/bootstrap.nix new file mode 100644 index 0000000..55348c5 --- /dev/null +++ b/artiq/pkgs/rust/bootstrap.nix @@ -0,0 +1,42 @@ +{ stdenv, fetchurl, callPackage }: + +let + # Note: the version MUST be one version prior to the version we're + # building + version = "1.28.0"; + + # fetch hashes by running `print-hashes.sh 1.24.1` + hashes = { + i686-unknown-linux-gnu = "de7cdb4e665e897ea9b10bf6fd545f900683296456d6a11d8510397bb330455f"; + x86_64-unknown-linux-gnu = "2a1390340db1d24a9498036884e6b2748e9b4b057fc5219694e298bdaa37b810"; + armv7-unknown-linux-gnueabihf = "346558d14050853b87049e5e1fbfae0bf0360a2f7c57433c6985b1a879c349a2"; + aarch64-unknown-linux-gnu = "9b6fbcee73070332c811c0ddff399fa31965bec62ef258656c0c90354f6231c1"; + i686-apple-darwin = "752e2c9182e057c4a54152d1e0b3949482c225d02bb69d9d9a4127dc2a65fb68"; + x86_64-apple-darwin = "5d7a70ed4701fe9410041c1eea025c95cad97e5b3d8acc46426f9ac4f9f02393"; + }; + + platform = + if stdenv.hostPlatform.system == "i686-linux" + then "i686-unknown-linux-gnu" + else if stdenv.hostPlatform.system == "x86_64-linux" + then "x86_64-unknown-linux-gnu" + else if stdenv.hostPlatform.system == "armv7l-linux" + then "armv7-unknown-linux-gnueabihf" + else if stdenv.hostPlatform.system == "aarch64-linux" + then "aarch64-unknown-linux-gnu" + else if stdenv.hostPlatform.system == "i686-darwin" + then "i686-apple-darwin" + else if stdenv.hostPlatform.system == "x86_64-darwin" + then "x86_64-apple-darwin" + else throw "missing bootstrap url for platform ${stdenv.hostPlatform.system}"; + + src = fetchurl { + url = "https://static.rust-lang.org/dist/rust-${version}-${platform}.tar.gz"; + sha256 = hashes."${platform}"; + }; + +in callPackage ./binaryBuild.nix + { inherit version src platform; + buildRustPackage = null; + versionType = "bootstrap"; + } diff --git a/artiq/pkgs/rust/default.nix b/artiq/pkgs/rust/default.nix new file mode 100644 index 0000000..3971c6f --- /dev/null +++ b/artiq/pkgs/rust/default.nix @@ -0,0 +1,88 @@ +{ stdenv, callPackage, recurseIntoAttrs, makeRustPlatform, llvm, fetchurl +, targets ? [] +, targetToolchains ? [] +, targetPatches ? [] +, fetchFromGitHub +}: + +let + rustPlatform = recurseIntoAttrs (makeRustPlatform (callPackage ./bootstrap.nix {})); + version = "1.28.0"; + src = fetchFromGitHub { + owner = "m-labs"; + repo = "rust"; + sha256 = "03lfps3xvvv7wv1nnwn3n1ji13z099vx8c3fpbzp9rnasrwzp5jy"; + rev = "f305fb024318e96997fbe6e4a105b0cc1052aad4"; # artiq-1.28.0 branch + fetchSubmodules = true; + }; +in rec { + # nixcloud team code + or1k-crates = stdenv.mkDerivation { + name = "or1k-crates"; + inherit src; + phases = [ "unpackPhase" "buildPhase" ]; + buildPhase = '' + destdir=$out + rustc="${rustc_internal}/bin/rustc --out-dir ''${destdir} -L ''${destdir} --target or1k-unknown-none -g -C target-feature=+mul,+div,+ffl1,+cmov,+addc -C opt-level=s --crate-type rlib" + + mkdir -p ''${destdir} + ''${rustc} --crate-name core src/libcore/lib.rs + ''${rustc} --crate-name compiler_builtins src/libcompiler_builtins/src/lib.rs --cfg 'feature="compiler-builtins"' --cfg 'feature="mem"' + ''${rustc} --crate-name std_unicode src/libstd_unicode/lib.rs + ''${rustc} --crate-name alloc src/liballoc/lib.rs + ''${rustc} --crate-name libc src/liblibc_mini/lib.rs + ''${rustc} --crate-name unwind src/libunwind/lib.rs + ''${rustc} -Cpanic=abort --crate-name panic_abort src/libpanic_abort/lib.rs + ''${rustc} -Cpanic=unwind --crate-name panic_unwind src/libpanic_unwind/lib.rs --cfg llvm_libunwind + ''; + }; + # nixcloud team code + # this is basically a wrapper, which uses rustc_internal and inserts or1k-crates into it + rustc = stdenv.mkDerivation { + name = "rustc"; + src = ./.; + installPhase = '' + mkdir $out + mkdir -p $out/lib/rustlib/or1k-unknown-none/lib/ + cp -r ${or1k-crates}/* $out/lib/rustlib/or1k-unknown-none/lib/ + cp -r ${rustc_internal}/* $out + ''; + meta = with stdenv.lib; { + homepage = https://www.rust-lang.org/; + description = "A safe, concurrent, practical language"; + #maintainers = with maintainers; [ sb0 ]; + license = [ licenses.mit licenses.asl20 ]; + platforms = platforms.linux ++ platforms.darwin; + }; + }; + # nixcloud team code + # originally rustc but now renamed to rustc_internal + rustc_internal = callPackage ./rustc.nix { + inherit stdenv llvm targets targetPatches targetToolchains rustPlatform version src; + + patches = [ + ./patches/net-tcp-disable-tests.patch + + # Re-evaluate if this we need to disable this one + #./patches/stdsimd-disable-doctest.patch + + # Fails on hydra - not locally; the exact reason is unknown. + # Comments in the test suggest that some non-reproducible environment + # variables such $RANDOM can make it fail. + ./patches/disable-test-inherit-env.patch + ]; + + forceBundledLLVM = true; + + #configureFlags = [ "--release-channel=stable" ]; + + # 1. Upstream is not running tests on aarch64: + # see https://github.com/rust-lang/rust/issues/49807#issuecomment-380860567 + # So we do the same. + # 2. Tests run out of memory for i686 + #doCheck = !stdenv.isAarch64 && !stdenv.isi686; + + # Disabled for now; see https://github.com/NixOS/nixpkgs/pull/42348#issuecomment-402115598. + doCheck = false; + }; +} diff --git a/artiq/pkgs/rust/patches/disable-test-inherit-env.patch b/artiq/pkgs/rust/patches/disable-test-inherit-env.patch new file mode 100644 index 0000000..fcb75ed --- /dev/null +++ b/artiq/pkgs/rust/patches/disable-test-inherit-env.patch @@ -0,0 +1,10 @@ +--- rustc-1.26.2-src.org/src/libstd/process.rs 2018-06-01 21:40:11.000000000 +0100 ++++ rustc-1.26.2-src/src/libstd/process.rs 2018-06-08 07:50:23.023828658 +0100 +@@ -1745,6 +1745,7 @@ + } + + #[test] ++ #[ignore] + fn test_inherit_env() { + use env; + diff --git a/artiq/pkgs/rust/patches/net-tcp-disable-tests.patch b/artiq/pkgs/rust/patches/net-tcp-disable-tests.patch new file mode 100644 index 0000000..10713b6 --- /dev/null +++ b/artiq/pkgs/rust/patches/net-tcp-disable-tests.patch @@ -0,0 +1,104 @@ +diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs +index 0f60b5b3e..9b08415e7 100644 +--- a/src/libstd/net/tcp.rs ++++ b/src/libstd/net/tcp.rs +@@ -962,6 +962,7 @@ mod tests { + } + } + ++ #[cfg_attr(target_os = "macos", ignore)] + #[test] + fn listen_localhost() { + let socket_addr = next_test_ip4(); +@@ -1020,6 +1021,7 @@ mod tests { + }) + } + ++ #[cfg_attr(target_os = "macos", ignore)] + #[test] + fn read_eof() { + each_ip(&mut |addr| { +@@ -1039,6 +1041,7 @@ mod tests { + }) + } + ++ #[cfg_attr(target_os = "macos", ignore)] + #[test] + fn write_close() { + each_ip(&mut |addr| { +@@ -1065,6 +1068,7 @@ mod tests { + }) + } + ++ #[cfg_attr(target_os = "macos", ignore)] + #[test] + fn multiple_connect_serial() { + each_ip(&mut |addr| { +@@ -1087,6 +1091,7 @@ mod tests { + }) + } + ++ #[cfg_attr(target_os = "macos", ignore)] + #[test] + fn multiple_connect_interleaved_greedy_schedule() { + const MAX: usize = 10; +@@ -1123,6 +1128,7 @@ mod tests { + } + + #[test] ++ #[cfg_attr(target_os = "macos", ignore)] + fn multiple_connect_interleaved_lazy_schedule() { + const MAX: usize = 10; + each_ip(&mut |addr| { +@@ -1401,6 +1407,7 @@ mod tests { + } + + #[test] ++ #[cfg_attr(target_os = "macos", ignore)] + fn clone_while_reading() { + each_ip(&mut |addr| { + let accept = t!(TcpListener::bind(&addr)); +@@ -1421,7 +1422,10 @@ mod tests { + + // FIXME: re-enabled bitrig/openbsd tests once their socket timeout code + // no longer has rounding errors. +- #[cfg_attr(any(target_os = "bitrig", target_os = "netbsd", target_os = "openbsd"), ignore)] ++ #[cfg_attr(any(target_os = "bitrig", ++ target_os = "netbsd", ++ target_os = "openbsd", ++ target_os = "macos"), ignore)] + #[test] + fn timeouts() { + let addr = next_test_ip4(); +@@ -1596,6 +1603,7 @@ mod tests { + drop(listener); + } + ++ #[cfg_attr(target_os = "macos", ignore)] + #[test] + fn nodelay() { + let addr = next_test_ip4(); +@@ -1610,6 +1618,7 @@ mod tests { + assert_eq!(false, t!(stream.nodelay())); + } + ++ #[cfg_attr(target_os = "macos", ignore)] + #[test] + fn ttl() { + let ttl = 100; +@@ -1647,6 +1656,7 @@ mod tests { + } + } + ++ #[cfg_attr(target_os = "macos", ignore)] + #[test] + fn peek() { + each_ip(&mut |addr| { +@@ -1679,6 +1689,7 @@ mod tests { + } + + #[test] ++ #[cfg_attr(any(target_os = "linux", target_os = "macos"), ignore)] + fn connect_timeout_unroutable() { + // this IP is unroutable, so connections should always time out, + // provided the network is reachable to begin with. diff --git a/artiq/pkgs/rust/patches/stdsimd-disable-doctest.patch b/artiq/pkgs/rust/patches/stdsimd-disable-doctest.patch new file mode 100644 index 0000000..6ef7fd0 --- /dev/null +++ b/artiq/pkgs/rust/patches/stdsimd-disable-doctest.patch @@ -0,0 +1,20 @@ +diff --git a/src/stdsimd/coresimd/x86/mod.rs b/src/stdsimd/coresimd/x86/mod.rs +index 32915c332..7cb54f31e 100644 +--- a/src/stdsimd/coresimd/x86/mod.rs ++++ b/src/stdsimd/coresimd/x86/mod.rs +@@ -279,7 +279,6 @@ types! { + /// + /// # Examples + /// +- /// ``` + /// # #![feature(cfg_target_feature, target_feature, stdsimd)] + /// # #![cfg_attr(not(dox), no_std)] + /// # #[cfg(not(dox))] +@@ -301,7 +300,6 @@ types! { + /// # } + /// # if is_x86_feature_detected!("sse") { unsafe { foo() } } + /// # } +- /// ``` + pub struct __m256(f32, f32, f32, f32, f32, f32, f32, f32); + + /// 256-bit wide set of four `f64` types, x86-specific diff --git a/artiq/pkgs/rust/print-hashes.sh b/artiq/pkgs/rust/print-hashes.sh new file mode 100755 index 0000000..7eb00a3 --- /dev/null +++ b/artiq/pkgs/rust/print-hashes.sh @@ -0,0 +1,38 @@ +#!/usr/bin/env bash +set -euo pipefail + +# All rust-related downloads can be found at +# https://static.rust-lang.org/dist/index.html. To find the date on +# which a particular thing was last updated, look for the *-date.txt +# file, e.g. +# https://static.rust-lang.org/dist/channel-rust-beta-date.txt + +PLATFORMS=( + i686-unknown-linux-gnu + x86_64-unknown-linux-gnu + armv7-unknown-linux-gnueabihf + aarch64-unknown-linux-gnu + i686-apple-darwin + x86_64-apple-darwin +) +BASEURL=https://static.rust-lang.org/dist +VERSION=${1:-} +DATE=${2:-} + +if [[ -z $VERSION ]] +then + echo "No version supplied" + exit -1 +fi + +if [[ -n $DATE ]] +then + BASEURL=$BASEURL/$DATE +fi + +for PLATFORM in "${PLATFORMS[@]}" +do + URL="$BASEURL/rust-$VERSION-$PLATFORM.tar.gz.sha256" + SHA256=$(curl -sSfL $URL | cut -d ' ' -f 1) + echo "$PLATFORM = \"$SHA256\";" +done diff --git a/artiq/pkgs/rust/rust-src.nix b/artiq/pkgs/rust/rust-src.nix new file mode 100644 index 0000000..1b819a7 --- /dev/null +++ b/artiq/pkgs/rust/rust-src.nix @@ -0,0 +1,11 @@ +{ stdenv, rustc }: + +stdenv.mkDerivation { + name = "rust-src"; + src = rustc.src; + phases = [ "unpackPhase" "installPhase" ]; + installPhase = '' + mv src $out + rm -rf $out/{ci,doc,driver,etc,grammar,llvm,rt,rtstartup,rustllvm,test,tools,vendor} + ''; +} diff --git a/artiq/pkgs/rust/rustc.nix b/artiq/pkgs/rust/rustc.nix new file mode 100644 index 0000000..34ca3ac --- /dev/null +++ b/artiq/pkgs/rust/rustc.nix @@ -0,0 +1,199 @@ +{ stdenv, targetPackages +, fetchurl, fetchgit, fetchzip, file, python2, tzdata, ps +, llvm, jemalloc, ncurses, darwin, rustPlatform, git, cmake, curl +, which, libffi, gdb +, version +, forceBundledLLVM ? false +, src +, configureFlags ? [] +, patches +, targets +, targetPatches +, targetToolchains +, doCheck ? true +, broken ? false +, pkgs +}: + +let + inherit (stdenv.lib) optional optionalString; + inherit (darwin.apple_sdk.frameworks) Security; + + llvmShared = llvm.override { enableSharedLibraries = true; }; + llvmOR1k = (import ../../default.nix {}).llvm-or1k; + + target = builtins.replaceStrings [" "] [","] (builtins.toString targets); + src_rustc = fetchurl { + url = "https://static.rust-lang.org/dist/rustc-1.28.0-src.tar.gz"; + sha256 = "11k4rn77bca2rikykkk9fmprrgjswd4x4kaq7fia08vgkir82nhx"; + }; + +in + +stdenv.mkDerivation { + name = "rustc-${version}"; + inherit version; + + inherit src; + + __darwinAllowLocalNetworking = true; + + # rustc complains about modified source files otherwise + dontUpdateAutotoolsGnuConfigScripts = true; + + # Running the default `strip -S` command on Darwin corrupts the + # .rlib files in "lib/". + # + # See https://github.com/NixOS/nixpkgs/pull/34227 + stripDebugList = if stdenv.isDarwin then [ "bin" ] else null; + + NIX_LDFLAGS = optionalString stdenv.isDarwin "-rpath ${llvmShared}/lib"; + + # Enable nightly features in stable compiles (used for + # bootstrapping, see https://github.com/rust-lang/rust/pull/37265). + # This loosens the hard restrictions on bootstrapping-compiler + # versions. + RUSTC_BOOTSTRAP = "1"; + + # Increase codegen units to introduce parallelism within the compiler. + RUSTFLAGS = "-Ccodegen-units=10"; + + # We need rust to build rust. If we don't provide it, configure will try to download it. + # Reference: https://github.com/rust-lang/rust/blob/master/src/bootstrap/configure.py + configureFlags = configureFlags + ++ [ "--enable-local-rust" "--local-rust-root=${rustPlatform.rust.rustc}" "--enable-rpath" ] + ++ [ "--enable-vendor" ] + # ++ [ "--jemalloc-root=${jemalloc}/lib" + ++ [ "--default-linker=${targetPackages.stdenv.cc}/bin/cc" ] + ++ optional (!forceBundledLLVM) [ "--enable-llvm-link-shared" ] + ++ optional (targets != []) "--target=${target}" + #++ optional (!forceBundledLLVM) "--llvm-root=${llvmShared}" + ++ [ "--llvm-root=${llvmOR1k}" ] ; + + # The bootstrap.py will generated a Makefile that then executes the build. + # The BOOTSTRAP_ARGS used by this Makefile must include all flags to pass + # to the bootstrap builder. + postConfigure = '' + substituteInPlace Makefile --replace 'BOOTSTRAP_ARGS :=' 'BOOTSTRAP_ARGS := --jobs $(NIX_BUILD_CORES)' + ''; + + # FIXME: qknight, readd deleted vendor folder from 1.28 rustc + preConfigure = '' + export HOME=$out + # HACK: we add the vendor folder from rustc 1.28 to make the compiling work + tar xf ${src_rustc} + mv rustc-1.28.0-src/src/vendor/ src/vendor + cp -R ${llvmOR1k} src/llvm + ''; + + patches = patches ++ targetPatches; + + # the rust build system complains that nix alters the checksums + dontFixLibtool = true; + + passthru.target = target; + + postPatch = '' + patchShebangs src/etc + + # Fix dynamic linking against llvm + #${optionalString (!forceBundledLLVM) ''sed -i 's/, kind = \\"static\\"//g' src/etc/mklldeps.py''} + + # Fix the configure script to not require curl as we won't use it + sed -i configure \ + -e '/probe_need CFG_CURL curl/d' + + # Fix the use of jemalloc prefixes which our jemalloc doesn't have + # TODO: reenable if we can figure out how to get our jemalloc to work + #[ -f src/liballoc_jemalloc/lib.rs ] && sed -i 's,je_,,g' src/liballoc_jemalloc/lib.rs + #[ -f src/liballoc/heap.rs ] && sed -i 's,je_,,g' src/liballoc/heap.rs # Remove for 1.4.0+ + + # Disable fragile tests. + rm -vr src/test/run-make/linker-output-non-utf8 || true + rm -vr src/test/run-make/issue-26092 || true + + # Remove test targeted at LLVM 3.9 - https://github.com/rust-lang/rust/issues/36835 + rm -vr src/test/run-pass/issue-36023.rs || true + + # Disable test getting stuck on hydra - possible fix: + # https://reviews.llvm.org/rL281650 + rm -vr src/test/run-pass/issue-36474.rs || true + + # On Hydra: `TcpListener::bind(&addr)`: Address already in use (os error 98)' + sed '/^ *fn fast_rebind()/i#[ignore]' -i src/libstd/net/tcp.rs + + # https://github.com/rust-lang/rust/issues/39522 + echo removing gdb-version-sensitive tests... + find src/test/debuginfo -type f -execdir grep -q ignore-gdb-version '{}' \; -print -delete + rm src/test/debuginfo/{borrowed-c-style-enum.rs,c-style-enum-in-composite.rs,gdb-pretty-struct-and-enums-pre-gdb-7-7.rs,generic-enum-with-different-disr-sizes.rs} + + # Useful debugging parameter + # export VERBOSE=1 + '' + optionalString stdenv.isDarwin '' + # Disable all lldb tests. + # error: Can't run LLDB test because LLDB's python path is not set + rm -vr src/test/debuginfo/* + rm -v src/test/run-pass/backtrace-debuginfo.rs + + # error: No such file or directory + rm -v src/test/run-pass/issue-45731.rs + + # Disable tests that fail when sandboxing is enabled. + substituteInPlace src/libstd/sys/unix/ext/net.rs \ + --replace '#[test]' '#[test] #[ignore]' + substituteInPlace src/test/run-pass/env-home-dir.rs \ + --replace 'home_dir().is_some()' true + rm -v src/test/run-pass/fds-are-cloexec.rs # FIXME: pipes? + rm -v src/test/run-pass/sync-send-in-std.rs # FIXME: ??? + ''; + + # rustc unfortunately need cmake for compiling llvm-rt but doesn't + # use it for the normal build. This disables cmake in Nix. + dontUseCmakeConfigure = true; + + # ps is needed for one of the test cases + nativeBuildInputs = + [ file python2 ps rustPlatform.rust.rustc git cmake + which libffi + ] + # Only needed for the debuginfo tests + ++ optional (!stdenv.isDarwin) gdb; + + buildInputs = [ ncurses pkgs.zlib ] ++ targetToolchains + ++ optional stdenv.isDarwin Security + ++ optional (!forceBundledLLVM) llvmShared; + + outputs = [ "out" "man" "doc" ]; + setOutputFlags = false; + + # Disable codegen units and hardening for the tests. + preCheck = '' + export RUSTFLAGS= + export TZDIR=${tzdata}/share/zoneinfo + export hardeningDisable=all + '' + + # Ensure TMPDIR is set, and disable a test that removing the HOME + # variable from the environment falls back to another home + # directory. + optionalString stdenv.isDarwin '' + export TMPDIR=/tmp + sed -i '28s/home_dir().is_some()/true/' ./src/test/run-pass/env-home-dir.rs + ''; + + inherit doCheck; + + configurePlatforms = []; + + # https://github.com/NixOS/nixpkgs/pull/21742#issuecomment-272305764 + # https://github.com/rust-lang/rust/issues/30181 + # enableParallelBuilding = false; + + meta = with stdenv.lib; { + homepage = https://www.rust-lang.org/; + description = "A safe, concurrent, practical language"; + #maintainers = with maintainers; [ sb0 ]; + license = [ licenses.mit licenses.asl20 ]; + platforms = platforms.linux ++ platforms.darwin; + broken = broken; + }; +} diff --git a/artiq/shell-dev.nix b/artiq/shell-dev.nix new file mode 100644 index 0000000..d7ff9a0 --- /dev/null +++ b/artiq/shell-dev.nix @@ -0,0 +1,6 @@ +{ pkgs ? import {}}: + +let + artiq-dev = import ./artiq-dev.nix { inherit pkgs; }; +in + artiq-dev.env diff --git a/artiq/shell.nix b/artiq/shell.nix new file mode 100644 index 0000000..2c32415 --- /dev/null +++ b/artiq/shell.nix @@ -0,0 +1,7 @@ +let + pkgs = import {}; + artiqpkgs = import ./default.nix { inherit pkgs; }; +in + pkgs.mkShell { + buildInputs = with artiqpkgs; [ binutils-or1k llvm-or1k llvmlite artiq ]; + } diff --git a/main.nix b/main.nix new file mode 100644 index 0000000..318ffd6 --- /dev/null +++ b/main.nix @@ -0,0 +1,56 @@ +{ pkgs ? import {}}: +let + artiqSrc = /nix/store/5418k539bag65rpdpn3jvhx9c3yn3jvp-artiq; + generatedNix = pkgs.runCommand "generated-nix" { buildInputs = [ pkgs.nix pkgs.git ]; } + '' + cp --no-preserve=mode,ownership -R ${./artiq} $out + REV=`git --git-dir ${artiqSrc}/.git rev-parse HEAD` + HASH=`nix-hash --type sha256 --base32 ${artiqSrc}` + cat > $out/pkgs/artiq-src.nix << EOF + { fetchgit }: + fetchgit { + url = "git://github.com/m-labs/artiq.git"; + rev = "$REV"; + sha256 = "$HASH"; + deepClone = true; + } + EOF + ''; + artiqPkgs = import "${generatedNix}/default.nix" { inherit pkgs; }; + + boards = [ + { target = "kasli"; variant = "tester"; } + { target = "kc705"; variant = "nist_clock"; } + ]; + boardJobs = pkgs.lib.lists.foldr (board: start: + let + boardBinaries = import "${generatedNix}/artiq-board.nix" { inherit pkgs; } { + target = board.target; + variant = board.variant; + }; + in + start // { + "artiq-board-${board.target}-${board.variant}" = boardBinaries; + "conda-artiq-board-${board.target}-${board.variant}" = import "${generatedNix}/conda-board.nix" { inherit pkgs; } { + artiqSrc = import "${generatedNix}/pkgs/artiq-src.nix" { fetchgit = pkgs.fetchgit; }; + boardBinaries = boardBinaries; + target = board.target; + variant = board.variant; + }; + }) {} boards; + + jobs = { + conda-artiq = import "${generatedNix}/conda-build.nix" { inherit pkgs; } { + name = "conda-artiq"; + src = import "${generatedNix}/pkgs/artiq-src.nix" { fetchgit = pkgs.fetchgit; }; + recipe = "conda/artiq"; + }; + } // boardJobs // artiqPkgs; +in + jobs // { + channel = pkgs.releaseTools.channel { + name = "main"; + src = ./.; + constituents = builtins.attrValues jobs; + }; + }