uboot: (firmwareOdroidC2/C4) don't invoke patch tool, use patches = [] instead

https://github.com/NixOS/nixpkgs/blob/master/pkgs/stdenv/generic/setup.sh#L948
this can do it nicely.

Signed-off-by: Anton Arapov <anton@deadbeef.mx>

pkgs/development/compilers/nim/NIM_CONFIG_DIR.patch

@@ -0,0 +1,23 @@
+diff --git a/compiler/nimconf.nim b/compiler/nimconf.nim
+index a470179bd..73cfa1a23 100644
+--- a/compiler/nimconf.nim
++++ b/compiler/nimconf.nim
+@@ -225,10 +225,15 @@ proc getUserConfigPath*(filename: RelativeFile): AbsoluteFile =
+ proc getSystemConfigPath*(conf: ConfigRef; filename: RelativeFile): AbsoluteFile =
+   # try standard configuration file (installation did not distribute files
+   # the UNIX way)
+-  let p = getPrefixDir(conf)
+-  result = p / RelativeDir"config" / filename
++  let
++    prefix = getPrefixDir(conf)
++    env = getEnv("NIM_CONFIG_PATH")
++  if env != "":
++    result = env.toAbsoluteDir / filename
++  else:
++    result = prefix / RelativeDir"config" / filename
+   when defined(unix):
+-    if not fileExists(result): result = p / RelativeDir"etc/nim" / filename
++    if not fileExists(result): result = prefix / RelativeDir"etc/nim" / filename
+     if not fileExists(result): result = AbsoluteDir"/etc/nim" / filename
+
+ proc loadConfigs*(cfg: RelativeFile; cache: IdentCache; conf: ConfigRef) =

pkgs/development/compilers/nim/default.nix

@@ -0,0 +1,337 @@
+# https://nim-lang.github.io/Nim/packaging.html
+# https://nim-lang.org/docs/nimc.html
+
+{ lib, callPackage, buildPackages, stdenv, fetchurl, fetchgit, fetchFromGitHub
+, makeWrapper, openssl, pcre, readline, boehmgc, sqlite, nim-unwrapped
+, nimble-unwrapped }:
+
+let
+  parseCpu = platform:
+    with platform;
+    # Derive a Nim CPU identifier
+    if isAarch32 then
+      "arm"
+    else if isAarch64 then
+      "arm64"
+    else if isAlpha then
+      "alpha"
+    else if isAvr then
+      "avr"
+    else if isMips && is32bit then
+      "mips"
+    else if isMips && is64bit then
+      "mips64"
+    else if isMsp430 then
+      "msp430"
+    else if isPower && is32bit then
+      "powerpc"
+    else if isPower && is64bit then
+      "powerpc64"
+    else if isRiscV && is64bit then
+      "riscv64"
+    else if isSparc then
+      "sparc"
+    else if isx86_32 then
+      "i386"
+    else if isx86_64 then
+      "amd64"
+    else
+      abort "no Nim CPU support known for ${config}";
+
+  parseOs = platform:
+    with platform;
+    # Derive a Nim OS identifier
+    if isAndroid then
+      "Android"
+    else if isDarwin then
+      "MacOSX"
+    else if isFreeBSD then
+      "FreeBSD"
+    else if isGenode then
+      "Genode"
+    else if isLinux then
+      "Linux"
+    else if isNetBSD then
+      "NetBSD"
+    else if isNone then
+      "Standalone"
+    else if isOpenBSD then
+      "OpenBSD"
+    else if isWindows then
+      "Windows"
+    else if isiOS then
+      "iOS"
+    else
+      abort "no Nim OS support known for ${config}";
+
+  parsePlatform = p: {
+    cpu = parseCpu p;
+    os = parseOs p;
+  };
+
+  nimHost = parsePlatform stdenv.hostPlatform;
+  nimTarget = parsePlatform stdenv.targetPlatform;
+
+  bootstrapCompiler = let
+    revision = "561b417c65791cd8356b5f73620914ceff845d10";
+  in stdenv.mkDerivation {
+    pname = "nim-bootstrap";
+    version = "g${lib.substring 0 7 revision}";
+
+    src = fetchFromGitHub {
+      owner = "nim-lang";
+      repo = "csources_v1";
+      rev = revision;
+      sha256 = "sha256-gwBFuR7lzO4zttR/6rgdjXMRxVhwKeLqDwpmOwMyU7A=";
+    };
+
+    enableParallelBuilding = true;
+
+    installPhase = ''
+      runHook preInstall
+      install -Dt $out/bin bin/nim
+      runHook postInstall
+    '';
+  };
+
+in {
+
+  nim-unwrapped = stdenv.mkDerivation rec {
+    pname = "nim-unwrapped";
+    version = "1.6.6";
+    strictDeps = true;
+
+    src = fetchurl {
+      url = "https://nim-lang.org/download/nim-${version}.tar.xz";
+      hash = "sha256-Z7ERzm84YVA7n8wcrln8NNASJWbT7P7zoGSiF0EhpFI=";
+    };
+
+    buildInputs = [ boehmgc openssl pcre readline sqlite ];
+
+    patches = [
+      ./NIM_CONFIG_DIR.patch
+      # Override compiler configuration via an environmental variable
+
+      ./nixbuild.patch
+      # Load libraries at runtime by absolute path
+    ] ++ lib.optional (!stdenv.hostPlatform.isWindows) ./toLocation.patch;
+
+    configurePhase = ''
+      runHook preConfigure
+      cp ${bootstrapCompiler}/bin/nim bin/
+      echo 'define:nixbuild' >> config/nim.cfg
+      runHook postConfigure
+    '';
+
+    kochArgs = [
+      "--cpu:${nimHost.cpu}"
+      "--os:${nimHost.os}"
+      "-d:release"
+      "-d:useGnuReadline"
+    ] ++ lib.optional (stdenv.isDarwin || stdenv.isLinux) "-d:nativeStacktrace";
+
+    buildPhase = ''
+      runHook preBuild
+      local HOME=$TMPDIR
+      ./bin/nim c koch
+      ./koch boot $kochArgs --parallelBuild:$NIX_BUILD_CORES
+      ./koch toolsNoExternal $kochArgs --parallelBuild:$NIX_BUILD_CORES
+      runHook postBuild
+    '';
+
+    installPhase = ''
+      runHook preInstall
+      install -Dt $out/bin bin/*
+      ln -sf $out/nim/bin/nim $out/bin/nim
+      ./install.sh $out
+      runHook postInstall
+    '';
+
+    meta = with lib; {
+      description = "Statically typed, imperative programming language";
+      homepage = "https://nim-lang.org/";
+      license = licenses.mit;
+      maintainers = with maintainers; [ ehmry ];
+    };
+  };
+
+  nimble-unwrapped = stdenv.mkDerivation rec {
+    pname = "nimble-unwrapped";
+    version = "0.13.1";
+    strictDeps = true;
+
+    src = fetchFromGitHub {
+      owner = "nim-lang";
+      repo = "nimble";
+      rev = "v${version}";
+      sha256 = "1idb4r0kjbqv16r6bgmxlr13w2vgq5332hmnc8pjbxiyfwm075x8";
+    };
+
+    depsBuildBuild = [ nim-unwrapped ];
+    buildInputs = [ openssl ];
+
+    nimFlags = [ "--cpu:${nimHost.cpu}" "--os:${nimHost.os}" "-d:release" ];
+
+    buildPhase = ''
+      runHook preBuild
+      HOME=$NIX_BUILD_TOP nim c $nimFlags src/nimble
+      runHook postBuild
+    '';
+
+    installPhase = ''
+      runHook preBuild
+      install -Dt $out/bin src/nimble
+      runHook postBuild
+    '';
+
+    meta = with lib; {
+      description = "Package manager for the Nim programming language";
+      homepage = "https://github.com/nim-lang/nimble";
+      license = licenses.bsd3;
+      maintainers = with maintainers; [ ehmry ];
+      mainProgram = "nimble";
+    };
+  };
+
+  nim = let
+    nim' = buildPackages.nim-unwrapped;
+    nimble' = buildPackages.nimble-unwrapped;
+    inherit (stdenv) targetPlatform;
+    self = stdenv.mkDerivation {
+      name = "${targetPlatform.config}-nim-wrapper-${nim'.version}";
+      inherit (nim') version;
+      preferLocalBuild = true;
+      strictDeps = true;
+
+      nativeBuildInputs = [ makeWrapper ];
+
+      patches = [
+        ./nim.cfg.patch
+        # Remove configurations that clash with ours
+      ];
+
+      unpackPhase = ''
+        runHook preUnpack
+        tar xf ${nim'.src} nim-$version/config
+        cd nim-$version
+        runHook postUnpack
+      '';
+
+      dontConfigure = true;
+
+      buildPhase =
+        # Configure the Nim compiler to use $CC and $CXX as backends
+        # The compiler is configured by two configuration files, each with
+        # a different DSL. The order of evaluation matters and that order
+        # is not documented, so duplicate the configuration across both files.
+        ''
+          runHook preBuild
+          cat >> config/config.nims << WTF
+
+          switch("os", "${nimTarget.os}")
+          switch("cpu", "${nimTarget.cpu}")
+          switch("define", "nixbuild")
+
+          # Configure the compiler using the $CC set by Nix at build time
+          import strutils
+          let cc = getEnv"CC"
+          if cc.contains("gcc"):
+            switch("cc", "gcc")
+          elif cc.contains("clang"):
+            switch("cc", "clang")
+          WTF
+
+          mv config/nim.cfg config/nim.cfg.old
+          cat > config/nim.cfg << WTF
+          os = "${nimTarget.os}"
+          cpu =  "${nimTarget.cpu}"
+          define:"nixbuild"
+          WTF
+
+          cat >> config/nim.cfg < config/nim.cfg.old
+          rm config/nim.cfg.old
+
+          cat >> config/nim.cfg << WTF
+
+          clang.cpp.exe %= "\$CXX"
+          clang.cpp.linkerexe %= "\$CXX"
+          clang.exe %= "\$CC"
+          clang.linkerexe %= "\$CC"
+          gcc.cpp.exe %= "\$CXX"
+          gcc.cpp.linkerexe %= "\$CXX"
+          gcc.exe %= "\$CC"
+          gcc.linkerexe %= "\$CC"
+          WTF
+
+          runHook postBuild
+        '';
+
+      wrapperArgs = [
+        "--prefix PATH : ${lib.makeBinPath [ buildPackages.gdb ]}:${
+          placeholder "out"
+        }/bin"
+        # Used by nim-gdb
+
+        "--prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ openssl pcre ]}"
+        # These libraries may be referred to by the standard library.
+        # This is broken for cross-compilation because the package
+        # set will be shifted back by nativeBuildInputs.
+
+        "--set NIM_CONFIG_PATH ${placeholder "out"}/etc/nim"
+        # Use the custom configuration
+
+        ''--set NIX_HARDENING_ENABLE "''${NIX_HARDENING_ENABLE/fortify}"''
+        # Fortify hardening appends -O2 to gcc flags which is unwanted for unoptimized nim builds.
+      ];
+
+      installPhase = ''
+        runHook preInstall
+
+        mkdir -p $out/bin $out/etc
+
+        cp -r config $out/etc/nim
+
+        for binpath in ${nim'}/bin/nim?*; do
+          local binname=`basename $binpath`
+          makeWrapper \
+            $binpath $out/bin/${targetPlatform.config}-$binname \
+            $wrapperArgs
+          ln -s $out/bin/${targetPlatform.config}-$binname $out/bin/$binname
+        done
+
+        makeWrapper \
+          ${nim'}/nim/bin/nim $out/bin/${targetPlatform.config}-nim \
+          --set-default CC $(command -v $CC) \
+          --set-default CXX $(command -v $CXX) \
+          $wrapperArgs
+        ln -s $out/bin/${targetPlatform.config}-nim $out/bin/nim
+
+        makeWrapper \
+          ${nim'}/bin/testament $out/bin/${targetPlatform.config}-testament \
+          $wrapperArgs
+        ln -s $out/bin/${targetPlatform.config}-testament $out/bin/testament
+
+        makeWrapper \
+          ${nimble'}/bin/nimble $out/bin/${targetPlatform.config}-nimble \
+          --suffix PATH : $out/bin
+        ln -s $out/bin/${targetPlatform.config}-nimble $out/bin/nimble
+
+        runHook postInstall
+      '';
+
+      passthru = {
+        nim = nim';
+        nimble = nimble';
+      };
+
+      meta = nim'.meta // {
+        description = nim'.meta.description
+          + " (${targetPlatform.config} wrapper)";
+        platforms = with lib.platforms; unix ++ genode;
+      };
+    };
+  in self // {
+    pkgs = callPackage ../../../top-level/nim-packages.nix { nim = self; };
+  };
+
+}

pkgs/development/compilers/nim/nim.cfg.patch

@@ -0,0 +1,31 @@
+diff --git a/config/nim.cfg b/config/nim.cfg
+index 3b964d124..850ed0ed9 100644
+--- a/config/nim.cfg
++++ b/config/nim.cfg
+@@ -8,26 +8,12 @@
+ # Environment variables can be accessed like so:
+ #  gcc.path %= "$CC_PATH"
+ 
+-cc = gcc
+-
+ # additional options always passed to the compiler:
+ --parallel_build: "0" # 0 to auto-detect number of processors
+ 
+ hint[LineTooLong]=off
+ #hint[XDeclaredButNotUsed]=off
+ 
+-# Examples of how to setup a cross-compiler:
+-
+-# Cross-compiling for Raspberry Pi.
+-# (This compiler is available in gcc-arm-linux-gnueabihf package on Ubuntu)
+-arm.linux.gcc.exe = "arm-linux-gnueabihf-gcc"
+-arm.linux.gcc.linkerexe = "arm-linux-gnueabihf-gcc"
+-
+-# For OpenWRT, you will also need to adjust PATH to point to your toolchain.
+-mips.linux.gcc.exe = "mips-openwrt-linux-gcc"
+-mips.linux.gcc.linkerexe = "mips-openwrt-linux-gcc"
+-
+-
+ path="$lib/deprecated/core"
+ path="$lib/deprecated/pure"
+ path="$lib/pure/collections"

pkgs/development/compilers/nim/nixbuild.patch

@@ -0,0 +1,51 @@
+commit 164ba50fc74b980f77047080b2ae1ea099ae9b27
+Author: Emery Hemingway <ehmry@posteo.net>
+Date:   Mon Sep 7 14:09:22 2020 +0200
+
+    Load libaries by absolute path on NixOS
+    
+    If "nixbuild" is defined then choose dynamic runtime libraries by
+    searching $NIX_LDFLAGS at compile-time.
+    
+    Fix #15194
+
+diff --git a/lib/pure/dynlib.nim b/lib/pure/dynlib.nim
+index f31ae94dd..debed9c07 100644
+--- a/lib/pure/dynlib.nim
++++ b/lib/pure/dynlib.nim
+@@ -56,6 +56,9 @@
+ 
+ import strutils
+ 
++when defined(nixbuild):
++  import os
++
+ type
+   LibHandle* = pointer ## a handle to a dynamically loaded library
+ 
+@@ -95,6 +98,25 @@ proc libCandidates*(s: string, dest: var seq[string]) =
+       libCandidates(prefix & middle & suffix, dest)
+   else:
+     add(dest, s)
++  when defined(nixbuild):
++    # Nix doesn't have a global library directory so
++    # load libraries using an absolute path if one
++    # can be derived from NIX_LDFLAGS.
++    #
++    # During Nix/NixOS packaging the line "define:nixbuild"
++    # should be appended to the ../../config/nim.cfg file
++    # to enable this behavior by default.
++    #
++    var libDirs = split(getEnv("LD_LIBRARY_PATH"), ':')
++    for flag in split(getEnv("NIX_LDFLAGS")):
++      if flag.startsWith("-L"):
++        libDirs.add(flag[2..flag.high])
++    for lib in dest:
++      for dir in libDirs:
++        let abs = dir / lib
++        if existsFile(abs):
++          dest = @[abs]
++          return
+ 
+ proc loadLibPattern*(pattern: string, globalSymbols = false): LibHandle =
+   ## loads a library with name matching `pattern`, similar to what `dlimport`

pkgs/development/compilers/nim/toLocation.patch

@@ -0,0 +1,16 @@
+diff --git a/lib/std/private/miscdollars.nim b/lib/std/private/miscdollars.nim
+index 840fedf54..6c3436308 100644
+--- a/lib/std/private/miscdollars.nim
++++ b/lib/std/private/miscdollars.nim
+@@ -6,9 +6,8 @@ template toLocation*(result: var string, file: string | cstring, line: int, col:
+   # it can be done in a single place.
+   result.add file
+   if line > 0:
+-    result.add "("
++    result.add ":"
+     addInt(result, line)
+     if col > 0:
+-      result.add ", "
++      result.add ":"
+       addInt(result, col)
+-    result.add ")"