core/pkgs/by-name/gc/gcc/packages.nix

{ noSysDirs, ... }:
res: pkgs: super:

with pkgs; {
  default-gcc-version = if (with stdenv.targetPlatform; isVc4 || libc == "relibc") then 6 else 13;
  gcc = pkgs.${"gcc${toString default-gcc-version}"};
  gccFun = callPackage ./.;
  gcc-unwrapped = gcc.cc;

  gccStdenv =
    if stdenv.cc.isGNU then
      stdenv
    else
      stdenv.override {
        cc = buildPackages.gcc;
        allowedRequisites = null;
        # Remove libcxx/libcxxabi, and add clang for AS if on darwin (it uses
        # clang's internal assembler).
        extraBuildInputs = lib.optional stdenv.hostPlatform.isDarwin clang.cc;
      };

  gcc49Stdenv = overrideCC gccStdenv buildPackages.gcc49;
  gcc6Stdenv = overrideCC gccStdenv buildPackages.gcc6;
  gcc7Stdenv = overrideCC gccStdenv buildPackages.gcc7;
  gcc8Stdenv = overrideCC gccStdenv buildPackages.gcc8;
  gcc9Stdenv = overrideCC gccStdenv buildPackages.gcc9;
  gcc10Stdenv = overrideCC gccStdenv buildPackages.gcc10;
  gcc11Stdenv = overrideCC gccStdenv buildPackages.gcc11;
  gcc12Stdenv = overrideCC gccStdenv buildPackages.gcc12;
  gcc13Stdenv = overrideCC gccStdenv buildPackages.gcc13;

  # This is not intended for use in nixpkgs but for providing a faster-running
  # compiler to nixpkgs users by building gcc with reproducibility-breaking
  # profile-guided optimizations
  fastStdenv = overrideCC gccStdenv (wrapNonDeterministicGcc gccStdenv buildPackages.gcc_latest);

  wrapCCMulti =
    cc:
    if stdenv.targetPlatform.system == "x86_64-linux" then
      let
        # Binutils with glibc multi
        bintools = cc.bintools.override { libc = glibc_multi; };
      in
      lowPrio (wrapCCWith {
        cc = cc.cc.override {
          stdenv = overrideCC stdenv (wrapCCWith {
            cc = cc.cc;
            inherit bintools;
            libc = glibc_multi;
          });
          profiledCompiler = false;
          enableMultilib = true;
        };
        libc = glibc_multi;
        inherit bintools;
        extraBuildCommands = ''
          echo "dontMoveLib64=1" >> $out/nix-support/setup-hook
        '';
      })
    else
      throw "Multilib ${cc.name} not supported for ‘${stdenv.targetPlatform.system}’";

  gcc_multi = wrapCCMulti gcc;

  gccMultiStdenv = overrideCC stdenv buildPackages.gcc_multi;

  gcc_debug = lowPrio (wrapCC (gcc.cc.overrideAttrs { dontStrip = true; }));

  gccCrossLibcStdenv = overrideCC stdenv buildPackages.gccWithoutTargetLibc;

  # The GCC used to build libc for the target platform. Normal gccs will be
  # built with, and use, that cross-compiled libc.
  gccWithoutTargetLibc =
    assert stdenv.targetPlatform != stdenv.hostPlatform;
    let
      libcCross1 = binutilsNoLibc.libc;
    in
    wrapCCWith {
      cc = gccFun {
        # copy-pasted
        inherit noSysDirs;
        majorMinorVersion = toString default-gcc-version;

        reproducibleBuild = true;
        profiledCompiler = false;

        isl = if !stdenv.isDarwin then isl_0_20 else null;

        withoutTargetLibc = true;
        langCC = false;
        libcCross = libcCross1;
        targetPackages.stdenv.cc.bintools = binutilsNoLibc;
        enableShared =
          stdenv.targetPlatform.hasSharedLibraries

          # temporarily disabled due to breakage;
          # see https://github.com/NixOS/nixpkgs/pull/243249
          && !stdenv.targetPlatform.isWindows
          && !(stdenv.targetPlatform.useLLVM or false);
      };
      bintools = binutilsNoLibc;
      libc = libcCross1;
      extraPackages = [ ];
    };

  inherit (callPackage ./all.nix { inherit noSysDirs; })
    gcc48
    gcc49
    gcc6
    gcc7
    gcc8
    gcc9
    gcc10
    gcc11
    gcc12
    gcc13
    ;

  gcc_latest = gcc13;

  libgcc = stdenv.cc.cc.libgcc or null;

  # This is for e.g. LLVM libraries on linux.
  gccForLibs =
    if
      stdenv.targetPlatform == stdenv.hostPlatform && targetPackages.stdenv.cc.isGNU
    # Can only do this is in the native case, otherwise we might get infinite
    # recursion if `targetPackages.stdenv.cc.cc` itself uses `gccForLibs`.
    then
      targetPackages.stdenv.cc.cc
    else
      gcc.cc;

  wrapNonDeterministicGcc =
    stdenv: ccWrapper:
    if ccWrapper.isGNU then
      ccWrapper.overrideAttrs (old: {
        env = old.env // {
          cc = old.env.cc.override {
            reproducibleBuild = false;
            profiledCompiler = with stdenv; (!isDarwin && hostPlatform.isx86);
          };
        };
      })
    else
      ccWrapper;

  # Use the same GCC version as the one from stdenv by default
  gfortran = wrapCC (
    gcc.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran48 = wrapCC (
    gcc48.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran49 = wrapCC (
    gcc49.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran6 = wrapCC (
    gcc6.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran7 = wrapCC (
    gcc7.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran8 = wrapCC (
    gcc8.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran9 = wrapCC (
    gcc9.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran10 = wrapCC (
    gcc10.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran11 = wrapCC (
    gcc11.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran12 = wrapCC (
    gcc12.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  gfortran13 = wrapCC (
    gcc13.cc.override {
      name = "gfortran";
      langFortran = true;
      langCC = false;
      langC = false;
      profiledCompiler = false;
    }
  );

  libgccjit = gcc.cc.override {
    name = "libgccjit";
    langFortran = false;
    langCC = false;
    langC = false;
    profiledCompiler = false;
    langJit = true;
    enableLTO = false;
  };

  gcj = gcj6;
  gcj6 = wrapCC (
    gcc6.cc.override {
      name = "gcj";
      langJava = true;
      langFortran = false;
      langCC = false;
      langC = false;
      profiledCompiler = false;
      inherit
        zip
        unzip
        zlib
        boehmgc
        gettext
        pkg-config
        perl
        ;
      inherit (gnome2) libart_lgpl;
    }
  );

  gnat = gnat12; # When changing this, update also gnatPackages

  gnat11 = wrapCC (
    gcc11.cc.override {
      name = "gnat";
      langC = true;
      langCC = false;
      langAda = true;
      profiledCompiler = false;
      # As per upstream instructions building a cross compiler
      # should be done with a (native) compiler of the same version.
      # If we are cross-compiling GNAT, we may as well do the same.
      gnat-bootstrap =
        if stdenv.hostPlatform == stdenv.targetPlatform && stdenv.buildPlatform == stdenv.hostPlatform then
          buildPackages.gnat-bootstrap11
        else
          buildPackages.gnat11;
    }
  );

  gnat12 = wrapCC (
    gcc12.cc.override {
      name = "gnat";
      langC = true;
      langCC = false;
      langAda = true;
      profiledCompiler = false;
      # As per upstream instructions building a cross compiler
      # should be done with a (native) compiler of the same version.
      # If we are cross-compiling GNAT, we may as well do the same.
      gnat-bootstrap =
        if stdenv.hostPlatform == stdenv.targetPlatform && stdenv.buildPlatform == stdenv.hostPlatform then
          buildPackages.gnat-bootstrap12
        else
          buildPackages.gnat12;
      stdenv =
        if
          stdenv.hostPlatform == stdenv.targetPlatform
          && stdenv.buildPlatform == stdenv.hostPlatform
          && stdenv.buildPlatform.isDarwin
          && stdenv.buildPlatform.isx86_64
        then
          overrideCC stdenv gnat-bootstrap12
        else
          stdenv;
    }
  );

  gnat13 = wrapCC (
    gcc13.cc.override {
      name = "gnat";
      langC = true;
      langCC = false;
      langAda = true;
      profiledCompiler = false;
      # As per upstream instructions building a cross compiler
      # should be done with a (native) compiler of the same version.
      # If we are cross-compiling GNAT, we may as well do the same.
      gnat-bootstrap =
        if stdenv.hostPlatform == stdenv.targetPlatform && stdenv.buildPlatform == stdenv.hostPlatform then
          buildPackages.gnat-bootstrap12
        else
          buildPackages.gnat13;
      stdenv =
        if
          stdenv.hostPlatform == stdenv.targetPlatform
          && stdenv.buildPlatform == stdenv.hostPlatform
          && stdenv.buildPlatform.isDarwin
          && stdenv.buildPlatform.isx86_64
        then
          overrideCC stdenv gnat-bootstrap12
        else
          stdenv;
    }
  );

  gnat-bootstrap = gnat-bootstrap12;
  gnat-bootstrap11 = wrapCC (
    callPackage ../development/compilers/gnat-bootstrap { majorVersion = "11"; }
  );
  gnat-bootstrap12 = wrapCCWith (
    {
      cc = callPackage ../development/compilers/gnat-bootstrap { majorVersion = "12"; };
    }
    // lib.optionalAttrs (stdenv.hostPlatform.isDarwin) { bintools = bintoolsDualAs; }
  );

  gnat12Packages = recurseIntoAttrs (callPackage ./ada-packages.nix { gnat = buildPackages.gnat12; });
  gnat13Packages = recurseIntoAttrs (callPackage ./ada-packages.nix { gnat = buildPackages.gnat13; });
  gnatPackages = gnat12Packages;

  inherit (gnatPackages) gprbuild gnatprove;

  gccgo = wrapCC (
    gcc.cc.override {
      name = "gccgo";
      langCC = true; # required for go.
      langC = true;
      langGo = true;
      langJit = true;
      profiledCompiler = false;
    }
    // {
      # not supported on darwin: https://github.com/golang/go/issues/463
      meta.broken = stdenv.hostPlatform.isDarwin;
    }
  );

  gccgo12 = wrapCC (
    gcc12.cc.override {
      name = "gccgo";
      langCC = true; # required for go.
      langC = true;
      langGo = true;
      langJit = true;
      profiledCompiler = false;
    }
    // {
      # not supported on darwin: https://github.com/golang/go/issues/463
      meta.broken = stdenv.hostPlatform.isDarwin;
    }
  );

  gccgo13 = wrapCC (
    gcc13.cc.override {
      name = "gccgo";
      langCC = true; # required for go.
      langC = true;
      langGo = true;
      langJit = true;
      profiledCompiler = false;
    }
    // {
      # not supported on darwin: https://github.com/golang/go/issues/463
      meta.broken = stdenv.hostPlatform.isDarwin;
    }
  );

  # It would be better to match the default gcc so that there are no linking errors
  # when using C/C++ libraries in D packages, but right now versions >= 12 are broken.
  gdc = gdc11;
  gdc11 = wrapCC (
    gcc11.cc.override {
      name = "gdc";
      langCC = false;
      langC = false;
      langD = true;
      profiledCompiler = false;
    }
  );
}