commit e5f02248813d468bc73f4eead759be433c820a04 · pyrox.dev/nixpkgs

+4 -19

nixos/modules/hardware/device-tree.nix

···

       56
       56
        
           };

     

       57
       57
        
         };

     

       58
       58
        
       

     

       59
       59
       -
         # this requires kernel package

     

       60
       60
       -
         dtbsWithSymbols = pkgs.stdenv.mkDerivation {

     

       61
       61
       -
           name = "dtbs-with-symbols";

     

       62
       62
       -
           inherit (cfg.kernelPackage) src nativeBuildInputs depsBuildBuild;

     

       63
       63
       -
           patches = map (patch: patch.patch) cfg.kernelPackage.kernelPatches;

     

       64
       64
       -
           buildPhase = ''

     

       65
       65
       -
             patchShebangs scripts/*

     

       66
       66
       -
             substituteInPlace scripts/Makefile.lib \

     

       67
       67
       -
               --replace 'DTC_FLAGS += $(DTC_FLAGS_$(basetarget))' 'DTC_FLAGS += $(DTC_FLAGS_$(basetarget)) -@'

     

       68
       68
       -
             make ${pkgs.stdenv.hostPlatform.linux-kernel.baseConfig} ARCH="${pkgs.stdenv.hostPlatform.linuxArch}"

     

       69
       69
       -
             make dtbs ARCH="${pkgs.stdenv.hostPlatform.linuxArch}"

     

       70
       70
       -
           '';

     

       71
       71
       -
           installPhase = ''

     

       72
       72
       -
             make dtbs_install INSTALL_DTBS_PATH=$out/dtbs  ARCH="${pkgs.stdenv.hostPlatform.linuxArch}"

     

       73
       73
       -
           '';

     

       74
       74
       -
         };

     

       75
       75
       -
       

     

       76
       59
        
         filterDTBs = src: if isNull cfg.filter

     

       77
       60
        
           then "${src}/dtbs"

     

       78
       61
        
           else

     
···

       82
       65
        
               find . -type f -name '${cfg.filter}' -print0 \

     

       83
       66
        
                 | xargs -0 cp -v --no-preserve=mode --target-directory $out --parents

     

       84
       67
        
             '';

     

       68
       68
       +
       

     

       69
       69
       +
         filteredDTBs = filterDTBs cfg.kernelPackage;

     

       85
       70
        
       

     

       86
       71
        
         # Compile single Device Tree overlay source

     

       87
       72
        
         # file (.dts) into its compiled variant (.dtbo)

     
···

       197
       182
        
           };

     

       198
       183
        
       

     

       199
       184
        
           hardware.deviceTree.package = if (cfg.overlays != [])

     

       200
       200
       -
             then pkgs.deviceTree.applyOverlays (filterDTBs dtbsWithSymbols) (withDTBOs cfg.overlays)

     

       201
       201
       -
             else (filterDTBs cfg.kernelPackage);

     

       185
       185
       +
             then pkgs.deviceTree.applyOverlays filteredDTBs (withDTBOs cfg.overlays)

     

       186
       186
       +
             else filteredDTBs;

     

       202
       187
        
         };

     

       203
       188
        
       }

+23 -13

nixos/modules/services/networking/https-dns-proxy.nix

···

       20
       20
        
             ips = [ "9.9.9.9" "149.112.112.112" ];

     

       21
       21
        
             url = "https://dns.quad9.net/dns-query";

     

       22
       22
        
           };

     

       23
       23
       +
           opendns = {

     

       24
       24
       +
             ips = [ "208.67.222.222" "208.67.220.220" ];

     

       25
       25
       +
             url = "https://doh.opendns.com/dns-query";

     

       26
       26
       +
           };

     

       27
       27
       +
           custom = {

     

       28
       28
       +
             inherit (cfg.provider) ips url;

     

       29
       29
       +
           };

     

       23
       30
        
         };

     

       24
       31
        
       

     

       25
       32
        
         defaultProvider = "quad9";

     

       26
       33
        
       

     

       27
       34
        
         providerCfg =

     

       28
       28
       -
           let

     

       29
       29
       -
             isCustom = cfg.provider.kind == "custom";

     

       30
       30
       -
           in

     

       31
       31
       -
           lib.concatStringsSep " " [

     

       35
       35
       +
           concatStringsSep " " [

     

       32
       36
        
             "-b"

     

       33
       33
       -
             (concatStringsSep "," (if isCustom then cfg.provider.ips else providers."${cfg.provider.kind}".ips))

     

       37
       37
       +
             (concatStringsSep "," providers."${cfg.provider.kind}".ips)

     

       34
       38
        
             "-r"

     

       35
       35
       -
             (if isCustom then cfg.provider.url else providers."${cfg.provider.kind}".url)

     

       39
       39
       +
             providers."${cfg.provider.kind}".url

     

       36
       40
        
           ];

     

       37
       41
        
       

     

       38
       42
        
       in

     
···

       62
       66
        
                 The upstream provider to use or custom in case you do not trust any of

     

       63
       67
        
                 the predefined providers or just want to use your own.

     

       64
       68
        
       

     

       65
       65
       -
                 The default is ${defaultProvider} and there are privacy and security trade-offs

     

       66
       66
       -
                 when using any upstream provider. Please consider that before using any

     

       67
       67
       -
                 of them.

     

       69
       69
       +
                 The default is ${defaultProvider} and there are privacy and security

     

       70
       70
       +
                 trade-offs when using any upstream provider. Please consider that

     

       71
       71
       +
                 before using any of them.

     

       68
       72
        
       

     

       69
       69
       -
                 If you pick a custom provider, you will need to provide the bootstrap

     

       70
       70
       -
                 IP addresses as well as the resolver https URL.

     

       73
       73
       +
                 Supported providers: ${concatStringsSep ", " (builtins.attrNames providers)}

     

       74
       74
       +
       

     

       75
       75
       +
                 If you pick the custom provider, you will need to provide the

     

       76
       76
       +
                 bootstrap IP addresses as well as the resolver https URL.

     

       71
       77
        
               '';

     

       72
       72
       -
               type = types.enum ((builtins.attrNames providers) ++ [ "custom" ]);

     

       78
       78
       +
               type = types.enum (builtins.attrNames providers);

     

       73
       79
        
               default = defaultProvider;

     

       74
       80
        
             };

     

       75
       81
        
       

     
···

       105
       111
        
         config = lib.mkIf cfg.enable {

     

       106
       112
        
           systemd.services.https-dns-proxy = {

     

       107
       113
        
             description = "DNS to DNS over HTTPS (DoH) proxy";

     

       114
       114
       +
             requires = [ "network.target" ];

     

       108
       115
        
             after = [ "network.target" ];

     

       116
       116
       +
             wants = [ "nss-lookup.target" ];

     

       117
       117
       +
             before = [ "nss-lookup.target" ];

     

       109
       118
        
             wantedBy = [ "multi-user.target" ];

     

       110
       119
        
             serviceConfig = rec {

     

       111
       120
        
               Type = "exec";

     

       112
       121
        
               DynamicUser = true;

     

       122
       122
       +
               ProtectHome = "tmpfs";

     

       113
       123
        
               ExecStart = lib.concatStringsSep " " (

     

       114
       124
        
                 [

     

       115
       115
       -
                   "${pkgs.https-dns-proxy}/bin/https_dns_proxy"

     

       125
       125
       +
                   (lib.getExe pkgs.https-dns-proxy)

     

       116
       126
        
                   "-a ${toString cfg.address}"

     

       117
       127
        
                   "-p ${toString cfg.port}"

     

       118
       128
        
                   "-l -"

+1 -7

nixos/modules/services/x11/display-managers/lightdm-greeters/slick.nix

···

       25
       25
        
       {

     

       26
       26
        
         options = {

     

       27
       27
        
           services.xserver.displayManager.lightdm.greeters.slick = {

     

       28
       28
       -
             enable = mkOption {

     

       29
       29
       -
               type = types.bool;

     

       30
       30
       -
               default = false;

     

       31
       31
       -
               description = lib.mdDoc ''

     

       32
       32
       -
                 Whether to enable lightdm-slick-greeter as the lightdm greeter.

     

       33
       33
       -
               '';

     

       34
       34
       -
             };

     

       28
       28
       +
             enable = mkEnableOption "lightdm-slick-greeter as the lightdm greeter";

     

       35
       29
        
       

     

       36
       30
        
             theme = {

     

       37
       31
        
               package = mkOption {

-8

nixos/modules/system/boot/systemd/initrd.nix

···

       100
       100
        
       

     

       101
       101
        
         fileSystems = filter utils.fsNeededForBoot config.system.build.fileSystems;

     

       102
       102
        
       

     

       103
       103
       -
         fstab = pkgs.writeText "initrd-fstab" (lib.concatMapStringsSep "\n"

     

       104
       104
       -
           ({ fsType, mountPoint, device, options, autoFormat, autoResize, ... }@fs: let

     

       105
       105
       -
               opts = options ++ optional autoFormat "x-systemd.makefs" ++ optional autoResize "x-systemd.growfs";

     

       106
       106
       -
               finalDevice = if (lib.elem "bind" options) then "/sysroot${device}" else device;

     

       107
       107
       -
             in "${finalDevice} /sysroot${mountPoint} ${fsType} ${lib.concatStringsSep "," opts}") fileSystems);

     

       108
       108
       -
       

     

       109
       103
        
         needMakefs = lib.any (fs: fs.autoFormat) fileSystems;

     

       110
       104
        
         needGrowfs = lib.any (fs: fs.autoResize) fileSystems;

     

       111
       105
        
       

     
···

       353
       347
        
                 [Manager]

     

       354
       348
        
                 DefaultEnvironment=PATH=/bin:/sbin ${optionalString (isBool cfg.emergencyAccess && cfg.emergencyAccess) "SYSTEMD_SULOGIN_FORCE=1"}

     

       355
       349
        
               '';

     

       356
       356
       -
       

     

       357
       357
       -
               "/etc/fstab".source = fstab;

     

       358
       350
        
       

     

       359
       351
        
               "/lib/modules".source = "${modulesClosure}/lib/modules";

     

       360
       352
        
               "/lib/firmware".source = "${modulesClosure}/lib/firmware";

+31 -17

nixos/modules/tasks/filesystems.nix

···

       153
       153
        
             specialMount "${mount.device}" "${mount.mountPoint}" "${concatStringsSep "," mount.options}" "${mount.fsType}"

     

       154
       154
        
           '') mounts);

     

       155
       155
        
       

     

       156
       156
       +
         makeFstabEntries =

     

       157
       157
       +
           let

     

       158
       158
       +
             fsToSkipCheck = [ "none" "bindfs" "btrfs" "zfs" "tmpfs" "nfs" "vboxsf" "glusterfs" "apfs" "9p" "cifs" "prl_fs" "vmhgfs" ];

     

       159
       159
       +
             isBindMount = fs: builtins.elem "bind" fs.options;

     

       160
       160
       +
             skipCheck = fs: fs.noCheck || fs.device == "none" || builtins.elem fs.fsType fsToSkipCheck || isBindMount fs;

     

       161
       161
       +
             # https://wiki.archlinux.org/index.php/fstab#Filepath_spaces

     

       162
       162
       +
             escape = string: builtins.replaceStrings [ " " "\t" ] [ "\\040" "\\011" ] string;

     

       163
       163
       +
           in fstabFileSystems: { rootPrefix ? "", excludeChecks ? false, extraOpts ? (fs: []) }: concatMapStrings (fs:

     

       164
       164
       +
             (optionalString (isBindMount fs) (escape rootPrefix))

     

       165
       165
       +
             + (if fs.device != null then escape fs.device

     

       166
       166
       +
                else if fs.label != null then "/dev/disk/by-label/${escape fs.label}"

     

       167
       167
       +
                else throw "No device specified for mount point ‘${fs.mountPoint}’.")

     

       168
       168
       +
             + " " + escape (rootPrefix + fs.mountPoint)

     

       169
       169
       +
             + " " + fs.fsType

     

       170
       170
       +
             + " " + builtins.concatStringsSep "," (fs.options ++ (extraOpts fs))

     

       171
       171
       +
             + " " + (optionalString (!excludeChecks)

     

       172
       172
       +
               ("0 " + (if skipCheck fs then "0" else if fs.mountPoint == "/" then "1" else "2")))

     

       173
       173
       +
             + "\n"

     

       174
       174
       +
           ) fstabFileSystems;

     

       175
       175
       +
       

     

       176
       176
       +
           initrdFstab = pkgs.writeText "initrd-fstab" (makeFstabEntries (filter utils.fsNeededForBoot fileSystems) {

     

       177
       177
       +
             rootPrefix = "/sysroot";

     

       178
       178
       +
             excludeChecks = true;

     

       179
       179
       +
             extraOpts = fs:

     

       180
       180
       +
               (optional fs.autoResize "x-systemd.growfs")

     

       181
       181
       +
               ++ (optional fs.autoFormat "x-systemd.makefs");

     

       182
       182
       +
           });

     

       183
       183
       +
       

     

       156
       184
        
       in

     

       157
       185
        
       

     

       158
       186
        
       {

     
···

       278
       306
        
       

     

       279
       307
        
           environment.etc.fstab.text =

     

       280
       308
        
             let

     

       281
       281
       -
               fsToSkipCheck = [ "none" "bindfs" "btrfs" "zfs" "tmpfs" "nfs" "vboxsf" "glusterfs" "apfs" "9p" "cifs" "prl_fs" "vmhgfs" ];

     

       282
       282
       -
               isBindMount = fs: builtins.elem "bind" fs.options;

     

       283
       283
       -
               skipCheck = fs: fs.noCheck || fs.device == "none" || builtins.elem fs.fsType fsToSkipCheck || isBindMount fs;

     

       284
       284
       -
               # https://wiki.archlinux.org/index.php/fstab#Filepath_spaces

     

       285
       285
       -
               escape = string: builtins.replaceStrings [ " " "\t" ] [ "\\040" "\\011" ] string;

     

       286
       309
        
               swapOptions = sw: concatStringsSep "," (

     

       287
       310
        
                 sw.options

     

       288
       311
        
                 ++ optional (sw.priority != null) "pri=${toString sw.priority}"

     
···

       297
       320
        
               # <file system> <mount point>   <type>  <options>       <dump>  <pass>

     

       298
       321
        
       

     

       299
       322
        
               # Filesystems.

     

       300
       300
       -
               ${concatMapStrings (fs:

     

       301
       301
       -
                   (if fs.device != null then escape fs.device

     

       302
       302
       -
                    else if fs.label != null then "/dev/disk/by-label/${escape fs.label}"

     

       303
       303
       -
                    else throw "No device specified for mount point ‘${fs.mountPoint}’.")

     

       304
       304
       -
                   + " " + escape fs.mountPoint

     

       305
       305
       -
                   + " " + fs.fsType

     

       306
       306
       -
                   + " " + builtins.concatStringsSep "," fs.options

     

       307
       307
       -
                   + " 0"

     

       308
       308
       -
                   + " " + (if skipCheck fs then "0" else

     

       309
       309
       -
                            if fs.mountPoint == "/" then "1" else "2")

     

       310
       310
       -
                   + "\n"

     

       311
       311
       -
               ) fileSystems}

     

       323
       323
       +
               ${makeFstabEntries fileSystems {}}

     

       312
       324
        
       

     

       313
       325
        
               # Swap devices.

     

       314
       326
        
               ${flip concatMapStrings config.swapDevices (sw:

     

       315
       327
        
                   "${sw.realDevice} none swap ${swapOptions sw}\n"

     

       316
       328
        
               )}

     

       317
       329
        
             '';

     

       330
       330
       +
       

     

       331
       331
       +
           boot.initrd.systemd.contents."/etc/fstab".source = initrdFstab;

     

       318
       332
        
       

     

       319
       333
        
           # Provide a target that pulls in all filesystems.

     

       320
       334
        
           systemd.targets.fs =

+2 -2

pkgs/applications/audio/osdlyrics/default.nix

···

       17
       17
        
       

     

       18
       18
        
       stdenv.mkDerivation rec {

     

       19
       19
        
         pname = "osdlyrics";

     

       20
       20
       -
         version = "0.5.10";

     

       20
       20
       +
         version = "0.5.11";

     

       21
       21
        
       

     

       22
       22
        
         src = fetchFromGitHub {

     

       23
       23
        
           owner = "osdlyrics";

     

       24
       24
        
           repo = "osdlyrics";

     

       25
       25
        
           rev = version;

     

       26
       26
       -
           sha256 = "sha256-x9gIT1JkfPIc4RmmQJLv9rOG2WqAftoTK5uiRlS65zU=";

     

       26
       26
       +
           sha256 = "sha256-VxLNaNe4hFwgSW4JEF1T4BWC2NwiOgfwVGiAIOszfGE=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         nativeBuildInputs = [

pkgs/applications/editors/neovim/neovim-override.vim pkgs/applications/editors/neovim/tests/init-override.vim

+28 -2

pkgs/applications/editors/neovim/tests.nix pkgs/applications/editors/neovim/tests/default.nix

···

       2
       2
        
       , lib, fetchFromGitHub, neovimUtils, wrapNeovimUnstable

     

       3
       3
        
       , neovim-unwrapped

     

       4
       4
        
       , fetchFromGitLab

     

       5
       5
       +
       , runCommandLocal

     

       5
       6
        
       , pkgs

     

       6
       7
        
       }:

     

       7
       8
        
       let

     
···

       19
       20
        
           }

     

       20
       21
        
         ];

     

       21
       22
        
       

     

       23
       23
       +
         packagesWithSingleLineConfigs = with vimPlugins; [

     

       24
       24
       +
           {

     

       25
       25
       +
             plugin = vim-obsession;

     

       26
       26
       +
             config = ''map <Leader>$ <Cmd>Obsession<CR>'';

     

       27
       27
       +
           }

     

       28
       28
       +
           {

     

       29
       29
       +
             plugin = trouble-nvim;

     

       30
       30
       +
             config = ''" placeholder config'';

     

       31
       31
       +
           }

     

       32
       32
       +
         ];

     

       33
       33
       +
       

     

       34
       34
       +
         nvimConfSingleLines = makeNeovimConfig {

     

       35
       35
       +
           plugins = packagesWithSingleLineConfigs;

     

       36
       36
       +
           customRC = ''

     

       37
       37
       +
             " just a comment

     

       38
       38
       +
           '';

     

       39
       39
       +
         };

     

       40
       40
       +
       

     

       22
       41
        
         nvimConfNix = makeNeovimConfig {

     

       23
       42
        
           inherit plugins;

     

       24
       43
        
           customRC = ''

     
···

       47
       66
        
           sha256 = "1ykcvyx82nhdq167kbnpgwkgjib8ii7c92y3427v986n2s5lsskc";

     

       48
       67
        
         };

     

       49
       68
        
       

     

       69
       69
       +
         # neovim-drv must be a wrapped neovim

     

       50
       70
        
         runTest = neovim-drv: buildCommand:

     

       51
       51
       -
           pkgs.runCommandLocal "test-${neovim-drv.name}" ({

     

       71
       71
       +
           runCommandLocal "test-${neovim-drv.name}" ({

     

       52
       72
        
             nativeBuildInputs = [ ];

     

       53
       73
        
             meta.platforms = neovim-drv.meta.platforms;

     

       54
       74
        
           }) (''

     
···

       67
       87
        
         ### neovim tests

     

       68
       88
        
         ##################

     

       69
       89
        
         nvim_with_plugins = wrapNeovim2 "-with-plugins" nvimConfNix;

     

       90
       90
       +
       

     

       91
       91
       +
         singlelinesconfig = runTest (wrapNeovim2 "-single-lines" nvimConfSingleLines) ''

     

       92
       92
       +
             assertFileContent \

     

       93
       93
       +
               "$vimrcGeneric" \

     

       94
       94
       +
               "${./init-single-lines.vim}"

     

       95
       95
       +
         '';

     

       70
       96
        
       

     

       71
       97
        
         nvim_via_override = neovim.override {

     

       72
       98
        
           extraName = "-via-override";

     
···

       131
       157
        
         nvim_via_override-test = runTest nvim_via_override ''

     

       132
       158
        
             assertFileContent \

     

       133
       159
        
               "$vimrcGeneric" \

     

       134
       134
       -
               "${./neovim-override.vim}"

     

       160
       160
       +
               "${./init-override.vim}"

     

       135
       161
        
         '';

     

       136
       162
        
       

     

       137
       163

pkgs/applications/editors/neovim/tests/init-single-lines.vim

···

       1
       1
       +
       map <Leader>$ <Cmd>Obsession<CR>

     

       2
       2
       +
       " placeholder config

     

       3
       3
       +
       " just a comment

+15 -6

pkgs/applications/editors/neovim/utils.nix

···

       49
       49
        
             };

     

       50
       50
        
       

     

       51
       51
        
             # transform all plugins into an attrset

     

       52
       52
       -
             # { optional = bool; plugin = package; dest = filename; }

     

       53
       53
       -
             pluginsNormalized = map (x: if x ? plugin then { dest = "init.vim"; optional = false; } // x else { plugin = x; optional = false;}) plugins;

     

       52
       52
       +
             # { optional = bool; plugin = package; }

     

       53
       53
       +
             pluginsNormalized = let

     

       54
       54
       +
               defaultPlugin = {

     

       55
       55
       +
                 plugin = null;

     

       56
       56
       +
                 config = null;

     

       57
       57
       +
                 optional = false;

     

       58
       58
       +
               };

     

       59
       59
       +
             in

     

       60
       60
       +
               map (x: defaultPlugin // (if (x ? plugin) then x else { plugin = x; })) plugins;

     

       54
       61
        
       

     

       55
       55
       -
       

     

       56
       56
       -
       

     

       57
       57
       -
             pluginRC = lib.concatMapStrings (p: p.config or "") pluginsNormalized;

     

       62
       62
       +
             pluginRC = lib.foldl (acc: p: if p.config != null then acc ++ [p.config] else acc) []  pluginsNormalized;

     

       58
       63
        
       

     

       59
       64
        
             pluginsPartitioned = lib.partition (x: x.optional == true) pluginsNormalized;

     

       60
       65
        
             requiredPlugins = vimUtils.requiredPluginsForPackage myVimPackage;

     
···

       116
       121
        
       

     

       117
       122
        
             manifestRc = vimUtils.vimrcContent ({ customRC = ""; }) ;

     

       118
       123
        
             # we call vimrcContent without 'packages' to avoid the init.vim generation

     

       119
       119
       -
             neovimRcContent = vimUtils.vimrcContent ({ beforePlugins = ""; customRC = pluginRC + customRC; packages = null; });

     

       124
       124
       +
             neovimRcContent = vimUtils.vimrcContent ({

     

       125
       125
       +
               beforePlugins = "";

     

       126
       126
       +
               customRC = lib.concatStringsSep "\n" (pluginRC ++ [customRC]);

     

       127
       127
       +
               packages = null;

     

       128
       128
       +
             });

     

       120
       129
        
           in

     

       121
       130
        
       

     

       122
       131
        
           builtins.removeAttrs args ["plugins"] // {

+1 -1

pkgs/applications/editors/neovim/wrapper.nix

···

       123
       123
        
             unwrapped = neovim;

     

       124
       124
        
             initRc = neovimRcContent;

     

       125
       125
        
       

     

       126
       126
       -
             tests = callPackage ./tests.nix {

     

       126
       126
       +
             tests = callPackage ./tests {

     

       127
       127
        
             };

     

       128
       128
        
           };

     

       129
       129

+3 -3

pkgs/applications/editors/setzer/default.nix

···

       18
       18
        
       

     

       19
       19
        
       python3.pkgs.buildPythonApplication rec {

     

       20
       20
        
         pname = "setzer";

     

       21
       21
       -
         version = "0.4.7";

     

       21
       21
       +
         version = "0.4.8";

     

       22
       22
        
       

     

       23
       23
        
         src = fetchFromGitHub {

     

       24
       24
        
           owner = "cvfosammmm";

     

       25
       25
        
           repo = "Setzer";

     

       26
       26
        
           rev = "v${version}";

     

       27
       27
       -
           hash = "sha256-IP56jOiiIK9EW4D5yEdLc49rUzcvegAX3Yyk2ERK/pE=";

     

       27
       27
       +
           hash = "sha256-7NPyvAof0xObYZws3KFAbdue/GpIRthzdX00jc9GhYs=";

     

       28
       28
        
         };

     

       29
       29
        
       

     

       30
       30
        
         format = "other";

     
···

       37
       37
        
           appstream-glib

     

       38
       38
        
           wrapGAppsHook

     

       39
       39
        
           desktop-file-utils

     

       40
       40
       +
           gobject-introspection

     

       40
       41
        
         ];

     

       41
       42
        
       

     

       42
       43
        
         buildInputs = [

     

       43
       43
       -
           gobject-introspection

     

       44
       44
        
           gtksourceview4

     

       45
       45
        
           gspell

     

       46
       46
        
           poppler_gi

+2 -2

pkgs/applications/finance/irpf/default.nix

···

       11
       11
        
       

     

       12
       12
        
       stdenvNoCC.mkDerivation rec {

     

       13
       13
        
         pname = "irpf";

     

       14
       14
       -
         version = "2022-1.6";

     

       14
       14
       +
         version = "2022-1.7";

     

       15
       15
        
       

     

       16
       16
        
         src = let

     

       17
       17
        
           year = lib.head (lib.splitVersion version);

     

       18
       18
        
         in fetchzip {

     

       19
       19
        
           url = "https://downloadirpf.receita.fazenda.gov.br/irpf/${year}/irpf/arquivos/IRPF${version}.zip";

     

       20
       20
       -
           sha256 = "sha256-/4dND4CMl4xnGGIb+FWqgL0wbt7fqUE78m737U0kAdw=";

     

       20
       20
       +
           sha256 = "sha256-EHuka0HzWoqjvT/DcuJ9LWSrWl0PW5FyS+7/PdCgrNQ=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [ unzip makeWrapper copyDesktopItems ];

+2 -2

pkgs/applications/misc/translate-shell/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "translate-shell";

     

       5
       5
       -
         version = "0.9.6.12";

     

       5
       5
       +
         version = "0.9.7";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "soimort";

     

       9
       9
        
           repo = "translate-shell";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "075vqnha21rhr1b61dim7dqlfwm1yffyzcaa83s36rpk9r5sddzx";

     

       11
       11
       +
           sha256 = "sha256-OLbGBP+QHW51mt0sFXf6SqrIYZ0iC/X10F148NAG4A4=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ makeWrapper ];

+3 -3

pkgs/applications/office/qnotero/default.nix

···

       3
       3
        
       python3Packages.buildPythonPackage rec {

     

       4
       4
        
         pname = "qnotero";

     

       5
       5
        
       

     

       6
       6
       -
         version = "2.3.0";

     

       6
       6
       +
         version = "2.3.1";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "ealbiter";

     

       10
       10
        
           repo = pname;

     

       11
       11
       -
           rev = "v${version}";

     

       12
       12
       -
           sha256 = "0y2xph4ha07slni039s034cn1wsk3q2d86hihy97h4ch47ignv20";

     

       11
       11
       +
           rev = "refs/tags/v${version}";

     

       12
       12
       +
           sha256 = "sha256-Rym7neluRbYCpuezRQyLc6gSl3xbVR9fvhOxxW5+Nzo=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         propagatedBuildInputs = [ python3Packages.pyqt5 wrapQtAppsHook ];

+30

pkgs/applications/window-managers/x-create-mouse-void/default.nix

···

       1
       1
       +
       { stdenv, lib, xorg, fetchFromGitHub }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         pname = "x-create-mouse-void";

     

       5
       5
       +
         version = "0.1";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "cas--";

     

       9
       9
       +
           repo = "XCreateMouseVoid";

     

       10
       10
       +
           rev = version;

     

       11
       11
       +
           sha256 = "151pv4gmzz9g6nd1xw94hmawlb5z8rgs1jb3x1zpvn3znd7f355c";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         buildInputs = [ xorg.libX11 ];

     

       15
       15
       +
       

     

       16
       16
       +
         installPhase = ''

     

       17
       17
       +
           runHook preInstall

     

       18
       18
       +
           mkdir -pv $out/bin

     

       19
       19
       +
           cp -a XCreateMouseVoid $out/bin/x-create-mouse-void

     

       20
       20
       +
           runHook postInstall

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         meta = with lib; {

     

       24
       24
       +
           homepage = "https://github.com/cas--/XCreateMouseVoid";

     

       25
       25
       +
           description = "Creates an undecorated black window and prevents the mouse from entering that window";

     

       26
       26
       +
           platforms = platforms.unix;

     

       27
       27
       +
           license = licenses.unfreeRedistributable;

     

       28
       28
       +
           maintainers = with maintainers; [ eigengrau ];

     

       29
       29
       +
         };

     

       30
       30
       +
       }

+79

pkgs/development/compilers/llvm/README.md

···

       1
       1
       +
       ## How to upgrade llvm_git

     

       2
       2
       +
       

     

       3
       3
       +
       - Run `update-git.py`.

     

       4
       4
       +
         This will set the github revision and sha256 for `llvmPackages_git.llvm` to whatever the latest chromium build is using.

     

       5
       5
       +
         For a more recent, commit run `nix-prefetch-github` and change the rev and sha256 accordingly.

     

       6
       6
       +
       

     

       7
       7
       +
       - That was the easy part.

     

       8
       8
       +
         The hard part is updating the patch files.

     

       9
       9
       +
       

     

       10
       10
       +
         The general process is:

     

       11
       11
       +
       

     

       12
       12
       +
         1. Try to build `llvmPackages_git.llvm` and associated packages such as

     

       13
       13
       +
            `clang` and `compiler-rt`. You can use the `-L` and `--keep-failed` flags to make

     

       14
       14
       +
            debugging patch errors easy, e.g., `nix build .#llvmPackages_git.clang -L --keep-failed`

     

       15
       15
       +
       

     

       16
       16
       +
         2. The build will error out with something similar to this:

     

       17
       17
       +
            ```sh

     

       18
       18
       +
            ...

     

       19
       19
       +
            clang-unstable> patching sources

     

       20
       20
       +
            clang-unstable> applying patch /nix/store/nndv6gq6w608n197fndvv5my4a5zg2qi-purity.patch

     

       21
       21
       +
            clang-unstable> patching file lib/Driver/ToolChains/Gnu.cpp

     

       22
       22
       +
            clang-unstable> Hunk #1 FAILED at 487.

     

       23
       23
       +
            clang-unstable> 1 out of 1 hunk FAILED -- saving rejects to file lib/Driver/ToolChains/Gnu.cpp.rej

     

       24
       24
       +
            note: keeping build directory '/tmp/nix-build-clang-unstable-2022-25-07.drv-17'

     

       25
       25
       +
            error: builder for '/nix/store/zwi123kpkyz52fy7p6v23azixd807r8c-clang-unstable-2022-25-07.drv' failed with exit code 1;

     

       26
       26
       +
                   last 8 log lines:

     

       27
       27
       +
                   > unpacking sources

     

       28
       28
       +
                   > unpacking source archive /nix/store/mrxadx11wv1ckjr2208qgxp472pmmg6g-clang-src-unstable-2022-25-07

     

       29
       29
       +
                   > source root is clang-src-unstable-2022-25-07/clang

     

       30
       30
       +
                   > patching sources

     

       31
       31
       +
                   > applying patch /nix/store/nndv6gq6w608n197fndvv5my4a5zg2qi-purity.patch

     

       32
       32
       +
                   > patching file lib/Driver/ToolChains/Gnu.cpp

     

       33
       33
       +
                   > Hunk #1 FAILED at 487.

     

       34
       34
       +
                   > 1 out of 1 hunk FAILED -- saving rejects to file lib/Driver/ToolChains/Gnu.cpp.rej

     

       35
       35
       +
                   For full logs, run 'nix log /nix/store/zwi123kpkyz52fy7p6v23azixd807r8c-clang-unstable-2022-25-07.drv'.

     

       36
       36
       +
            note: keeping build directory '/tmp/nix-build-compiler-rt-libc-unstable-2022-25-07.drv-20'

     

       37
       37
       +
            error: 1 dependencies of derivation '/nix/store/ndbbh3wrl0l39b22azf46f1n7zlqwmag-clang-wrapper-unstable-2022-25-07.drv' failed to build

     

       38
       38
       +
            ```

     

       39
       39
       +
       

     

       40
       40
       +
            Notice the `Hunk #1 Failed at 487` line.

     

       41
       41
       +
            The lines above show us that the `purity.patch` failed on `lib/Driver/ToolChains/Gnu.cpp` when compiling `clang`.

     

       42
       42
       +
       

     

       43
       43
       +
        3. The task now is to cross reference the hunks in the purity patch with

     

       44
       44
       +
           `lib/Driver/ToolCahins/Gnu.cpp.orig` to see why the patch failed.

     

       45
       45
       +
           The `.orig` file will be in the build directory referenced in the line `note: keeping build directory ...`;

     

       46
       46
       +
           this message results from the `--keep-failed` flag.

     

       47
       47
       +
       

     

       48
       48
       +
        4. Now you should be able to open whichever patch failed, and the `foo.orig` file that it failed on.

     

       49
       49
       +
           Correct the patch by adapting it to the new code and be mindful of whitespace;

     

       50
       50
       +
           which can be an easily missed reason for failures.

     

       51
       51
       +
           For cases where the hunk is no longer needed you can simply remove it from the patch.

     

       52
       52
       +
       

     

       53
       53
       +
        This is fine for small corrections, but when more serious changes are needed its better to use git.

     

       54
       54
       +
       

     

       55
       55
       +
        1. Clone the LLVM monorepo at https://github.com/llvm/llvm-project/

     

       56
       56
       +
       

     

       57
       57
       +
        2. Check out the revision we were using before.

     

       58
       58
       +
       

     

       59
       59
       +
        3. Use `patch -p1 < path/to-path` in the project subdirectories to apply the patches and commit.

     

       60
       60
       +
       

     

       61
       61
       +
        4. Use `git rebase HEAD^ --onto <dest>` to rebase the patches onto the new revision we are trying to build, and fix all conflicts.

     

       62
       62
       +
       

     

       63
       63
       +
        5. Use `git diff HEAD^:<project> HEAD:<project>` to get subdir diff to write back to Nixpkgs.

     

       64
       64
       +
       

     

       65
       65
       +
       ## Information on our current patch sets

     

       66
       66
       +
       

     

       67
       67
       +
       ### "GNU Install Dirs" patches

     

       68
       68
       +
       

     

       69
       69
       +
       Use CMake's [`GNUInstallDirs`](https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html) to support multiple outputs.

     

       70
       70
       +
       

     

       71
       71
       +
       Previously, LLVM Just hard-coded `bin`, `include`, and `lib${LLVM_TARGET_PREFIX}`.

     

       72
       72
       +
       We are making it use these variables.

     

       73
       73
       +
       

     

       74
       74
       +
       For the older LLVM versions, these patches live in https://github.com/Ericson2314/llvm-project branches `split-prefix`.

     

       75
       75
       +
       Instead of applying the patches to the worktree per the above instructions, one can checkout those directly and rebase those instead.

     

       76
       76
       +
       

     

       77
       77
       +
       For newer LLVM versions, enough has has been upstreamed,

     

       78
       78
       +
       (see https://reviews.llvm.org/differential/query/5UAfpj_9zHwY/ for my progress upstreaming),

     

       79
       79
       +
       that I have just assembled new gnu-install-dirs patches from the remaining unmerged patches instead of rebasing from the prior LLVM's gnu install dirs patch.

+3 -1

pkgs/development/compilers/llvm/git/clang/default.nix

···

       15
       15
        
             mkdir -p "$out"

     

       16
       16
        
             cp -r ${monorepoSrc}/cmake "$out"

     

       17
       17
        
             cp -r ${monorepoSrc}/${pname} "$out"

     

       18
       18
       +
             cp -r ${monorepoSrc}/clang-tools-extra "$out"

     

       18
       19
        
           '';

     

       19
       20
        
       

     

       20
       21
        
           sourceRoot = "${src.name}/${pname}";

     
···

       26
       27
        
           buildInputs = [ libxml2 libllvm ];

     

       27
       28
        
       

     

       28
       29
        
           cmakeFlags = [

     

       30
       30
       +
             "-DCLANG_INSTALL_PACKAGE_DIR=${placeholder "dev"}/lib/cmake/clang"

     

       29
       31
        
             "-DCMAKE_CXX_FLAGS=-std=c++14"

     

       30
       32
        
             "-DCLANGD_BUILD_XPC=OFF"

     

       31
       33
        
             "-DLLVM_ENABLE_RTTI=ON"

     
···

       71
       73
        
             # Move libclang to 'lib' output

     

       72
       74
        
             moveToOutput "lib/libclang.*" "$lib"

     

       73
       75
        
             moveToOutput "lib/libclang-cpp.*" "$lib"

     

       74
       74
       -
             substituteInPlace $out/lib/cmake/clang/ClangTargets-release.cmake \

     

       76
       76
       +
             substituteInPlace $dev/lib/cmake/clang/ClangTargets-release.cmake \

     

       75
       77
        
                 --replace "\''${_IMPORT_PREFIX}/lib/libclang." "$lib/lib/libclang." \

     

       76
       78
        
                 --replace "\''${_IMPORT_PREFIX}/lib/libclang-cpp." "$lib/lib/libclang-cpp."

     

       77
       79

+68 -198

pkgs/development/compilers/llvm/git/clang/gnu-install-dirs.patch

···

       1
       1
        
       diff --git a/CMakeLists.txt b/CMakeLists.txt

     

       2
       2
       -
       index 7ea37850ad60..ac0f2d4f60b4 100644

     

       2
       2
       +
       index c27beec313d7..480f13e73c9f 100644

     

       3
       3
        
       --- a/CMakeLists.txt

     

       4
       4
        
       +++ b/CMakeLists.txt

     

       5
       5
       -
       @@ -5,6 +5,8 @@ cmake_minimum_required(VERSION 3.13.4)

     

       6
       6
       -
        if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)

     

       7
       7
       -
          project(Clang)

     

       5
       5
       +
       @@ -78,15 +78,17 @@ if(CLANG_BUILT_STANDALONE)

     

       6
       6
       +
          if (NOT LLVM_CONFIG_FOUND)

     

       7
       7
       +
            # Pull values from LLVMConfig.cmake.  We can drop this once the llvm-config

     

       8
       8
       +
            # path is removed.

     

       9
       9
       +
       -    set(MAIN_INCLUDE_DIR "${LLVM_INCLUDE_DIR}")

     

       10
       10
       +
       +    set(INCLUDE_DIRS ${LLVM_INCLUDE_DIRS})

     

       11
       11
       +
            set(LLVM_OBJ_DIR "${LLVM_BINARY_DIR}")

     

       12
       12
       +
            # N.B. this is just a default value, the CACHE PATHs below can be overriden.

     

       13
       13
       +
            set(MAIN_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../llvm")

     

       14
       14
       +
            set(TOOLS_BINARY_DIR "${LLVM_TOOLS_BINARY_DIR}")

     

       15
       15
       +
            set(LIBRARY_DIR "${LLVM_LIBRARY_DIR}")

     

       16
       16
       +
       +  else()

     

       17
       17
       +
       +    set(INCLUDE_DIRS "${LLVM_BINARY_DIR}/include" "${MAIN_INCLUDE_DIR}")

     

       18
       18
       +
          endif()

     

       8
       19
        
        

     

       9
       9
       -
       +  include(GNUInstallDirs)

     

       10
       10
       -
       +

     

       11
       11
       -
          set(CMAKE_CXX_STANDARD 14 CACHE STRING "C++ standard to conform to")

     

       12
       12
       -
          set(CMAKE_CXX_STANDARD_REQUIRED YES)

     

       13
       13
       -
          set(CMAKE_CXX_EXTENSIONS NO)

     

       14
       14
       -
       @@ -424,7 +426,7 @@ include_directories(BEFORE

     

       20
       20
       +
       -  set(LLVM_MAIN_INCLUDE_DIR "${MAIN_INCLUDE_DIR}" CACHE PATH "Path to llvm/include")

     

       21
       21
       +
       +  set(LLVM_INCLUDE_DIRS ${INCLUDE_DIRS} CACHE PATH "Path to llvm/include and any other header dirs needed")

     

       22
       22
       +
          set(LLVM_BINARY_DIR "${LLVM_OBJ_ROOT}" CACHE PATH "Path to LLVM build tree")

     

       23
       23
       +
          set(LLVM_MAIN_SRC_DIR "${MAIN_SRC_DIR}" CACHE PATH "Path to LLVM source tree")

     

       24
       24
       +
          set(LLVM_TOOLS_BINARY_DIR "${TOOLS_BINARY_DIR}" CACHE PATH "Path to llvm/bin")

     

       25
       25
       +
       @@ -128,7 +130,7 @@ if(CLANG_BUILT_STANDALONE)

     

       26
       26
       +
            set(LLVM_INCLUDE_TESTS ON)

     

       27
       27
       +
          endif()

     

       15
       28
        
        

     

       16
       16
       -
        if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)

     

       17
       17
       -
          install(DIRECTORY include/clang include/clang-c

     

       18
       18
       -
       -    DESTINATION include

     

       19
       19
       -
       +    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}

     

       20
       20
       -
            COMPONENT clang-headers

     

       21
       21
       -
            FILES_MATCHING

     

       22
       22
       -
            PATTERN "*.def"

     

       23
       23
       -
       @@ -433,7 +435,7 @@ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)

     

       24
       24
       -
            )

     

       29
       29
       +
       -  include_directories("${LLVM_BINARY_DIR}/include" "${LLVM_MAIN_INCLUDE_DIR}")

     

       30
       30
       +
       +  include_directories(${LLVM_INCLUDE_DIRS})

     

       31
       31
       +
          link_directories("${LLVM_LIBRARY_DIR}")

     

       25
       32
        
        

     

       26
       26
       -
          install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/clang

     

       27
       27
       -
       -    DESTINATION include

     

       28
       28
       -
       +    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}

     

       29
       29
       -
            COMPONENT clang-headers

     

       30
       30
       -
            FILES_MATCHING

     

       31
       31
       -
            PATTERN "CMakeFiles" EXCLUDE

     

       32
       32
       -
       @@ -453,7 +455,7 @@ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)

     

       33
       33
       -
        

     

       34
       34
       -
          add_custom_target(bash-autocomplete DEPENDS utils/bash-autocomplete.sh)

     

       35
       35
       -
          install(PROGRAMS utils/bash-autocomplete.sh

     

       36
       36
       -
       -          DESTINATION share/clang

     

       37
       37
       -
       +          DESTINATION ${CMAKE_INSTALL_DATADIR}/clang

     

       38
       38
       -
                  COMPONENT bash-autocomplete)

     

       39
       39
       -
          if(NOT LLVM_ENABLE_IDE)

     

       40
       40
       -
            add_llvm_install_targets(install-bash-autocomplete

     

       33
       33
       +
          set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin )

     

       41
       34
        
       diff --git a/cmake/modules/AddClang.cmake b/cmake/modules/AddClang.cmake

     

       42
       42
       -
       index 5752f4277444..5bf08dbf5e83 100644

     

       35
       35
       +
       index 21ac332e4f5f..b16c314bd1e2 100644

     

       43
       36
        
       --- a/cmake/modules/AddClang.cmake

     

       44
       37
        
       +++ b/cmake/modules/AddClang.cmake

     

       45
       45
       -
       @@ -118,9 +118,9 @@ macro(add_clang_library name)

     

       38
       38
       +
       @@ -119,8 +119,8 @@ macro(add_clang_library name)

     

       46
       39
        
                install(TARGETS ${lib}

     

       47
       40
        
                  COMPONENT ${lib}

     

       48
       41
        
                  ${export_to_clangtargets}

     

       49
       42
        
       -          LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}

     

       50
       43
        
       -          ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}

     

       51
       51
       -
       -          RUNTIME DESTINATION bin)

     

       52
       52
       -
       +          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}

     

       53
       53
       -
       +          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}

     

       54
       54
       -
       +          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

     

       44
       44
       +
       +          LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}"

     

       45
       45
       +
       +          ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}"

     

       46
       46
       +
                  RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")

     

       55
       47
        
        

     

       56
       48
        
                if (NOT LLVM_ENABLE_IDE)

     

       57
       57
       -
                  add_llvm_install_targets(install-${lib}

     

       58
       58
       -
       @@ -159,7 +159,7 @@ macro(add_clang_tool name)

     

       59
       59
       -
            get_target_export_arg(${name} Clang export_to_clangtargets)

     

       60
       60
       -
            install(TARGETS ${name}

     

       61
       61
       -
              ${export_to_clangtargets}

     

       62
       62
       -
       -      RUNTIME DESTINATION bin

     

       63
       63
       -
       +      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}

     

       64
       64
       -
              COMPONENT ${name})

     

       65
       65
       -
        

     

       66
       66
       -
            if(NOT LLVM_ENABLE_IDE)

     

       67
       67
       -
       @@ -174,7 +174,7 @@ endmacro()

     

       68
       68
       -
        macro(add_clang_symlink name dest)

     

       69
       69
       -
          add_llvm_tool_symlink(${name} ${dest} ALWAYS_GENERATE)

     

       70
       70
       -
          # Always generate install targets

     

       71
       71
       -
       -  llvm_install_symlink(${name} ${dest} ALWAYS_GENERATE)

     

       72
       72
       -
       +  llvm_install_symlink(${name} ${dest} ${CMAKE_INSTALL_FULL_BINDIR} ALWAYS_GENERATE)

     

       73
       73
       -
        endmacro()

     

       74
       74
       -
        

     

       75
       75
       -
        function(clang_target_link_libraries target type)

     

       76
       49
        
       diff --git a/lib/Headers/CMakeLists.txt b/lib/Headers/CMakeLists.txt

     

       77
       77
       -
       index 078988980c52..14b58614b40a 100644

     

       50
       50
       +
       index 6e2060991b92..b9bc930d26b8 100644

     

       78
       51
        
       --- a/lib/Headers/CMakeLists.txt

     

       79
       52
        
       +++ b/lib/Headers/CMakeLists.txt

     

       80
       80
       -
       @@ -234,7 +234,7 @@ set_target_properties(clang-resource-headers PROPERTIES

     

       81
       81
       -
          FOLDER "Misc"

     

       82
       82
       -
          RUNTIME_OUTPUT_DIRECTORY "${output_dir}")

     

       53
       53
       +
       @@ -420,7 +420,7 @@ add_header_target("openmp-resource-headers" ${openmp_wrapper_files})

     

       54
       54
       +
        add_header_target("windows-resource-headers" ${windows_only_files})

     

       55
       55
       +
        add_header_target("utility-resource-headers" ${utility_files})

     

       83
       56
        
        

     

       84
       57
        
       -set(header_install_dir lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}/include)

     

       85
       58
        
       +set(header_install_dir ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}/include)

     

       86
       59
        
        

     

       87
       87
       -
        install(

     

       88
       88
       -
          FILES ${files} ${generated_files}

     

       89
       89
       -
       diff --git a/tools/c-index-test/CMakeLists.txt b/tools/c-index-test/CMakeLists.txt

     

       90
       90
       -
       index 99c6081db2d6..0887102febb3 100644

     

       91
       91
       -
       --- a/tools/c-index-test/CMakeLists.txt

     

       92
       92
       -
       +++ b/tools/c-index-test/CMakeLists.txt

     

       93
       93
       -
       @@ -49,7 +49,7 @@ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)

     

       94
       94
       -
            set_property(TARGET c-index-test APPEND PROPERTY INSTALL_RPATH

     

       95
       95
       -
               "@executable_path/../../lib")

     

       96
       96
       -
          else()

     

       97
       97
       -
       -    set(INSTALL_DESTINATION bin)

     

       98
       98
       -
       +    set(INSTALL_DESTINATION ${CMAKE_INSTALL_BINDIR})

     

       99
       99
       -
          endif()

     

       100
       100
       -
        

     

       101
       101
       -
          install(TARGETS c-index-test

     

       102
       102
       -
       diff --git a/tools/clang-format/CMakeLists.txt b/tools/clang-format/CMakeLists.txt

     

       103
       103
       -
       index 35ecdb11253c..d77d75de0094 100644

     

       104
       104
       -
       --- a/tools/clang-format/CMakeLists.txt

     

       105
       105
       -
       +++ b/tools/clang-format/CMakeLists.txt

     

       106
       106
       -
       @@ -21,20 +21,20 @@ if( LLVM_LIB_FUZZING_ENGINE OR LLVM_USE_SANITIZE_COVERAGE )

     

       107
       107
       -
        endif()

     

       108
       108
       -
        

     

       109
       109
       -
        install(PROGRAMS clang-format-bbedit.applescript

     

       110
       110
       -
       -  DESTINATION share/clang

     

       111
       111
       -
       +  DESTINATION ${CMAKE_INSTALL_DATADIR}/clang

     

       112
       112
       -
          COMPONENT clang-format)

     

       113
       113
       -
        install(PROGRAMS clang-format-diff.py

     

       114
       114
       -
       -  DESTINATION share/clang

     

       115
       115
       -
       +  DESTINATION ${CMAKE_INSTALL_DATADIR}/clang

     

       116
       116
       -
          COMPONENT clang-format)

     

       117
       117
       -
        install(PROGRAMS clang-format-sublime.py

     

       118
       118
       -
       -  DESTINATION share/clang

     

       119
       119
       -
       +  DESTINATION ${CMAKE_INSTALL_DATADIR}/clang

     

       120
       120
       -
          COMPONENT clang-format)

     

       121
       121
       -
        install(PROGRAMS clang-format.el

     

       122
       122
       -
       -  DESTINATION share/clang

     

       123
       123
       -
       +  DESTINATION ${CMAKE_INSTALL_DATADIR}/clang

     

       124
       124
       -
          COMPONENT clang-format)

     

       125
       125
       -
        install(PROGRAMS clang-format.py

     

       126
       126
       -
       -  DESTINATION share/clang

     

       127
       127
       -
       +  DESTINATION ${CMAKE_INSTALL_DATADIR}/clang

     

       128
       128
       -
          COMPONENT clang-format)

     

       129
       129
       -
        install(PROGRAMS git-clang-format

     

       130
       130
       -
       -  DESTINATION bin

     

       131
       131
       -
       +  DESTINATION ${CMAKE_INSTALL_BINDIR}

     

       132
       132
       -
          COMPONENT clang-format)

     

       133
       133
       -
       diff --git a/tools/clang-rename/CMakeLists.txt b/tools/clang-rename/CMakeLists.txt

     

       134
       134
       -
       index cda8e29ec5b1..0134d8ccd70b 100644

     

       135
       135
       -
       --- a/tools/clang-rename/CMakeLists.txt

     

       136
       136
       -
       +++ b/tools/clang-rename/CMakeLists.txt

     

       137
       137
       -
       @@ -19,8 +19,8 @@ clang_target_link_libraries(clang-rename

     

       138
       138
       -
          )

     

       139
       139
       -
        

     

       140
       140
       -
        install(PROGRAMS clang-rename.py

     

       141
       141
       -
       -  DESTINATION share/clang

     

       142
       142
       -
       +  DESTINATION ${CMAKE_INSTALL_DATADIR}/clang

     

       143
       143
       -
          COMPONENT clang-rename)

     

       144
       144
       -
        install(PROGRAMS clang-rename.el

     

       145
       145
       -
       -  DESTINATION share/clang

     

       146
       146
       -
       +  DESTINATION ${CMAKE_INSTALL_DATADIR}/clang

     

       147
       147
       -
          COMPONENT clang-rename)

     

       60
       60
       +
        #############################################################

     

       61
       61
       +
        # Install rules for the catch-all clang-resource-headers target

     

       148
       62
        
       diff --git a/tools/libclang/CMakeLists.txt b/tools/libclang/CMakeLists.txt

     

       149
       149
       -
       index bf88dca0a34b..7a10181e7738 100644

     

       63
       63
       +
       index 8d95d0900e8c..ebc70ff7526d 100644

     

       150
       64
        
       --- a/tools/libclang/CMakeLists.txt

     

       151
       65
        
       +++ b/tools/libclang/CMakeLists.txt

     

       152
       152
       -
       @@ -186,7 +186,7 @@ endif()

     

       153
       153
       -
        if(INTERNAL_INSTALL_PREFIX)

     

       154
       154
       -
          set(LIBCLANG_HEADERS_INSTALL_DESTINATION "${INTERNAL_INSTALL_PREFIX}/include")

     

       155
       155
       -
        else()

     

       156
       156
       -
       -  set(LIBCLANG_HEADERS_INSTALL_DESTINATION include)

     

       157
       157
       -
       +  set(LIBCLANG_HEADERS_INSTALL_DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

     

       158
       158
       -
        endif()

     

       159
       159
       -
        

     

       160
       160
       -
        install(DIRECTORY ../../include/clang-c

     

       161
       161
       -
       @@ -216,7 +216,7 @@ foreach(PythonVersion ${CLANG_PYTHON_BINDINGS_VERSIONS})

     

       66
       66
       +
       @@ -180,7 +180,7 @@ foreach(PythonVersion ${CLANG_PYTHON_BINDINGS_VERSIONS})

     

       162
       67
        
                  COMPONENT

     

       163
       68
        
                    libclang-python-bindings

     

       164
       69
        
                  DESTINATION

     
···

       167
       72
        
        endforeach()

     

       168
       73
        
        if(NOT LLVM_ENABLE_IDE)

     

       169
       74
        
          add_custom_target(libclang-python-bindings)

     

       170
       170
       -
       diff --git a/tools/scan-build/CMakeLists.txt b/tools/scan-build/CMakeLists.txt

     

       171
       171
       -
       index 74334e53c9b1..ebaae33e4324 100644

     

       172
       172
       -
       --- a/tools/scan-build/CMakeLists.txt

     

       173
       173
       -
       +++ b/tools/scan-build/CMakeLists.txt

     

       174
       174
       -
       @@ -47,7 +47,7 @@ if(CLANG_INSTALL_SCANBUILD)

     

       175
       175
       -
                               DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/bin/${BinFile})

     

       176
       176
       -
            list(APPEND Depends ${CMAKE_BINARY_DIR}/bin/${BinFile})

     

       177
       177
       -
            install(PROGRAMS bin/${BinFile}

     

       178
       178
       -
       -            DESTINATION bin

     

       179
       179
       -
       +            DESTINATION ${CMAKE_INSTALL_BINDIR}

     

       180
       180
       -
                    COMPONENT scan-build)

     

       181
       181
       -
          endforeach()

     

       75
       75
       +
       diff --git a/tools/scan-build-py/CMakeLists.txt b/tools/scan-build-py/CMakeLists.txt

     

       76
       76
       +
       index 061dc7ef4dd9..adc54b2edc32 100644

     

       77
       77
       +
       --- a/tools/scan-build-py/CMakeLists.txt

     

       78
       78
       +
       +++ b/tools/scan-build-py/CMakeLists.txt

     

       79
       79
       +
       @@ -88,7 +88,7 @@ foreach(lib ${LibScanbuild})

     

       80
       80
       +
                             DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/${lib})

     

       81
       81
       +
          list(APPEND Depends ${CMAKE_BINARY_DIR}/lib/libscanbuild/${lib})

     

       82
       82
       +
          install(PROGRAMS lib/libscanbuild/${lib}

     

       83
       83
       +
       -          DESTINATION lib/libscanbuild

     

       84
       84
       +
       +          DESTINATION "${CMAKE_INSTALL_LIBDIR}/libscanbuild"

     

       85
       85
       +
                  COMPONENT scan-build-py)

     

       86
       86
       +
        endforeach()

     

       182
       87
        
        

     

       183
       183
       -
       @@ -61,7 +61,7 @@ if(CLANG_INSTALL_SCANBUILD)

     

       184
       184
       -
                               DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/libexec/${LibexecFile})

     

       185
       185
       -
            list(APPEND Depends ${CMAKE_BINARY_DIR}/libexec/${LibexecFile})

     

       186
       186
       -
            install(PROGRAMS libexec/${LibexecFile}

     

       187
       187
       -
       -            DESTINATION libexec

     

       188
       188
       -
       +            DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}

     

       189
       189
       -
                    COMPONENT scan-build)

     

       190
       190
       -
          endforeach()

     

       191
       191
       -
        

     

       192
       192
       -
       @@ -89,7 +89,7 @@ if(CLANG_INSTALL_SCANBUILD)

     

       193
       193
       -
                               DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/share/scan-build/${ShareFile})

     

       194
       194
       -
            list(APPEND Depends ${CMAKE_BINARY_DIR}/share/scan-build/${ShareFile})

     

       195
       195
       -
            install(FILES share/scan-build/${ShareFile}

     

       196
       196
       -
       -            DESTINATION share/scan-build

     

       197
       197
       -
       +            DESTINATION ${CMAKE_INSTALL_DATADIR}/scan-build

     

       198
       198
       -
                    COMPONENT scan-build)

     

       199
       199
       -
          endforeach()

     

       200
       200
       -
        

     

       201
       201
       -
       diff --git a/tools/scan-view/CMakeLists.txt b/tools/scan-view/CMakeLists.txt

     

       202
       202
       -
       index eccc6b83195b..ff72d9cf0666 100644

     

       203
       203
       -
       --- a/tools/scan-view/CMakeLists.txt

     

       204
       204
       -
       +++ b/tools/scan-view/CMakeLists.txt

     

       205
       205
       -
       @@ -20,7 +20,7 @@ if(CLANG_INSTALL_SCANVIEW)

     

       206
       206
       -
                               DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/bin/${BinFile})

     

       207
       207
       -
            list(APPEND Depends ${CMAKE_BINARY_DIR}/bin/${BinFile})

     

       208
       208
       -
            install(PROGRAMS bin/${BinFile}

     

       209
       209
       -
       -            DESTINATION bin

     

       210
       210
       -
       +            DESTINATION ${CMAKE_INSTALL_BINDIR}

     

       211
       211
       -
                    COMPONENT scan-view)

     

       212
       212
       -
          endforeach()

     

       213
       213
       -
        

     

       214
       214
       -
       @@ -34,7 +34,7 @@ if(CLANG_INSTALL_SCANVIEW)

     

       215
       215
       -
                               DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/share/${ShareFile})

     

       216
       216
       -
            list(APPEND Depends ${CMAKE_BINARY_DIR}/share/scan-view/${ShareFile})

     

       217
       217
       -
            install(FILES share/${ShareFile}

     

       218
       218
       -
       -            DESTINATION share/scan-view

     

       219
       219
       -
       +            DESTINATION ${CMAKE_INSTALL_DATADIR}/scan-view

     

       220
       220
       -
                    COMPONENT scan-view)

     

       221
       221
       -
          endforeach()

     

       88
       88
       +
       @@ -106,7 +106,7 @@ foreach(resource ${LibScanbuildResources})

     

       89
       89
       +
                             DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/resources/${resource})

     

       90
       90
       +
          list(APPEND Depends ${CMAKE_BINARY_DIR}/lib/libscanbuild/resources/${resource})

     

       91
       91
       +
          install(PROGRAMS lib/libscanbuild/resources/${resource}

     

       92
       92
       +
       -          DESTINATION lib/libscanbuild/resources

     

       93
       93
       +
       +          DESTINATION "${CMAKE_INSTALL_LIBDIR}/libscanbuild/resources"

     

       94
       94
       +
                  COMPONENT scan-build-py)

     

       95
       95
       +
        endforeach()

     

       222
       96
        
        

     

       223
       223
       -
       diff --git a/utils/hmaptool/CMakeLists.txt b/utils/hmaptool/CMakeLists.txt

     

       224
       224
       -
       index 62f2de0cb15c..6aa66825b6ec 100644

     

       225
       225
       -
       --- a/utils/hmaptool/CMakeLists.txt

     

       226
       226
       -
       +++ b/utils/hmaptool/CMakeLists.txt

     

       227
       227
       -
       @@ -10,7 +10,7 @@ add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin/${CLANG_HM

     

       228
       228
       -
        

     

       229
       229
       -
        list(APPEND Depends ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin/${CLANG_HMAPTOOL})

     

       230
       230
       -
        install(PROGRAMS ${CLANG_HMAPTOOL}

     

       231
       231
       -
       -        DESTINATION bin

     

       232
       232
       -
       +        DESTINATION ${CMAKE_INSTALL_BINDIR}

     

       233
       233
       -
                COMPONENT hmaptool)

     

       97
       97
       +
       @@ -122,7 +122,7 @@ foreach(lib ${LibEar})

     

       98
       98
       +
                             DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/libear/${lib})

     

       99
       99
       +
          list(APPEND Depends ${CMAKE_BINARY_DIR}/lib/libear/${lib})

     

       100
       100
       +
          install(PROGRAMS lib/libear/${lib}

     

       101
       101
       +
       -          DESTINATION lib/libear

     

       102
       102
       +
       +          DESTINATION "${CMAKE_INSTALL_LIBDIR}/libear"

     

       103
       103
       +
                  COMPONENT scan-build-py)

     

       104
       104
       +
        endforeach()

     

       234
       105
        
        

     

       235
       235
       -
        add_custom_target(hmaptool ALL DEPENDS ${Depends})

+5 -4

pkgs/development/compilers/llvm/git/clang/purity.patch

···

       11
       11
        
       index fe3c0191bb..c6a482bece 100644

     

       12
       12
        
       --- a/lib/Driver/ToolChains/Gnu.cpp

     

       13
       13
        
       +++ b/lib/Driver/ToolChains/Gnu.cpp

     

       14
       14
       -
       @@ -487,12 +487,6 @@ void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,

     

       15
       15
       -
          if (!IsStatic) {

     

       14
       14
       +
       @@ -487,13 +487,7 @@ void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,

     

       15
       15
       +
          } else {

     

       16
       16
        
            if (Args.hasArg(options::OPT_rdynamic))

     

       17
       17
        
              CmdArgs.push_back("-export-dynamic");

     

       18
       18
       -
       -

     

       19
       19
       -
       -    if (!Args.hasArg(options::OPT_shared) && !IsStaticPIE) {

     

       18
       18
       +
       

     

       19
       19
       +
       -    if (!Args.hasArg(options::OPT_shared) && !IsStaticPIE &&

     

       20
       20
       +
       -        !Args.hasArg(options::OPT_r)) {

     

       20
       21
        
       -      CmdArgs.push_back("-dynamic-linker");

     

       21
       22
        
       -      CmdArgs.push_back(Args.MakeArgString(Twine(D.DyldPrefix) +

     

       22
       23
        
       -                                           ToolChain.getDynamicLinker(Args)));

+2 -2

pkgs/development/compilers/llvm/git/compiler-rt/X86-support-extension.patch

···

       2
       2
        
       index 3a66dd9c3fb..7efc85d9f9f 100644

     

       3
       3
        
       --- a/lib/builtins/CMakeLists.txt

     

       4
       4
        
       +++ b/lib/builtins/CMakeLists.txt

     

       5
       5
       -
       @@ -345,4 +345,8 @@ if (NOT MSVC)

     

       5
       5
       +
       @@ -348,4 +348,8 @@ if (NOT MSVC)

     

       6
       6
        
        

     

       7
       7
        
       +  set(i486_SOURCES ${i386_SOURCES})

     

       8
       8
        
       +  set(i586_SOURCES ${i386_SOURCES})

     
···

       11
       11
        
          if (WIN32)

     

       12
       12
        
            set(i386_SOURCES

     

       13
       13
        
              ${i386_SOURCES}

     

       14
       14
       -
       @@ -608,6 +612,7 @@ else ()

     

       14
       14
       +
       @@ -723,6 +723,7 @@ else ()

     

       15
       15
        
          endif()

     

       16
       16
        
        

     

       17
       17
        
          foreach (arch ${BUILTIN_SUPPORTED_ARCH})

-1

pkgs/development/compilers/llvm/git/compiler-rt/default.nix

···

       66
       66
        
         outputs = [ "out" "dev" ];

     

       67
       67
        
       

     

       68
       68
        
         patches = [

     

       69
       69
       -
           ./codesign.patch # Revert compiler-rt commit that makes codesign mandatory

     

       70
       69
        
           ./X86-support-extension.patch # Add support for i486 i586 i686 by reusing i386 config

     

       71
       70
        
           ./gnu-install-dirs.patch

     

       72
       71
        
           # ld-wrapper dislikes `-rpath-link //nix/store`, so we normalize away the

+2 -37

pkgs/development/compilers/llvm/git/compiler-rt/gnu-install-dirs.patch

···

       1
       1
       -
       diff --git a/CMakeLists.txt b/CMakeLists.txt

     

       2
       2
       -
       index c5003b5efa1d..4fffb9721284 100644

     

       3
       3
       -
       --- a/CMakeLists.txt

     

       4
       4
       -
       +++ b/CMakeLists.txt

     

       5
       5
       -
       @@ -5,6 +5,8 @@

     

       6
       6
       -
        

     

       7
       7
       -
        cmake_minimum_required(VERSION 3.13.4)

     

       8
       8
       -
        

     

       9
       9
       -
       +include(GNUInstallDirs)

     

       10
       10
       -
       +

     

       11
       11
       -
        # Check if compiler-rt is built as a standalone project.

     

       12
       12
       -
        if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR OR COMPILER_RT_STANDALONE_BUILD)

     

       13
       13
       -
          project(CompilerRT C CXX ASM)

     

       14
       1
        
       diff --git a/cmake/base-config-ix.cmake b/cmake/base-config-ix.cmake

     

       15
       15
       -
       index 1ada0ab30ba0..b4be6c4a3c73 100644

     

       2
       2
       +
       index 8a6219568b3f..30ee68a47ccf 100644

     

       16
       3
        
       --- a/cmake/base-config-ix.cmake

     

       17
       4
        
       +++ b/cmake/base-config-ix.cmake

     

       18
       18
       -
       @@ -66,7 +66,7 @@ if (LLVM_TREE_AVAILABLE)

     

       19
       19
       -
        else()

     

       20
       20
       -
            # Take output dir and install path from the user.

     

       21
       21
       -
          set(COMPILER_RT_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE PATH

     

       22
       22
       -
       -    "Path where built compiler-rt libraries should be stored.")

     

       23
       23
       -
       +    "Path where built compiler-rt build artifacts should be stored.")

     

       24
       24
       -
          set(COMPILER_RT_EXEC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/bin CACHE PATH

     

       25
       25
       -
            "Path where built compiler-rt executables should be stored.")

     

       26
       26
       -
          set(COMPILER_RT_INSTALL_PATH "" CACHE PATH

     

       27
       27
       -
       @@ -98,23 +98,23 @@ endif()

     

       5
       5
       +
       @@ -100,13 +100,13 @@ endif()

     

       28
       6
        
        if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)

     

       29
       7
        
          set(COMPILER_RT_OUTPUT_LIBRARY_DIR

     

       30
       8
        
            ${COMPILER_RT_OUTPUT_DIR}/lib)

     
···

       40
       18
        
          set(COMPILER_RT_INSTALL_LIBRARY_DIR "${default_install_path}" CACHE PATH

     

       41
       19
        
            "Path where built compiler-rt libraries should be installed.")

     

       42
       20
        
        endif()

     

       43
       43
       -
       -extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" bin)

     

       44
       44
       -
       +extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" "${CMAKE_INSTALL_BINDIR}")

     

       45
       45
       -
        set(COMPILER_RT_INSTALL_BINARY_DIR "${default_install_path}" CACHE PATH

     

       46
       46
       -
          "Path where built compiler-rt executables should be installed.")

     

       47
       47
       -
       -extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" include)

     

       48
       48
       -
       +extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" "${CMAKE_INSTALL_INCLUDEDIR}")

     

       49
       49
       -
        set(COMPILER_RT_INSTALL_INCLUDE_DIR "${default_install_path}" CACHE PATH

     

       50
       50
       -
          "Path where compiler-rt headers should be installed.")

     

       51
       51
       -
       -extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" share)

     

       52
       52
       -
       +extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" "${CMAKE_INSTALL_DATADIR}")

     

       53
       53
       -
        set(COMPILER_RT_INSTALL_DATA_DIR "${default_install_path}" CACHE PATH

     

       54
       54
       -
          "Path where compiler-rt data files should be installed.")

     

       55
       55
       -

+28 -26

pkgs/development/compilers/llvm/git/default.nix

···

       18
       18
        
       }:

     

       19
       19
        
       

     

       20
       20
        
       let

     

       21
       21
       -
         release_version = "14.0.0";

     

       21
       21
       +
         release_version = "15.0.0";

     

       22
       22
        
         candidate = ""; # empty or "rcN"

     

       23
       23
        
         dash-candidate = lib.optionalString (candidate != "") "-${candidate}";

     

       24
       24
       -
         rev = "fb1582f6c54422995c6fb61ba4c55126b357f64e"; # When using a Git commit

     

       25
       25
       -
         rev-version = "unstable-2022-01-07"; # When using a Git commit

     

       24
       24
       +
         rev = "a5640968f2f7485b2aa4919f5fa68fd8f23e2d1f"; # When using a Git commit

     

       25
       25
       +
         rev-version = "unstable-2022-26-07"; # When using a Git commit

     

       26
       26
        
         version = if rev != "" then rev-version else "${release_version}${dash-candidate}";

     

       27
       27
        
         targetConfig = stdenv.targetPlatform.config;

     

       28
       28
        
       

     
···

       30
       30
        
           owner = "llvm";

     

       31
       31
        
           repo = "llvm-project";

     

       32
       32
        
           rev = if rev != "" then rev else "llvmorg-${version}";

     

       33
       33
       -
           sha256 = "1pkgdsscvf59i22ix763lp2z3sg0v2z2ywh0n07k3ki7q1qpqbhk";

     

       33
       33
       +
           sha256 = "1sh5xihdfdn2hp7ds3lkaq1bfrl4alj36gl1aidmhlw65p5rdvl7";

     

       34
       34
        
         };

     

       35
       35
        
       

     

       36
       36
        
         llvm_meta = {

     
···

       158
       158
        
             ] ++ lib.optionals (!stdenv.targetPlatform.isWasm) [

     

       159
       159
        
               targetLlvmLibraries.libunwind

     

       160
       160
        
             ];

     

       161
       161
       -
             extraBuildCommands = ''

     

       162
       162
       -
               echo "-rtlib=compiler-rt -Wno-unused-command-line-argument" >> $out/nix-support/cc-cflags

     

       163
       163
       -
               echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags

     

       164
       164
       -
             '' + lib.optionalString (!stdenv.targetPlatform.isWasm) ''

     

       165
       165
       -
               echo "--unwindlib=libunwind" >> $out/nix-support/cc-cflags

     

       166
       166
       -
             '' + lib.optionalString (!stdenv.targetPlatform.isWasm && stdenv.targetPlatform.useLLVM or false) ''

     

       167
       167
       -
               echo "-lunwind" >> $out/nix-support/cc-ldflags

     

       168
       168
       -
             '' + lib.optionalString stdenv.targetPlatform.isWasm ''

     

       169
       169
       -
               echo "-fno-exceptions" >> $out/nix-support/cc-cflags

     

       170
       170
       -
             '' + mkExtraBuildCommands cc;

     

       161
       161
       +
             extraBuildCommands = mkExtraBuildCommands cc;

     

       162
       162
       +
             nixSupport.cc-cflags =

     

       163
       163
       +
               [ "-rtlib=compiler-rt"

     

       164
       164
       +
                 "-Wno-unused-command-line-argument"

     

       165
       165
       +
                 "-B${targetLlvmLibraries.compiler-rt}/lib"

     

       166
       166
       +
               ]

     

       167
       167
       +
               ++ lib.optional (!stdenv.targetPlatform.isWasm) "--unwindlib=libunwind"

     

       168
       168
       +
               ++ lib.optional

     

       169
       169
       +
                 (!stdenv.targetPlatform.isWasm && stdenv.targetPlatform.useLLVM or false)

     

       170
       170
       +
                 "-lunwind"

     

       171
       171
       +
               ++ lib.optional stdenv.targetPlatform.isWasm "-fno-exceptions";

     

       171
       172
        
           };

     

       172
       173
        
       

     

       173
       174
        
           clangNoLibcxx = wrapCCWith rec {

     
···

       177
       178
        
             extraPackages = [

     

       178
       179
        
               targetLlvmLibraries.compiler-rt

     

       179
       180
        
             ];

     

       180
       180
       -
             extraBuildCommands = ''

     

       181
       181
       -
               echo "-rtlib=compiler-rt" >> $out/nix-support/cc-cflags

     

       182
       182
       -
               echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags

     

       183
       183
       -
               echo "-nostdlib++" >> $out/nix-support/cc-cflags

     

       184
       184
       -
             '' + mkExtraBuildCommands cc;

     

       181
       181
       +
             extraBuildCommands = mkExtraBuildCommands cc;

     

       182
       182
       +
             nixSupport.cc-cflags = [

     

       183
       183
       +
               "-rtlib=compiler-rt"

     

       184
       184
       +
               "-B${targetLlvmLibraries.compiler-rt}/lib"

     

       185
       185
       +
               "-nostdlib++"

     

       186
       186
       +
             ];

     

       185
       187
        
           };

     

       186
       188
        
       

     

       187
       189
        
           clangNoLibc = wrapCCWith rec {

     
···

       191
       193
        
             extraPackages = [

     

       192
       194
        
               targetLlvmLibraries.compiler-rt

     

       193
       195
        
             ];

     

       194
       194
       -
             extraBuildCommands = ''

     

       195
       195
       -
               echo "-rtlib=compiler-rt" >> $out/nix-support/cc-cflags

     

       196
       196
       -
               echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags

     

       197
       197
       -
             '' + mkExtraBuildCommands cc;

     

       196
       196
       +
             extraBuildCommands = mkExtraBuildCommands cc;

     

       197
       197
       +
             nixSupport.cc-cflags = [

     

       198
       198
       +
               "-rtlib=compiler-rt"

     

       199
       199
       +
               "-B${targetLlvmLibraries.compiler-rt}/lib"

     

       200
       200
       +
             ];

     

       198
       201
        
           };

     

       199
       202
        
       

     

       200
       203
        
           clangNoCompilerRt = wrapCCWith rec {

     
···

       202
       205
        
             libcxx = null;

     

       203
       206
        
             bintools = bintoolsNoLibc';

     

       204
       207
        
             extraPackages = [ ];

     

       205
       205
       -
             extraBuildCommands = ''

     

       206
       206
       -
               echo "-nostartfiles" >> $out/nix-support/cc-cflags

     

       207
       207
       -
             '' + mkExtraBuildCommands0 cc;

     

       208
       208
       +
             extraBuildCommands = mkExtraBuildCommands0 cc;

     

       209
       209
       +
             nixSupport.cc-cflags = [ "-nostartfiles" ];

     

       208
       210
        
           };

     

       209
       211
        
       

     

       210
       212
        
           clangNoCompilerRtWithLibc = wrapCCWith rec {

+16 -11

pkgs/development/compilers/llvm/git/libcxx/default.nix

···

       29
       29
        
           mkdir -p "$out/llvm"

     

       30
       30
        
           cp -r ${monorepoSrc}/llvm/cmake "$out/llvm"

     

       31
       31
        
           cp -r ${monorepoSrc}/llvm/utils "$out/llvm"

     

       32
       32
       +
           cp -r ${monorepoSrc}/third-party "$out"

     

       33
       33
       +
           cp -r ${monorepoSrc}/runtimes "$out"

     

       32
       34
        
         '';

     

       33
       35
        
       

     

       34
       34
       -
         sourceRoot = "${src.name}/${basename}";

     

       36
       36
       +
         sourceRoot = "${src.name}/runtimes";

     

       35
       37
        
       

     

       36
       38
        
         outputs = [ "out" ] ++ lib.optional (!headersOnly) "dev";

     

       37
       39
        
       

     

       40
       40
       +
         prePatch = ''

     

       41
       41
       +
           cd ../${basename}

     

       42
       42
       +
           chmod -R u+w .

     

       43
       43
       +
         '';

     

       44
       44
       +
       

     

       38
       45
        
         patches = [

     

       39
       46
        
           ./gnu-install-dirs.patch

     

       40
       47
        
         ] ++ lib.optionals stdenv.hostPlatform.isMusl [

     

       41
       48
        
           ../../libcxx-0001-musl-hacks.patch

     

       42
       49
        
         ];

     

       43
       50
        
       

     

       51
       51
       +
         postPatch = ''

     

       52
       52
       +
           cd ../runtimes

     

       53
       53
       +
         '';

     

       54
       54
       +
       

     

       44
       55
        
         preConfigure = lib.optionalString stdenv.hostPlatform.isMusl ''

     

       45
       56
        
           patchShebangs utils/cat_files.py

     

       46
       57
        
         '';

     
···

       50
       61
        
       

     

       51
       62
        
         buildInputs = lib.optionals (!headersOnly) [ libcxxabi ];

     

       52
       63
        
       

     

       53
       53
       -
         cmakeFlags = [ "-DLIBCXX_CXX_ABI=libcxxabi" ]

     

       64
       64
       +
         cmakeFlags = [

     

       65
       65
       +
           "-DLLVM_ENABLE_RUNTIMES=libcxx"

     

       66
       66
       +
           "-DLIBCXX_CXX_ABI=${lib.optionalString (!headersOnly) "system-"}libcxxabi"

     

       67
       67
       +
         ] ++ lib.optional (!headersOnly) "-DLIBCXX_CXX_ABI_INCLUDE_PATHS=${libcxxabi.dev}/include/c++/v1"

     

       54
       68
        
           ++ lib.optional (stdenv.hostPlatform.isMusl || stdenv.hostPlatform.isWasi) "-DLIBCXX_HAS_MUSL_LIBC=1"

     

       55
       69
        
           ++ lib.optional (stdenv.hostPlatform.useLLVM or false) "-DLIBCXX_USE_COMPILER_RT=ON"

     

       56
       70
        
           ++ lib.optionals stdenv.hostPlatform.isWasm [

     
···

       61
       75
        
       

     

       62
       76
        
         buildFlags = lib.optional headersOnly "generate-cxx-headers";

     

       63
       77
        
         installTargets = lib.optional headersOnly "install-cxx-headers";

     

       64
       64
       -
       

     

       65
       65
       -
         # At this point, cxxabi headers would be installed in the dev output, which

     

       66
       66
       -
         # prevents moveToOutput from doing its job later in the build process.

     

       67
       67
       -
         postInstall = lib.optionalString (!headersOnly) ''

     

       68
       68
       -
           mv "$dev/include/c++/v1/"* "$out/include/c++/v1/"

     

       69
       69
       -
           pushd "$dev"

     

       70
       70
       -
           rmdir -p include/c++/v1

     

       71
       71
       -
           popd

     

       72
       72
       -
         '';

     

       73
       78
        
       

     

       74
       79
        
         passthru = {

     

       75
       80
        
           isLLVM = true;

+7 -70

pkgs/development/compilers/llvm/git/libcxx/gnu-install-dirs.patch

···

       1
       1
        
       diff --git a/CMakeLists.txt b/CMakeLists.txt

     

       2
       2
       -
       index b0569a4a54ca..7d665f5a3258 100644

     

       2
       2
       +
       index 74eff2002fc9..c935d10878bb 100644

     

       3
       3
        
       --- a/CMakeLists.txt

     

       4
       4
        
       +++ b/CMakeLists.txt

     

       5
       5
       -
       @@ -10,6 +10,8 @@ endif()

     

       6
       6
       -
        #===============================================================================

     

       7
       7
       -
        cmake_minimum_required(VERSION 3.13.4)

     

       8
       8
       -
        

     

       9
       9
       -
       +include(GNUInstallDirs)

     

       10
       10
       -
       +

     

       11
       11
       -
        set(LLVM_COMMON_CMAKE_UTILS "${CMAKE_CURRENT_SOURCE_DIR}/../cmake")

     

       12
       12
       -
        

     

       13
       13
       -
        # Add path for custom modules

     

       14
       14
       -
       @@ -415,13 +417,13 @@ if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)

     

       5
       5
       +
       @@ -419,7 +419,7 @@ if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)

     

       15
       6
        
          set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})

     

       16
       7
        
          set(LIBCXX_GENERATED_INCLUDE_DIR "${LLVM_BINARY_DIR}/include/c++/v1")

     

       17
       8
        
          set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LLVM_BINARY_DIR}/include/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1")

     

       18
       9
        
       -  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH

     

       19
       19
       -
       +  set(LIBCXX_INSTALL_LIBRARY_DIR "${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE}" CACHE PATH

     

       10
       10
       +
       +  set(LIBCXX_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH

     

       20
       11
        
              "Path where built libc++ libraries should be installed.")

     

       21
       21
       -
       -  set(LIBCXX_INSTALL_RUNTIME_DIR bin CACHE PATH

     

       22
       22
       -
       +  set(LIBCXX_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH

     

       23
       23
       -
              "Path where built libc++ runtime libraries should be installed.")

     

       24
       24
       -
       -  set(LIBCXX_INSTALL_INCLUDE_DIR "include/c++/v1" CACHE PATH

     

       25
       25
       -
       +  set(LIBCXX_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/c++/v1" CACHE PATH

     

       26
       26
       -
              "Path where target-agnostic libc++ headers should be installed.")

     

       27
       27
       -
       -  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "include/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1" CACHE PATH

     

       28
       28
       -
       +  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${CMAKE_INSTALL_INCLUDEDIR}/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1" CACHE PATH

     

       12
       12
       +
          set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${CMAKE_INSTALL_INCLUDEDIR}/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1" CACHE PATH

     

       29
       13
        
              "Path where target-specific libc++ headers should be installed.")

     

       30
       30
       -
          if(LIBCXX_LIBDIR_SUBDIR)

     

       31
       31
       -
            string(APPEND LIBCXX_LIBRARY_DIR /${LIBCXX_LIBDIR_SUBDIR})

     

       32
       32
       -
       @@ -431,11 +433,11 @@ elseif(LLVM_LIBRARY_OUTPUT_INTDIR)

     

       33
       33
       -
          set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})

     

       34
       34
       -
          set(LIBCXX_GENERATED_INCLUDE_DIR "${LLVM_BINARY_DIR}/include/c++/v1")

     

       14
       14
       +
       @@ -436,7 +436,7 @@ else()

     

       15
       15
       +
            set(LIBCXX_GENERATED_INCLUDE_DIR "${CMAKE_BINARY_DIR}/include/c++/v1")

     

       16
       16
       +
          endif()

     

       35
       17
        
          set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LIBCXX_GENERATED_INCLUDE_DIR}")

     

       36
       18
        
       -  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LIBCXX_LIBDIR_SUFFIX} CACHE PATH

     

       37
       19
        
       +  set(LIBCXX_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}${LIBCXX_LIBDIR_SUFFIX} CACHE PATH

     

       38
       20
        
              "Path where built libc++ libraries should be installed.")

     

       39
       39
       -
       -  set(LIBCXX_INSTALL_RUNTIME_DIR bin CACHE PATH

     

       40
       40
       -
       +  set(LIBCXX_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}/c++/v1" CACHE PATH

     

       41
       41
       -
              "Path where built libc++ runtime libraries should be installed.")

     

       42
       42
       -
       -  set(LIBCXX_INSTALL_INCLUDE_DIR "include/c++/v1" CACHE PATH

     

       43
       43
       -
       +  set(LIBCXX_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/c++/v1" CACHE PATH

     

       44
       44
       -
              "Path where target-agnostic libc++ headers should be installed.")

     

       45
       21
        
          set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${LIBCXX_INSTALL_INCLUDE_DIR}" CACHE PATH

     

       46
       22
        
              "Path where target-specific libc++ headers should be installed.")

     

       47
       47
       -
       @@ -443,11 +445,11 @@ else()

     

       48
       48
       -
          set(LIBCXX_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBCXX_LIBDIR_SUFFIX})

     

       49
       49
       -
          set(LIBCXX_GENERATED_INCLUDE_DIR "${CMAKE_BINARY_DIR}/include/c++/v1")

     

       50
       50
       -
          set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LIBCXX_GENERATED_INCLUDE_DIR}")

     

       51
       51
       -
       -  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LIBCXX_LIBDIR_SUFFIX} CACHE PATH

     

       52
       52
       -
       +  set(LIBCXX_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}${LIBCXX_LIBDIR_SUFFIX} CACHE PATH

     

       53
       53
       -
              "Path where built libc++ libraries should be installed.")

     

       54
       54
       -
       -  set(LIBCXX_INSTALL_RUNTIME_DIR bin CACHE PATH

     

       55
       55
       -
       +  set(LIBCXX_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH

     

       56
       56
       -
              "Path where built libc++ runtime libraries should be installed.")

     

       57
       57
       -
       -  set(LIBCXX_INSTALL_INCLUDE_DIR "include/c++/v1" CACHE PATH

     

       58
       58
       -
       +  set(LIBCXX_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/c++/v1" CACHE PATH

     

       59
       59
       -
              "Path where target-agnostic libc++ headers should be installed.")

     

       60
       60
       -
          set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${LIBCXX_INSTALL_INCLUDE_DIR}" CACHE PATH

     

       61
       61
       -
              "Path where target-specific libc++ headers should be installed.")

     

       62
       62
       -
       diff --git a/cmake/Modules/HandleLibCXXABI.cmake b/cmake/Modules/HandleLibCXXABI.cmake

     

       63
       63
       -
       index 5a8a4a270a1a..d69405ddeeac 100644

     

       64
       64
       -
       --- a/cmake/Modules/HandleLibCXXABI.cmake

     

       65
       65
       -
       +++ b/cmake/Modules/HandleLibCXXABI.cmake

     

       66
       66
       -
       @@ -1,8 +1,9 @@

     

       67
       67
       -
       -

     

       68
       68
       -
        #===============================================================================

     

       69
       69
       -
        # Add an ABI library if appropriate

     

       70
       70
       -
        #===============================================================================

     

       71
       71
       -
        

     

       72
       72
       -
       +include(GNUInstallDirs)

     

       73
       73
       -
       +

     

       74
       74
       -
        #

     

       75
       75
       -
        # _setup_abi: Set up the build to use an ABI library

     

       76
       76
       -
        #

     

       77
       77
       -
       @@ -63,7 +64,7 @@ macro(setup_abi_lib abidefines abishared abistatic abifiles abidirs)

     

       78
       78
       -
        

     

       79
       79
       -
                if (LIBCXX_INSTALL_HEADERS)

     

       80
       80
       -
                  install(FILES "${LIBCXX_BINARY_INCLUDE_DIR}/${fpath}"

     

       81
       81
       -
       -            DESTINATION include/c++/v1/${dstdir}

     

       82
       82
       -
       +            DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/c++/v1/${dstdir}"

     

       83
       83
       -
                    COMPONENT cxx-headers

     

       84
       84
       -
                    PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ

     

       85
       85
       -
                    )

+28 -23

pkgs/development/compilers/llvm/git/libcxxabi/default.nix

···

       18
       18
        
           cp -r ${monorepoSrc}/libcxx/src/include "$out/libcxx/src"

     

       19
       19
        
           mkdir -p "$out/llvm"

     

       20
       20
        
           cp -r ${monorepoSrc}/llvm/cmake "$out/llvm"

     

       21
       21
       +
           cp -r ${monorepoSrc}/llvm/utils "$out/llvm"

     

       22
       22
       +
           cp -r ${monorepoSrc}/runtimes "$out"

     

       21
       23
        
         '';

     

       22
       24
        
       

     

       23
       23
       -
         sourceRoot = "${src.name}/${pname}";

     

       25
       25
       +
         sourceRoot = "${src.name}/runtimes";

     

       24
       26
        
       

     

       25
       27
        
         outputs = [ "out" "dev" ];

     

       26
       28
        
       

     
···

       30
       32
        
           patch -p1 -d llvm -i ${./wasm.patch}

     

       31
       33
        
         '';

     

       32
       34
        
       

     

       35
       35
       +
         prePatch = ''

     

       36
       36
       +
           cd ../${pname}

     

       37
       37
       +
           chmod -R u+w .

     

       38
       38
       +
         '';

     

       39
       39
       +
       

     

       33
       40
        
         patches = [

     

       34
       41
        
           ./gnu-install-dirs.patch

     

       42
       42
       +
           ./skip-other-project-tests.patch

     

       35
       43
        
         ];

     

       36
       44
        
       

     

       45
       45
       +
         postPatch = ''

     

       46
       46
       +
           cd ../runtimes

     

       47
       47
       +
         '';

     

       48
       48
       +
       

     

       37
       49
        
         nativeBuildInputs = [ cmake python3 ];

     

       38
       50
        
         buildInputs = lib.optional (!stdenv.isDarwin && !stdenv.isFreeBSD && !stdenv.hostPlatform.isWasm) libunwind;

     

       39
       51
        
       

     

       40
       52
        
         cmakeFlags = [

     

       53
       53
       +
           "-DLLVM_ENABLE_RUNTIMES=libcxxabi"

     

       41
       54
        
           "-DLIBCXXABI_LIBCXX_INCLUDES=${cxx-headers}/include/c++/v1"

     

       42
       55
        
         ] ++ lib.optionals (stdenv.hostPlatform.useLLVM or false) [

     

       43
       56
        
           "-DLLVM_ENABLE_LIBCXX=ON"

     
···

       49
       62
        
           "-DLIBCXXABI_ENABLE_SHARED=OFF"

     

       50
       63
        
         ];

     

       51
       64
        
       

     

       52
       52
       -
         installPhase = if stdenv.isDarwin

     

       53
       53
       -
           then ''

     

       54
       54
       -
             for file in lib/*.dylib; do

     

       55
       55
       -
               # this should be done in CMake, but having trouble figuring out

     

       56
       56
       -
               # the magic combination of necessary CMake variables

     

       57
       57
       -
               # if you fancy a try, take a look at

     

       58
       58
       -
               # https://gitlab.kitware.com/cmake/community/-/wikis/doc/cmake/RPATH-handling

     

       59
       59
       -
               install_name_tool -id $out/$file $file

     

       60
       60
       -
             done

     

       61
       61
       -
             make install

     

       62
       62
       -
             install -d 755 $out/include

     

       63
       63
       -
             install -m 644 ../include/*.h $out/include

     

       64
       64
       -
           ''

     

       65
       65
       -
           else ''

     

       66
       66
       -
             install -d -m 755 $out/include $out/lib

     

       67
       67
       -
             install -m 644 lib/libc++abi.a $out/lib

     

       68
       68
       -
             install -m 644 ../include/cxxabi.h $out/include

     

       69
       69
       -
           '' + lib.optionalString enableShared ''

     

       70
       70
       -
             install -m 644 lib/libc++abi.so.1.0 $out/lib

     

       71
       71
       -
             ln -s libc++abi.so.1.0 $out/lib/libc++abi.so

     

       72
       72
       -
             ln -s libc++abi.so.1.0 $out/lib/libc++abi.so.1

     

       73
       73
       -
           '';

     

       65
       65
       +
         preInstall = lib.optionalString stdenv.isDarwin ''

     

       66
       66
       +
           for file in lib/*.dylib; do

     

       67
       67
       +
             # this should be done in CMake, but having trouble figuring out

     

       68
       68
       +
             # the magic combination of necessary CMake variables

     

       69
       69
       +
             # if you fancy a try, take a look at

     

       70
       70
       +
             # https://gitlab.kitware.com/cmake/community/-/wikis/doc/cmake/RPATH-handling

     

       71
       71
       +
             install_name_tool -id $out/$file $file

     

       72
       72
       +
           done

     

       73
       73
       +
         '';

     

       74
       74
       +
       

     

       75
       75
       +
         postInstall = ''

     

       76
       76
       +
           mkdir -p "$dev/include"

     

       77
       77
       +
           install -m 644 ../../${pname}/include/${if stdenv.isDarwin then "*" else "cxxabi.h"} "$dev/include"

     

       78
       78
       +
         '';

     

       74
       79
        
       

     

       75
       80
        
         meta = llvm_meta // {

     

       76
       81
        
           homepage = "https://libcxxabi.llvm.org/";

+6 -30

pkgs/development/compilers/llvm/git/libcxxabi/gnu-install-dirs.patch

···

       1
       1
        
       diff --git a/CMakeLists.txt b/CMakeLists.txt

     

       2
       2
       -
       index 858f5d5cfd7f..16c67d7062be 100644

     

       2
       2
       +
       index b8326d08d23a..a1e36f713161 100644

     

       3
       3
        
       --- a/CMakeLists.txt

     

       4
       4
        
       +++ b/CMakeLists.txt

     

       5
       5
       -
       @@ -10,6 +10,8 @@ endif()

     

       6
       6
       -
        

     

       7
       7
       -
        cmake_minimum_required(VERSION 3.13.4)

     

       8
       8
       -
        

     

       9
       9
       -
       +include(GNUInstallDirs)

     

       10
       10
       -
       +

     

       11
       11
       -
        set(LLVM_COMMON_CMAKE_UTILS "${CMAKE_CURRENT_SOURCE_DIR}/../cmake")

     

       12
       12
       -
        

     

       13
       13
       -
        # Add path for custom modules

     

       14
       14
       -
       @@ -213,9 +215,9 @@ set(CMAKE_MODULE_PATH

     

       5
       5
       +
       @@ -187,7 +187,7 @@ set(LIBCXXABI_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH

     

       15
       6
        
        if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)

     

       16
       7
        
          set(LIBCXXABI_HEADER_DIR ${LLVM_BINARY_DIR})

     

       17
       8
        
          set(LIBCXXABI_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})

     

       18
       9
        
       -  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH

     

       19
       10
        
       +  set(LIBCXXABI_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH

     

       20
       11
        
              "Path where built libc++abi libraries should be installed.")

     

       21
       21
       -
       -  set(LIBCXXABI_INSTALL_RUNTIME_DIR bin CACHE PATH

     

       22
       22
       -
       +  set(LIBCXXABI_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH

     

       23
       23
       -
              "Path where built libc++abi runtime libraries should be installed.")

     

       24
       12
        
          if(LIBCXX_LIBDIR_SUBDIR)

     

       25
       13
        
            string(APPEND LIBCXXABI_LIBRARY_DIR /${LIBCXXABI_LIBDIR_SUBDIR})

     

       26
       26
       -
       @@ -224,16 +226,16 @@ if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)

     

       27
       27
       -
        elseif(LLVM_LIBRARY_OUTPUT_INTDIR)

     

       28
       28
       -
          set(LIBCXXABI_HEADER_DIR ${LLVM_BINARY_DIR})

     

       29
       29
       -
          set(LIBCXXABI_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})

     

       30
       30
       -
       -  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LIBCXXABI_LIBDIR_SUFFIX} CACHE PATH

     

       31
       31
       -
       +  set(LIBCXXABI_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}${LIBCXXABI_LIBDIR_SUFFIX} CACHE PATH

     

       32
       32
       -
              "Path where built libc++abi libraries should be installed.")

     

       33
       33
       -
       -  set(LIBCXXABI_INSTALL_RUNTIME_DIR bin CACHE PATH

     

       34
       34
       -
       +  set(LIBCXXABI_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH

     

       35
       35
       -
              "Path where built libc++abi runtime libraries should be installed.")

     

       36
       36
       -
        else()

     

       37
       37
       -
          set(LIBCXXABI_HEADER_DIR ${CMAKE_BINARY_DIR})

     

       38
       38
       -
          set(LIBCXXABI_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBCXXABI_LIBDIR_SUFFIX})

     

       14
       14
       +
       @@ -201,7 +201,7 @@ else()

     

       15
       15
       +
            set(LIBCXXABI_HEADER_DIR ${CMAKE_BINARY_DIR})

     

       16
       16
       +
            set(LIBCXXABI_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBCXXABI_LIBDIR_SUFFIX})

     

       17
       17
       +
          endif()

     

       39
       18
        
       -  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LIBCXXABI_LIBDIR_SUFFIX} CACHE PATH

     

       40
       19
        
       +  set(LIBCXXABI_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}${LIBCXXABI_LIBDIR_SUFFIX} CACHE PATH

     

       41
       20
        
              "Path where built libc++abi libraries should be installed.")

     

       42
       42
       -
       -  set(LIBCXXABI_INSTALL_RUNTIME_DIR bin CACHE PATH

     

       43
       43
       -
       +  set(LIBCXXABI_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH

     

       44
       44
       -
              "Path where built libc++abi runtime libraries should be installed.")

     

       45
       21
        
        endif()

     

       46
       22

+45

pkgs/development/compilers/llvm/git/libcxxabi/skip-other-project-tests.patch

···

       1
       1
       +
       --- a/CMakeLists.txt

     

       2
       2
       +
       +++ b/CMakeLists.txt

     

       3
       3
       +
       @@ -131,10 +131,21 @@ if (NOT LIBCXXABI_ENABLE_SHARED AND NOT LIBCXXABI_ENABLE_STATIC)

     

       4
       4
       +
          message(FATAL_ERROR "libc++abi must be built as either a shared or static library.")

     

       5
       5
       +
        endif()

     

       6
       6
       +
       

     

       7
       7
       +
       -# TODO: Remove this, which shouldn't be necessary since we know we're being built

     

       8
       8
       +
       -#       side-by-side with libc++.

     

       9
       9
       +
        set(LIBCXXABI_LIBCXX_INCLUDES "" CACHE PATH

     

       10
       10
       +
            "Specify path to libc++ includes.")

     

       11
       11
       +
       +if (NOT libcxx IN_LIST LLVM_ENABLE_RUNTIMES)

     

       12
       12
       +
       +  if (NOT IS_DIRECTORY ${LIBCXXABI_LIBCXX_INCLUDES})

     

       13
       13
       +
       +    message(FATAL_ERROR

     

       14
       14
       +
       +      "LIBCXXABI_LIBCXX_INCLUDES=${LIBCXXABI_LIBCXX_INCLUDES} is not a valid directory. "

     

       15
       15
       +
       +      "Please provide the path to where the libc++ headers have been installed.")

     

       16
       16
       +
       +  endif()

     

       17
       17
       +
       +  add_library(cxx-headers INTERFACE)

     

       18
       18
       +
       +  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_CXX_SIMULATE_ID}" STREQUAL "MSVC")

     

       19
       19
       +
       +    target_compile_options(cxx-headers INTERFACE /I "${LIBCXXABI_LIBCXX_INCLUDES}")

     

       20
       20
       +
       +  else()

     

       21
       21
       +
       +    target_compile_options(cxx-headers INTERFACE -I "${LIBCXXABI_LIBCXX_INCLUDES}")

     

       22
       22
       +
       +  endif()

     

       23
       23
       +
       +endif()

     

       24
       24
       +
       

     

       25
       25
       +
        set(LIBCXXABI_HERMETIC_STATIC_LIBRARY_DEFAULT OFF)

     

       26
       26
       +
        if (WIN32)

     

       27
       27
       +
       --- a/test/CMakeLists.txt

     

       28
       28
       +
       +++ b/test/CMakeLists.txt

     

       29
       29
       +
       @@ -61,9 +61,13 @@ if (LIBCXXABI_BUILD_EXTERNAL_THREAD_LIBRARY)

     

       30
       30
       +
          list(APPEND LIBCXXABI_TEST_DEPS cxx_external_threads)

     

       31
       31
       +
        endif()

     

       32
       32
       +
       

     

       33
       33
       +
       -list(APPEND LIBCXXABI_TEST_DEPS cxx)

     

       34
       34
       +
       -if (LIBCXXABI_USE_LLVM_UNWINDER AND TARGET unwind)

     

       35
       35
       +
       -  list(APPEND LIBCXXABI_TEST_DEPS unwind)

     

       36
       36
       +
       +if(libcxx IN_LIST LLVM_ENABLE_RUNTIMES)

     

       37
       37
       +
       +  list(APPEND LIBCXXABI_TEST_DEPS cxx)

     

       38
       38
       +
       +endif()

     

       39
       39
       +
       +if(libunwind IN_LIST LLVM_ENABLE_RUNTIMES)

     

       40
       40
       +
       +  if (LIBCXXABI_USE_LLVM_UNWINDER AND TARGET unwind)

     

       41
       41
       +
       +    list(APPEND LIBCXXABI_TEST_DEPS unwind)

     

       42
       42
       +
       +  endif()

     

       43
       43
       +
        endif()

     

       44
       44
       +
       

     

       45
       45
       +
        set(AUTO_GEN_COMMENT "## Autogenerated by libcxxabi configuration.\n# Do not edit!")

+17 -3

pkgs/development/compilers/llvm/git/libunwind/default.nix

···

       1
       1
        
       { lib, stdenv, llvm_meta, version

     

       2
       2
        
       , monorepoSrc, runCommand

     

       3
       3
        
       , cmake

     

       4
       4
       +
       , python3

     

       4
       5
        
       , enableShared ? !stdenv.hostPlatform.isStatic

     

       5
       6
        
       }:

     

       6
       7
        
       

     
···

       19
       20
        
           cp -r ${monorepoSrc}/libcxx/utils "$out/libcxx"

     

       20
       21
        
           mkdir -p "$out/llvm"

     

       21
       22
        
           cp -r ${monorepoSrc}/llvm/cmake "$out/llvm"

     

       23
       23
       +
           cp -r ${monorepoSrc}/llvm/utils "$out/llvm"

     

       24
       24
       +
           cp -r ${monorepoSrc}/runtimes "$out"

     

       22
       25
        
         '';

     

       23
       26
        
       

     

       24
       24
       -
         sourceRoot = "${src.name}/${pname}";

     

       27
       27
       +
         sourceRoot = "${src.name}/runtimes";

     

       28
       28
       +
       

     

       29
       29
       +
         prePatch = ''

     

       30
       30
       +
           cd ../${pname}

     

       31
       31
       +
           chmod -R u+w .

     

       32
       32
       +
         '';

     

       25
       33
        
       

     

       26
       34
        
         patches = [

     

       27
       35
        
           ./gnu-install-dirs.patch

     

       28
       36
        
         ];

     

       29
       37
        
       

     

       38
       38
       +
         postPatch = ''

     

       39
       39
       +
           cd ../runtimes

     

       40
       40
       +
         '';

     

       41
       41
       +
       

     

       30
       42
        
         outputs = [ "out" "dev" ];

     

       31
       43
        
       

     

       32
       32
       -
         nativeBuildInputs = [ cmake ];

     

       44
       44
       +
         nativeBuildInputs = [ cmake python3 ];

     

       33
       45
        
       

     

       34
       34
       -
         cmakeFlags = lib.optional (!enableShared) "-DLIBUNWIND_ENABLE_SHARED=OFF";

     

       46
       46
       +
         cmakeFlags = [

     

       47
       47
       +
           "-DLLVM_ENABLE_RUNTIMES=libunwind"

     

       48
       48
       +
         ] ++ lib.optional (!enableShared) "-DLIBUNWIND_ENABLE_SHARED=OFF";

     

       35
       49
        
       

     

       36
       50
        
         meta = llvm_meta // {

     

       37
       51
        
           # Details: https://github.com/llvm/llvm-project/blob/main/libunwind/docs/index.rst

+5 -48

pkgs/development/compilers/llvm/git/libunwind/gnu-install-dirs.patch

···

       1
       1
        
       diff --git a/CMakeLists.txt b/CMakeLists.txt

     

       2
       2
       -
       index e3cc66dd2226..1299b596ce0d 100644

     

       2
       2
       +
       index 5a06805f05f1..86a50329e6a8 100644

     

       3
       3
        
       --- a/CMakeLists.txt

     

       4
       4
        
       +++ b/CMakeLists.txt

     

       5
       5
       -
       @@ -8,6 +8,8 @@ endif()

     

       6
       6
       -
        

     

       7
       7
       -
        cmake_minimum_required(VERSION 3.13.4)

     

       8
       8
       -
        

     

       9
       9
       -
       +include(GNUInstallDirs)

     

       10
       10
       -
       +

     

       11
       11
       -
        set(LLVM_COMMON_CMAKE_UTILS "${CMAKE_CURRENT_SOURCE_DIR}/../cmake")

     

       12
       12
       -
        

     

       13
       13
       -
        # Add path for custom modules

     

       14
       14
       -
       @@ -139,25 +141,27 @@ set(CMAKE_MODULE_PATH

     

       5
       5
       +
       @@ -117,7 +117,7 @@ set(LIBUNWIND_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH

     

       15
       6
        
        

     

       16
       7
        
        if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)

     

       17
       8
        
          set(LIBUNWIND_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})

     

       18
       9
        
       -  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH

     

       19
       19
       -
       +  set(LIBUNWIND_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/${LLVM_DEFAULT_TARGET_TRIPLE}" CACHE PATH

     

       20
       20
       -
       +      "Path where built libunwind headers should be installed.")

     

       21
       10
        
       +  set(LIBUNWIND_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH

     

       22
       11
        
              "Path where built libunwind libraries should be installed.")

     

       23
       23
       -
       -  set(LIBUNWIND_INSTALL_RUNTIME_DIR bin CACHE PATH

     

       24
       24
       -
       +  set(LIBUNWIND_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH

     

       25
       25
       -
              "Path where built libunwind runtime libraries should be installed.")

     

       26
       12
        
          if(LIBCXX_LIBDIR_SUBDIR)

     

       27
       13
        
            string(APPEND LIBUNWIND_LIBRARY_DIR /${LIBUNWIND_LIBDIR_SUBDIR})

     

       28
       28
       -
            string(APPEND LIBUNWIND_INSTALL_LIBRARY_DIR /${LIBUNWIND_LIBDIR_SUBDIR})

     

       14
       14
       +
       @@ -129,7 +129,7 @@ else()

     

       15
       15
       +
          else()

     

       16
       16
       +
            set(LIBUNWIND_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBUNWIND_LIBDIR_SUFFIX})

     

       29
       17
        
          endif()

     

       30
       30
       -
       -elseif(LLVM_LIBRARY_OUTPUT_INTDIR)

     

       31
       31
       -
       -  set(LIBUNWIND_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})

     

       32
       18
        
       -  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LIBUNWIND_LIBDIR_SUFFIX} CACHE PATH

     

       33
       33
       -
       -      "Path where built libunwind libraries should be installed.")

     

       34
       34
       -
       -  set(LIBUNWIND_INSTALL_RUNTIME_DIR bin CACHE PATH

     

       35
       35
       -
       -      "Path where built libunwind runtime libraries should be installed.")

     

       36
       36
       -
        else()

     

       37
       37
       -
       -  set(LIBUNWIND_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBUNWIND_LIBDIR_SUFFIX})

     

       38
       38
       -
       -  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LIBUNWIND_LIBDIR_SUFFIX} CACHE PATH

     

       39
       39
       -
       +  if(LLVM_LIBRARY_OUTPUT_INTDIR)

     

       40
       40
       -
       +    set(LIBUNWIND_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})

     

       41
       41
       -
       +  else()

     

       42
       42
       -
       +    set(LIBUNWIND_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBUNWIND_LIBDIR_SUFFIX})

     

       43
       43
       -
       +  endif()

     

       44
       44
       -
       +  set(LIBUNWIND_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}" CACHE PATH

     

       45
       45
       -
       +      "Path where built libunwind headers should be installed.")

     

       46
       19
        
       +  set(LIBUNWIND_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}${LIBUNWIND_LIBDIR_SUFFIX} CACHE PATH

     

       47
       20
        
              "Path where built libunwind libraries should be installed.")

     

       48
       48
       -
       -  set(LIBUNWIND_INSTALL_RUNTIME_DIR bin CACHE PATH

     

       49
       49
       -
       +  set(LIBUNWIND_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH

     

       50
       50
       -
              "Path where built libunwind runtime libraries should be installed.")

     

       51
       21
        
        endif()

     

       52
       22
        
        

     

       53
       53
       -
       diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt

     

       54
       54
       -
       index c3bb1dd0f69f..adf1766c44cb 100644

     

       55
       55
       -
       --- a/include/CMakeLists.txt

     

       56
       56
       -
       +++ b/include/CMakeLists.txt

     

       57
       57
       -
       @@ -14,7 +14,7 @@ if(LIBUNWIND_INSTALL_HEADERS)

     

       58
       58
       -
          foreach(file ${files})

     

       59
       59
       -
            get_filename_component(dir ${file} DIRECTORY)

     

       60
       60
       -
            install(FILES ${file}

     

       61
       61
       -
       -      DESTINATION "include/${dir}"

     

       62
       62
       -
       +      DESTINATION "${LIBUNWIND_INSTALL_INCLUDE_DIR}/${dir}"

     

       63
       63
       -
              COMPONENT unwind-headers

     

       64
       64
       -
              PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ

     

       65
       65
       -
            )

+3 -5

pkgs/development/compilers/llvm/git/lld/default.nix

···

       25
       25
        
       

     

       26
       26
        
         patches = [

     

       27
       27
        
           ./gnu-install-dirs.patch

     

       28
       28
       -
           # On Darwin the llvm-config is perhaps not working fine as the

     

       29
       29
       -
           # LLVM_MAIN_SRC_DIR is not getting set correctly, and the build fails as

     

       30
       30
       -
           # the include path is not correct.

     

       31
       31
       -
           ./fix-root-src-dir.patch

     

       32
       28
        
         ];

     

       33
       29
        
       

     

       34
       30
        
         nativeBuildInputs = [ cmake ];

     

       35
       31
        
         buildInputs = [ libllvm libxml2 ];

     

       36
       32
        
       

     

       37
       37
       -
         cmakeFlags = lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [

     

       33
       33
       +
         cmakeFlags = [

     

       34
       34
       +
           "-DLLD_INSTALL_PACKAGE_DIR=${placeholder "dev"}/lib/cmake/lld"

     

       35
       35
       +
         ] ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [

     

       38
       36
        
           "-DLLVM_TABLEGEN_EXE=${buildLlvmTools.llvm}/bin/llvm-tblgen"

     

       39
       37
        
         ];

     

       40
       38

-13

pkgs/development/compilers/llvm/git/lld/fix-root-src-dir.patch

···

       1
       1
       -
       diff --git a/lld/CMakeLists.txt b/lld/CMakeLists.txt

     

       2
       2
       -
       index e1a29b884d17..9d542f8fbfc1 100644

     

       3
       3
       -
       --- a/CMakeLists.txt

     

       4
       4
       -
       +++ b/CMakeLists.txt

     

       5
       5
       -
       @@ -64,7 +64,7 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)

     

       6
       6
       -
        

     

       7
       7
       -
          set(LLVM_MAIN_INCLUDE_DIR ${MAIN_INCLUDE_DIR} CACHE PATH "Path to llvm/include")

     

       8
       8
       -
          set(LLVM_BINARY_DIR ${LLVM_OBJ_ROOT} CACHE PATH "Path to LLVM build tree")

     

       9
       9
       -
       -  set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree")

     

       10
       10
       -
       +  set(LLVM_MAIN_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../llvm" CACHE PATH "Path to LLVM source tree")

     

       11
       11
       -
        

     

       12
       12
       -
          find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" ${LLVM_TOOLS_BINARY_DIR}

     

       13
       13
       -
            NO_DEFAULT_PATH)

+32 -8

pkgs/development/compilers/llvm/git/lld/gnu-install-dirs.patch

···

       1
       1
       +
       diff --git a/CMakeLists.txt b/CMakeLists.txt

     

       2
       2
       +
       index dcc649629a4b..58dca54642e4 100644

     

       3
       3
       +
       --- a/CMakeLists.txt

     

       4
       4
       +
       +++ b/CMakeLists.txt

     

       5
       5
       +
       @@ -70,13 +70,15 @@ if(LLD_BUILT_STANDALONE)

     

       6
       6
       +
          if (NOT LLVM_CONFIG_FOUND)

     

       7
       7
       +
            # Pull values from LLVMConfig.cmake.  We can drop this once the llvm-config

     

       8
       8
       +
            # path is removed.

     

       9
       9
       +
       -    set(MAIN_INCLUDE_DIR "${LLVM_INCLUDE_DIR}")

     

       10
       10
       +
       +    set(INCLUDE_DIRS ${LLVM_INCLUDE_DIRS})

     

       11
       11
       +
            set(LLVM_OBJ_DIR "${LLVM_BINARY_DIR}")

     

       12
       12
       +
            # N.B. this is just a default value, the CACHE PATHs below can be overridden.

     

       13
       13
       +
            set(MAIN_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../llvm")

     

       14
       14
       +
       +  else()

     

       15
       15
       +
       +    set(INCLUDE_DIRS "${LLVM_BINARY_DIR}/include" "${MAIN_INCLUDE_DIR}")

     

       16
       16
       +
          endif()

     

       17
       17
       +
        

     

       18
       18
       +
       -  set(LLVM_MAIN_INCLUDE_DIR "${MAIN_INCLUDE_DIR}" CACHE PATH "Path to llvm/include")

     

       19
       19
       +
       +  set(LLVM_INCLUDE_DIRS ${INCLUDE_DIRS} CACHE PATH "Path to llvm/include and any other header dirs needed")

     

       20
       20
       +
          set(LLVM_BINARY_DIR "${LLVM_OBJ_ROOT}" CACHE PATH "Path to LLVM build tree")

     

       21
       21
       +
          set(LLVM_MAIN_SRC_DIR "${MAIN_SRC_DIR}" CACHE PATH "Path to LLVM source tree")

     

       22
       22
       +
        

     

       23
       23
       +
       @@ -95,7 +97,7 @@ if(LLD_BUILT_STANDALONE)

     

       24
       24
       +
        

     

       25
       25
       +
          set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")

     

       26
       26
       +
        

     

       27
       27
       +
       -  include_directories("${LLVM_BINARY_DIR}/include" ${LLVM_INCLUDE_DIRS})

     

       28
       28
       +
       +  include_directories(${LLVM_INCLUDE_DIRS})

     

       29
       29
       +
          link_directories(${LLVM_LIBRARY_DIRS})

     

       30
       30
       +
        

     

       31
       31
       +
          if(LLVM_INCLUDE_TESTS)

     

       1
       32
        
       diff --git a/cmake/modules/AddLLD.cmake b/cmake/modules/AddLLD.cmake

     

       2
       2
       -
       index dd2898ce6236..ebbea040ff54 100644

     

       33
       33
       +
       index d3924f7243d4..42a7cd62281c 100644

     

       3
       34
        
       --- a/cmake/modules/AddLLD.cmake

     

       4
       35
        
       +++ b/cmake/modules/AddLLD.cmake

     

       5
       36
        
       @@ -18,8 +18,8 @@ macro(add_lld_library name)

     
···

       13
       44
        
              RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")

     

       14
       45
        
        

     

       15
       46
        
            if (${ARG_SHARED} AND NOT CMAKE_CONFIGURATION_TYPES)

     

       16
       16
       -
       @@ -62,5 +62,5 @@ endmacro()

     

       17
       17
       -
        macro(add_lld_symlink name dest)

     

       18
       18
       -
          add_llvm_tool_symlink(${name} ${dest} ALWAYS_GENERATE)

     

       19
       19
       -
          # Always generate install targets

     

       20
       20
       -
       -  llvm_install_symlink(${name} ${dest} ALWAYS_GENERATE)

     

       21
       21
       -
       +  llvm_install_symlink(${name} ${dest} ${CMAKE_INSTALL_FULL_BINDIR} ALWAYS_GENERATE)

     

       22
       22
       -
        endmacro()

-13

pkgs/development/compilers/llvm/git/lldb/gnu-install-dirs.patch

···

       1
       1
       -
       diff --git a/CMakeLists.txt b/CMakeLists.txt

     

       2
       2
       -
       index 79d451965ed4..78188978d6de 100644

     

       3
       3
       -
       --- a/CMakeLists.txt

     

       4
       4
       -
       +++ b/CMakeLists.txt

     

       5
       5
       -
       @@ -12,6 +12,8 @@ set(CMAKE_MODULE_PATH

     

       6
       6
       -
        # If we are not building as part of LLVM, build LLDB as a standalone project,

     

       7
       7
       -
        # using LLVM as an external library.

     

       8
       8
       -
        if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)

     

       9
       9
       -
       +  include(GNUInstallDirs)

     

       10
       10
       -
       +

     

       11
       11
       -
          project(lldb)

     

       12
       12
       -
          include(LLDBStandalone)

     

       13
       13
       -
        

     

       14
       1
        
       diff --git a/cmake/modules/AddLLDB.cmake b/cmake/modules/AddLLDB.cmake

     

       15
       2
        
       index 3291a7c808e1..b27d27ce6a87 100644

     

       16
       3
        
       --- a/cmake/modules/AddLLDB.cmake

+10 -1

pkgs/development/compilers/llvm/git/lldb/procfs.patch

···

       1
       1
        
       --- a/source/Plugins/Process/Linux/Procfs.h

     

       2
       2
        
       +++ b/source/Plugins/Process/Linux/Procfs.h

     

       3
       3
       -
       @@ -11,21 +11,12 @@

     

       3
       3
       +
       @@ -10,6 +10,7 @@

     

       4
       4
        
        // sys/procfs.h on Android/Linux for all supported architectures.

     

       5
       5
        
        

     

       6
       6
        
        #include <sys/ptrace.h>

     

       7
       7
        
       +#include <asm/ptrace.h>

     

       8
       8
       +
        

     

       9
       9
       +
        #include "lldb/lldb-types.h"

     

       10
       10
       +
        

     

       11
       11
       +
       @@ -17,23 +18,13 @@

     

       12
       12
       +
        

     

       13
       13
       +
        #include <vector>

     

       8
       14
        
        

     

       9
       15
        
       -#ifdef __ANDROID__

     

       10
       16
        
       -#if defined(__arm64__) || defined(__aarch64__)

     
···

       29
       35
        
        #include <sys/procfs.h>

     

       30
       36
        
       -#endif // __ANDROID__

     

       31
       37
        
       +#endif

     

       38
       38
       +
        

     

       39
       39
       +
        namespace lldb_private {

     

       40
       40
       +
        namespace process_linux {

+8 -2

pkgs/development/compilers/llvm/git/llvm/default.nix

···

       89
       89
        
           rm test/DebugInfo/X86/convert-inlined.ll

     

       90
       90
        
           rm test/DebugInfo/X86/convert-linked.ll

     

       91
       91
        
           rm test/tools/dsymutil/X86/op-convert.test

     

       92
       92
       +
           rm test/tools/gold/X86/split-dwarf.ll

     

       93
       93
       +
           rm test/tools/llvm-dwarfdump/X86/prettyprint_types.s

     

       94
       94
       +
           rm test/tools/llvm-dwarfdump/X86/simplified-template-names.s

     

       92
       95
        
         '' + optionalString (stdenv.hostPlatform.system == "armv6l-linux") ''

     

       93
       96
        
           # Seems to require certain floating point hardware (NEON?)

     

       94
       97
        
           rm test/ExecutionEngine/frem.ll

     
···

       114
       117
        
           # Some flags don't need to be repassed because LLVM already does so (like

     

       115
       118
        
           # CMAKE_BUILD_TYPE), others are irrelevant to the result.

     

       116
       119
        
           flagsForLlvmConfig = [

     

       117
       117
       -
             "-DLLVM_INSTALL_CMAKE_DIR=${placeholder "dev"}/lib/cmake/llvm/"

     

       120
       120
       +
             "-DLLVM_INSTALL_PACKAGE_DIR=${placeholder "dev"}/lib/cmake/llvm"

     

       118
       121
        
             "-DLLVM_ENABLE_RTTI=ON"

     

       119
       122
        
           ] ++ optionals enableSharedLibraries [

     

       120
       123
        
             "-DLLVM_LINK_LLVM_DYLIB=ON"

     
···

       194
       197
        
             --replace "\''${_IMPORT_PREFIX}/lib/lib" "$lib/lib/lib" \

     

       195
       198
        
             --replace "$out/bin/llvm-config" "$dev/bin/llvm-config"

     

       196
       199
        
           substituteInPlace "$dev/lib/cmake/llvm/LLVMConfig.cmake" \

     

       197
       197
       -
             --replace 'set(LLVM_BINARY_DIR "''${LLVM_INSTALL_PREFIX}")' 'set(LLVM_BINARY_DIR "''${LLVM_INSTALL_PREFIX}'"$lib"'")'

     

       200
       200
       +
             --replace 'set(LLVM_BINARY_DIR "''${LLVM_INSTALL_PREFIX}")' 'set(LLVM_BINARY_DIR "'"$lib"'")'

     

       198
       201
        
         ''

     

       199
       202
        
         + optionalString (stdenv.isDarwin && enableSharedLibraries) ''

     

       200
       203
        
           ln -s $lib/lib/libLLVM.dylib $lib/lib/libLLVM-${shortVersion}.dylib

     
···

       208
       211
        
           && (stdenv.hostPlatform == stdenv.buildPlatform);

     

       209
       212
        
       

     

       210
       213
        
         checkTarget = "check-all";

     

       214
       214
       +
       

     

       215
       215
       +
         # For the update script:

     

       216
       216
       +
         passthru.monorepoSrc = monorepoSrc;

     

       211
       217
        
       

     

       212
       218
        
         requiredSystemFeatures = [ "big-parallel" ];

     

       213
       219
        
         meta = llvm_meta // {

+44 -126

pkgs/development/compilers/llvm/git/llvm/gnu-install-dirs.patch

···

       1
       1
        
       diff --git a/CMakeLists.txt b/CMakeLists.txt

     

       2
       2
       -
       index fec956091cd5..5a766f5c5d7c 100644

     

       2
       2
       +
       index 45399dc0537e..5d946e9e6583 100644

     

       3
       3
        
       --- a/CMakeLists.txt

     

       4
       4
        
       +++ b/CMakeLists.txt

     

       5
       5
       -
       @@ -303,6 +303,9 @@ set(LLVM_EXAMPLES_INSTALL_DIR "examples" CACHE STRING

     

       6
       6
       -
            "Path for examples subdirectory (enabled by LLVM_BUILD_EXAMPLES=ON) (defaults to 'examples')")

     

       7
       7
       -
        mark_as_advanced(LLVM_EXAMPLES_INSTALL_DIR)

     

       8
       8
       -
        

     

       9
       9
       -
       +set(LLVM_INSTALL_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}/cmake/llvm" CACHE STRING

     

       10
       10
       -
       +	"Path for CMake subdirectory (defaults to lib/cmake/llvm)" )

     

       11
       11
       -
       +

     

       12
       12
       -
        # They are used as destination of target generators.

     

       13
       13
       -
        set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)

     

       14
       14
       -
        set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})

     

       5
       5
       +
       @@ -942,7 +942,7 @@ if (NOT TENSORFLOW_AOT_PATH STREQUAL "")

     

       6
       6
       +
          add_subdirectory(${TENSORFLOW_AOT_PATH}/xla_aot_runtime_src

     

       7
       7
       +
            ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/tf_runtime)

     

       8
       8
       +
          install(TARGETS tf_xla_runtime EXPORT LLVMExports

     

       9
       9
       +
       -    ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT tf_xla_runtime)

     

       10
       10
       +
       +    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX} COMPONENT tf_xla_runtime)

     

       11
       11
       +
          set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS tf_xla_runtime)

     

       12
       12
       +
          # Once we add more modules, we should handle this more automatically.

     

       13
       13
       +
          if (DEFINED LLVM_OVERRIDE_MODEL_HEADER_INLINERSIZEMODEL)

     

       15
       14
        
       diff --git a/cmake/modules/AddLLVM.cmake b/cmake/modules/AddLLVM.cmake

     

       16
       16
       -
       index fed1fec7d72e..4baed19b9e98 100644

     

       15
       15
       +
       index 057431208322..56f0dcb258da 100644

     

       17
       16
        
       --- a/cmake/modules/AddLLVM.cmake

     

       18
       17
        
       +++ b/cmake/modules/AddLLVM.cmake

     

       19
       19
       -
       @@ -838,8 +838,8 @@ macro(add_llvm_library name)

     

       18
       18
       +
       @@ -844,8 +844,8 @@ macro(add_llvm_library name)

     

       20
       19
        
              get_target_export_arg(${name} LLVM export_to_llvmexports ${umbrella})

     

       21
       20
        
              install(TARGETS ${name}

     

       22
       21
        
                      ${export_to_llvmexports}

     
···

       27
       26
        
                      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT ${name})

     

       28
       27
        
        

     

       29
       28
        
              if (NOT LLVM_ENABLE_IDE)

     

       30
       30
       -
       @@ -1056,7 +1056,7 @@ function(process_llvm_pass_plugins)

     

       31
       31
       -
                  "set(LLVM_STATIC_EXTENSIONS ${LLVM_STATIC_EXTENSIONS})")

     

       32
       32
       -
              install(FILES

     

       33
       33
       -
                  ${llvm_cmake_builddir}/LLVMConfigExtensions.cmake

     

       34
       34
       -
       -          DESTINATION ${LLVM_INSTALL_PACKAGE_DIR}

     

       35
       35
       -
       +          DESTINATION ${LLVM_INSTALL_CMAKE_DIR}

     

       36
       36
       -
                  COMPONENT cmake-exports)

     

       37
       37
       -
        

     

       38
       38
       -
              set(ExtensionDef "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def")

     

       39
       39
       -
       @@ -1902,7 +1902,7 @@ function(llvm_install_library_symlink name dest type)

     

       29
       29
       +
       @@ -2007,7 +2007,7 @@ function(llvm_install_library_symlink name dest type)

     

       40
       30
        
          set(full_name ${CMAKE_${type}_LIBRARY_PREFIX}${name}${CMAKE_${type}_LIBRARY_SUFFIX})

     

       41
       31
        
          set(full_dest ${CMAKE_${type}_LIBRARY_PREFIX}${dest}${CMAKE_${type}_LIBRARY_SUFFIX})

     

       42
       32
        
        

     

       43
       33
        
       -  set(output_dir lib${LLVM_LIBDIR_SUFFIX})

     

       44
       34
        
       +  set(output_dir ${CMAKE_INSTALL_FULL_LIBDIR}${LLVM_LIBDIR_SUFFIX})

     

       45
       35
        
          if(WIN32 AND "${type}" STREQUAL "SHARED")

     

       46
       46
       -
            set(output_dir bin)

     

       36
       36
       +
            set(output_dir "${CMAKE_INSTALL_BINDIR}")

     

       47
       37
        
          endif()

     

       48
       48
       -
       @@ -1913,7 +1913,7 @@ function(llvm_install_library_symlink name dest type)

     

       38
       38
       +
       @@ -2271,15 +2271,15 @@ function(llvm_setup_rpath name)

     

       49
       39
        
        

     

       50
       50
       -
        endfunction()

     

       51
       51
       -
        

     

       52
       52
       -
       -function(llvm_install_symlink name dest)

     

       53
       53
       -
       +function(llvm_install_symlink name dest output_dir)

     

       54
       54
       -
          cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN})

     

       55
       55
       -
          foreach(path ${CMAKE_MODULE_PATH})

     

       56
       56
       -
            if(EXISTS ${path}/LLVMInstallSymlink.cmake)

     

       57
       57
       -
       @@ -1936,7 +1936,7 @@ function(llvm_install_symlink name dest)

     

       58
       58
       -
          set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})

     

       59
       59
       -
        

     

       60
       60
       -
          install(SCRIPT ${INSTALL_SYMLINK}

     

       61
       61
       -
       -          CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"

     

       62
       62
       -
       +          CODE "install_symlink(${full_name} ${full_dest} ${output_dir})"

     

       63
       63
       -
                  COMPONENT ${component})

     

       64
       64
       -
        

     

       65
       65
       -
          if (NOT LLVM_ENABLE_IDE AND NOT ARG_ALWAYS_GENERATE)

     

       66
       66
       -
       @@ -2019,7 +2019,8 @@ function(add_llvm_tool_symlink link_name target)

     

       67
       67
       -
            endif()

     

       68
       68
       -
        

     

       69
       69
       -
            if ((TOOL_IS_TOOLCHAIN OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY) AND LLVM_BUILD_TOOLS)

     

       70
       70
       -
       -      llvm_install_symlink(${link_name} ${target})

     

       71
       71
       -
       +      GNUInstallDirs_get_absolute_install_dir(output_dir LLVM_TOOLS_INSTALL_DIR)

     

       72
       72
       -
       +      llvm_install_symlink(${link_name} ${target} ${output_dir})

     

       73
       73
       -
            endif()

     

       74
       74
       -
          endif()

     

       75
       75
       -
        endfunction()

     

       76
       76
       -
       @@ -2148,9 +2149,9 @@ function(llvm_setup_rpath name)

     

       40
       40
       +
          if (APPLE)

     

       41
       41
       +
            set(_install_name_dir INSTALL_NAME_DIR "@rpath")

     

       42
       42
       +
       -    set(_install_rpath "@loader_path/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})

     

       43
       43
       +
       +    set(_install_rpath "@loader_path/../${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})

     

       44
       44
       +
          elseif(${CMAKE_SYSTEM_NAME} MATCHES "AIX" AND BUILD_SHARED_LIBS)

     

       45
       45
       +
            # $ORIGIN is not interpreted at link time by aix ld.

     

       77
       46
        
            # Since BUILD_SHARED_LIBS is only recommended for use by developers,

     

       78
       47
        
            # hardcode the rpath to build/install lib dir first in this mode.

     

       79
       48
        
            # FIXME: update this when there is better solution.

     

       80
       49
        
       -    set(_install_rpath "${LLVM_LIBRARY_OUTPUT_INTDIR}" "${CMAKE_INSTALL_PREFIX}/lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})

     

       81
       81
       -
       +    set(_install_rpath "${LLVM_LIBRARY_OUTPUT_INTDIR}" "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})

     

       50
       50
       +
       +    set(_install_rpath "${LLVM_LIBRARY_OUTPUT_INTDIR}" "${CMAKE_INSTALL_FULL_LIBDIR}${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})

     

       82
       51
        
          elseif(UNIX)

     

       83
       52
        
       -    set(_install_rpath "\$ORIGIN/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})

     

       84
       53
        
       +    set(_install_rpath "\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})

     
···

       102
       71
        
          list(APPEND ocaml_flags "-ldopt" "-Wl,-rpath,${ocaml_rpath}")

     

       103
       72
        
        

     

       104
       73
        
       diff --git a/cmake/modules/CMakeLists.txt b/cmake/modules/CMakeLists.txt

     

       105
       105
       -
       index cea0c1df0a14..eedcd9450312 100644

     

       74
       74
       +
       index d4b0ab959148..26ed981fd09f 100644

     

       106
       75
        
       --- a/cmake/modules/CMakeLists.txt

     

       107
       76
        
       +++ b/cmake/modules/CMakeLists.txt

     

       108
       108
       -
       @@ -2,7 +2,7 @@ include(ExtendPath)

     

       109
       109
       -
        include(LLVMDistributionSupport)

     

       110
       110
       -
        include(FindPrefixFromConfig)

     

       111
       111
       -
        

     

       112
       112
       -
       -set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)

     

       113
       113
       -
       +set(LLVM_INSTALL_PACKAGE_DIR ${LLVM_INSTALL_CMAKE_DIR} CACHE STRING "Path for CMake subdirectory (defaults to 'cmake/llvm')")

     

       114
       114
       -
        set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")

     

       115
       115
       -
        

     

       116
       116
       -
        # First for users who use an installed LLVM, create the LLVMExports.cmake file.

     

       117
       117
       -
       @@ -122,7 +122,7 @@ set(LLVM_CONFIG_INCLUDE_DIRS

     

       77
       77
       +
       @@ -128,7 +128,7 @@ set(LLVM_CONFIG_INCLUDE_DIRS

     

       118
       78
        
          )

     

       119
       79
        
        list(REMOVE_DUPLICATES LLVM_CONFIG_INCLUDE_DIRS)

     

       120
       80
        
        

     
···

       123
       83
        
        set(LLVM_CONFIG_LIBRARY_DIRS

     

       124
       84
        
          "${LLVM_CONFIG_LIBRARY_DIR}"

     

       125
       85
        
          # FIXME: Should there be other entries here?

     

       126
       126
       -
       diff --git a/cmake/modules/LLVMInstallSymlink.cmake b/cmake/modules/LLVMInstallSymlink.cmake

     

       127
       127
       -
       index b5c35f706cb7..9261ab797de6 100644

     

       128
       128
       -
       --- a/cmake/modules/LLVMInstallSymlink.cmake

     

       129
       129
       -
       +++ b/cmake/modules/LLVMInstallSymlink.cmake

     

       130
       130
       -
       @@ -6,7 +6,7 @@ include(GNUInstallDirs)

     

       131
       131
       -
        

     

       132
       132
       -
        function(install_symlink name target outdir)

     

       133
       133
       -
          set(DESTDIR $ENV{DESTDIR})

     

       134
       134
       -
       -  set(bindir "${DESTDIR}${CMAKE_INSTALL_PREFIX}/${outdir}")

     

       135
       135
       -
       +  set(bindir "${DESTDIR}${outdir}/")

     

       136
       136
       -
        

     

       137
       137
       -
          message(STATUS "Creating ${name}")

     

       138
       138
       -
        

     

       139
       86
        
       diff --git a/docs/CMake.rst b/docs/CMake.rst

     

       140
       140
       -
       index 044ec8a4d39d..504d0eac3ade 100644

     

       87
       87
       +
       index 879b7b231d4c..9c31d14e8950 100644

     

       141
       88
        
       --- a/docs/CMake.rst

     

       142
       89
        
       +++ b/docs/CMake.rst

     

       143
       143
       -
       @@ -224,7 +224,7 @@ description is in `LLVM-related variables`_ below.

     

       90
       90
       +
       @@ -250,7 +250,7 @@ description is in `LLVM-related variables`_ below.

     

       144
       91
        
        **LLVM_LIBDIR_SUFFIX**:STRING

     

       145
       92
        
          Extra suffix to append to the directory where libraries are to be

     

       146
       93
        
          installed. On a 64-bit architecture, one could use ``-DLLVM_LIBDIR_SUFFIX=64``

     
···

       149
       96
        
        

     

       150
       97
        
        **LLVM_PARALLEL_{COMPILE,LINK}_JOBS**:STRING

     

       151
       98
        
          Building the llvm toolchain can use a lot of resources, particularly

     

       152
       152
       -
       @@ -910,9 +910,11 @@ the ``cmake`` command or by setting it directly in ``ccmake`` or ``cmake-gui``).

     

       99
       99
       +
       @@ -284,6 +284,10 @@ manual, or execute ``cmake --help-variable VARIABLE_NAME``.

     

       100
       100
       +
          The path to install executables, relative to the *CMAKE_INSTALL_PREFIX*.

     

       101
       101
       +
          Defaults to "bin".

     

       153
       102
        
        

     

       154
       154
       -
        This file is available in two different locations.

     

       155
       155
       -
        

     

       156
       156
       -
       -* ``<INSTALL_PREFIX>/lib/cmake/llvm/LLVMConfig.cmake`` where

     

       157
       157
       -
       -  ``<INSTALL_PREFIX>`` is the install prefix of an installed version of LLVM.

     

       158
       158
       -
       -  On Linux typically this is ``/usr/lib/cmake/llvm/LLVMConfig.cmake``.

     

       159
       159
       -
       +* ``<LLVM_INSTALL_PACKAGE_DIR>LLVMConfig.cmake`` where

     

       160
       160
       -
       +  ``<LLVM_INSTALL_PACKAGE_DIR>`` is the location where LLVM CMake modules are

     

       161
       161
       -
       +  installed as part of an installed version of LLVM. This is typically

     

       162
       162
       -
       +  ``cmake/llvm/`` within the lib directory. On Linux, this is typically

     

       163
       163
       -
       +  ``/usr/lib/cmake/llvm/LLVMConfig.cmake``.

     

       164
       164
       -
        

     

       165
       165
       -
        * ``<LLVM_BUILD_ROOT>/lib/cmake/llvm/LLVMConfig.cmake`` where

     

       166
       166
       -
          ``<LLVM_BUILD_ROOT>`` is the root of the LLVM build tree. **Note: this is only

     

       167
       167
       -
       diff --git a/include/llvm/CMakeLists.txt b/include/llvm/CMakeLists.txt

     

       168
       168
       -
       index b46319f24fc8..2feabd1954e4 100644

     

       169
       169
       -
       --- a/include/llvm/CMakeLists.txt

     

       170
       170
       -
       +++ b/include/llvm/CMakeLists.txt

     

       171
       171
       -
       @@ -5,5 +5,5 @@ add_subdirectory(Frontend)

     

       172
       172
       -
        # If we're doing an out-of-tree build, copy a module map for generated

     

       173
       173
       -
        # header files into the build area.

     

       174
       174
       -
        if (NOT "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")

     

       175
       175
       -
       -  configure_file(module.modulemap.build module.modulemap COPYONLY)

     

       176
       176
       -
       +  configure_file(module.modulemap.build ${LLVM_INCLUDE_DIR}/module.modulemap COPYONLY)

     

       177
       177
       -
        endif (NOT "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")

     

       103
       103
       +
       +**CMAKE_INSTALL_LIBDIR**:PATH

     

       104
       104
       +
       +  The path to install libraries, relative to the *CMAKE_INSTALL_PREFIX*.

     

       105
       105
       +
       +  Defaults to "lib".

     

       106
       106
       +
       +

     

       107
       107
       +
        **CMAKE_INSTALL_INCLUDEDIR**:PATH

     

       108
       108
       +
          The path to install header files, relative to the *CMAKE_INSTALL_PREFIX*.

     

       109
       109
       +
          Defaults to "include".

     

       178
       110
        
       diff --git a/tools/llvm-config/BuildVariables.inc.in b/tools/llvm-config/BuildVariables.inc.in

     

       179
       179
       -
       index abbb8a450da6..70c497be12f5 100644

     

       111
       111
       +
       index 370005cd8d7d..7e790bc52111 100644

     

       180
       112
        
       --- a/tools/llvm-config/BuildVariables.inc.in

     

       181
       113
        
       +++ b/tools/llvm-config/BuildVariables.inc.in

     

       182
       182
       -
       @@ -23,7 +23,10 @@

     

       114
       114
       +
       @@ -23,6 +23,7 @@

     

       183
       115
        
        #define LLVM_CXXFLAGS "@LLVM_CXXFLAGS@"

     

       184
       116
        
        #define LLVM_BUILDMODE "@LLVM_BUILDMODE@"

     

       185
       117
        
        #define LLVM_LIBDIR_SUFFIX "@LLVM_LIBDIR_SUFFIX@"

     

       186
       186
       -
       +#define LLVM_INSTALL_BINDIR "@CMAKE_INSTALL_BINDIR@"

     

       187
       118
        
       +#define LLVM_INSTALL_LIBDIR "@CMAKE_INSTALL_LIBDIR@"

     

       188
       119
        
        #define LLVM_INSTALL_INCLUDEDIR "@CMAKE_INSTALL_INCLUDEDIR@"

     

       189
       189
       -
       +#define LLVM_INSTALL_CMAKEDIR "@LLVM_INSTALL_CMAKE_DIR@"

     

       120
       120
       +
        #define LLVM_INSTALL_PACKAGE_DIR "@LLVM_INSTALL_PACKAGE_DIR@"

     

       190
       121
        
        #define LLVM_TARGETS_BUILT "@LLVM_TARGETS_BUILT@"

     

       191
       191
       -
        #define LLVM_SYSTEM_LIBS "@LLVM_SYSTEM_LIBS@"

     

       192
       192
       -
        #define LLVM_BUILD_SYSTEM "@LLVM_BUILD_SYSTEM@"

     

       193
       122
        
       diff --git a/tools/llvm-config/llvm-config.cpp b/tools/llvm-config/llvm-config.cpp

     

       194
       194
       -
       index 8ed88f33ead4..5e7184bab90d 100644

     

       123
       123
       +
       index 2c6c55f89d38..f6d2068a0827 100644

     

       195
       124
        
       --- a/tools/llvm-config/llvm-config.cpp

     

       196
       125
        
       +++ b/tools/llvm-config/llvm-config.cpp

     

       197
       197
       -
       @@ -363,12 +363,20 @@ int main(int argc, char **argv) {

     

       198
       198
       -
              ActiveIncludeDir = std::string(Path.str());

     

       199
       199
       -
            }

     

       200
       200
       -
            {

     

       201
       201
       -
       -      SmallString<256> Path(LLVM_TOOLS_INSTALL_DIR);

     

       202
       202
       -
       +      SmallString<256> Path(LLVM_INSTALL_BINDIR);

     

       126
       126
       +
       @@ -369,7 +369,11 @@ int main(int argc, char **argv) {

     

       203
       127
        
              sys::fs::make_absolute(ActivePrefix, Path);

     

       204
       128
        
              ActiveBinDir = std::string(Path.str());

     

       205
       129
        
            }

     

       206
       130
        
       -    ActiveLibDir = ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX;

     

       207
       207
       -
       -    ActiveCMakeDir = ActiveLibDir + "/cmake/llvm";

     

       208
       131
        
       +    {

     

       209
       132
        
       +      SmallString<256> Path(LLVM_INSTALL_LIBDIR LLVM_LIBDIR_SUFFIX);

     

       210
       133
        
       +      sys::fs::make_absolute(ActivePrefix, Path);

     

       211
       134
        
       +      ActiveLibDir = std::string(Path.str());

     

       212
       135
        
       +    }

     

       213
       213
       -
       +    {

     

       214
       214
       -
       +      SmallString<256> Path(LLVM_INSTALL_CMAKEDIR);

     

       215
       215
       -
       +      sys::fs::make_absolute(ActivePrefix, Path);

     

       216
       216
       -
       +      ActiveCMakeDir = std::string(Path.str());

     

       217
       217
       -
       +    }

     

       218
       218
       -
            ActiveIncludeOption = "-I" + ActiveIncludeDir;

     

       219
       219
       -
          }

     

       220
       220
       -
        

     

       136
       136
       +
            {

     

       137
       137
       +
              SmallString<256> Path(LLVM_INSTALL_PACKAGE_DIR);

     

       138
       138
       +
              sys::fs::make_absolute(ActivePrefix, Path);

+16 -3

pkgs/development/compilers/llvm/git/openmp/default.nix

···

       5
       5
        
       , runCommand

     

       6
       6
        
       , cmake

     

       7
       7
        
       , llvm

     

       8
       8
       +
       , lit

     

       8
       9
        
       , clang-unwrapped

     

       9
       10
        
       , perl

     

       10
       11
        
       , pkg-config

     
···

       24
       25
        
         sourceRoot = "${src.name}/${pname}";

     

       25
       26
        
       

     

       26
       27
        
         patches = [

     

       28
       28
       +
           ./fix-find-tool.patch

     

       27
       29
        
           ./gnu-install-dirs.patch

     

       28
       28
       -
           ./fix-find-tool.patch

     

       30
       30
       +
           ./run-lit-directly.patch

     

       29
       31
        
         ];

     

       30
       32
        
       

     

       31
       33
        
         outputs = [ "out" "dev" ];

     

       32
       34
        
       

     

       33
       33
       -
         nativeBuildInputs = [ cmake perl pkg-config clang-unwrapped ];

     

       35
       35
       +
         nativeBuildInputs = [ cmake perl pkg-config lit ];

     

       34
       36
        
         buildInputs = [ llvm ];

     

       35
       37
        
       

     

       38
       38
       +
         # Unsup:Pass:XFail:Fail

     

       39
       39
       +
         # 26:267:16:8

     

       40
       40
       +
         doCheck = false;

     

       41
       41
       +
         checkTarget = "check-openmp";

     

       42
       42
       +
       

     

       43
       43
       +
         preCheck = ''

     

       44
       44
       +
           patchShebangs ../tools/archer/tests/deflake.bash

     

       45
       45
       +
         '';

     

       46
       46
       +
       

     

       36
       47
        
         cmakeFlags = [

     

       37
       37
       -
           "-DLIBOMPTARGET_BUILD_AMDGCN_BCLIB=OFF" # Building the AMDGCN device RTL currently fails

     

       48
       48
       +
           "-DCLANG_TOOL=${clang-unwrapped}/bin/clang"

     

       49
       49
       +
           "-DOPT_TOOL=${llvm}/bin/opt"

     

       50
       50
       +
           "-DLINK_TOOL=${llvm}/bin/llvm-link"

     

       38
       51
        
         ];

     

       39
       52
        
       

     

       40
       53
        
         meta = llvm_meta // {

+9 -45

pkgs/development/compilers/llvm/git/openmp/fix-find-tool.patch

···

       1
       1
        
       diff --git a/libomptarget/DeviceRTL/CMakeLists.txt b/libomptarget/DeviceRTL/CMakeLists.txt

     

       2
       2
       -
       index 242df638f80d..a4654e96371f 100644

     

       2
       2
       +
       index ce66214822a2..6ab7b33c95da 100644

     

       3
       3
        
       --- a/libomptarget/DeviceRTL/CMakeLists.txt

     

       4
       4
        
       +++ b/libomptarget/DeviceRTL/CMakeLists.txt

     

       5
       5
       -
       @@ -25,16 +25,16 @@ endif()

     

       6
       6
       -
        

     

       7
       7
       -
        if (LLVM_DIR)

     

       8
       8
       -
          # Builds that use pre-installed LLVM have LLVM_DIR set.

     

       9
       9
       -
       -  find_program(CLANG_TOOL clang PATHS ${LLVM_TOOLS_BINARY_DIR} NO_DEFAULT_PATH)

     

       10
       10
       -
       +  find_program(CLANG_TOOL clang PATHS ${LLVM_TOOLS_BINARY_DIR} REQUIRED)

     

       11
       11
       -
          find_program(LINK_TOOL llvm-link PATHS ${LLVM_TOOLS_BINARY_DIR}

     

       12
       12
       -
       -    NO_DEFAULT_PATH)

     

       13
       13
       -
       -  find_program(OPT_TOOL opt PATHS ${LLVM_TOOLS_BINARY_DIR} NO_DEFAULT_PATH)

     

       14
       14
       -
       +    REQUIRED)

     

       15
       15
       -
       +  find_program(OPT_TOOL opt PATHS ${LLVM_TOOLS_BINARY_DIR} REQUIRED)

     

       16
       16
       -
          libomptarget_say("Building DeviceRTL. Using clang: ${CLANG_TOOL}")

     

       17
       17
       -
        elseif (LLVM_TOOL_CLANG_BUILD AND NOT CMAKE_CROSSCOMPILING AND NOT OPENMP_STANDALONE_BUILD)

     

       18
       18
       -
          # LLVM in-tree builds may use CMake target names to discover the tools.

     

       19
       19
       -
       -  set(CLANG_TOOL $<TARGET_FILE:clang>)

     

       20
       20
       -
       -  set(LINK_TOOL $<TARGET_FILE:llvm-link>)

     

       21
       21
       -
       -  set(OPT_TOOL $<TARGET_FILE:opt>)

     

       22
       22
       -
       +  set(CLANG_TOOL $<TARGET_FILE:clang> REQUIRED)

     

       23
       23
       -
       +  set(LINK_TOOL $<TARGET_FILE:llvm-link> REQUIRED)

     

       24
       24
       -
       +  set(OPT_TOOL $<TARGET_FILE:opt> REQUIRED)

     

       25
       25
       -
          libomptarget_say("Building DeviceRTL. Using clang from in-tree build")

     

       26
       26
       -
        else()

     

       27
       27
       -
          libomptarget_say("Not building DeviceRTL. No appropriate clang found")

     

       28
       28
       -
       diff --git a/libomptarget/deviceRTLs/amdgcn/CMakeLists.txt b/libomptarget/deviceRTLs/amdgcn/CMakeLists.txt

     

       29
       29
       -
       index 3f4c02671aeb..be9f4677d7b5 100644

     

       30
       30
       -
       --- a/libomptarget/deviceRTLs/amdgcn/CMakeLists.txt

     

       31
       31
       -
       +++ b/libomptarget/deviceRTLs/amdgcn/CMakeLists.txt

     

       32
       32
       -
       @@ -38,16 +38,16 @@ endif()

     

       33
       33
       -
        

     

       5
       5
       +
       @@ -27,10 +27,10 @@ endif()

     

       34
       6
        
        if (LLVM_DIR)

     

       35
       7
        
          # Builds that use pre-installed LLVM have LLVM_DIR set.

     

       8
       8
       +
          # A standalone or LLVM_ENABLE_RUNTIMES=openmp build takes this route

     

       36
       9
        
       -  find_program(CLANG_TOOL clang PATHS ${LLVM_TOOLS_BINARY_DIR} NO_DEFAULT_PATH)

     

       37
       37
       -
       +  find_program(CLANG_TOOL clang PATHS ${LLVM_TOOLS_BINARY_DIR} REQUIRED)

     

       10
       10
       +
       +  find_program(CLANG_TOOL clang PATHS ${LLVM_TOOLS_BINARY_DIR})

     

       38
       11
        
          find_program(LINK_TOOL llvm-link PATHS ${LLVM_TOOLS_BINARY_DIR}

     

       39
       12
        
       -    NO_DEFAULT_PATH)

     

       40
       13
        
       -  find_program(OPT_TOOL opt PATHS ${LLVM_TOOLS_BINARY_DIR} NO_DEFAULT_PATH)

     

       41
       41
       -
       +    REQUIRED)

     

       42
       42
       -
       +  find_program(OPT_TOOL opt PATHS ${LLVM_TOOLS_BINARY_DIR} REQUIRED)

     

       43
       43
       -
          libomptarget_say("Building AMDGCN device RTL. Using clang: ${CLANG_TOOL}")

     

       44
       44
       -
        elseif (LLVM_TOOL_CLANG_BUILD AND NOT CMAKE_CROSSCOMPILING AND NOT OPENMP_STANDALONE_BUILD)

     

       45
       45
       -
          # LLVM in-tree builds may use CMake target names to discover the tools.

     

       46
       46
       -
       -  set(CLANG_TOOL $<TARGET_FILE:clang>)

     

       47
       47
       -
       -  set(LINK_TOOL $<TARGET_FILE:llvm-link>)

     

       48
       48
       -
       -  set(OPT_TOOL $<TARGET_FILE:opt>)

     

       49
       49
       -
       +  set(CLANG_TOOL $<TARGET_FILE:clang> REQUIRED)

     

       50
       50
       -
       +  set(LINK_TOOL $<TARGET_FILE:llvm-link> REQUIRED)

     

       51
       51
       -
       +  set(OPT_TOOL $<TARGET_FILE:opt> REQUIRED)

     

       52
       52
       -
          libomptarget_say("Building AMDGCN device RTL. Using clang from in-tree build")

     

       53
       53
       -
        else()

     

       54
       54
       -
          libomptarget_say("Not building AMDGCN device RTL. No appropriate clang found")

     

       14
       14
       +
       +    )

     

       15
       15
       +
       +  find_program(OPT_TOOL opt PATHS ${LLVM_TOOLS_BINARY_DIR})

     

       16
       16
       +
          if ((NOT CLANG_TOOL) OR (NOT LINK_TOOL) OR (NOT OPT_TOOL))

     

       17
       17
       +
            libomptarget_say("Not building DeviceRTL. Missing clang: ${CLANG_TOOL}, llvm-link: ${LINK_TOOL} or opt: ${OPT_TOOL}")

     

       18
       18
       +
            return()

+3 -70

pkgs/development/compilers/llvm/git/openmp/gnu-install-dirs.patch

···

       1
       1
        
       diff --git a/CMakeLists.txt b/CMakeLists.txt

     

       2
       2
       -
       index 7f11a05f5622..fb90f8f6a49b 100644

     

       2
       2
       +
       index b6ddbe90516d..311ab1d50e7f 100644

     

       3
       3
        
       --- a/CMakeLists.txt

     

       4
       4
        
       +++ b/CMakeLists.txt

     

       5
       5
       -
       @@ -8,6 +8,8 @@ if (OPENMP_STANDALONE_BUILD OR "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_S

     

       6
       6
       -
          set(OPENMP_STANDALONE_BUILD TRUE)

     

       7
       7
       -
          project(openmp C CXX)

     

       8
       8
       -
        

     

       9
       9
       -
       +  include(GNUInstallDirs)

     

       10
       10
       -
       +

     

       11
       11
       -
          # CMAKE_BUILD_TYPE was not set, default to Release.

     

       12
       12
       -
          if (NOT CMAKE_BUILD_TYPE)

     

       13
       13
       -
            set(CMAKE_BUILD_TYPE Release)

     

       14
       14
       -
       @@ -19,7 +21,7 @@ if (OPENMP_STANDALONE_BUILD OR "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_S

     

       5
       5
       +
       @@ -29,7 +29,7 @@ if (OPENMP_STANDALONE_BUILD)

     

       15
       6
        
          set(OPENMP_LIBDIR_SUFFIX "" CACHE STRING

     

       16
       7
        
            "Suffix of lib installation directory, e.g. 64 => lib64")

     

       17
       8
        
          # Do not use OPENMP_LIBDIR_SUFFIX directly, use OPENMP_INSTALL_LIBDIR.

     
···

       20
       11
        
        

     

       21
       12
        
          # Group test settings.

     

       22
       13
        
          set(OPENMP_TEST_C_COMPILER ${CMAKE_C_COMPILER} CACHE STRING

     

       23
       23
       -
       @@ -30,7 +32,7 @@ if (OPENMP_STANDALONE_BUILD OR "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_S

     

       14
       14
       +
       @@ -40,7 +40,7 @@ if (OPENMP_STANDALONE_BUILD)

     

       24
       15
        
        else()

     

       25
       16
        
          set(OPENMP_ENABLE_WERROR ${LLVM_ENABLE_WERROR})

     

       26
       17
        
          # If building in tree, we honor the same install suffix LLVM uses.

     
···

       29
       20
        
        

     

       30
       21
        
          if (NOT MSVC)

     

       31
       22
        
            set(OPENMP_TEST_C_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang)

     

       32
       32
       -
       index 0e1ce2afd154..8b3810f83713 100644

     

       33
       33
       -
       --- a/libomptarget/plugins/amdgpu/CMakeLists.txt

     

       34
       34
       -
       +++ b/libomptarget/plugins/amdgpu/CMakeLists.txt

     

       35
       35
       -
       @@ -80,7 +80,7 @@ add_library(omptarget.rtl.amdgpu SHARED

     

       36
       36
       -
        

     

       37
       37
       -
        # Install plugin under the lib destination folder.

     

       38
       38
       -
        # When we build for debug, OPENMP_LIBDIR_SUFFIX get set to -debug

     

       39
       39
       -
       -install(TARGETS omptarget.rtl.amdgpu LIBRARY DESTINATION "lib${OPENMP_LIBDIR_SUFFIX}")

     

       40
       40
       -
       +install(TARGETS omptarget.rtl.amdgpu LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}${OPENMP_LIBDIR_SUFFIX}")

     

       41
       41
       -
        set_property(TARGET omptarget.rtl.amdgpu PROPERTY INSTALL_RPATH_USE_LINK_PATH ON)

     

       42
       42
       -
        

     

       43
       43
       -
        if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")

     

       44
       44
       -
       diff --git a/libomptarget/plugins/ve/CMakeLists.txt b/libomptarget/plugins/ve/CMakeLists.txt

     

       45
       45
       -
       index 16ce0891ca23..db30ee9c769f 100644

     

       46
       46
       -
       --- a/libomptarget/plugins/ve/CMakeLists.txt

     

       47
       47
       -
       +++ b/libomptarget/plugins/ve/CMakeLists.txt

     

       48
       48
       -
       @@ -32,7 +32,7 @@ if(${LIBOMPTARGET_DEP_VEO_FOUND})

     

       49
       49
       -
        

     

       50
       50
       -
          # Install plugin under the lib destination folder.

     

       51
       51
       -
          install(TARGETS "omptarget.rtl.${tmachine_libname}"

     

       52
       52
       -
       -    LIBRARY DESTINATION lib${OPENMP_LIBDIR_SUFFIX})

     

       53
       53
       -
       +    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}${OPENMP_LIBDIR_SUFFIX})

     

       54
       54
       -
        

     

       55
       55
       -
          target_link_libraries(

     

       56
       56
       -
            "omptarget.rtl.${tmachine_libname}"

     

       57
       57
       -
       diff --git a/runtime/src/CMakeLists.txt b/runtime/src/CMakeLists.txt

     

       58
       58
       -
       index e4f4e6e1e73f..1164b3b22b0e 100644

     

       59
       59
       -
       --- a/runtime/src/CMakeLists.txt

     

       60
       60
       -
       +++ b/runtime/src/CMakeLists.txt

     

       61
       61
       -
       @@ -346,13 +346,13 @@ add_dependencies(libomp-micro-tests libomp-test-deps)

     

       62
       62
       -
        # We want to install libomp in DESTDIR/CMAKE_INSTALL_PREFIX/lib

     

       63
       63
       -
        # We want to install headers in DESTDIR/CMAKE_INSTALL_PREFIX/include

     

       64
       64
       -
        if(${OPENMP_STANDALONE_BUILD})

     

       65
       65
       -
       -  set(LIBOMP_HEADERS_INSTALL_PATH include)

     

       66
       66
       -
       +  set(LIBOMP_HEADERS_INSTALL_PATH "${CMAKE_INSTALL_INCLUDEDIR}")

     

       67
       67
       -
        else()

     

       68
       68
       -
          string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" CLANG_VERSION ${PACKAGE_VERSION})

     

       69
       69
       -
          set(LIBOMP_HEADERS_INSTALL_PATH "${OPENMP_INSTALL_LIBDIR}/clang/${CLANG_VERSION}/include")

     

       70
       70
       -
        endif()

     

       71
       71
       -
        if(WIN32)

     

       72
       72
       -
       -  install(TARGETS omp RUNTIME DESTINATION bin)

     

       73
       73
       -
       +  install(TARGETS omp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

     

       74
       74
       -
          install(TARGETS ${LIBOMP_IMP_LIB_TARGET} ARCHIVE DESTINATION "${OPENMP_INSTALL_LIBDIR}")

     

       75
       75
       -
          # Create aliases (regular copies) of the library for backwards compatibility

     

       76
       76
       -
          set(LIBOMP_ALIASES "libiomp5md")

     

       77
       77
       -
       diff --git a/tools/multiplex/CMakeLists.txt b/tools/multiplex/CMakeLists.txt

     

       78
       78
       -
       index 64317c112176..4002784da736 100644

     

       79
       79
       -
       --- a/tools/multiplex/CMakeLists.txt

     

       80
       80
       -
       +++ b/tools/multiplex/CMakeLists.txt

     

       81
       81
       -
       @@ -4,7 +4,7 @@ if(LIBOMP_OMPT_SUPPORT)

     

       82
       82
       -
          add_library(ompt-multiplex INTERFACE)

     

       83
       83
       -
          target_include_directories(ompt-multiplex INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

     

       84
       84
       -
        

     

       85
       85
       -
       -  install(FILES ompt-multiplex.h DESTINATION include)

     

       86
       86
       -
       +  install(FILES ompt-multiplex.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

     

       87
       87
       -
        

     

       88
       88
       -
          add_subdirectory(tests)

     

       89
       89
       -
        endif()

+12

pkgs/development/compilers/llvm/git/openmp/run-lit-directly.patch

···

       1
       1
       +
       diff --git a/cmake/OpenMPTesting.cmake b/cmake/OpenMPTesting.cmake

     

       2
       2
       +
       --- a/cmake/OpenMPTesting.cmake

     

       3
       3
       +
       +++ b/cmake/OpenMPTesting.cmake

     

       4
       4
       +
       @@ -185,7 +185,7 @@ function(add_openmp_testsuite target comment)

     

       5
       5
       +
          if (${OPENMP_STANDALONE_BUILD})

     

       6
       6
       +
            set(LIT_ARGS ${OPENMP_LIT_ARGS} ${ARG_ARGS})

     

       7
       7
       +
            add_custom_target(${target}

     

       8
       8
       +
       -      COMMAND ${PYTHON_EXECUTABLE} ${OPENMP_LLVM_LIT_EXECUTABLE} ${LIT_ARGS} ${ARG_UNPARSED_ARGUMENTS}

     

       9
       9
       +
       +      COMMAND ${OPENMP_LLVM_LIT_EXECUTABLE} ${LIT_ARGS} ${ARG_UNPARSED_ARGUMENTS}

     

       10
       10
       +
              COMMENT ${comment}

     

       11
       11
       +
              DEPENDS ${ARG_DEPENDS}

     

       12
       12
       +
              USES_TERMINAL

+3 -5

pkgs/development/libraries/boxfort/default.nix

···

       1
       1
        
       { lib, stdenv, fetchFromGitHub, meson, ninja, python3Packages }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         version = "unstable-2019-10-09";

     

       5
       4
        
         pname = "boxfort";

     

       5
       5
       +
         version = "0.1.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "Snaipe";

     

       9
       9
        
           repo = "BoxFort";

     

       10
       10
       -
           rev = "356f047db08b7344ea7980576b705e65b9fc8772";

     

       11
       11
       -
           sha256 = "1p0llz7n0p5gzpvqszmra9p88vnr0j88sp5ixhgbfz89bswg62ss";

     

       10
       10
       +
           rev = "v${version}";

     

       11
       11
       +
           sha256 = "jmtWTOkOlqVZ7tFya3IrQjr714Y8TzAVY5Cq+RzDuRs=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ meson ninja ];

     
···

       29
       29
        
           license = licenses.mit;

     

       30
       30
        
           maintainers = with maintainers; [ thesola10 Yumasi ];

     

       31
       31
        
           platforms = platforms.unix;

     

       32
       32
       -
           # Upstream currently broken for macOS https://cirrus-ci.com/build/5624937369042944

     

       33
       33
       -
           broken = stdenv.targetPlatform.isDarwin;

     

       34
       32
        
         };

     

       35
       33
        
       }

+14 -7

pkgs/development/libraries/criterion/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, boxfort, cmake, libcsptr, pkg-config, gettext

     

       2
       2
       -
       , dyncall , nanomsg, python3Packages }:

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, boxfort, meson, libcsptr, pkg-config, gettext

     

       2
       2
       +
       , cmake, ninja, protobuf, libffi, libgit2, dyncall, nanomsg, nanopbMalloc

     

       3
       3
       +
       , python3Packages }:

     

       3
       4
        
       

     

       4
       5
        
       stdenv.mkDerivation rec {

     

       5
       5
       -
         version = "2.3.3";

     

       6
       6
        
         pname = "criterion";

     

       7
       7
       +
         version = "2.4.1";

     

       7
       8
        
       

     

       8
       9
        
         src = fetchFromGitHub {

     

       9
       10
        
           owner = "Snaipe";

     

       10
       11
        
           repo = "Criterion";

     

       11
       12
        
           rev = "v${version}";

     

       12
       12
       -
           sha256 = "0y1ay8is54k3y82vagdy0jsa3nfkczpvnqfcjm5n9iarayaxaq8p";

     

       13
       13
       +
           sha256 = "KT1XvhT9t07/ubsqzrVUp4iKcpVc1Z+saGF4pm2RsgQ=";

     

       13
       14
        
           fetchSubmodules = true;

     

       14
       15
        
         };

     

       15
       16
        
       

     

       16
       16
       -
         nativeBuildInputs = [ cmake pkg-config ];

     

       17
       17
       +
         nativeBuildInputs = [ meson ninja cmake pkg-config protobuf ];

     

       17
       18
        
       

     

       18
       19
        
         buildInputs = [

     

       19
       20
        
           boxfort.dev

     
···

       21
       22
        
           gettext

     

       22
       23
        
           libcsptr

     

       23
       24
        
           nanomsg

     

       25
       25
       +
           nanopbMalloc

     

       26
       26
       +
           libgit2

     

       27
       27
       +
           libffi

     

       24
       28
        
         ];

     

       25
       29
        
       

     

       26
       30
        
         checkInputs = with python3Packages; [ cram ];

     

       27
       31
        
       

     

       28
       28
       -
         cmakeFlags = [ "-DCTESTS=ON" ];

     

       29
       32
        
         doCheck = true;

     

       30
       30
       -
         checkTarget = "criterion_tests test";

     

       33
       33
       +
         checkTarget = "test";

     

       34
       34
       +
       

     

       35
       35
       +
         postPatch = ''

     

       36
       36
       +
           patchShebangs ci/isdir.py src/protocol/gen-pb.py

     

       37
       37
       +
         '';

     

       31
       38
        
       

     

       32
       39
        
         outputs = [ "dev" "out" ];

     

       33
       40

+2 -1

pkgs/development/libraries/nanopb/default.nix

···

       6
       6
        
       , python3

     

       7
       7
        
       , stdenv

     

       8
       8
        
       , buildPackages

     

       9
       9
       +
       , mallocBuild ? false

     

       9
       10
        
       }:

     

       10
       11
        
       

     

       11
       12
        
       stdenv.mkDerivation rec {

     
···

       27
       28
        
           "-DBUILD_SHARED_LIBS=ON" # generate $out/lib/libprotobuf-nanopb.so{.0,}

     

       28
       29
        
           "-DBUILD_STATIC_LIBS=ON" # generate $out/lib/libprotobuf-nanopb.a

     

       29
       30
        
           "-Dnanopb_PROTOC_PATH=${buildPackages.protobuf}/bin/protoc"

     

       30
       30
       -
         ];

     

       31
       31
       +
         ] ++ lib.optional mallocBuild "-DCMAKE_C_FLAGS=-DPB_ENABLE_MALLOC 1";

     

       31
       32
        
       

     

       32
       33
        
         postInstall = ''

     

       33
       34
        
           mkdir -p $out/share/nanopb/generator/proto

+2 -2

pkgs/development/python-modules/arc4/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage rec {

     

       9
       9
        
         pname = "arc4";

     

       10
       10
       -
         version = "0.2.0";

     

       10
       10
       +
         version = "0.3.0";

     

       11
       11
        
         format = "setuptools";

     

       12
       12
        
       

     

       13
       13
        
         disabled = pythonOlder "3.7";

     
···

       16
       16
        
           owner = "manicmaniac";

     

       17
       17
        
           repo = pname;

     

       18
       18
        
           rev = version;

     

       19
       19
       -
           hash = "sha256-1VgPYLyBQkxyuUO7KZv5sqYIEieV1RkBtlLVkLUUO4w=";

     

       19
       19
       +
           hash = "sha256-z8zj46/xX/gXtWzlmnHuAsnK3xYCL4NM5/xpYcH+Qlo=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         checkInputs = [

+2 -2

pkgs/development/python-modules/datasets/default.nix

···

       20
       20
        
       

     

       21
       21
        
       buildPythonPackage rec {

     

       22
       22
        
         pname = "datasets";

     

       23
       23
       -
         version = "2.3.2";

     

       23
       23
       +
         version = "2.4.0";

     

       24
       24
        
         format = "setuptools";

     

       25
       25
        
       

     

       26
       26
        
         disabled = pythonOlder "3.7";

     
···

       29
       29
        
           owner = "huggingface";

     

       30
       30
        
           repo = pname;

     

       31
       31
        
           rev = "refs/tags/${version}";

     

       32
       32
       -
           hash = "sha256-VBYCDEOK5KyYuvlybr37LgOchlEUAl/aqiC+J6WQbSA=";

     

       32
       32
       +
           hash = "sha256-1XdOcZjqtpQV5RgkCBwg+Ql5lUzUspgveoV8P/PBmII=";

     

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         postPatch = ''

+46

pkgs/development/python-modules/dinghy/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , pytestCheckHook

     

       5
       5
       +
       , aiofiles

     

       6
       6
       +
       , aiohttp

     

       7
       7
       +
       , click-log

     

       8
       8
       +
       , emoji

     

       9
       9
       +
       , glom

     

       10
       10
       +
       , jinja2

     

       11
       11
       +
       , pyyaml

     

       12
       12
       +
       }:

     

       13
       13
       +
       

     

       14
       14
       +
       buildPythonPackage rec {

     

       15
       15
       +
         pname = "dinghy";

     

       16
       16
       +
         version = "0.13.2";

     

       17
       17
       +
         format = "setuptools";

     

       18
       18
       +
       

     

       19
       19
       +
         src = fetchFromGitHub {

     

       20
       20
       +
           owner = "nedbat";

     

       21
       21
       +
           repo = pname;

     

       22
       22
       +
           rev = version;

     

       23
       23
       +
           sha256 = "sha256-uRiWcrs3xIb6zxNg0d6/+NCqnEgadHSTLpS53CoZ5so=";

     

       24
       24
       +
         };

     

       25
       25
       +
       

     

       26
       26
       +
         propagatedBuildInputs = [

     

       27
       27
       +
           aiofiles

     

       28
       28
       +
           aiohttp

     

       29
       29
       +
           click-log

     

       30
       30
       +
           emoji

     

       31
       31
       +
           glom

     

       32
       32
       +
           jinja2

     

       33
       33
       +
           pyyaml

     

       34
       34
       +
         ];

     

       35
       35
       +
       

     

       36
       36
       +
         checkInputs = [ pytestCheckHook ];

     

       37
       37
       +
       

     

       38
       38
       +
         pythonImportsCheck = [ "dinghy.cli" ];

     

       39
       39
       +
       

     

       40
       40
       +
         meta = with lib; {

     

       41
       41
       +
           description = "A GitHub activity digest tool";

     

       42
       42
       +
           homepage = "https://github.com/nedbat/dinghy";

     

       43
       43
       +
           license = licenses.asl20;

     

       44
       44
       +
           maintainers = with maintainers; [ trundle veehaitch ];

     

       45
       45
       +
         };

     

       46
       46
       +
       }

+19 -7

pkgs/development/python-modules/duckdb-engine/default.nix

···

       13
       13
        
       

     

       14
       14
        
       buildPythonPackage rec {

     

       15
       15
        
         pname = "duckdb-engine";

     

       16
       16
       -
         version = "0.2.0";

     

       16
       16
       +
         version = "0.5.0";

     

       17
       17
        
         format = "pyproject";

     

       18
       18
        
       

     

       19
       19
        
         disabled = pythonOlder "3.7";

     
···

       22
       22
        
           repo = "duckdb_engine";

     

       23
       23
        
           owner = "Mause";

     

       24
       24
        
           rev = "refs/tags/v${version}";

     

       25
       25
       -
           hash = "sha256-UoTGFsno92iejBGvCsJ/jnhKJ41K9eTGwC7DomAp7IE=";

     

       25
       25
       +
           hash = "sha256-6bR2pt7gUHZu4I7VmJgVsFT9u3/e4c9RAKHHlbX/Tyk=";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
       -
         nativeBuildInputs = [ poetry-core ];

     

       28
       28
       +
         nativeBuildInputs = [

     

       29
       29
       +
           poetry-core

     

       30
       30
       +
         ];

     

       29
       31
        
       

     

       30
       30
       -
         propagatedBuildInputs = [ duckdb sqlalchemy ];

     

       32
       32
       +
         propagatedBuildInputs = [

     

       33
       33
       +
           duckdb

     

       34
       34
       +
           sqlalchemy

     

       35
       35
       +
         ];

     

       31
       36
        
       

     

       32
       32
       -
         checkInputs = [ pytestCheckHook hypothesis ipython-sql typing-extensions ];

     

       37
       37
       +
         checkInputs = [

     

       38
       38
       +
           pytestCheckHook

     

       39
       39
       +
           hypothesis

     

       40
       40
       +
           ipython-sql

     

       41
       41
       +
           typing-extensions

     

       42
       42
       +
         ];

     

       33
       43
        
       

     

       34
       34
       -
         pythonImportsCheck = [ "duckdb_engine" ];

     

       44
       44
       +
         pythonImportsCheck = [

     

       45
       45
       +
           "duckdb_engine"

     

       46
       46
       +
         ];

     

       35
       47
        
       

     

       36
       48
        
         meta = with lib; {

     

       37
       37
       -
           description = "Very very very basic sqlalchemy driver for duckdb";

     

       49
       49
       +
           description = "SQLAlchemy driver for duckdb";

     

       38
       50
        
           homepage = "https://github.com/Mause/duckdb_engine";

     

       39
       51
        
           license = licenses.mit;

     

       40
       52
        
           maintainers = with maintainers; [ cpcloud ];

+2 -2

pkgs/development/python-modules/envisage/default.nix

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "envisage";

     

       15
       15
       -
         version = "6.0.1";

     

       15
       15
       +
         version = "6.1.0";

     

       16
       16
        
         format = "setuptools";

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.6";

     

       19
       19
        
       

     

       20
       20
        
         src = fetchPypi {

     

       21
       21
        
           inherit pname version;

     

       22
       22
       -
           sha256 = "8864c29aa344f7ac26eeb94788798f2d0cc791dcf95c632da8d79ebc580e114c";

     

       22
       22
       +
           sha256 = "sha256-AATsUNcYLB4vtyvuooAMDZx8p5fayijb6yJoUKTCW40=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         # for the optional dependency ipykernel, only versions < 6 are

+2 -2

pkgs/development/python-modules/peaqevcore/default.nix

···

       6
       6
        
       

     

       7
       7
        
       buildPythonPackage rec {

     

       8
       8
        
         pname = "peaqevcore";

     

       9
       9
       -
         version = "5.10.3";

     

       9
       9
       +
         version = "5.10.5";

     

       10
       10
        
         format = "setuptools";

     

       11
       11
        
       

     

       12
       12
        
         disabled = pythonOlder "3.7";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchPypi {

     

       15
       15
        
           inherit pname version;

     

       16
       16
       -
           hash = "sha256-Ua3yDPxZEa4F66knhSfu4hxCNVJTUy/4BO/+a8GqOB0=";

     

       16
       16
       +
           hash = "sha256-rW9QWbnG1sURiWNYxYuACqK3kGS7hIjswcwR5cVwwVg=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         postPatch = ''

+15 -7

pkgs/development/python-modules/sphinx-argparse/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchPypi

     

       4
       4
       -
       , pytest

     

       4
       4
       +
       , pytestCheckHook

     

       5
       5
        
       , sphinx

     

       6
       6
        
       }:

     

       7
       7
        
       

     
···

       14
       14
        
           sha256 = "82151cbd43ccec94a1530155f4ad34f251aaca6a0ffd5516d7fadf952d32dc1e";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         checkInputs = [

     

       18
       18
       -
           pytest

     

       19
       19
       -
         ];

     

       20
       20
       -
       

     

       21
       21
       -
         checkPhase = "py.test";

     

       17
       17
       +
         postPatch = ''

     

       18
       18
       +
           # Fix tests for python-3.10 and add 3.10 to CI matrix

     

       19
       19
       +
           # Should be fixed in versions > 0.3.1

     

       20
       20
       +
           # https://github.com/ashb/sphinx-argparse/pull/3

     

       21
       21
       +
           substituteInPlace sphinxarg/parser.py \

     

       22
       22
       +
             --replace "if action_group.title == 'optional arguments':" "if action_group.title == 'optional arguments' or action_group.title == 'options':"

     

       23
       23
       +
         '';

     

       22
       24
        
       

     

       23
       25
        
         propagatedBuildInputs = [

     

       24
       26
        
           sphinx

     

       25
       27
        
         ];

     

       26
       28
        
       

     

       29
       29
       +
         checkInputs = [

     

       30
       30
       +
           pytestCheckHook

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         pythonImportsCheck = [ "sphinxarg" ];

     

       34
       34
       +
       

     

       27
       35
        
         meta = {

     

       28
       36
        
           description = "A sphinx extension that automatically documents argparse commands and options";

     

       29
       29
       -
           homepage = "https://github.com/ribozz/sphinx-argparse";

     

       37
       37
       +
           homepage = "https://github.com/ashb/sphinx-argparse";

     

       30
       38
        
           license = lib.licenses.mit;

     

       31
       39
        
           maintainers = with lib.maintainers; [ clacke ];

     

       32
       40
        
         };

+18 -6

pkgs/development/python-modules/superqt/default.nix

···

       5
       5
        
       , pyqt5

     

       6
       6
        
       , qtpy

     

       7
       7
        
       , typing-extensions

     

       8
       8
       -
       , pytest

     

       9
       8
        
       , pytestCheckHook

     

       9
       9
       +
       , pygments

     

       10
       10
        
       }:

     

       11
       11
        
       

     

       12
       12
        
       buildPythonPackage rec {

     

       13
       13
        
         pname = "superqt";

     

       14
       14
       -
         version = "0.3.3";

     

       14
       14
       +
         version = "0.3.5";

     

       15
       15
       +
         format = "pyproject";

     

       15
       16
        
       

     

       16
       17
        
         src = fetchFromGitHub {

     

       17
       18
        
           owner = "napari";

     

       18
       19
        
           repo = pname;

     

       19
       20
        
           rev = "refs/tags/v${version}";

     

       20
       20
       -
           sha256 = "sha256-Ns3AFUL0BReIwTHfrlfXr/2GLtLvT7hfSjjh+r7btcY=";

     

       21
       21
       +
           sha256 = "sha256-nKNFV/mzdugQ+UJ/qB0SkCSm5vEpvI/tgHYKJr6NEyg=";

     

       21
       22
        
         };

     

       22
       22
       -
         format = "pyproject";

     

       23
       23
       +
       

     

       23
       24
        
         nativeBuildInputs = [ setuptools-scm ];

     

       24
       24
       -
         propagatedBuildInputs = [ pyqt5 qtpy typing-extensions ];

     

       25
       25
       -
         checkInputs = [ pytestCheckHook pytest ];

     

       25
       25
       +
       

     

       26
       26
       +
         propagatedBuildInputs = [

     

       27
       27
       +
           pyqt5

     

       28
       28
       +
           qtpy

     

       29
       29
       +
           typing-extensions

     

       30
       30
       +
           pygments

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         checkInputs = [ pytestCheckHook ];

     

       34
       34
       +
       

     

       26
       35
        
         doCheck = false; # Segfaults...

     

       36
       36
       +
       

     

       37
       37
       +
         pythonImportsCheck = [ "superqt" ];

     

       38
       38
       +
       

     

       27
       39
        
         SETUPTOOLS_SCM_PRETEND_VERSION = version;

     

       28
       40
        
       

     

       29
       41
        
         meta = with lib; {

+3 -3

pkgs/development/tools/analysis/flow/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "flow";

     

       5
       5
       -
         version = "0.183.1";

     

       5
       5
       +
         version = "0.185.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "facebook";

     

       9
       9
        
           repo = "flow";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-RaME+vbmF/hDjwB/ZdvL+/ZgLtWeETMpi/xBlK1EvA0=";

     

       11
       11
       +
           sha256 = "sha256-GZ1DzMlhwIyQtkNYXU6sLoqRNinOXN+A7ImkaNSGuJY=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         makeFlags = [ "FLOW_RELEASE=1" ];

     
···

       18
       18
        
           install -Dm644 resources/shell/bash-completion $out/share/bash-completion/completions/flow

     

       19
       19
        
         '';

     

       20
       20
        
       

     

       21
       21
       -
         buildInputs = (with ocamlPackages; [ ocaml findlib ocamlbuild ocaml-migrate-parsetree-2 dtoa core_kernel sedlex ocaml_lwt lwt_log lwt_ppx ppx_deriving ppx_gen_rec visitors wtf8 ])

     

       21
       21
       +
         buildInputs = (with ocamlPackages; [ ocaml findlib ocamlbuild ocaml-migrate-parsetree-2 dtoa fileutils core_kernel sedlex ocaml_lwt lwt_log lwt_ppx ppx_deriving ppx_gen_rec visitors wtf8 ])

     

       22
       22
        
           ++ lib.optionals stdenv.isDarwin [ CoreServices ];

     

       23
       23
        
       

     

       24
       24
        
         meta = with lib; {

+3 -3

pkgs/development/tools/godot/default.nix

···

       81
       81
        
           mkdir -p "$out/bin"

     

       82
       82
        
           cp bin/godot.* $out/bin/godot

     

       83
       83
        
       

     

       84
       84
       +
           wrapProgram "$out/bin/godot" \

     

       85
       85
       +
             --set ALSA_PLUGIN_DIR ${alsa-plugins}/lib/alsa-lib

     

       86
       86
       +
       

     

       84
       87
        
           mkdir "$dev"

     

       85
       88
        
           cp -r modules/gdnative/include $dev

     

       86
       89
        
       

     
···

       93
       96
        
           cp icon.png "$out/share/icons/godot.png"

     

       94
       97
        
           substituteInPlace "$out/share/applications/org.godotengine.Godot.desktop" \

     

       95
       98
        
             --replace "Exec=godot" "Exec=$out/bin/godot"

     

       96
       96
       -
       

     

       97
       97
       -
           makeWrapper $out/bin/godot $out/bin/godot \

     

       98
       98
       -
             --set ALSA_PLUGIN_DIR ${alsa-plugins}/lib/alsa-lib

     

       99
       99
        
         '';

     

       100
       100
        
       

     

       101
       101
        
         meta = with lib; {

+4 -4

pkgs/development/tools/rgp/default.nix

···

       19
       19
        
       }:

     

       20
       20
        
       

     

       21
       21
        
       let

     

       22
       22
       -
         buildNum = "2022-04-20-920";

     

       22
       22
       +
         buildNum = "2022-08-01-115";

     

       23
       23
        
       in

     

       24
       24
        
       stdenv.mkDerivation rec {

     

       25
       25
        
         pname = "rgp";

     

       26
       26
       -
         version = "1.13";

     

       26
       26
       +
         version = "1.13.1";

     

       27
       27
        
       

     

       28
       28
        
         src = fetchurl {

     

       29
       29
        
           url = "https://gpuopen.com/download/radeon-developer-tool-suite/RadeonDeveloperToolSuite-${buildNum}.tgz";

     

       30
       30
       -
           hash = "sha256-/Z7mSZVAvaTAY9RU7suK/gA0RJIeeLdN6LWiseVq9Js=";

     

       30
       30
       +
           hash = "sha256-e88vk+ZtDPB/1HrDKXbzkDaMESNE+qIW7ERwrqe+ZN8=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
        
         nativeBuildInputs = [ makeWrapper autoPatchelfHook ];

     
···

       57
       57
        
           chmod +x $out/opt/rgp/scripts/*

     

       58
       58
        
           patchShebangs $out/opt/rgp/scripts

     

       59
       59
        
       

     

       60
       60
       -
           for prog in RadeonDeveloperPanel RadeonDeveloperService RadeonDeveloperServiceCLI RadeonGPUAnalyzer RadeonGPUProfiler rga rtda; do

     

       60
       60
       +
           for prog in RadeonDeveloperPanel RadeonDeveloperService RadeonDeveloperServiceCLI RadeonGPUAnalyzer RadeonGPUProfiler RadeonMemoryVisualizer RadeonRaytracingAnalyzer rga rtda; do

     

       61
       61
        
             # makeWrapper is needed so that executables are started from the opt

     

       62
       62
        
             # directory, where qt.conf and other tools are

     

       63
       63
        
             makeWrapper \

+3 -3

pkgs/development/tools/rust/cargo-public-api/default.nix

···

       8
       8
        
       

     

       9
       9
        
       rustPlatform.buildRustPackage rec {

     

       10
       10
        
         pname = "cargo-public-api";

     

       11
       11
       -
         version = "0.13.0";

     

       11
       11
       +
         version = "0.14.0";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchCrate {

     

       14
       14
        
           inherit pname version;

     

       15
       15
       -
           sha256 = "sha256-e+HM4pO0bLszlcSklsiRPamr/GUVckuw7uBSgDSK7d0=";

     

       15
       15
       +
           sha256 = "sha256-OFWmrwZdyvIhyKsWEfaU7wHIqeuNhjwZQkwKTccBnTI=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         cargoSha256 = "sha256-RKO/YMVWKVtparAfDUtpQ3mbRWataNnjnFUUQozQghs=";

     

       18
       18
       +
         cargoSha256 = "sha256-nubWXEG8XmX2t7WsNvbcDpub5H1x5467cSFRvs8PEpQ=";

     

       19
       19
        
       

     

       20
       20
        
         nativeBuildInputs = [ pkg-config ];

     

       21
       21

+59 -15

pkgs/os-specific/linux/kernel/manual-config.nix

···

       59
       59
        
           ++ optional (lib.versionAtLeast version "4.14") libelf

     

       60
       60
        
           ++ optional (lib.versionAtLeast version "5.13") zstd;

     

       61
       61
        
       

     

       62
       62
       -
       

     

       63
       63
       -
         installkernel = buildPackages.writeShellScript "installkernel" ''

     

       64
       64
       -
           set -e

     

       65
       65
       -
           mkdir -p $4

     

       66
       66
       -
           cp -av $2 $4

     

       67
       67
       -
           cp -av $3 $4

     

       68
       68
       -
         '';

     

       69
       69
       -
       

     

       70
       62
        
         drvAttrs = config_: kernelConf: kernelPatches: configfile:

     

       71
       63
        
           let

     

       72
       64
        
             config = let attrName = attr: "CONFIG_" + attr; in {

     
···

       114
       106
        
               ++ optional (lib.versionAtLeast version "5.2" && lib.versionOlder version "5.4") ./gen-kheaders-metadata.patch;

     

       115
       107
        
       

     

       116
       108
        
             prePatch = ''

     

       117
       117
       -
               for mf in $(find -name Makefile -o -name Makefile.include -o -name install.sh); do

     

       118
       118
       -
                   echo "stripping FHS paths in \`$mf'..."

     

       119
       119
       -
                   sed -i "$mf" -e 's|/usr/bin/||g ; s|/bin/||g ; s|/sbin/||g'

     

       120
       120
       -
               done

     

       121
       109
        
               sed -i Makefile -e 's|= depmod|= ${buildPackages.kmod}/bin/depmod|'

     

       122
       110
        
       

     

       123
       111
        
               # Don't include a (random) NT_GNU_BUILD_ID, to make the build more deterministic.

     
···

       146
       134
        
               fi

     

       147
       135
        
       

     

       148
       136
        
               patchShebangs scripts

     

       137
       137
       +
       

     

       138
       138
       +
               # also patch arch-specific install scripts

     

       139
       139
       +
               for i in $(find arch -name install.sh); do

     

       140
       140
       +
                   patchShebangs "$i"

     

       141
       141
       +
               done

     

       149
       142
        
             '';

     

       150
       143
        
       

     

       151
       144
        
             configurePhase = ''

     
···

       185
       178
        
               kernelConf.target

     

       186
       179
        
               "vmlinux"  # for "perf" and things like that

     

       187
       180
        
             ] ++ optional isModular "modules"

     

       188
       188
       -
               ++ optional buildDTBs "dtbs"

     

       181
       181
       +
               ++ optionals buildDTBs ["dtbs" "DTC_FLAGS=-@"]

     

       189
       182
        
             ++ extraMakeFlags;

     

       190
       183
        
       

     

       191
       184
        
             installFlags = [

     

       192
       192
       -
               "INSTALLKERNEL=${installkernel}"

     

       193
       185
        
               "INSTALL_PATH=$(out)"

     

       194
       186
        
             ] ++ (optional isModular "INSTALL_MOD_PATH=$(out)")

     

       195
       187
        
             ++ optional installsFirmware "INSTALL_FW_PATH=$(out)/lib/firmware"

     

       196
       188
        
             ++ optionals buildDTBs ["dtbs_install" "INSTALL_DTBS_PATH=$(out)/dtbs"];

     

       197
       189
        
       

     

       198
       198
       -
             preInstall = ''

     

       190
       190
       +
             preInstall = let

     

       191
       191
       +
               # All we really need to do here is copy the final image and System.map to $out,

     

       192
       192
       +
               # and use the kernel's modules_install, firmware_install, dtbs_install, etc. targets

     

       193
       193
       +
               # for the rest. Easy, right?

     

       194
       194
       +
               #

     

       195
       195
       +
               # Unfortunately for us, the obvious way of getting the built image path,

     

       196
       196
       +
               # make -s image_name, does not work correctly, because some architectures

     

       197
       197
       +
               # (*cough* aarch64 *cough*) change KBUILD_IMAGE on the fly in their install targets,

     

       198
       198
       +
               # so we end up attempting to install the thing we didn't actually build.

     

       199
       199
       +
               #

     

       200
       200
       +
               # Thankfully, there's a way out that doesn't involve just hardcoding everything.

     

       201
       201
       +
               #

     

       202
       202
       +
               # The kernel has an install target, which runs a pretty simple shell script

     

       203
       203
       +
               # (located at scripts/install.sh or arch/$arch/boot/install.sh, depending on

     

       204
       204
       +
               # which kernel version you're looking at) that tries to do something sensible.

     

       205
       205
       +
               #

     

       206
       206
       +
               # (it would be great to hijack this script immediately, as it has all the

     

       207
       207
       +
               #   information we need passed to it and we don't need it to try and be smart,

     

       208
       208
       +
               #   but unfortunately, the exact location of the scripts differs between kernel

     

       209
       209
       +
               #   versions, and they're seemingly not considered to be public API at all)

     

       210
       210
       +
               #

     

       211
       211
       +
               # One of the ways it tries to discover what "something sensible" actually is

     

       212
       212
       +
               # is by delegating to what's supposed to be a user-provided install script

     

       213
       213
       +
               # located at ~/bin/installkernel.

     

       214
       214
       +
               #

     

       215
       215
       +
               # (the other options are:

     

       216
       216
       +
               #   - a distribution-specific script at /sbin/installkernel,

     

       217
       217
       +
               #        which we can't really create in the sandbox easily

     

       218
       218
       +
               #   - an architecture-specific script at arch/$arch/boot/install.sh,

     

       219
       219
       +
               #        which attempts to guess _something_ and usually guesses very wrong)

     

       220
       220
       +
               #

     

       221
       221
       +
               # More specifically, the install script exec's into ~/bin/installkernel, if one

     

       222
       222
       +
               # exists, with the following arguments:

     

       223
       223
       +
               #

     

       224
       224
       +
               # $1: $KERNELRELEASE - full kernel version string

     

       225
       225
       +
               # $2: $KBUILD_IMAGE - the final image path

     

       226
       226
       +
               # $3: System.map - path to System.map file, seemingly hardcoded everywhere

     

       227
       227
       +
               # $4: $INSTALL_PATH - path to the destination directory as specified in installFlags

     

       228
       228
       +
               #

     

       229
       229
       +
               # $2 is exactly what we want, so hijack the script and use the knowledge given to it

     

       230
       230
       +
               # by the makefile overlords for our own nefarious ends.

     

       231
       231
       +
               #

     

       232
       232
       +
               # Note that the makefiles specifically look in ~/bin/installkernel, and

     

       233
       233
       +
               # writeShellScriptBin writes the script to <store path>/bin/installkernel,

     

       234
       234
       +
               # so HOME needs to be set to just the store path.

     

       235
       235
       +
               #

     

       236
       236
       +
               # FIXME: figure out a less roundabout way of doing this.

     

       237
       237
       +
               installkernel = buildPackages.writeShellScriptBin "installkernel" ''

     

       238
       238
       +
                 cp -av $2 $4

     

       239
       239
       +
                 cp -av $3 $4

     

       240
       240
       +
               '';

     

       241
       241
       +
             in ''

     

       199
       242
        
               installFlagsArray+=("-j$NIX_BUILD_CORES")

     

       243
       243
       +
               export HOME=${installkernel}

     

       200
       244
        
             '';

     

       201
       245
        
       

     

       202
       246
        
             # Some image types need special install targets (e.g. uImage is installed with make uinstall)

+24 -7

pkgs/servers/dns/https-dns-proxy/default.nix

···

       1
       1
        
       { lib, stdenv, fetchFromGitHub, cmake, gtest, c-ares, curl, libev }:

     

       2
       2
        
       

     

       3
       3
       +
       let

     

       4
       4
       +
         # https-dns-proxy supports HTTP3 if curl has support, but as of 2022-08 curl doesn't work with that enabled

     

       5
       5
       +
         # curl' = (curl.override { http3Support = true; });

     

       6
       6
       +
         curl' = curl;

     

       7
       7
       +
       

     

       8
       8
       +
       in

     

       3
       9
        
       stdenv.mkDerivation rec {

     

       4
       10
        
         pname = "https-dns-proxy";

     

       5
       11
        
         # there are no stable releases (yet?)

     

       6
       6
       -
         version = "unstable-2021-03-29";

     

       12
       12
       +
         version = "unstable-2022-05-05";

     

       7
       13
        
       

     

       8
       14
        
         src = fetchFromGitHub {

     

       9
       15
        
           owner = "aarond10";

     

       10
       16
        
           repo = "https_dns_proxy";

     

       11
       11
       -
           rev = "bbd9ef272dcda3ead515871f594768af13192af7";

     

       12
       12
       -
           sha256 = "sha256-r+IpDklI3vITK8ZlZvIFm3JdDe2r8DK2ND3n1a/ThrM=";

     

       17
       17
       +
           rev = "d310a378795790350703673388821558163944de";

     

       18
       18
       +
           hash = "sha256-On4SKUeltPhzM/x+K9aKciKBw5lmVySxnmLi2tnKr3Y=";

     

       13
       19
        
         };

     

       14
       20
        
       

     

       21
       21
       +
         postPatch = ''

     

       22
       22
       +
           substituteInPlace https_dns_proxy.service.in \

     

       23
       23
       +
             --replace "\''${CMAKE_INSTALL_PREFIX}/" ""

     

       24
       24
       +
           substituteInPlace munin/https_dns_proxy.plugin \

     

       25
       25
       +
             --replace '--unit https_dns_proxy.service' '--unit https-dns-proxy.service'

     

       26
       26
       +
         '';

     

       27
       27
       +
       

     

       15
       28
        
         nativeBuildInputs = [ cmake gtest ];

     

       16
       29
        
       

     

       17
       17
       -
         buildInputs = [ c-ares curl libev ];

     

       30
       30
       +
         buildInputs = [ c-ares curl' libev ];

     

       18
       31
        
       

     

       19
       19
       -
         installPhase = ''

     

       20
       20
       -
           install -Dm555 -t $out/bin https_dns_proxy

     

       21
       21
       -
           install -Dm444 -t $out/share/doc/${pname} ../{LICENSE,README}.*

     

       32
       32
       +
         postInstall = ''

     

       33
       33
       +
           install -Dm444 -t $out/share/doc/${pname} ../{LICENSE,*.md}

     

       34
       34
       +
           install -Dm444 -t $out/share/${pname}/munin ../munin/*

     

       35
       35
       +
           # the systemd service definition is garbage, and we use our own with NixOS

     

       36
       36
       +
           mv $out/lib/systemd $out/share/${pname}

     

       37
       37
       +
           rmdir $out/lib

     

       22
       38
        
         '';

     

       23
       39
        
       

     

       24
       40
        
         # upstream wants to add tests and the gtest framework is in place, so be ready

     
···

       30
       46
        
           license = licenses.mit;

     

       31
       47
        
           maintainers = with maintainers; [ peterhoeg ];

     

       32
       48
        
           platforms = platforms.linux;

     

       49
       49
       +
           mainProgram = "https_dns_proxy";

     

       33
       50
        
         };

     

       34
       51
        
       }

+2 -2

pkgs/servers/jellyfin/default.nix

···

       29
       29
        
       in

     

       30
       30
        
       buildDotnetModule rec {

     

       31
       31
        
         pname = "jellyfin";

     

       32
       32
       -
         version = "10.8.3"; # ensure that jellyfin-web has matching version

     

       32
       32
       +
         version = "10.8.4"; # ensure that jellyfin-web has matching version

     

       33
       33
        
       

     

       34
       34
        
         src = fetchFromGitHub {

     

       35
       35
        
           owner = "jellyfin";

     

       36
       36
        
           repo = "jellyfin";

     

       37
       37
        
           rev = "v${version}";

     

       38
       38
       -
           sha256 = "QVpmHhVR4+UbVz5m92g5VcpcxVz1/9MNll2YN7ZnNHw=";

     

       38
       38
       +
           sha256 = "dzaySywQ43Vdj0GUGjpKaSgsu5Zu0SKyoOCYHAfp/v8=";

     

       39
       39
        
         };

     

       40
       40
        
       

     

       41
       41
        
         patches = [

+2 -2

pkgs/servers/jellyfin/node-deps.nix

···

       11817
       11817
        
         args = {

     

       11818
       11818
        
           name = "jellyfin-web";

     

       11819
       11819
        
           packageName = "jellyfin-web";

     

       11820
       11820
       -
           version = "10.8.3";

     

       11821
       11821
       -
           src = ../../../../../../../nix/store/d2926w8z62c6p0v09x8mhq0r9g1x354w-source;

     

       11820
       11820
       +
           version = "10.8.4";

     

       11821
       11821
       +
           src = ../../../../../../../nix/store/xhax6fynqk44hhwd647im3jd31dbaw4n-source;

     

       11822
       11822
        
           dependencies = [

     

       11823
       11823
        
             sources."@ampproject/remapping-2.1.2"

     

       11824
       11824
        
             (sources."@apideck/better-ajv-errors-0.3.3" // {

+16 -16

pkgs/servers/jellyfin/nuget-deps.nix

···

       14
       14
        
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "6.0.6"; sha256 = "1fv3xvqc98l3ma4s8f2g4fklifbj1i24fngcvlhfm4j6s295xjj1"; })

     

       15
       15
        
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "6.0.6"; sha256 = "1z50gqg0jimk98yd0zr2vxn087h3h1qn08fdcqbaxfgpcw30yi87"; })

     

       16
       16
        
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "6.0.6"; sha256 = "0ndah9cqkgswhi60wrnni10j1d2hdg8jljij83lk1wbfqbng86jm"; })

     

       17
       17
       -
         (fetchNuGet { pname = "Microsoft.AspNetCore.Authorization"; version = "6.0.7"; sha256 = "0ib35ikrdcfq49jgqp595r9k061b8pmizx5cxkggw71j5rpiswp1"; })

     

       18
       18
       -
         (fetchNuGet { pname = "Microsoft.AspNetCore.Metadata"; version = "6.0.7"; sha256 = "132lij9fkpim2vckm20kvwlqv8apjd4hr43mh09amk2pblih872q"; })

     

       17
       17
       +
         (fetchNuGet { pname = "Microsoft.AspNetCore.Authorization"; version = "6.0.8"; sha256 = "0lyqamnvhgmk818sv4n9162vri5ysr3lyfai60zpk3kjlqz34j09"; })

     

       18
       18
       +
         (fetchNuGet { pname = "Microsoft.AspNetCore.Metadata"; version = "6.0.8"; sha256 = "065mdy88ybiavjxfq2nlx5zsrlyyqga1nbhgddag4q4f49jfc45b"; })

     

       19
       19
        
         (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "6.0.0"; sha256 = "15gqy2m14fdlvy1g59207h5kisznm355kbw010gy19vh47z8gpz3"; })

     

       20
       20
        
         (fetchNuGet { pname = "Microsoft.Build.Tasks.Git"; version = "1.1.1"; sha256 = "1bb5p4zlnfn88skkvymxfsn0jybqncl4356hwnic9jxdq2d4fz1w"; })

     

       21
       21
        
         (fetchNuGet { pname = "Microsoft.CodeAnalysis.BannedApiAnalyzers"; version = "3.3.3"; sha256 = "1z6x0d8lpcfjr3sxy25493i17vvcg5bsay6c03qan6mnj5aqzw2k"; })

     

       22
       22
        
         (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.0.1"; sha256 = "0zxc0apx1gcx361jlq8smc9pfdgmyjh6hpka8dypc9w23nlsh6yj"; })

     

       23
       23
       -
         (fetchNuGet { pname = "Microsoft.Data.Sqlite.Core"; version = "6.0.7"; sha256 = "0r5njqyl10dv0akwl5y32ik0rpzs9lwj151j6ayz358pn4x26akk"; })

     

       24
       24
       -
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore"; version = "6.0.7"; sha256 = "1wcjjn70v8cyy5flga0nlnhg973s6pzb3rpnzv905ix3g70zdp4k"; })

     

       25
       25
       -
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Abstractions"; version = "6.0.7"; sha256 = "0xhkh9k3xpgjdsizg1wdncwz4rdjvffq3x0sfcarscmg2j5fa4yj"; })

     

       26
       26
       -
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Analyzers"; version = "6.0.7"; sha256 = "0fdh0w5c51kkpvh1p5f0dn90kikh3zdyc1k4hjvv1z8kr603nd1b"; })

     

       27
       27
       -
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Design"; version = "6.0.7"; sha256 = "0mdb2gqmb94sw38cpqm972vdhh88n7q81xhq4gq771hp2wspn5ap"; })

     

       28
       28
       -
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Relational"; version = "6.0.7"; sha256 = "1kx0ac7jgf8nmp5nra4cd6h2xbwvb3zkyzx7cds60y1j9nm7lx1g"; })

     

       29
       29
       -
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Sqlite"; version = "6.0.7"; sha256 = "1mam4qg6yq6qnlkx3i45gs3nwgd7njfm9r5gjs1p9wm6bm953dad"; })

     

       30
       30
       -
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Sqlite.Core"; version = "6.0.7"; sha256 = "15l36dgq6rzvgx7i9g9jm3298p9g1pdahwa2dxblmm0gzsp65wpl"; })

     

       31
       31
       -
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Tools"; version = "6.0.7"; sha256 = "1sp693z0x7crbficpl2s0y06pz0c39mbbj9as8y6bln7bx8khymy"; })

     

       23
       23
       +
         (fetchNuGet { pname = "Microsoft.Data.Sqlite.Core"; version = "6.0.8"; sha256 = "1q3rp78yni4mj8bgr5dg1s99mg0dh3rd2ha4f29vfhvp9gps5khi"; })

     

       24
       24
       +
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore"; version = "6.0.8"; sha256 = "1lacqr6mj655vdqrg7pna3a00nzkr5z1c2ddz4l0m28lsfyb7390"; })

     

       25
       25
       +
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Abstractions"; version = "6.0.8"; sha256 = "1nx66ygn3xs14raa51zhb6a1g58vq4r5b7vm1y5gw7995bcgdgha"; })

     

       26
       26
       +
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Analyzers"; version = "6.0.8"; sha256 = "1f934bynjb7k2bfdmsslbnvg2gdrr7n1789pk4sglj41raaxdlvl"; })

     

       27
       27
       +
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Design"; version = "6.0.8"; sha256 = "1sb8qkfkghn3bw21rlnb2gpban7gzs293qps7d2qdxs64nnbjcq7"; })

     

       28
       28
       +
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Relational"; version = "6.0.8"; sha256 = "1qbi5srbgl6y70gq3cdy4qfpw0b5wk447jd353xqgblj0nhpqaxn"; })

     

       29
       29
       +
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Sqlite"; version = "6.0.8"; sha256 = "19z7w26ksq553x47b0p3qxiib5yz4cfkjdqimb855cly55117jyy"; })

     

       30
       30
       +
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Sqlite.Core"; version = "6.0.8"; sha256 = "1bnim9p7qv3p2fg0ajkbkbvi8jnbam70hd49shgp0a38y0j6dhd4"; })

     

       31
       31
       +
         (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Tools"; version = "6.0.8"; sha256 = "1rh69cxchvxnmwkdjm6ffvfivbk3lbg2ahjp7pd1f40dicxf7rvd"; })

     

       32
       32
        
         (fetchNuGet { pname = "Microsoft.Extensions.ApiDescription.Server"; version = "3.0.0"; sha256 = "13a47xcqyi5gz85swxd4mgp7ndgl4kknrvv3xwmbn71hsh953hsh"; })

     

       33
       33
        
         (fetchNuGet { pname = "Microsoft.Extensions.Caching.Abstractions"; version = "6.0.0"; sha256 = "0qn30d3pg4rx1x2k525jj4x5g1fxm2v5m0ksz2dmk1gmqalpask8"; })

     

       34
       34
        
         (fetchNuGet { pname = "Microsoft.Extensions.Caching.Memory"; version = "6.0.1"; sha256 = "0ra0ldbg09r40jzvfqhpb3h42h80nafvka9hg51dja32k3mxn5gk"; })

     
···

       55
       55
        
         (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "6.0.0"; sha256 = "1vi67fw7q99gj7jd64gnnfr4d2c0ijpva7g9prps48ja6g91x6a9"; })

     

       56
       56
        
         (fetchNuGet { pname = "Microsoft.Extensions.DependencyModel"; version = "3.0.0"; sha256 = "1cm0hycgb33mf1ja9q91wxi3gk13d1p462gdq7gndrya23hw2jm5"; })

     

       57
       57
        
         (fetchNuGet { pname = "Microsoft.Extensions.DependencyModel"; version = "6.0.0"; sha256 = "08c4fh1n8vsish1vh7h73mva34g0as4ph29s4lvps7kmjb4z64nl"; })

     

       58
       58
       -
         (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics.HealthChecks"; version = "6.0.7"; sha256 = "14jqhm15gg03smjx74vfcqmviw42yb9lqfdy0h8824mls350cb73"; })

     

       59
       59
       -
         (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions"; version = "6.0.7"; sha256 = "1bv9p3yw4icz602pn95hk8640s16ysqgp2c2lj2znrz7iay2jg4m"; })

     

       60
       60
       -
         (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore"; version = "6.0.7"; sha256 = "1gvgv6r0pp4x8whfgqxvyc876300v91rz0rysy33gjg71imf5557"; })

     

       58
       58
       +
         (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics.HealthChecks"; version = "6.0.8"; sha256 = "18h8bccffwvlcjf6bva7b62lyx887hcj3qmd0zzcyn00lc818i8z"; })

     

       59
       59
       +
         (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions"; version = "6.0.8"; sha256 = "006sd4b0sh529fka8wwh4hf7n7c4qb3z7rawaqg9j1rwz6i10zvd"; })

     

       60
       60
       +
         (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore"; version = "6.0.8"; sha256 = "1gjq3nj81vhfhfzfqs2dfm76lqpbhc0j8kl69m9qzigwsvvcvqpp"; })

     

       61
       61
        
         (fetchNuGet { pname = "Microsoft.Extensions.FileProviders.Abstractions"; version = "3.1.8"; sha256 = "0z173lsfypzjdx1a352svh1pgk7lgq2wpj5q60i1rgcrd3ib8b21"; })

     

       62
       62
        
         (fetchNuGet { pname = "Microsoft.Extensions.FileProviders.Abstractions"; version = "6.0.0"; sha256 = "1fbqmfapxdz77drcv1ndyj2ybvd2rv4c9i9pgiykcpl4fa6dc65q"; })

     

       63
       63
        
         (fetchNuGet { pname = "Microsoft.Extensions.FileProviders.Physical"; version = "6.0.0"; sha256 = "1ikc3kf325xig6njbi2aj5kmww4xlaq9lsrpc8v764fsm4x10474"; })

     
···

       151
       151
        
         (fetchNuGet { pname = "Serilog.Sinks.File"; version = "5.0.0"; sha256 = "097rngmgcrdfy7jy8j7dq3xaq2qky8ijwg0ws6bfv5lx0f3vvb0q"; })

     

       152
       152
        
         (fetchNuGet { pname = "Serilog.Sinks.Graylog"; version = "2.3.0"; sha256 = "1mnji4p1n9rsjxlaal84zkypwqcfciws1si863zz4ld2xvv9adri"; })

     

       153
       153
        
         (fetchNuGet { pname = "SerilogAnalyzer"; version = "0.15.0.0"; sha256 = "0k83cyzl9520q282vp07zb8rs16a56axv7a31l3m5fb1afq2hv9l"; })

     

       154
       154
       -
         (fetchNuGet { pname = "SharpCompress"; version = "0.32.1"; sha256 = "0n7iv6kp7gzgqrxxvwdxklvhia3ngpydc6l2nw7hzw637v4bjfl6"; })

     

       154
       154
       +
         (fetchNuGet { pname = "SharpCompress"; version = "0.32.2"; sha256 = "1p198bl08ia89rf4n6yjpacj3yrz6s574snsfl40l8vlqcdrc1pm"; })

     

       155
       155
        
         (fetchNuGet { pname = "SkiaSharp"; version = "2.88.1-preview.79"; sha256 = "0yf7kkzzlqi692c9s27g54xm29fh8vs7wxv8zz5z8lvk432hwvhn"; })

     

       156
       156
        
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.1-preview.79"; sha256 = "08538148f7pmkrfn3lb1167gg8kqw59xlygrsas2x4888h9zlxjh"; })

     

       157
       157
        
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.1-preview.79"; sha256 = "033d36x2i8xan9qbv7fikc9i7z93n46jfk031ds2yiqh850b2am5"; })

     
···

       219
       219
        
         (fetchNuGet { pname = "System.Threading"; version = "4.0.11"; sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls"; })

     

       220
       220
        
         (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.0.11"; sha256 = "0nr1r41rak82qfa5m0lhk9mp0k93bvfd7bbd9sdzwx9mb36g28p5"; })

     

       221
       221
        
         (fetchNuGet { pname = "System.Threading.Tasks.Dataflow"; version = "6.0.0"; sha256 = "1b4vyjdir9kdkiv2fqqm4f76h0df68k8gcd7jb2b38zgr2vpnk3c"; })

     

       222
       222
       -
         (fetchNuGet { pname = "TagLibSharp"; version = "2.2.0"; sha256 = "0jb0f84p4jd59ha36spyk9q08g6fjap3xywq32rcs2xwzhhqiq0y"; })

     

       222
       222
       +
         (fetchNuGet { pname = "TagLibSharp"; version = "2.3.0"; sha256 = "1z7v9lrkss1f8s42sclsq3az9zjihgmhyxnwhjyf0scgk1amngrw"; })

     

       223
       223
        
         (fetchNuGet { pname = "TMDbLib"; version = "1.9.2"; sha256 = "10vh8wx9f1rcr7wsqiqvi1gq31y4skai1px079hq08y4rbslllnq"; })

     

       224
       224
        
         (fetchNuGet { pname = "UTF.Unknown"; version = "2.5.1"; sha256 = "0giks1ww539m4r5kzdyzkq0cvfi5k50va9idjz93rclgljl96gpl"; })

     

       225
       225
        
         (fetchNuGet { pname = "zlib.net-mutliplatform"; version = "1.0.5"; sha256 = "168z0p5aywajxpwhnrns0j2ddza9n0k2dcnm5h2cxdbcirphjprg"; })

+2 -2

pkgs/servers/jellyfin/web.nix

···

       7
       7
        
       

     

       8
       8
        
       stdenv.mkDerivation rec {

     

       9
       9
        
         pname = "jellyfin-web";

     

       10
       10
       -
         version = "10.8.3";

     

       10
       10
       +
         version = "10.8.4";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "jellyfin";

     

       14
       14
        
           repo = "jellyfin-web";

     

       15
       15
        
           rev = "v${version}";

     

       16
       16
       -
           sha256 = "ZQXvF8Tt5xSylIpxQpkOeJR8nWXw806s7uDcSiVDQyA=";

     

       16
       16
       +
           sha256 = "3A2eBwO0Vg0Qgwm0Y04jheu42JpbxL6XtJRkrxSUkGo=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [

+2 -2

pkgs/servers/komga/default.nix

···

       8
       8
        
       

     

       9
       9
        
       stdenvNoCC.mkDerivation rec {

     

       10
       10
        
         pname = "komga";

     

       11
       11
       -
         version = "0.157.0";

     

       11
       11
       +
         version = "0.157.1";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchurl {

     

       14
       14
        
           url = "https://github.com/gotson/${pname}/releases/download/v${version}/${pname}-${version}.jar";

     

       15
       15
       -
           sha256 = "sha256-PkQL61fKplt6h1jcFCIMER+ZfzowDP466dR1AaDHw5Q=";

     

       15
       15
       +
           sha256 = "sha256-EXwMvUVNi2FuN+/6HI+HOxBpbwELhTSyvRtyGNgzSAQ=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         nativeBuildInputs = [

+2 -2

pkgs/servers/mail/postsrsd/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "postsrsd";

     

       5
       5
       -
         version = "1.11";

     

       5
       5
       +
         version = "1.12";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "roehling";

     

       9
       9
        
           repo = "postsrsd";

     

       10
       10
        
           rev = version;

     

       11
       11
       -
           sha256 = "sha256-M1VtH+AToLh9J4zwIznInfFJzqmKElTvqAgI+qqL+Lw=";

     

       11
       11
       +
           sha256 = "sha256-aSI9TR1wSyMA0SKkbavk+IugRfW4ZEgpzrNiXn0F5ak=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         cmakeFlags = [ "-DGENERATE_SRS_SECRET=OFF" "-DINIT_FLAVOR=systemd" ];

+3 -3

pkgs/servers/monitoring/prometheus/artifactory-exporter.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "artifactory_exporter";

     

       5
       5
       -
         version = "1.9.1";

     

       5
       5
       +
         version = "1.9.4";

     

       6
       6
        
         rev = "v${version}";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "peimanja";

     

       10
       10
        
           repo = pname;

     

       11
       11
        
           rev = rev;

     

       12
       12
       -
           sha256 = "1m68isplrs3zvkg0mans9bgablsif6264x3w475bpnhf68r87v1q";

     

       12
       12
       +
           sha256 = "sha256-vrbuKWoKfDrgJEOYsncwJZ8lyAfanbV8jKQDVCZY2Sg=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
       -
         vendorSha256 = "0acwgb0h89parkx75jp057m2hrqyd95vr2zcfqnxbnyy98gxip73";

     

       15
       15
       +
         vendorSha256 = "sha256-wKBSAZSE/lSUbkHkyBEkO0wvkrK6fKxXIjF6G+ILqHM=";

     

       16
       16
        
       

     

       17
       17
        
         subPackages = [ "." ];

     

       18
       18

+3 -3

pkgs/servers/monitoring/prometheus/fastly-exporter.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "fastly-exporter";

     

       5
       5
       -
         version = "7.0.1";

     

       5
       5
       +
         version = "7.2.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "peterbourgon";

     

       9
       9
        
           repo = pname;

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-KL+UfYuHtfQ9sKad7Q1KqIK4CFzDsIWvgG1YO1ZbUQc=";

     

       11
       11
       +
           sha256 = "sha256-dg2JPVZJSjbBirvKvfQHGi06Fah48RHk5vbHgn5Q59M=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-yE7yvnyDfrrFdBmBBYe2gBU7b4gOWl5kfqkoblE51EQ=";

     

       14
       14
       +
         vendorSha256 = "sha256-wsOgZTeErUQkt+yJ7P0Oi8Ks7WBj/e457lZNs+ZwJgY=";

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

     

       17
       17
        
           description = "Prometheus exporter for the Fastly Real-time Analytics API";

+41

pkgs/servers/pocketbase/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildGoModule

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildGoModule rec {

     

       7
       7
       +
         pname = "pocketbase";

     

       8
       8
       +
         version = "0.4.2";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "pocketbase";

     

       12
       12
       +
           repo = pname;

     

       13
       13
       +
           rev = "v${version}";

     

       14
       14
       +
           sha256 = "sha256-uDseJmuK6SI3e2ICqr8SJ0iKOVCXONueZUJ6J8MKwYE=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         vendorSha256 = "sha256-8IiY/gjK8m2ntOXyG84HMiyT4GK3CgDTRG1DB+v0jAs=";

     

       18
       18
       +
       

     

       19
       19
       +
         # This is the released subpackage from upstream repo

     

       20
       20
       +
         subPackages = [ "examples/base" ];

     

       21
       21
       +
       

     

       22
       22
       +
         CGO_ENABLED = 0;

     

       23
       23
       +
       

     

       24
       24
       +
         # Upstream build instructions

     

       25
       25
       +
         ldflags = [

     

       26
       26
       +
           "-s"

     

       27
       27
       +
           "-w"

     

       28
       28
       +
           "-X github.com/pocketbase/pocketbase.Version=${version}"

     

       29
       29
       +
         ];

     

       30
       30
       +
       

     

       31
       31
       +
         postInstall = ''

     

       32
       32
       +
           mv $out/bin/base $out/bin/pocketbase

     

       33
       33
       +
         '';

     

       34
       34
       +
       

     

       35
       35
       +
         meta = with lib; {

     

       36
       36
       +
           description = "Open Source realtime backend in 1 file";

     

       37
       37
       +
           homepage = "https://github.com/pocketbase/pocketbase";

     

       38
       38
       +
           license = licenses.mit;

     

       39
       39
       +
           maintainers = with maintainers; [ dit7ya ];

     

       40
       40
       +
         };

     

       41
       41
       +
       }

+3 -3

pkgs/servers/soft-serve/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "soft-serve";

     

       5
       5
       -
         version = "0.3.3";

     

       5
       5
       +
         version = "0.4.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "charmbracelet";

     

       9
       9
        
           repo = "soft-serve";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-LxtVum/yM+G3lyGSsOv3bICQrQC6kZKIMoAA7AnQ8VY=";

     

       11
       11
       +
           sha256 = "sha256-X9Dym2AV2By7huPI1Ns0UWue3qRZcauroIv/UAePf/U=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-KUB6w03Dw57baRYhRK1wWVWFvjMLx3KOJnS/YLbE7GE=";

     

       14
       14
       +
         vendorSha256 = "sha256-FCTJJ5T2UCtpctd+ubL7ey24xtbdiw7Q2kRBdAVPtCI=";

     

       15
       15
        
       

     

       16
       16
        
         doCheck = false;

     

       17
       17

+2 -2

pkgs/servers/sql/postgresql/ext/postgis.nix

···

       15
       15
        
       }:

     

       16
       16
        
       stdenv.mkDerivation rec {

     

       17
       17
        
         pname = "postgis";

     

       18
       18
       -
         version = "3.2.2";

     

       18
       18
       +
         version = "3.2.3";

     

       19
       19
        
       

     

       20
       20
        
         outputs = [ "out" "doc" ];

     

       21
       21
        
       

     

       22
       22
        
         src = fetchurl {

     

       23
       23
        
           url = "https://download.osgeo.org/postgis/source/postgis-${version}.tar.gz";

     

       24
       24
       -
           sha256 = "sha256-GM89AT9FsaqO1Z14vHB+nhJeJQ2PBhU5aum/4918PXw=";

     

       24
       24
       +
           sha256 = "sha256-G02LXHVuWrpZ77wYM7Iu/k1lYneO7KVvpJf+susTZow=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         buildInputs = [ libxml2 postgresql geos proj gdal json_c protobufc ]

+2 -2

pkgs/servers/web-apps/netbox/default.nix

···

       17
       17
        
       in

     

       18
       18
        
       py.pkgs.buildPythonApplication rec {

     

       19
       19
        
           pname = "netbox";

     

       20
       20
       -
           version = "3.2.8";

     

       20
       20
       +
           version = "3.3.0";

     

       21
       21
        
       

     

       22
       22
        
           src = fetchFromGitHub {

     

       23
       23
        
             owner = "netbox-community";

     

       24
       24
        
             repo = pname;

     

       25
       25
        
             rev = "refs/tags/v${version}";

     

       26
       26
       -
             sha256 = "sha256-fMTla+WVojoStwguHvsciyr0YNI09AvotuGB2o0hBUQ=";

     

       26
       26
       +
             sha256 = "sha256-tdl3A5l8CDNdVpNMKHg31QJoQSdr1v0COTcX33Sh7nc=";

     

       27
       27
        
           };

     

       28
       28
        
       

     

       29
       29
        
           format = "other";

+3 -3

pkgs/tools/admin/kics/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "kics";

     

       5
       5
       -
         version = "1.5.13";

     

       5
       5
       +
         version = "1.5.14";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "Checkmarx";

     

       9
       9
        
           repo = "kics";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-+trrtcK0zIjgl8SzURbvaabB/RtDKMEYyU8ZttD0hOs=";

     

       11
       11
       +
           sha256 = "sha256-6ZxkKtzav9mq6MTTuf83l3F8aH1EYyX4cV/xKqyv+2Q=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-/hoyT/PJ/nEQFg/1CJTb4lwOQ8ZYZtuHQeQUpPZepvc=";

     

       14
       14
       +
         vendorSha256 = "sha256-G19VVoba15pCJld5hSIWZGr5bYDUcdC82GYWXdx0OMc=";

     

       15
       15
        
       

     

       16
       16
        
         subPackages = [ "cmd/console" ];

     

       17
       17

+2 -2

pkgs/tools/misc/mmctl/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "mmctl";

     

       8
       8
       -
         version = "7.1.2";

     

       8
       8
       +
         version = "7.2.0";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "mattermost";

     

       12
       12
        
           repo = "mmctl";

     

       13
       13
        
           rev = "v${version}";

     

       14
       14
       -
           sha256 = "sha256-wqX6HVcI8PTE0gFYh03oxWRQ1Tzs/Z9V2cG9qu1MsLA=";

     

       14
       14
       +
           sha256 = "sha256-LPhFWZrQdusJKv0pDHWOv1gQ0EyVpT3nzkPYshh6pRw=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         vendorSha256 = null;

+3 -3

pkgs/tools/networking/dnsmonster/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildGoModule rec {

     

       9
       9
        
         pname = "dnsmonster";

     

       10
       10
       -
         version = "0.9.4";

     

       10
       10
       +
         version = "0.9.5";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "mosajjal";

     

       14
       14
        
           repo = pname;

     

       15
       15
        
           rev = "v${version}";

     

       16
       16
       -
           hash = "sha256-5+ivBnpE4odmm7N1FVJcKw5VlEkPiGOadsFy4Vq6gVo=";

     

       16
       16
       +
           hash = "sha256-csYJ8jdk84Uf0Sti5wGK27NH9FFHzUHFJXV8r4FWO68=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         vendorSha256 = "sha256-WCgaf34l+4dq79STBtUp1wX02ldKuTYvB+op/UTAtNQ=";

     

       19
       19
       +
         vendorSha256 = "sha256-+Wpn9VhFDx5NPk7lbp/iP3kdn3bvR+AL5nfivu8944I=";

     

       20
       20
        
       

     

       21
       21
        
         buildInputs = [

     

       22
       22
        
           libpcap

+2 -2

pkgs/tools/networking/reaver-wps-t6x/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "reaver-wps-t6x";

     

       5
       5
       -
         version = "1.6.5";

     

       5
       5
       +
         version = "1.6.6";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "t6x";

     

       9
       9
        
           repo = "reaver-wps-fork-t6x";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "03v5jyb4if74rpg0mcd8700snb120b6w2gnsa3aqdgj5676ic5dn";

     

       11
       11
       +
           sha256 = "sha256-7g4ZRkyu0TIOUw68dSPP4RyIRyeq1GgUMYFVSQB8/1I=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ makeWrapper ];

+33

pkgs/tools/text/subedit/default.nix

···

       1
       1
       +
       { stdenv, lib, fetchFromGitHub, makeWrapper, libuchardet, dos2unix, file }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation {

     

       4
       4
       +
         pname = "subedit";

     

       5
       5
       +
         version = "1.2.2";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "helixarch";

     

       9
       9
       +
           repo = "subedit";

     

       10
       10
       +
           rev = "74e11816d7b4813064a2434a5abc0f78f66c0e53";

     

       11
       11
       +
           sha256 = "sha256-3ywBBCWbwDqNNkxRupNJX6mYKxVFnoCFKav3Hc4E+8A=";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         nativeBuildInputs = [ makeWrapper ];

     

       15
       15
       +
       

     

       16
       16
       +
         buildInputs = [ libuchardet dos2unix file ];

     

       17
       17
       +
       

     

       18
       18
       +
         installPhase = ''

     

       19
       19
       +
           mkdir -p $out/bin

     

       20
       20
       +
           install -m555 subedit $out/bin/

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         postFixup = ''

     

       24
       24
       +
           wrapProgram $out/bin/subedit --prefix PATH : "${lib.makeBinPath [ libuchardet dos2unix file ]}"

     

       25
       25
       +
         '';

     

       26
       26
       +
       

     

       27
       27
       +
         meta = with lib; {

     

       28
       28
       +
           homepage = "https://github.com/helixarch/subedit";

     

       29
       29
       +
           description = "Command-line subtitle editor written in BASH";

     

       30
       30
       +
           license = licenses.gpl2;

     

       31
       31
       +
           maintainers = with maintainers; [ ppom ];

     

       32
       32
       +
         };

     

       33
       33
       +
       }

pkgs/top-level/all-packages.nix

···

       9898
       9898
        
       

     

       9899
       9899
        
         podiff = callPackage ../tools/text/podiff { };

     

       9900
       9900
        
       

     

       9901
       9901
       +
         pocketbase = callPackage ../servers/pocketbase { };

     

       9902
       9902
       +
       

     

       9901
       9903
        
         podman = callPackage ../applications/virtualization/podman/wrapper.nix { };

     

       9902
       9904
        
         podman-unwrapped = callPackage ../applications/virtualization/podman { };

     

       9903
       9905
        
       

     
···

       11038
       11040
        
         su-exec = callPackage ../tools/security/su-exec {};

     

       11039
       11041
        
       

     

       11040
       11042
        
         subberthehut = callPackage ../tools/misc/subberthehut { };

     

       11043
       11043
       +
       

     

       11044
       11044
       +
         subedit = callPackage ../tools/text/subedit { };

     

       11041
       11045
        
       

     

       11042
       11046
        
         subgit = callPackage ../applications/version-management/git-and-tools/subgit { };

     

       11043
       11047
        
       

     
···

       20834
       20838
        
         flatbuffers = callPackage ../development/libraries/flatbuffers { };

     

       20835
       20839
        
       

     

       20836
       20840
        
         nanopb = callPackage ../development/libraries/nanopb { };

     

       20841
       20841
       +
         nanopbMalloc = callPackage ../development/libraries/nanopb { mallocBuild = true; };

     

       20837
       20842
        
       

     

       20838
       20843
        
         gnupth = callPackage ../development/libraries/pth { };

     

       20839
       20844
        
         pth = if stdenv.hostPlatform.isMusl then npth else gnupth;

     
···

       31734
       31739
        
         xchm = callPackage ../applications/misc/xchm { };

     

       31735
       31740
        
       

     

       31736
       31741
        
         inherit (xorg) xcompmgr;

     

       31742
       31742
       +
       

     

       31743
       31743
       +
         x-create-mouse-void = callPackage ../applications/window-managers/x-create-mouse-void { };

     

       31737
       31744
        
       

     

       31738
       31745
        
         picom = callPackage ../applications/window-managers/picom {};

     

       31739
       31746

pkgs/top-level/python-packages.nix

···

       2403
       2403
        
       

     

       2404
       2404
        
         dingz = callPackage ../development/python-modules/dingz { };

     

       2405
       2405
        
       

     

       2406
       2406
       +
         dinghy = callPackage ../development/python-modules/dinghy { };

     

       2407
       2407
       +
       

     

       2406
       2408
        
         diofant = callPackage ../development/python-modules/diofant { };

     

       2407
       2409
        
       

     

       2408
       2410
        
         dipy = callPackage ../development/python-modules/dipy { };