commit e51bc1ab23bb2551370f16f6806989b1ecae8e2f · pyrox.dev/nixpkgs

+137

pkgs/development/compilers/gcc/ng/15/gcc/0001-find_a_program-First-search-with-machine-prefix.patch

···

       1
       +
       From 3af17de3a5f6acd5a2f9340d84b8667459f43eea Mon Sep 17 00:00:00 2001

     

       2
       +
       From: John Ericson <git@JohnEricson.me>

     

       3
       +
       Date: Wed, 18 Aug 2021 01:55:31 -0400

     

       4
       +
       Subject: [PATCH 1/3] find_a_program: First search with machine prefix

     

       5
       +
       

     

       6
       +
       This matches the behavior of Clang, and makes it easier to work with

     

       7
       +
       cross compilers without heeding to hard-code paths at build time.

     

       8
       +
       ---

     

       9
       +
        gcc/gcc.cc | 78 +++++++++++++++++++++++++++++++++++++++++++++++-------

     

       10
       +
        1 file changed, 68 insertions(+), 10 deletions(-)

     

       11
       +
       

     

       12
       +
       diff --git a/gcc/gcc.cc b/gcc/gcc.cc

     

       13
       +
       index 4fd87f2c4a1..55738d258b3 100644

     

       14
       +
       --- a/gcc/gcc.cc

     

       15
       +
       +++ b/gcc/gcc.cc

     

       16
       +
       @@ -1600,6 +1600,11 @@ static const char *machine_suffix = 0;

     

       17
       +
        

     

       18
       +
        static const char *just_machine_suffix = 0;

     

       19
       +
        

     

       20
       +
       +/* Prefix to attach to *basename* of commands being searched.

     

       21
       +
       +   This is just `MACHINE-'.  */

     

       22
       +
       +

     

       23
       +
       +static const char *just_machine_prefix = 0;

     

       24
       +
       +

     

       25
       +
        /* Adjusted value of GCC_EXEC_PREFIX envvar.  */

     

       26
       +
        

     

       27
       +
        static const char *gcc_exec_prefix;

     

       28
       +
       @@ -3043,15 +3048,6 @@ file_at_path (char *path, void *data)

     

       29
       +
          memcpy (path + len, info->name, info->name_len);

     

       30
       +
          len += info->name_len;

     

       31
       +
        

     

       32
       +
       -  /* Some systems have a suffix for executable files.

     

       33
       +
       -     So try appending that first.  */

     

       34
       +
       -  if (info->suffix_len)

     

       35
       +
       -    {

     

       36
       +
       -      memcpy (path + len, info->suffix, info->suffix_len + 1);

     

       37
       +
       -      if (access_check (path, info->mode) == 0)

     

       38
       +
       -	return path;

     

       39
       +
       -    }

     

       40
       +
       -

     

       41
       +
          path[len] = '\0';

     

       42
       +
          if (access_check (path, info->mode) == 0)

     

       43
       +
            return path;

     

       44
       +
       @@ -3091,12 +3087,52 @@ find_a_file (const struct path_prefix *pprefix, const char *name, int mode,

     

       45
       +
        				file_at_path, &info);

     

       46
       +
        }

     

       47
       +
        

     

       48
       +
       +/* Callback for find_a_program.  Appends the file name to the directory

     

       49
       +
       +   path. Like file_at_path but tries machine prefix and exe suffix too. */

     

       50
       +
       +

     

       51
       +
       +static void *

     

       52
       +
       +program_at_path (char *path, void *data)

     

       53
       +
       +{

     

       54
       +
       +  /* try first with machine-prefixed name */

     

       55
       +
       +  struct file_at_path_info *info = (struct file_at_path_info *) data;

     

       56
       +
       +  size_t path_len = strlen (path);

     

       57
       +
       +

     

       58
       +
       +  for (auto prefix : { just_machine_prefix, "" })

     

       59
       +
       +    {

     

       60
       +
       +      auto len = path_len;

     

       61
       +
       +

     

       62
       +
       +      auto prefix_len = strlen(prefix);

     

       63
       +
       +      memcpy (path + len, prefix, prefix_len);

     

       64
       +
       +      len += prefix_len;

     

       65
       +
       +

     

       66
       +
       +      memcpy (path + len, info->name, info->name_len);

     

       67
       +
       +      len += info->name_len;

     

       68
       +
       +

     

       69
       +
       +      /* Some systems have a suffix for executable files.

     

       70
       +
       +	 So try appending that first.  */

     

       71
       +
       +      if (info->suffix_len)

     

       72
       +
       +	{

     

       73
       +
       +	  memcpy (path + len, info->suffix, info->suffix_len + 1);

     

       74
       +
       +	  if (access_check (path, info->mode) == 0)

     

       75
       +
       +	    return path;

     

       76
       +
       +	}

     

       77
       +
       +

     

       78
       +
       +      path[len] = '\0';

     

       79
       +
       +      if (access_check (path, info->mode) == 0)

     

       80
       +
       +	return path;

     

       81
       +
       +    }

     

       82
       +
       +

     

       83
       +
       +  return NULL;

     

       84
       +
       +}

     

       85
       +
       +

     

       86
       +
        /* Specialization of find_a_file for programs that also takes into account

     

       87
       +
           configure-specified default programs. */

     

       88
       +
        

     

       89
       +
        static char*

     

       90
       +
        find_a_program (const char *name)

     

       91
       +
        {

     

       92
       +
       +  const int mode = X_OK;

     

       93
       +
       +

     

       94
       +
          /* Do not search if default matches query. */

     

       95
       +
        

     

       96
       +
        #ifdef DEFAULT_ASSEMBLER

     

       97
       +
       @@ -3114,7 +3150,28 @@ find_a_program (const char *name)

     

       98
       +
            return xstrdup (DEFAULT_DSYMUTIL);

     

       99
       +
        #endif

     

       100
       +
        

     

       101
       +
       -  return find_a_file (&exec_prefixes, name, X_OK, false);

     

       102
       +
       +  /* Find the filename in question (special case for absolute paths).  */

     

       103
       +
       +

     

       104
       +
       +  if (IS_ABSOLUTE_PATH (name))

     

       105
       +
       +    {

     

       106
       +
       +      if (access (name, mode) == 0)

     

       107
       +
       +	return xstrdup (name);

     

       108
       +
       +

     

       109
       +
       +      return NULL;

     

       110
       +
       +    }

     

       111
       +
       +

     

       112
       +
       +  struct file_at_path_info info;

     

       113
       +
       +

     

       114
       +
       +  info.name = name;

     

       115
       +
       +  info.suffix = HOST_EXECUTABLE_SUFFIX;

     

       116
       +
       +  info.name_len = strlen (info.name);

     

       117
       +
       +  info.suffix_len = strlen (info.suffix);

     

       118
       +
       +  info.mode = mode;

     

       119
       +
       +

     

       120
       +
       +  return (char*) for_each_path (

     

       121
       +
       +    &exec_prefixes, false,

     

       122
       +
       +    info.name_len + info.suffix_len + strlen(just_machine_prefix),

     

       123
       +
       +    program_at_path, &info);

     

       124
       +
        }

     

       125
       +
        

     

       126
       +
        /* Ranking of prefixes in the sort list. -B prefixes are put before

     

       127
       +
       @@ -8492,6 +8549,7 @@ driver::set_up_specs () const

     

       128
       +
          machine_suffix = concat (spec_host_machine, dir_separator_str, spec_version,

     

       129
       +
        			   accel_dir_suffix, dir_separator_str, NULL);

     

       130
       +
          just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);

     

       131
       +
       +  just_machine_prefix = concat (spec_machine, "-", NULL);

     

       132
       +
        

     

       133
       +
          specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);

     

       134
       +
          /* Read the specs file unless it is a default one.  */

     

       135
       +
       -- 

     

       136
       +
       2.47.2

     

       137
       +

+103

pkgs/development/compilers/gcc/ng/15/gcc/0002-driver-for_each_pass-Pass-to-callback-whether-dir-is.patch

···

       1
       +
       From 8e1b7a128a69393c6d3f53b8f66bd52c6bbce908 Mon Sep 17 00:00:00 2001

     

       2
       +
       From: John Ericson <git@JohnEricson.me>

     

       3
       +
       Date: Wed, 18 Aug 2021 01:55:45 -0400

     

       4
       +
       Subject: [PATCH 2/3] driver: for_each_pass: Pass to callback whether dir is

     

       5
       +
        machine-disambiguated

     

       6
       +
       

     

       7
       +
       We will use this in the subsequent diff to control what basenames we

     

       8
       +
       search for. In machine-specific subdirectories, we should just look for

     

       9
       +
       the original basename, but in machine-agnostic subdirectories, we might

     

       10
       +
       additionally look for prefixed disambiguated names, as an alternate

     

       11
       +
       method of keeping targets apart.

     

       12
       +
       ---

     

       13
       +
        gcc/gcc.cc | 18 +++++++++---------

     

       14
       +
        1 file changed, 9 insertions(+), 9 deletions(-)

     

       15
       +
       

     

       16
       +
       diff --git a/gcc/gcc.cc b/gcc/gcc.cc

     

       17
       +
       index 55738d258b3..f9f83d1a804 100644

     

       18
       +
       --- a/gcc/gcc.cc

     

       19
       +
       +++ b/gcc/gcc.cc

     

       20
       +
       @@ -2783,7 +2783,7 @@ static void *

     

       21
       +
        for_each_path (const struct path_prefix *paths,

     

       22
       +
        	       bool do_multi,

     

       23
       +
        	       size_t extra_space,

     

       24
       +
       -	       void *(*callback) (char *, void *),

     

       25
       +
       +	       void *(*callback) (char *, bool, void *),

     

       26
       +
        	       void *callback_info)

     

       27
       +
        {

     

       28
       +
          struct prefix_list *pl;

     

       29
       +
       @@ -2844,7 +2844,7 @@ for_each_path (const struct path_prefix *paths,

     

       30
       +
        	  if (!skip_multi_dir)

     

       31
       +
        	    {

     

       32
       +
        	      memcpy (path + len, multi_suffix, suffix_len + 1);

     

       33
       +
       -	      ret = callback (path, callback_info);

     

       34
       +
       +	      ret = callback (path, true, callback_info);

     

       35
       +
        	      if (ret)

     

       36
       +
        		break;

     

       37
       +
        	    }

     

       38
       +
       @@ -2855,7 +2855,7 @@ for_each_path (const struct path_prefix *paths,

     

       39
       +
        	      && pl->require_machine_suffix == 2)

     

       40
       +
        	    {

     

       41
       +
        	      memcpy (path + len, just_multi_suffix, just_suffix_len + 1);

     

       42
       +
       -	      ret = callback (path, callback_info);

     

       43
       +
       +	      ret = callback (path, true, callback_info);

     

       44
       +
        	      if (ret)

     

       45
       +
        		break;

     

       46
       +
        	    }

     

       47
       +
       @@ -2865,7 +2865,7 @@ for_each_path (const struct path_prefix *paths,

     

       48
       +
        	      && !pl->require_machine_suffix && multiarch_dir)

     

       49
       +
        	    {

     

       50
       +
        	      memcpy (path + len, multiarch_suffix, multiarch_len + 1);

     

       51
       +
       -	      ret = callback (path, callback_info);

     

       52
       +
       +	      ret = callback (path, true, callback_info);

     

       53
       +
        	      if (ret)

     

       54
       +
        		break;

     

       55
       +
        	    }

     

       56
       +
       @@ -2893,7 +2893,7 @@ for_each_path (const struct path_prefix *paths,

     

       57
       +
        	      else

     

       58
       +
        		path[len] = '\0';

     

       59
       +
        

     

       60
       +
       -	      ret = callback (path, callback_info);

     

       61
       +
       +	      ret = callback (path, false, callback_info);

     

       62
       +
        	      if (ret)

     

       63
       +
        		break;

     

       64
       +
        	    }

     

       65
       +
       @@ -2948,7 +2948,7 @@ struct add_to_obstack_info {

     

       66
       +
        };

     

       67
       +
        

     

       68
       +
        static void *

     

       69
       +
       -add_to_obstack (char *path, void *data)

     

       70
       +
       +add_to_obstack (char *path, bool, void *data)

     

       71
       +
        {

     

       72
       +
          struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;

     

       73
       +
        

     

       74
       +
       @@ -3040,7 +3040,7 @@ struct file_at_path_info {

     

       75
       +
        };

     

       76
       +
        

     

       77
       +
        static void *

     

       78
       +
       -file_at_path (char *path, void *data)

     

       79
       +
       +file_at_path (char *path, bool, void *data)

     

       80
       +
        {

     

       81
       +
          struct file_at_path_info *info = (struct file_at_path_info *) data;

     

       82
       +
          size_t len = strlen (path);

     

       83
       +
       @@ -3091,7 +3091,7 @@ find_a_file (const struct path_prefix *pprefix, const char *name, int mode,

     

       84
       +
           path. Like file_at_path but tries machine prefix and exe suffix too. */

     

       85
       +
        

     

       86
       +
        static void *

     

       87
       +
       -program_at_path (char *path, void *data)

     

       88
       +
       +program_at_path (char *path, bool machine_specific, void *data)

     

       89
       +
        {

     

       90
       +
          /* try first with machine-prefixed name */

     

       91
       +
          struct file_at_path_info *info = (struct file_at_path_info *) data;

     

       92
       +
       @@ -6074,7 +6074,7 @@ struct spec_path_info {

     

       93
       +
        };

     

       94
       +
        

     

       95
       +
        static void *

     

       96
       +
       -spec_path (char *path, void *data)

     

       97
       +
       +spec_path (char *path, bool, void *data)

     

       98
       +
        {

     

       99
       +
          struct spec_path_info *info = (struct spec_path_info *) data;

     

       100
       +
          size_t len = 0;

     

       101
       +
       -- 

     

       102
       +
       2.47.2

     

       103
       +

+75

pkgs/development/compilers/gcc/ng/15/gcc/0003-find_a_program-Only-search-for-prefixed-paths-in-und.patch

···

       1
       +
       From e1ee1a2df1ad32de24e8fdaeac0a533681710578 Mon Sep 17 00:00:00 2001

     

       2
       +
       From: John Ericson <git@JohnEricson.me>

     

       3
       +
       Date: Wed, 18 Aug 2021 01:55:52 -0400

     

       4
       +
       Subject: [PATCH 3/3] find_a_program: Only search for prefixed paths in

     

       5
       +
        undisambiguated dirs

     

       6
       +
       

     

       7
       +
       This means, we might search for:

     

       8
       +
       

     

       9
       +
       - path/$machine/$version/prog

     

       10
       +
       - path/$machine/prog

     

       11
       +
       - path/$machine-prog

     

       12
       +
       

     

       13
       +
       But not

     

       14
       +
       

     

       15
       +
       - path/$machine/$version/$machine-prog

     

       16
       +
       

     

       17
       +
       because disambiguating $machine twice is unnecessary.

     

       18
       +
       

     

       19
       +
       This does mean we less liberal in what we accept than LLVM, but that's

     

       20
       +
       OK. The down side of always Postel's law is everyone converges on

     

       21
       +
       accepting all sorts of garbage, which makes debugging end-to-end hard

     

       22
       +
       when mistakes are not caught early.

     

       23
       +
       ---

     

       24
       +
        gcc/gcc.cc | 25 ++++++++++++++++---------

     

       25
       +
        1 file changed, 16 insertions(+), 9 deletions(-)

     

       26
       +
       

     

       27
       +
       diff --git a/gcc/gcc.cc b/gcc/gcc.cc

     

       28
       +
       index f9f83d1a804..d837b6ea779 100644

     

       29
       +
       --- a/gcc/gcc.cc

     

       30
       +
       +++ b/gcc/gcc.cc

     

       31
       +
       @@ -3097,15 +3097,9 @@ program_at_path (char *path, bool machine_specific, void *data)

     

       32
       +
          struct file_at_path_info *info = (struct file_at_path_info *) data;

     

       33
       +
          size_t path_len = strlen (path);

     

       34
       +
        

     

       35
       +
       -  for (auto prefix : { just_machine_prefix, "" })

     

       36
       +
       +  auto search = [=](size_t len) -> void *

     

       37
       +
            {

     

       38
       +
       -      auto len = path_len;

     

       39
       +
       -

     

       40
       +
       -      auto prefix_len = strlen(prefix);

     

       41
       +
       -      memcpy (path + len, prefix, prefix_len);

     

       42
       +
       -      len += prefix_len;

     

       43
       +
       -

     

       44
       +
       -      memcpy (path + len, info->name, info->name_len);

     

       45
       +
       +      memcpy (path + len, info->name, info->name_len + 1);

     

       46
       +
              len += info->name_len;

     

       47
       +
        

     

       48
       +
              /* Some systems have a suffix for executable files.

     

       49
       +
       @@ -3120,9 +3114,22 @@ program_at_path (char *path, bool machine_specific, void *data)

     

       50
       +
              path[len] = '\0';

     

       51
       +
              if (access_check (path, info->mode) == 0)

     

       52
       +
        	return path;

     

       53
       +
       +

     

       54
       +
       +      return NULL;

     

       55
       +
       +    };

     

       56
       +
       +

     

       57
       +
       +  /* Additionally search for $target-prog in machine-agnostic dirs, as an

     

       58
       +
       +     additional way to disambiguate targets. Do not do this in machine-specific

     

       59
       +
       +     dirs because so further disambiguation is needed. */

     

       60
       +
       +  if (!machine_specific)

     

       61
       +
       +    {

     

       62
       +
       +      auto prefix_len = strlen(just_machine_prefix);

     

       63
       +
       +      memcpy (path + path_len, just_machine_prefix, prefix_len);

     

       64
       +
       +      auto res = search(path_len + prefix_len);

     

       65
       +
       +      if (res) return res;

     

       66
       +
            }

     

       67
       +
        

     

       68
       +
       -  return NULL;

     

       69
       +
       +  return search(path_len);

     

       70
       +
        }

     

       71
       +
        

     

       72
       +
        /* Specialization of find_a_file for programs that also takes into account

     

       73
       +
       -- 

     

       74
       +
       2.47.2

     

       75
       +

+180

pkgs/development/compilers/gcc/ng/15/gcc/custom-threading-model.patch

···

       1
       +
       From 1eaf7ce77bb4eb73e5565ede220557c2ef0290b0 Mon Sep 17 00:00:00 2001

     

       2
       +
       From: John Ericson <git@JohnEricson.me>

     

       3
       +
       Date: Sun, 22 Aug 2021 01:14:22 -0400

     

       4
       +
       Subject: [PATCH] Allow explicitly specifying the thread model for runtime libs

     

       5
       +
       

     

       6
       +
       Previously, they always scraped the thread mode from `$CC -v', now, that

     

       7
       +
       is the default but one may pass `--with-threads=MODEL` to be explicit

     

       8
       +
       instead.

     

       9
       +
       

     

       10
       +
       One use-case is bootstraping with a shorter critical path. The

     

       11
       +
       traditionally route was to build an entire "static stage" GCC, build

     

       12
       +
       libc, and then build GCC again supporting dynamic linking,

     

       13
       +
       multithreading, etc. But this is wasteful in that GCC itself is built

     

       14
       +
       twice.

     

       15
       +
       

     

       16
       +
       With this change, rather than having to mess with spec files we can just

     

       17
       +
       configure the runtime libraries the way we want directly. In turn, that

     

       18
       +
       opens to just building libgcc twice rather than all of GCC.

     

       19
       +
       

     

       20
       +
       Frankly, specs were always a rather indirect approach to coordinate this

     

       21
       +
       during GCC's bootstrap, since GCC itself really doesn't care what the

     

       22
       +
       threading model is, just that the runtime libraries agree among

     

       23
       +
       themselves. Relying on a hard-coded spec for this also keeps us one step

     

       24
       +
       further from the long-term goal of multi-target GCC, for what it's

     

       25
       +
       worth.

     

       26
       +
       

     

       27
       +
       For the record, "single stage" builds of GCC have some precedent in

     

       28
       +
       downstream packaging, for example with [1]. That one, as far as I can

     

       29
       +
       tell, builds libgcc once, but with the headers of the libc

     

       30
       +
       implementation provided and then cyclic linking down later. They are

     

       31
       +
       both fine approaches, but I don't think one should have to be forced

     

       32
       +
       into cyclic dependencies if they don't want to. That opens the door to

     

       33
       +
       non-terminating programs due to, e.g., atomics used in a threads

     

       34
       +
       implementation being lowered to threads absent hardware support.

     

       35
       +
       

     

       36
       +
       Finally, I understand that such custom bootstrapping is not officially

     

       37
       +
       supported. I don't mean to imply it should be --- a lot more cleanup

     

       38
       +
       work to the build system would be necessary before supporting it

     

       39
       +
       wouldn't be a huge additional maintainer burden --- I just hope to add a

     

       40
       +
       reasonable knob for those comfortable with doing unsupported things

     

       41
       +
       already.

     

       42
       +
       

     

       43
       +
       [1]: https://github.com/richfelker/musl-cross-make

     

       44
       +
       ---

     

       45
       +
        config/gthr.m4              | 32 ++++++++++++++++++++++++++++++++

     

       46
       +
        libatomic/configure.ac      |  4 +---

     

       47
       +
        libgcc/configure.ac         |  4 +---

     

       48
       +
        libphobos/m4/druntime/os.m4 |  2 +-

     

       49
       +
        libstdc++-v3/acinclude.m4   |  8 +++-----

     

       50
       +
        5 files changed, 38 insertions(+), 12 deletions(-)

     

       51
       +
       

     

       52
       +
       diff --git a/config/gthr.m4 b/config/gthr.m4

     

       53
       +
       index 11996247f15..7aed5d3df0d 100644

     

       54
       +
       --- a/config/gthr.m4

     

       55
       +
       +++ b/config/gthr.m4

     

       56
       +
       @@ -5,6 +5,35 @@ dnl Public License, this file may be distributed as part of a program

     

       57
       +
        dnl that contains a configuration script generated by Autoconf, under

     

       58
       +
        dnl the same distribution terms as the rest of that program.

     

       59
       +
        

     

       60
       +
       +dnl Define thread model

     

       61
       +
       +

     

       62
       +
       +dnl usage: GCC_AC_THREAD_MODEL

     

       63
       +
       +AC_DEFUN([GCC_AC_THREAD_MODEL],

     

       64
       +
       +[

     

       65
       +
       +# With threads

     

       66
       +
       +# Pass with no value to take from compiler's metadata

     

       67
       +
       +# Pass with a value to specify a thread package

     

       68
       +
       +# 'single' means single threaded -- without threads.

     

       69
       +
       +AC_ARG_WITH(threads,

     

       70
       +
       +[AS_HELP_STRING([[--with-threads=MODEL]],

     

       71
       +
       +		[specify thread model for this GCC

     

       72
       +
       +		 runtime library])],,

     

       73
       +
       +[with_threads=''])

     

       74
       +
       +

     

       75
       +
       +if test x"$with_threads" = x'yes'; then

     

       76
       +
       +    AC_MSG_ERROR([Cannot pass bare --with-threads, must pass explicit --with-threads=MODEL])

     

       77
       +
       +elif test x"$with_threads" = x'no'; then

     

       78
       +
       +    target_thread_file=single

     

       79
       +
       +elif test x"$with_threads" = x''; then

     

       80
       +
       +    AC_MSG_CHECKING([for thread model used by GCC])

     

       81
       +
       +    target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`

     

       82
       +
       +    AC_MSG_RESULT([$target_thread_file])

     

       83
       +
       +else

     

       84
       +
       +    target_thread_file=$with_threads

     

       85
       +
       +fi

     

       86
       +
       +])

     

       87
       +
       +

     

       88
       +
       +

     

       89
       +
        dnl Define header location by thread model

     

       90
       +
        

     

       91
       +
        dnl usage: GCC_AC_THREAD_HEADER([thread_model])

     

       92
       +
       @@ -23,6 +52,9 @@ case $1 in

     

       93
       +
            vxworks)	thread_header=config/gthr-vxworks.h ;;

     

       94
       +
            win32)	thread_header=config/i386/gthr-win32.h ;;

     

       95
       +
            mcf)	thread_header=config/i386/gthr-mcf.h ;;

     

       96
       +
       +    *)

     

       97
       +
       +        AC_MSG_ERROR([No known header for threading model '$1'.])

     

       98
       +
       +        ;;

     

       99
       +
        esac

     

       100
       +
        AC_SUBST(thread_header)

     

       101
       +
        ])

     

       102
       +
       diff --git a/libatomic/configure.ac b/libatomic/configure.ac

     

       103
       +
       index 85824fa7614..691f4948f6c 100644

     

       104
       +
       --- a/libatomic/configure.ac

     

       105
       +
       +++ b/libatomic/configure.ac

     

       106
       +
       @@ -162,9 +162,7 @@ libtool_VERSION=3:0:2

     

       107
       +
        AC_SUBST(libtool_VERSION)

     

       108
       +
        

     

       109
       +
        # Check for used threading-model

     

       110
       +
       -AC_MSG_CHECKING([for thread model used by GCC])

     

       111
       +
       -target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`

     

       112
       +
       -AC_MSG_RESULT([$target_thread_file])

     

       113
       +
       +GCC_AC_THREAD_MODEL

     

       114
       +
        

     

       115
       +
        case "$target" in

     

       116
       +
         *aarch64*)

     

       117
       +
       diff --git a/libgcc/configure.ac b/libgcc/configure.ac

     

       118
       +
       index 4e8c036990f..acf54e24c79 100644

     

       119
       +
       --- a/libgcc/configure.ac

     

       120
       +
       +++ b/libgcc/configure.ac

     

       121
       +
       @@ -305,9 +305,7 @@ AC_SUBST([use_tm_clone_registry])

     

       122
       +
        

     

       123
       +
        AC_LIB_PROG_LD_GNU

     

       124
       +
        

     

       125
       +
       -AC_MSG_CHECKING([for thread model used by GCC])

     

       126
       +
       -target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`

     

       127
       +
       -AC_MSG_RESULT([$target_thread_file]) 

     

       128
       +
       +GCC_AC_THREAD_MODEL

     

       129
       +
        

     

       130
       +
        # Check for assembler CFI support.

     

       131
       +
        AC_CACHE_CHECK([whether assembler supports CFI directives], [libgcc_cv_cfi],

     

       132
       +
       diff --git a/libphobos/m4/druntime/os.m4 b/libphobos/m4/druntime/os.m4

     

       133
       +
       index 15cde3b04b8..28bd4d3d2bd 100644

     

       134
       +
       --- a/libphobos/m4/druntime/os.m4

     

       135
       +
       +++ b/libphobos/m4/druntime/os.m4

     

       136
       +
       @@ -32,7 +32,7 @@ case $1 in

     

       137
       +
            # TODO: These targets need porting.

     

       138
       +
            dce|mipssde|rtems|tpf|vxworks)

     

       139
       +
        	    DCFG_THREAD_MODEL="Single" ;;

     

       140
       +
       -    *)	    as_fn_error "Thread implementation '$1' not recognised" "$LINENO" 5 ;;

     

       141
       +
       +    *)	    AC_MSG_ERROR([Thread implementation '$1' not recognised]) ;;

     

       142
       +
        esac

     

       143
       +
        AC_SUBST(DCFG_THREAD_MODEL)

     

       144
       +
        ])

     

       145
       +
       diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4

     

       146
       +
       index 51a08bcc8b1..71697f59d6d 100644

     

       147
       +
       --- a/libstdc++-v3/acinclude.m4

     

       148
       +
       +++ b/libstdc++-v3/acinclude.m4

     

       149
       +
       @@ -4342,9 +4342,7 @@ dnl Substs:

     

       150
       +
        dnl  thread_header

     

       151
       +
        dnl

     

       152
       +
        AC_DEFUN([GLIBCXX_ENABLE_THREADS], [

     

       153
       +
       -  AC_MSG_CHECKING([for thread model used by GCC])

     

       154
       +
       -  target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`

     

       155
       +
       -  AC_MSG_RESULT([$target_thread_file])

     

       156
       +
       +  GCC_AC_THREAD_MODEL

     

       157
       +
          GCC_AC_THREAD_HEADER([$target_thread_file])

     

       158
       +
        ])

     

       159
       +
        

     

       160
       +
       @@ -4354,7 +4352,8 @@ dnl Check if gthread implementation defines the types and functions

     

       161
       +
        dnl required by the c++0x thread library.  Conforming gthread

     

       162
       +
        dnl implementations can define __GTHREADS_CXX0X to enable use with c++0x.

     

       163
       +
        dnl

     

       164
       +
       -dnl GLIBCXX_ENABLE_SYMVERS must be done before this.

     

       165
       +
       +dnl GLIBCXX_ENABLE_SYMVERS and GLIBCXX_ENABLE_THREADS must be done

     

       166
       +
       +dnl before this.

     

       167
       +
        dnl

     

       168
       +
        AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [

     

       169
       +
          GLIBCXX_ENABLE(libstdcxx-threads,auto,,[enable C++11 threads support])

     

       170
       +
       @@ -4369,7 +4368,6 @@ AC_DEFUN([GLIBCXX_CHECK_GTHREADS], [

     

       171
       +
          CXXFLAGS="$CXXFLAGS -fno-exceptions \

     

       172
       +
        	-I${toplevel_srcdir}/libgcc -I${toplevel_builddir}/libgcc"

     

       173
       +
        

     

       174
       +
       -  target_thread_file=`$CXX -v 2>&1 | sed -n 's/^Thread model: //p'`

     

       175
       +
          case $target_thread_file in

     

       176
       +
            posix)

     

       177
       +
              CXXFLAGS="$CXXFLAGS -DSUPPORTS_WEAK -DGTHREAD_USE_WEAK -D_PTHREADS"

     

       178
       +
       -- 

     

       179
       +
       2.44.1

     

       180
       +

+315

pkgs/development/compilers/gcc/ng/15/gcc/fix-collect2-paths.diff

···

       1
       +
       diff --git a/gcc/collect2.cc b/gcc/collect2.cc

     

       2
       +
       index 268ac378b9c..8a5c606075a 100644

     

       3
       +
       --- a/gcc/collect2.cc

     

       4
       +
       +++ b/gcc/collect2.cc

     

       5
       +
       @@ -327,7 +327,7 @@ static void write_aix_file (FILE *, struct id *);

     

       6
       +
        static char *resolve_lib_name (const char *);

     

       7
       +
        #endif

     

       8
       +
        static char *extract_string (const char **);

     

       9
       +
       -static void post_ld_pass (bool);

     

       10
       +
       +static void post_ld_pass (bool, bool);

     

       11
       +
        static void process_args (int *argcp, char **argv);

     

       12
       +
        

     

       13
       +
        /* Enumerations describing which pass this is for scanning the

     

       14
       +
       @@ -513,12 +513,10 @@ is_ctor_dtor (const char *s)

     

       15
       +
        

     

       16
       +
        static struct path_prefix cpath, path;

     

       17
       +
        

     

       18
       +
       -#ifdef CROSS_DIRECTORY_STRUCTURE

     

       19
       +
        /* This is the name of the target machine.  We use it to form the name

     

       20
       +
           of the files to execute.  */

     

       21
       +
        

     

       22
       +
        static const char *const target_machine = TARGET_MACHINE;

     

       23
       +
       -#endif

     

       24
       +
        

     

       25
       +
        /* Search for NAME using prefix list PPREFIX.  We only look for executable

     

       26
       +
           files.

     

       27
       +
       @@ -577,7 +575,7 @@ add_lto_object (struct lto_object_list *list, const char *name)

     

       28
       +
        

     

       29
       +
        static void

     

       30
       +
        maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,

     

       31
       +
       -			  const char **object, bool force)

     

       32
       +
       +			  const char **object, bool force, bool is_cross_compiler)

     

       33
       +
        {

     

       34
       +
          const char **object_file = CONST_CAST2 (const char **, char **, object_lst);

     

       35
       +
        

     

       36
       +
       @@ -722,7 +720,7 @@ maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,

     

       37
       +
        		    "ld_args");

     

       38
       +
              /* We assume that temp files were created, and therefore we need to take

     

       39
       +
                 that into account (maybe run dsymutil).  */

     

       40
       +
       -      post_ld_pass (/*temp_file*/true);

     

       41
       +
       +      post_ld_pass (/*temp_file*/true, is_cross_compiler);

     

       42
       +
              free (lto_ld_argv);

     

       43
       +
        

     

       44
       +
              maybe_unlink_list (lto_o_files);

     

       45
       +
       @@ -734,10 +732,10 @@ maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,

     

       46
       +
              fork_execute ("ld", lto_ld_argv, HAVE_GNU_LD && at_file_supplied,

     

       47
       +
        		    "ld_args");

     

       48
       +
              /* No LTO objects were found, so no new temp file.  */

     

       49
       +
       -      post_ld_pass (/*temp_file*/false);

     

       50
       +
       +      post_ld_pass (/*temp_file*/false, is_cross_compiler);

     

       51
       +
            }

     

       52
       +
          else

     

       53
       +
       -    post_ld_pass (false); /* No LTO objects were found, no temp file.  */

     

       54
       +
       +    post_ld_pass (false, is_cross_compiler); /* No LTO objects were found, no temp file.  */

     

       55
       +
        }

     

       56
       +
        /* Entry point for linker invoation.  Called from main in collect2.cc.

     

       57
       +
           LD_ARGV is an array of arguments for the linker.  */

     

       58
       +
       @@ -799,33 +797,14 @@ main (int argc, char **argv)

     

       59
       +
          static const char *const gstrip_suffix = "gstrip";

     

       60
       +
        

     

       61
       +
          const char *full_ld_suffixes[USE_LD_MAX];

     

       62
       +
       -#ifdef CROSS_DIRECTORY_STRUCTURE

     

       63
       +
       -  /* If we look for a program in the compiler directories, we just use

     

       64
       +
       -     the short name, since these directories are already system-specific.

     

       65
       +
       -     But it we look for a program in the system directories, we need to

     

       66
       +
       -     qualify the program name with the target machine.  */

     

       67
       +
       -

     

       68
       +
       -  const char *const full_nm_suffix =

     

       69
       +
       -    concat (target_machine, "-", nm_suffix, NULL);

     

       70
       +
       -  const char *const full_gnm_suffix =

     

       71
       +
       -    concat (target_machine, "-", gnm_suffix, NULL);

     

       72
       +
       -#ifdef LDD_SUFFIX

     

       73
       +
       -  const char *const full_ldd_suffix =

     

       74
       +
       -    concat (target_machine, "-", ldd_suffix, NULL);

     

       75
       +
       -#endif

     

       76
       +
       -  const char *const full_strip_suffix =

     

       77
       +
       -    concat (target_machine, "-", strip_suffix, NULL);

     

       78
       +
       -  const char *const full_gstrip_suffix =

     

       79
       +
       -    concat (target_machine, "-", gstrip_suffix, NULL);

     

       80
       +
       -#else

     

       81
       +
       +  const char *full_nm_suffix;

     

       82
       +
       +  const char *full_gnm_suffix;

     

       83
       +
       +  const char *full_strip_suffix;

     

       84
       +
       +  const char *full_gstrip_suffix;

     

       85
       +
       +

     

       86
       +
        #ifdef LDD_SUFFIX

     

       87
       +
       -  const char *const full_ldd_suffix	= ldd_suffix;

     

       88
       +
       +  const char *full_ldd_suffix;

     

       89
       +
        #endif

     

       90
       +
       -  const char *const full_nm_suffix	= nm_suffix;

     

       91
       +
       -  const char *const full_gnm_suffix	= gnm_suffix;

     

       92
       +
       -  const char *const full_strip_suffix	= strip_suffix;

     

       93
       +
       -  const char *const full_gstrip_suffix	= gstrip_suffix;

     

       94
       +
       -#endif /* CROSS_DIRECTORY_STRUCTURE */

     

       95
       +
        

     

       96
       +
          const char *arg;

     

       97
       +
          FILE *outf;

     

       98
       +
       @@ -840,6 +819,7 @@ main (int argc, char **argv)

     

       99
       +
          const char **ld1;

     

       100
       +
          bool use_plugin = false;

     

       101
       +
          bool use_collect_ld = false;

     

       102
       +
       +  bool is_cross_compiler = false;

     

       103
       +
        

     

       104
       +
          /* The kinds of symbols we will have to consider when scanning the

     

       105
       +
             outcome of a first pass link.  This is ALL to start with, then might

     

       106
       +
       @@ -864,17 +844,6 @@ main (int argc, char **argv)

     

       107
       +
        #endif

     

       108
       +
          int i;

     

       109
       +
        

     

       110
       +
       -  for (i = 0; i < USE_LD_MAX; i++)

     

       111
       +
       -#ifdef CROSS_DIRECTORY_STRUCTURE

     

       112
       +
       -    /* lld and mold are platform-agnostic and not prefixed with target

     

       113
       +
       -       triple.  */

     

       114
       +
       -    if (!(i == USE_LLD_LD || i == USE_MOLD_LD))

     

       115
       +
       -      full_ld_suffixes[i] = concat (target_machine, "-", ld_suffixes[i],

     

       116
       +
       -				    NULL);

     

       117
       +
       -    else

     

       118
       +
       -#endif

     

       119
       +
       -      full_ld_suffixes[i] = ld_suffixes[i];

     

       120
       +
       -

     

       121
       +
          p = argv[0] + strlen (argv[0]);

     

       122
       +
          while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))

     

       123
       +
            --p;

     

       124
       +
       @@ -1050,6 +1019,65 @@ main (int argc, char **argv)

     

       125
       +
          prefix_from_env ("COMPILER_PATH", &cpath);

     

       126
       +
          prefix_from_env ("PATH", &path);

     

       127
       +
        

     

       128
       +
       +  /* Determine the full path name of the C compiler to use.  */

     

       129
       +
       +  c_file_name = getenv ("COLLECT_GCC");

     

       130
       +
       +  if (c_file_name == 0)

     

       131
       +
       +    {

     

       132
       +
       +      c_file_name = concat (target_machine, "-gcc", NULL);

     

       133
       +
       +      p = find_a_file (&cpath, c_file_name, X_OK);

     

       134
       +
       +      if (p == 0)

     

       135
       +
       +        p = find_a_file (&path, c_file_name, X_OK);

     

       136
       +
       +

     

       137
       +
       +      if (p == 0) {

     

       138
       +
       +        c_file_name = "gcc";

     

       139
       +
       +        p = find_a_file (&cpath, c_file_name, X_OK);

     

       140
       +
       +        if (p == 0)

     

       141
       +
       +          p = find_a_file (&path, c_file_name, X_OK);

     

       142
       +
       +      }

     

       143
       +
       +    }

     

       144
       +
       +  else

     

       145
       +
       +    {

     

       146
       +
       +      p = find_a_file (&cpath, c_file_name, X_OK);

     

       147
       +
       +

     

       148
       +
       +      /* Here it should be safe to use the system search path since we should have

     

       149
       +
       +        already qualified the name of the compiler when it is needed.  */

     

       150
       +
       +      if (p == 0)

     

       151
       +
       +        p = find_a_file (&path, c_file_name, X_OK);

     

       152
       +
       +    }

     

       153
       +
       +

     

       154
       +
       +  if (p)

     

       155
       +
       +    c_file_name = p;

     

       156
       +
       +

     

       157
       +
       +  if (c_file_name) {

     

       158
       +
       +    is_cross_compiler = strncmp(basename(c_file_name), target_machine, strlen(target_machine)) == 0;

     

       159
       +
       +  }

     

       160
       +
       +

     

       161
       +
       +  for (i = 0; i < USE_LD_MAX; i++)

     

       162
       +
       +    /* lld and mold are platform-agnostic and not prefixed with target

     

       163
       +
       +       triple.  */

     

       164
       +
       +    if (!(i == USE_LLD_LD || i == USE_MOLD_LD) && is_cross_compiler)

     

       165
       +
       +      full_ld_suffixes[i] = concat (target_machine, "-", ld_suffixes[i],

     

       166
       +
       +				    NULL);

     

       167
       +
       +    else

     

       168
       +
       +      full_ld_suffixes[i] = ld_suffixes[i];

     

       169
       +
       +

     

       170
       +
       +  full_nm_suffix =

     

       171
       +
       +    is_cross_compiler ? concat (target_machine, "-", nm_suffix, NULL) : nm_suffix;

     

       172
       +
       +

     

       173
       +
       +  full_gnm_suffix =

     

       174
       +
       +    is_cross_compiler ? concat (target_machine, "-", gnm_suffix, NULL) : gnm_suffix;

     

       175
       +
       +

     

       176
       +
       +  full_strip_suffix =

     

       177
       +
       +    is_cross_compiler ? concat (target_machine, "-", strip_suffix, NULL) : strip_suffix;

     

       178
       +
       +

     

       179
       +
       +  full_gstrip_suffix =

     

       180
       +
       +    is_cross_compiler ? concat (target_machine, "-", gstrip_suffix, NULL) : gstrip_suffix;

     

       181
       +
       +

     

       182
       +
       +#ifdef LDD_SUFFIX

     

       183
       +
       +  full_ldd_suffix =

     

       184
       +
       +    is_cross_compiler ? concat (target_machine, "-", ldd_suffix, NULL) : ldd_suffix;

     

       185
       +
       +#endif

     

       186
       +
       +

     

       187
       +
          /* Try to discover a valid linker/nm/strip to use.  */

     

       188
       +
        

     

       189
       +
          /* Maybe we know the right file to use (if not cross).  */

     

       190
       +
       @@ -1139,27 +1167,6 @@ main (int argc, char **argv)

     

       191
       +
          if (strip_file_name == 0)

     

       192
       +
            strip_file_name = find_a_file (&path, full_strip_suffix, X_OK);

     

       193
       +
        

     

       194
       +
       -  /* Determine the full path name of the C compiler to use.  */

     

       195
       +
       -  c_file_name = getenv ("COLLECT_GCC");

     

       196
       +
       -  if (c_file_name == 0)

     

       197
       +
       -    {

     

       198
       +
       -#ifdef CROSS_DIRECTORY_STRUCTURE

     

       199
       +
       -      c_file_name = concat (target_machine, "-gcc", NULL);

     

       200
       +
       -#else

     

       201
       +
       -      c_file_name = "gcc";

     

       202
       +
       -#endif

     

       203
       +
       -    }

     

       204
       +
       -

     

       205
       +
       -  p = find_a_file (&cpath, c_file_name, X_OK);

     

       206
       +
       -

     

       207
       +
       -  /* Here it should be safe to use the system search path since we should have

     

       208
       +
       -     already qualified the name of the compiler when it is needed.  */

     

       209
       +
       -  if (p == 0)

     

       210
       +
       -    p = find_a_file (&path, c_file_name, X_OK);

     

       211
       +
       -

     

       212
       +
       -  if (p)

     

       213
       +
       -    c_file_name = p;

     

       214
       +
       -

     

       215
       +
          *ld1++ = *ld2++ = ld_file_name;

     

       216
       +
        

     

       217
       +
          /* Make temp file names.  */

     

       218
       +
       @@ -1595,6 +1602,8 @@ main (int argc, char **argv)

     

       219
       +
        	       (c_file ? c_file : "not found"));

     

       220
       +
              fprintf (stderr, "o_file              = %s\n",

     

       221
       +
        	       (o_file ? o_file : "not found"));

     

       222
       +
       +      fprintf (stderr, "is_cross_compiler   = %s\n",

     

       223
       +
       +          (is_cross_compiler ? "yes" : "no"));

     

       224
       +
        

     

       225
       +
              ptr = getenv ("COLLECT_GCC_OPTIONS");

     

       226
       +
              if (ptr)

     

       227
       +
       @@ -1644,9 +1653,9 @@ main (int argc, char **argv)

     

       228
       +
        	  maybe_unlink (export_file);

     

       229
       +
        #endif

     

       230
       +
        	if (lto_mode != LTO_MODE_NONE)

     

       231
       +
       -	  maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);

     

       232
       +
       +	  maybe_run_lto_and_relink (ld1_argv, object_lst, object, false, is_cross_compiler);

     

       233
       +
        	else

     

       234
       +
       -	  post_ld_pass (/*temp_file*/false);

     

       235
       +
       +	  post_ld_pass (/*temp_file*/false, is_cross_compiler);

     

       236
       +
        

     

       237
       +
        	return 0;

     

       238
       +
              }

     

       239
       +
       @@ -1698,7 +1707,7 @@ main (int argc, char **argv)

     

       240
       +
        	do_link (ld1_argv, "ld1_args");

     

       241
       +
        

     

       242
       +
              if (lto_mode)

     

       243
       +
       -        maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);

     

       244
       +
       +        maybe_run_lto_and_relink (ld1_argv, object_lst, object, false, is_cross_compiler);

     

       245
       +
        

     

       246
       +
              /* Strip now if it was requested on the command line.  */

     

       247
       +
              if (strip_flag)

     

       248
       +
       @@ -1716,7 +1725,7 @@ main (int argc, char **argv)

     

       249
       +
        #ifdef COLLECT_EXPORT_LIST

     

       250
       +
              maybe_unlink (export_file);

     

       251
       +
        #endif

     

       252
       +
       -      post_ld_pass (/*temp_file*/false);

     

       253
       +
       +      post_ld_pass (/*temp_file*/false, is_cross_compiler);

     

       254
       +
              return 0;

     

       255
       +
            }

     

       256
       +
        

     

       257
       +
       @@ -1799,15 +1808,15 @@ main (int argc, char **argv)

     

       258
       +
          do_link (ld2_argv, "ld2_args");

     

       259
       +
        

     

       260
       +
          if (lto_mode)

     

       261
       +
       -    maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);

     

       262
       +
       +    maybe_run_lto_and_relink (ld2_argv, object_lst, object, false, is_cross_compiler);

     

       263
       +
        #else

     

       264
       +
          /* Otherwise, simply call ld because link is already done.  */

     

       265
       +
          if (lto_mode)

     

       266
       +
       -    maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);

     

       267
       +
       +    maybe_run_lto_and_relink (ld2_argv, object_lst, object, true, is_cross_compiler);

     

       268
       +
          else

     

       269
       +
            {

     

       270
       +
              fork_execute ("ld", ld2_argv, HAVE_GNU_LD && at_file_supplied, "ld_args");

     

       271
       +
       -      post_ld_pass (/*temp_file*/false);

     

       272
       +
       +      post_ld_pass (/*temp_file*/false, is_cross_compiler);

     

       273
       +
            }

     

       274
       +
        

     

       275
       +
          /* Let scan_prog_file do any final mods (OSF/rose needs this for

     

       276
       +
       @@ -3020,7 +3029,7 @@ process_args (int *argcp, char **argv) {

     

       277
       +
        }

     

       278
       +
        

     

       279
       +
        static void

     

       280
       +
       -do_dsymutil (const char *output_file) {

     

       281
       +
       +do_dsymutil (const char *output_file, bool is_cross_compiler) {

     

       282
       +
          const char *dsymutil = 0;

     

       283
       +
          struct pex_obj *pex;

     

       284
       +
          char **real_argv = XCNEWVEC (char *, verbose ? 4 : 3);

     

       285
       +
       @@ -3032,11 +3041,7 @@ do_dsymutil (const char *output_file) {

     

       286
       +
           here is consistent with the way other installations work (and one can

     

       287
       +
           always symlink a multitarget dsymutil with a target-specific name).  */

     

       288
       +
          const char *dsname = "dsymutil";

     

       289
       +
       -#ifdef CROSS_DIRECTORY_STRUCTURE

     

       290
       +
       -  const char *qname = concat (target_machine, "-", dsname, NULL);

     

       291
       +
       -#else

     

       292
       +
       -  const char *qname = dsname;

     

       293
       +
       -#endif

     

       294
       +
       +  const char *qname = is_cross_compiler ? concat (target_machine, "-", dsname, NULL) : dsname;

     

       295
       +
        #ifdef DEFAULT_DSYMUTIL

     

       296
       +
          /* Configured default takes priority.  */

     

       297
       +
          if (dsymutil == 0 && access (DEFAULT_DSYMUTIL, X_OK) == 0)

     

       298
       +
       @@ -3071,14 +3076,14 @@ do_dsymutil (const char *output_file) {

     

       299
       +
        }

     

       300
       +
        

     

       301
       +
        static void

     

       302
       +
       -post_ld_pass (bool temp_file) {

     

       303
       +
       +post_ld_pass (bool temp_file, bool is_cross_compiler) {

     

       304
       +
          if (!(temp_file && flag_idsym) && !flag_dsym)

     

       305
       +
            return;

     

       306
       +
        

     

       307
       +
       -  do_dsymutil (output_file);

     

       308
       +
       +  do_dsymutil (output_file, is_cross_compiler);

     

       309
       +
        }

     

       310
       +
        #else

     

       311
       +
        static void

     

       312
       +
        process_args (int *argcp ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { }

     

       313
       +
       -static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED) { }

     

       314
       +
       +static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED, bool is_cross_compiler ATTRIBUTE_UNUSED) { }

     

       315
       +
        #endif

pkgs/development/compilers/gcc/ng/README.md

···

       1
       +
       # GCC Next-Generation

     

       2
       +
       

     

       3
       +
       Experimental split GCC package set based on the LLVM package set design.

+47

pkgs/development/compilers/gcc/ng/common/common-let.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         fetchurl ? null,

     

       4
       +
         fetchgit ? null,

     

       5
       +
         release_version ? null,

     

       6
       +
         gitRelease ? null,

     

       7
       +
         officialRelease ? null,

     

       8
       +
         monorepoSrc' ? null,

     

       9
       +
         version ? null,

     

       10
       +
       }@args:

     

       11
       +
       

     

       12
       +
       rec {

     

       13
       +
         gcc_meta = {

     

       14
       +
           license = with lib.licenses; [ gpl3Plus ];

     

       15
       +
           teams = [ lib.teams.gcc ];

     

       16
       +
         };

     

       17
       +
       

     

       18
       +
         releaseInfo =

     

       19
       +
           if gitRelease != null then

     

       20
       +
             rec {

     

       21
       +
               original = gitRelease;

     

       22
       +
               release_version = args.version or original.version;

     

       23
       +
               version = gitRelease.rev-version;

     

       24
       +
             }

     

       25
       +
           else

     

       26
       +
             rec {

     

       27
       +
               original = officialRelease;

     

       28
       +
               release_version = args.version or original.version;

     

       29
       +
               version =

     

       30
       +
                 if original ? candidate then "${release_version}-${original.candidate}" else release_version;

     

       31
       +
             };

     

       32
       +
       

     

       33
       +
         monorepoSrc =

     

       34
       +
           if monorepoSrc' != null then

     

       35
       +
             monorepoSrc'

     

       36
       +
           else if gitRelease != null then

     

       37
       +
             fetchgit {

     

       38
       +
               url = "https://gcc.gnu.org/git/gcc.git";

     

       39
       +
               inherit (gitRelease) rev;

     

       40
       +
               hash = releaseInfo.original.sha256;

     

       41
       +
             }

     

       42
       +
           else

     

       43
       +
             fetchurl {

     

       44
       +
               url = "mirror://gcc/releases/gcc-${releaseInfo.version}/gcc-${releaseInfo.version}.tar.xz";

     

       45
       +
               hash = releaseInfo.original.sha256;

     

       46
       +
             };

     

       47
       +
       }

+221

pkgs/development/compilers/gcc/ng/common/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         newScope,

     

       4
       +
         stdenv,

     

       5
       +
         overrideCC,

     

       6
       +
         fetchgit,

     

       7
       +
         fetchurl,

     

       8
       +
         gitRelease ? null,

     

       9
       +
         officialRelease ? null,

     

       10
       +
         monorepoSrc ? null,

     

       11
       +
         version ? null,

     

       12
       +
         patchesFn ? lib.id,

     

       13
       +
         wrapCCWith,

     

       14
       +
         binutilsNoLibc,

     

       15
       +
         binutils,

     

       16
       +
         buildGccPackages,

     

       17
       +
         targetGccPackages,

     

       18
       +
         makeScopeWithSplicing',

     

       19
       +
         otherSplices,

     

       20
       +
         ...

     

       21
       +
       }@args:

     

       22
       +
       

     

       23
       +
       assert lib.assertMsg (lib.xor (gitRelease != null) (officialRelease != null)) (

     

       24
       +
         "must specify `gitRelease` or `officialRelease`"

     

       25
       +
         + (lib.optionalString (gitRelease != null) " — not both")

     

       26
       +
       );

     

       27
       +
       

     

       28
       +
       let

     

       29
       +
         monorepoSrc' = monorepoSrc;

     

       30
       +
       

     

       31
       +
         metadata = rec {

     

       32
       +
           inherit

     

       33
       +
             (import ./common-let.nix {

     

       34
       +
               inherit (args)

     

       35
       +
                 lib

     

       36
       +
                 gitRelease

     

       37
       +
                 officialRelease

     

       38
       +
                 version

     

       39
       +
                 ;

     

       40
       +
             })

     

       41
       +
             releaseInfo

     

       42
       +
             ;

     

       43
       +
           inherit (releaseInfo) release_version version;

     

       44
       +
           inherit

     

       45
       +
             (import ./common-let.nix {

     

       46
       +
               inherit

     

       47
       +
                 lib

     

       48
       +
                 fetchgit

     

       49
       +
                 fetchurl

     

       50
       +
                 release_version

     

       51
       +
                 gitRelease

     

       52
       +
                 officialRelease

     

       53
       +
                 monorepoSrc'

     

       54
       +
                 version

     

       55
       +
                 ;

     

       56
       +
             })

     

       57
       +
             gcc_meta

     

       58
       +
             monorepoSrc

     

       59
       +
             ;

     

       60
       +
           src = monorepoSrc;

     

       61
       +
           versionDir =

     

       62
       +
             (builtins.toString ../.)

     

       63
       +
             + "/${if (gitRelease != null) then "git" else lib.versions.major release_version}";

     

       64
       +
           getVersionFile =

     

       65
       +
             p:

     

       66
       +
             builtins.path {

     

       67
       +
               name = builtins.baseNameOf p;

     

       68
       +
               path =

     

       69
       +
                 let

     

       70
       +
                   patches = args.patchesFn (import ./patches.nix);

     

       71
       +
       

     

       72
       +
                   constraints = patches."${p}" or null;

     

       73
       +
                   matchConstraint =

     

       74
       +
                     {

     

       75
       +
                       before ? null,

     

       76
       +
                       after ? null,

     

       77
       +
                       path,

     

       78
       +
                     }:

     

       79
       +
                     let

     

       80
       +
                       check = fn: value: if value == null then true else fn release_version value;

     

       81
       +
                       matchBefore = check lib.versionOlder before;

     

       82
       +
                       matchAfter = check lib.versionAtLeast after;

     

       83
       +
                     in

     

       84
       +
                     matchBefore && matchAfter;

     

       85
       +
       

     

       86
       +
                   patchDir =

     

       87
       +
                     toString

     

       88
       +
                       (

     

       89
       +
                         if constraints == null then

     

       90
       +
                           { path = metadata.versionDir; }

     

       91
       +
                         else

     

       92
       +
                           (lib.findFirst matchConstraint { path = metadata.versionDir; } constraints)

     

       93
       +
                       ).path;

     

       94
       +
                 in

     

       95
       +
                 "${patchDir}/${p}";

     

       96
       +
             };

     

       97
       +
         };

     

       98
       +
       in

     

       99
       +
       makeScopeWithSplicing' {

     

       100
       +
         inherit otherSplices;

     

       101
       +
         f =

     

       102
       +
           gccPackages:

     

       103
       +
           let

     

       104
       +
             callPackage = gccPackages.newScope (args // metadata);

     

       105
       +
           in

     

       106
       +
           {

     

       107
       +
             stdenv = overrideCC stdenv gccPackages.gcc;

     

       108
       +
       

     

       109
       +
             gcc-unwrapped = callPackage ./gcc {

     

       110
       +
               bintools = binutils;

     

       111
       +
             };

     

       112
       +
       

     

       113
       +
             libbacktrace = callPackage ./libbacktrace { };

     

       114
       +
             libiberty = callPackage ./libiberty { };

     

       115
       +
             libsanitizer = callPackage ./libsanitizer { };

     

       116
       +
             libquadmath = callPackage ./libquadmath { };

     

       117
       +
       

     

       118
       +
             gfortran-unwrapped = gccPackages.gcc-unwrapped.override {

     

       119
       +
               stdenv = overrideCC stdenv buildGccPackages.gcc;

     

       120
       +
               langFortran = true;

     

       121
       +
             };

     

       122
       +
       

     

       123
       +
             gfortran = wrapCCWith rec {

     

       124
       +
               cc = gccPackages.gfortran-unwrapped;

     

       125
       +
               libcxx = targetGccPackages.libstdcxx;

     

       126
       +
               bintools = binutils;

     

       127
       +
               extraPackages = [

     

       128
       +
                 targetGccPackages.libgcc

     

       129
       +
               ];

     

       130
       +
               nixSupport.cc-cflags = [

     

       131
       +
                 "-B${targetGccPackages.libgcc}/lib"

     

       132
       +
                 "-B${targetGccPackages.libssp}/lib"

     

       133
       +
                 "-B${targetGccPackages.libatomic}/lib"

     

       134
       +
               ];

     

       135
       +
             };

     

       136
       +
       

     

       137
       +
             gcc = wrapCCWith rec {

     

       138
       +
               cc = gccPackages.gcc-unwrapped;

     

       139
       +
               libcxx = targetGccPackages.libstdcxx;

     

       140
       +
               bintools = binutils;

     

       141
       +
               extraPackages = [

     

       142
       +
                 targetGccPackages.libgcc

     

       143
       +
               ];

     

       144
       +
               nixSupport.cc-cflags = [

     

       145
       +
                 "-B${targetGccPackages.libgcc}/lib"

     

       146
       +
                 "-B${targetGccPackages.libssp}/lib"

     

       147
       +
                 "-B${targetGccPackages.libatomic}/lib"

     

       148
       +
               ];

     

       149
       +
             };

     

       150
       +
       

     

       151
       +
             gccNoLibgcc = wrapCCWith rec {

     

       152
       +
               cc = gccPackages.gcc-unwrapped;

     

       153
       +
               libcxx = null;

     

       154
       +
               bintools = binutilsNoLibc;

     

       155
       +
               extraPackages = [ ];

     

       156
       +
               nixSupport.cc-cflags = [

     

       157
       +
                 "-nostartfiles"

     

       158
       +
               ];

     

       159
       +
             };

     

       160
       +
       

     

       161
       +
             libgcc = callPackage ./libgcc {

     

       162
       +
               stdenv = overrideCC stdenv buildGccPackages.gccNoLibgcc;

     

       163
       +
             };

     

       164
       +
       

     

       165
       +
             gccWithLibc = wrapCCWith rec {

     

       166
       +
               cc = gccPackages.gcc-unwrapped;

     

       167
       +
               libcxx = null;

     

       168
       +
               bintools = binutils;

     

       169
       +
               extraPackages = [

     

       170
       +
                 targetGccPackages.libgcc

     

       171
       +
               ];

     

       172
       +
               nixSupport.cc-cflags = [

     

       173
       +
                 "-B${targetGccPackages.libgcc}/lib"

     

       174
       +
               ];

     

       175
       +
             };

     

       176
       +
       

     

       177
       +
             libssp = callPackage ./libssp {

     

       178
       +
               stdenv = overrideCC stdenv buildGccPackages.gccWithLibc;

     

       179
       +
             };

     

       180
       +
       

     

       181
       +
             gccWithLibssp = wrapCCWith rec {

     

       182
       +
               cc = gccPackages.gcc-unwrapped;

     

       183
       +
               libcxx = null;

     

       184
       +
               bintools = binutils;

     

       185
       +
               extraPackages = [

     

       186
       +
                 targetGccPackages.libgcc

     

       187
       +
               ];

     

       188
       +
               nixSupport.cc-cflags = [

     

       189
       +
                 "-B${targetGccPackages.libgcc}/lib"

     

       190
       +
                 "-B${targetGccPackages.libssp}/lib"

     

       191
       +
               ];

     

       192
       +
             };

     

       193
       +
       

     

       194
       +
             libatomic = callPackage ./libatomic {

     

       195
       +
               stdenv = overrideCC stdenv buildGccPackages.gccWithLibssp;

     

       196
       +
             };

     

       197
       +
       

     

       198
       +
             gccWithLibatomic = wrapCCWith rec {

     

       199
       +
               cc = gccPackages.gcc-unwrapped;

     

       200
       +
               libcxx = null;

     

       201
       +
               bintools = binutils;

     

       202
       +
               extraPackages = [

     

       203
       +
                 targetGccPackages.libgcc

     

       204
       +
               ];

     

       205
       +
               nixSupport.cc-cflags = [

     

       206
       +
                 "-B${targetGccPackages.libgcc}/lib"

     

       207
       +
                 "-B${targetGccPackages.libssp}/lib"

     

       208
       +
                 "-B${targetGccPackages.libatomic}/lib"

     

       209
       +
               ];

     

       210
       +
             };

     

       211
       +
       

     

       212
       +
             libgfortran = callPackage ./libgfortran {

     

       213
       +
               stdenv = overrideCC stdenv buildGccPackages.gcc;

     

       214
       +
               inherit (buildGccPackages) gfortran;

     

       215
       +
             };

     

       216
       +
       

     

       217
       +
             libstdcxx = callPackage ./libstdcxx {

     

       218
       +
               stdenv = overrideCC stdenv buildGccPackages.gccWithLibatomic;

     

       219
       +
             };

     

       220
       +
           };

     

       221
       +
       }

+249

pkgs/development/compilers/gcc/ng/common/gcc/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         gcc_meta,

     

       5
       +
         release_version,

     

       6
       +
         version,

     

       7
       +
         monorepoSrc ? null,

     

       8
       +
         langAda ? false,

     

       9
       +
         langC ? true,

     

       10
       +
         langCC ? true,

     

       11
       +
         langD ? false,

     

       12
       +
         langFortran ? false,

     

       13
       +
         langGo ? false,

     

       14
       +
         langJava ? false,

     

       15
       +
         langObjC ? stdenv.targetPlatform.isDarwin,

     

       16
       +
         langObjCpp ? stdenv.targetPlatform.isDarwin,

     

       17
       +
         langJit ? false,

     

       18
       +
         enablePlugin ? lib.systems.equals stdenv.hostPlatform stdenv.buildPlatform,

     

       19
       +
         runCommand,

     

       20
       +
         buildPackages,

     

       21
       +
         isl,

     

       22
       +
         zlib,

     

       23
       +
         gmp,

     

       24
       +
         libmpc,

     

       25
       +
         mpfr,

     

       26
       +
         libelf,

     

       27
       +
         perl,

     

       28
       +
         texinfo,

     

       29
       +
         which,

     

       30
       +
         gettext,

     

       31
       +
         getVersionFile,

     

       32
       +
         buildGccPackages,

     

       33
       +
         targetPackages,

     

       34
       +
         libc,

     

       35
       +
         bintools,

     

       36
       +
       }:

     

       37
       +
       let

     

       38
       +
         inherit (stdenv) targetPlatform hostPlatform;

     

       39
       +
         targetPrefix = lib.optionalString (targetPlatform != hostPlatform) "${targetPlatform.config}-";

     

       40
       +
       in

     

       41
       +
       stdenv.mkDerivation (finalAttrs: {

     

       42
       +
         pname = "${targetPrefix}${if langFortran then "gfortran" else "gcc"}";

     

       43
       +
         inherit version;

     

       44
       +
       

     

       45
       +
         src = monorepoSrc;

     

       46
       +
       

     

       47
       +
         outputs = [

     

       48
       +
           "out"

     

       49
       +
           "man"

     

       50
       +
           "info"

     

       51
       +
         ];

     

       52
       +
       

     

       53
       +
         patches = [

     

       54
       +
           # Submitted:

     

       55
       +
           #  - https://gcc.gnu.org/pipermail/gcc-patches/2021-August/577639.html

     

       56
       +
           #  - https://gcc.gnu.org/pipermail/gcc-patches/2021-August/577640.html

     

       57
       +
           #  - https://gcc.gnu.org/pipermail/gcc-patches/2021-August/577638.html

     

       58
       +
           #

     

       59
       +
           # In Git: https://github.com/Ericson2314/gcc/tree/prog-target-15

     

       60
       +
           (getVersionFile "gcc/0001-find_a_program-First-search-with-machine-prefix.patch")

     

       61
       +
           (getVersionFile "gcc/0002-driver-for_each_pass-Pass-to-callback-whether-dir-is.patch")

     

       62
       +
           (getVersionFile "gcc/0003-find_a_program-Only-search-for-prefixed-paths-in-und.patch")

     

       63
       +
       

     

       64
       +
           # Submitted: https://inbox.sourceware.org/gcc-patches/20210818203840.1550133-1-John.Ericson@Obsidian.Systems/T/#t

     

       65
       +
           # In Git: https://github.com/Ericson2314/gcc/tree/libgcc-custom-threading-model-15

     

       66
       +
           (getVersionFile "gcc/custom-threading-model.patch")

     

       67
       +
       

     

       68
       +
           # TODO: fix up and send to upstream

     

       69
       +
           (getVersionFile "gcc/fix-collect2-paths.diff")

     

       70
       +
         ];

     

       71
       +
       

     

       72
       +
         enableParallelBuilding = true;

     

       73
       +
       

     

       74
       +
         hardeningDisable = [

     

       75
       +
           "format" # Some macro-indirect formatting in e.g. libcpp

     

       76
       +
         ];

     

       77
       +
       

     

       78
       +
         strictDeps = true;

     

       79
       +
       

     

       80
       +
         depsBuildBuild = [ buildPackages.stdenv.cc ];

     

       81
       +
         nativeBuildInputs = [

     

       82
       +
           texinfo

     

       83
       +
           which

     

       84
       +
           gettext

     

       85
       +
         ] ++ lib.optional (perl != null) perl;

     

       86
       +
       

     

       87
       +
         buildInputs =

     

       88
       +
           [

     

       89
       +
             gmp

     

       90
       +
             libmpc

     

       91
       +
             mpfr

     

       92
       +
             libelf

     

       93
       +
           ]

     

       94
       +
           ++ lib.optional (isl != null) isl

     

       95
       +
           ++ lib.optional (zlib != null) zlib;

     

       96
       +
       

     

       97
       +
         postUnpack = ''

     

       98
       +
           mkdir -p ./build

     

       99
       +
           buildRoot=$(readlink -e "./build")

     

       100
       +
         '';

     

       101
       +
       

     

       102
       +
         postPatch =

     

       103
       +
           ''

     

       104
       +
             configureScripts=$(find . -name configure)

     

       105
       +
             for configureScript in $configureScripts; do

     

       106
       +
               patchShebangs $configureScript

     

       107
       +
             done

     

       108
       +
       

     

       109
       +
             patchShebangs libbacktrace/install-debuginfo-for-buildid.sh

     

       110
       +
             patchShebangs runtest

     

       111
       +
           ''

     

       112
       +
           # This should kill all the stdinc frameworks that gcc and friends like to

     

       113
       +
           # insert into default search paths.

     

       114
       +
           + lib.optionalString hostPlatform.isDarwin ''

     

       115
       +
             substituteInPlace gcc/config/darwin-c.c \

     

       116
       +
               --replace 'if (stdinc)' 'if (0)'

     

       117
       +
           '';

     

       118
       +
       

     

       119
       +
         preConfigure =

     

       120
       +
           # Don't built target libraries, because we want to build separately

     

       121
       +
           ''

     

       122
       +
             substituteInPlace configure \

     

       123
       +
               --replace 'noconfigdirs=""' 'noconfigdirs="$noconfigdirs $target_libraries"'

     

       124
       +
           ''

     

       125
       +
           # HACK: if host and target config are the same, but the platforms are

     

       126
       +
           # actually different we need to convince the configure script that it

     

       127
       +
           # is in fact building a cross compiler although it doesn't believe it.

     

       128
       +
           +

     

       129
       +
             lib.optionalString (targetPlatform.config == hostPlatform.config && targetPlatform != hostPlatform)

     

       130
       +
               ''

     

       131
       +
                 substituteInPlace configure --replace is_cross_compiler=no is_cross_compiler=yes

     

       132
       +
               ''

     

       133
       +
           # Cannot configure from src dir

     

       134
       +
           + ''

     

       135
       +
             cd "$buildRoot"

     

       136
       +
       

     

       137
       +
             mkdir -p "$buildRoot/libbacktrace/.libs"

     

       138
       +
             cp ${buildGccPackages.libbacktrace}/lib/libbacktrace.a "$buildRoot/libbacktrace/.libs/libbacktrace.a"

     

       139
       +
             cp -r ${buildGccPackages.libbacktrace}/lib/*.la "$buildRoot/libbacktrace"

     

       140
       +
             cp -r ${buildGccPackages.libbacktrace.dev}/include/*.h "$buildRoot/libbacktrace"

     

       141
       +
       

     

       142
       +
             mkdir -p "$buildRoot/libiberty/pic"

     

       143
       +
             cp ${buildGccPackages.libiberty}/lib/libiberty.a "$buildRoot/libiberty"

     

       144
       +
             cp ${buildGccPackages.libiberty}/lib/libiberty_pic.a "$buildRoot/libiberty/pic/libiberty.a"

     

       145
       +
             touch "$buildRoot/libiberty/stamp-noasandir"

     

       146
       +
             touch "$buildRoot/libiberty/stamp-h"

     

       147
       +
             touch "$buildRoot/libiberty/stamp-picdir"

     

       148
       +
       

     

       149
       +
             mkdir -p "$buildRoot/build-${stdenv.hostPlatform.config}"

     

       150
       +
             cp -r "$buildRoot/libiberty" "$buildRoot/build-${stdenv.hostPlatform.config}/libiberty"

     

       151
       +
       

     

       152
       +
             configureScript=../$sourceRoot/configure

     

       153
       +
           '';

     

       154
       +
       

     

       155
       +
         # Don't store the configure flags in the resulting executables.

     

       156
       +
         postConfigure = ''

     

       157
       +
           sed -e '/TOPLEVEL_CONFIGURE_ARGUMENTS=/d' -i Makefile

     

       158
       +
         '';

     

       159
       +
       

     

       160
       +
         dontDisableStatic = true;

     

       161
       +
       

     

       162
       +
         configurePlatforms = [

     

       163
       +
           "build"

     

       164
       +
           "host"

     

       165
       +
           "target"

     

       166
       +
         ];

     

       167
       +
       

     

       168
       +
         configureFlags =

     

       169
       +
           [

     

       170
       +
             # Force target prefix. The behavior if `--target` and `--host` are

     

       171
       +
             # specified is inconsistent: Sometimes specifying `--target` always causes

     

       172
       +
             # a prefix to be generated, sometimes it's only added if the `--host` and

     

       173
       +
             # `--target` differ. This means that sometimes there may be a prefix even

     

       174
       +
             # though nixpkgs doesn't expect one and sometimes there may be none even

     

       175
       +
             # though nixpkgs expects one (since not all information is serialized into

     

       176
       +
             # the config attribute). The easiest way out of these problems is to always

     

       177
       +
             # set the program prefix, so gcc will conform to our expectations.

     

       178
       +
             "--program-prefix=${targetPrefix}"

     

       179
       +
       

     

       180
       +
             "--disable-dependency-tracking"

     

       181
       +
             "--enable-fast-install"

     

       182
       +
             "--disable-serial-configure"

     

       183
       +
             "--disable-bootstrap"

     

       184
       +
             "--disable-decimal-float"

     

       185
       +
             "--disable-install-libiberty"

     

       186
       +
             "--disable-multilib"

     

       187
       +
             "--disable-nls"

     

       188
       +
             "--disable-shared"

     

       189
       +
             "--enable-languages=${

     

       190
       +
               lib.concatStrings (

     

       191
       +
                 lib.intersperse "," (

     

       192
       +
                   lib.optional langC "c"

     

       193
       +
                   ++ lib.optional langCC "c++"

     

       194
       +
                   ++ lib.optional langD "d"

     

       195
       +
                   ++ lib.optional langFortran "fortran"

     

       196
       +
                   ++ lib.optional langJava "java"

     

       197
       +
                   ++ lib.optional langAda "ada"

     

       198
       +
                   ++ lib.optional langGo "go"

     

       199
       +
                   ++ lib.optional langObjC "objc"

     

       200
       +
                   ++ lib.optional langObjCpp "obj-c++"

     

       201
       +
                   ++ lib.optional langJit "jit"

     

       202
       +
                 )

     

       203
       +
               )

     

       204
       +
             }"

     

       205
       +
             (lib.withFeature (isl != null) "isl")

     

       206
       +
             "--without-headers"

     

       207
       +
             "--with-gnu-as"

     

       208
       +
             "--with-gnu-ld"

     

       209
       +
             "--with-as=${lib.getExe' bintools "${bintools.targetPrefix}as"}"

     

       210
       +
             "--with-system-zlib"

     

       211
       +
             "--without-included-gettext"

     

       212
       +
             "--enable-linker-build-id"

     

       213
       +
             "--with-sysroot=${lib.getDev (targetPackages.libc or libc)}"

     

       214
       +
             "--with-native-system-header-dir=/include"

     

       215
       +
           ]

     

       216
       +
           ++ lib.optionals enablePlugin [

     

       217
       +
             "--enable-plugin"

     

       218
       +
             "--enable-plugins"

     

       219
       +
           ]

     

       220
       +
           ++

     

       221
       +
             # Only pass when the arch supports it.

     

       222
       +
             # Exclude RISC-V because GCC likes to fail when the string is empty on RISC-V.

     

       223
       +
             lib.optionals (targetPlatform.isAarch || targetPlatform.isAvr || targetPlatform.isx86_64) [

     

       224
       +
               "--with-multilib-list="

     

       225
       +
             ];

     

       226
       +
       

     

       227
       +
         doCheck = false;

     

       228
       +
       

     

       229
       +
         postInstall = ''

     

       230
       +
           moveToOutput "lib/gcc/${targetPlatform.config}/${version}/plugin/include" "''${!outputDev}"

     

       231
       +
         '';

     

       232
       +
       

     

       233
       +
         passthru = {

     

       234
       +
           inherit

     

       235
       +
             langC

     

       236
       +
             langCC

     

       237
       +
             langObjC

     

       238
       +
             langObjCpp

     

       239
       +
             langAda

     

       240
       +
             langFortran

     

       241
       +
             langGo

     

       242
       +
             ;

     

       243
       +
           isGNU = true;

     

       244
       +
         };

     

       245
       +
       

     

       246
       +
         meta = gcc_meta // {

     

       247
       +
           homepage = "https://gcc.gnu.org/";

     

       248
       +
         };

     

       249
       +
       })

+48

pkgs/development/compilers/gcc/ng/common/libatomic/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         gcc_meta,

     

       5
       +
         release_version,

     

       6
       +
         version,

     

       7
       +
         getVersionFile,

     

       8
       +
         autoreconfHook269,

     

       9
       +
         monorepoSrc ? null,

     

       10
       +
         runCommand,

     

       11
       +
       }:

     

       12
       +
       stdenv.mkDerivation (finalAttrs: {

     

       13
       +
         pname = "libatomic";

     

       14
       +
         inherit version;

     

       15
       +
       

     

       16
       +
         src = monorepoSrc;

     

       17
       +
       

     

       18
       +
         patches = [

     

       19
       +
           (getVersionFile "gcc/custom-threading-model.patch")

     

       20
       +
         ];

     

       21
       +
       

     

       22
       +
         enableParallelBuilding = true;

     

       23
       +
       

     

       24
       +
         nativeBuildInputs = [

     

       25
       +
           autoreconfHook269

     

       26
       +
         ];

     

       27
       +
       

     

       28
       +
         postPatch = ''

     

       29
       +
           sourceRoot=$(readlink -e "./libatomic")

     

       30
       +
         '';

     

       31
       +
       

     

       32
       +
         preConfigure = ''

     

       33
       +
           mkdir ../build

     

       34
       +
           cd ../build

     

       35
       +
           configureScript=$sourceRoot/configure

     

       36
       +
           chmod +x "$configureScript"

     

       37
       +
         '';

     

       38
       +
       

     

       39
       +
         doCheck = true;

     

       40
       +
       

     

       41
       +
         passthru = {

     

       42
       +
           isGNU = true;

     

       43
       +
         };

     

       44
       +
       

     

       45
       +
         meta = gcc_meta // {

     

       46
       +
           homepage = "https://gcc.gnu.org/";

     

       47
       +
         };

     

       48
       +
       })

+74

pkgs/development/compilers/gcc/ng/common/libbacktrace/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         gcc_meta,

     

       5
       +
         release_version,

     

       6
       +
         version,

     

       7
       +
         monorepoSrc ? null,

     

       8
       +
         runCommand,

     

       9
       +
       }:

     

       10
       +
       stdenv.mkDerivation (finalAttrs: {

     

       11
       +
         pname = "libbacktrace";

     

       12
       +
         inherit version;

     

       13
       +
       

     

       14
       +
         src = runCommand "libbacktrace-src-${version}" { src = monorepoSrc; } ''

     

       15
       +
           runPhase unpackPhase

     

       16
       +
       

     

       17
       +
           mkdir -p "$out/gcc"

     

       18
       +
           cp gcc/BASE-VER "$out/gcc"

     

       19
       +
           cp gcc/DATESTAMP "$out/gcc"

     

       20
       +
       

     

       21
       +
           cp -r include "$out"

     

       22
       +
           cp -r libbacktrace "$out"

     

       23
       +
       

     

       24
       +
           cp config.guess "$out"

     

       25
       +
           cp config.rpath "$out"

     

       26
       +
           cp config.sub "$out"

     

       27
       +
           cp config-ml.in "$out"

     

       28
       +
           cp ltmain.sh "$out"

     

       29
       +
           cp install-sh "$out"

     

       30
       +
           cp move-if-change "$out"

     

       31
       +
           cp mkinstalldirs "$out"

     

       32
       +
           cp test-driver "$out"

     

       33
       +
       

     

       34
       +
           [[ -f MD5SUMS ]]; cp MD5SUMS "$out"

     

       35
       +
         '';

     

       36
       +
       

     

       37
       +
         outputs = [

     

       38
       +
           "out"

     

       39
       +
           "dev"

     

       40
       +
         ];

     

       41
       +
       

     

       42
       +
         enableParallelBuilding = true;

     

       43
       +
       

     

       44
       +
         sourceRoot = "${finalAttrs.src.name}/libbacktrace";

     

       45
       +
       

     

       46
       +
         preConfigure = ''

     

       47
       +
           mkdir ../../build

     

       48
       +
           cd ../../build

     

       49
       +
           configureScript=../$sourceRoot/configure

     

       50
       +
         '';

     

       51
       +
       

     

       52
       +
         installPhase = ''

     

       53
       +
           runHook preInstall

     

       54
       +
       

     

       55
       +
           mkdir -p "$out/lib"

     

       56
       +
           cp .libs/*.a "$out/lib"

     

       57
       +
           cp libbacktrace*.la "$out/lib"

     

       58
       +
       

     

       59
       +
           mkdir -p "$dev/include"

     

       60
       +
           cp backtrace-supported.h "$dev/include"

     

       61
       +
       

     

       62
       +
           runHook postInstall

     

       63
       +
         '';

     

       64
       +
       

     

       65
       +
         doCheck = true;

     

       66
       +
       

     

       67
       +
         passthru = {

     

       68
       +
           isGNU = true;

     

       69
       +
         };

     

       70
       +
       

     

       71
       +
         meta = gcc_meta // {

     

       72
       +
           homepage = "https://gcc.gnu.org/";

     

       73
       +
         };

     

       74
       +
       })

+205

pkgs/development/compilers/gcc/ng/common/libgcc/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         gcc_meta,

     

       5
       +
         release_version,

     

       6
       +
         version,

     

       7
       +
         getVersionFile,

     

       8
       +
         monorepoSrc ? null,

     

       9
       +
         autoreconfHook269,

     

       10
       +
         buildGccPackages,

     

       11
       +
         buildPackages,

     

       12
       +
         which,

     

       13
       +
         python3,

     

       14
       +
       }:

     

       15
       +
       stdenv.mkDerivation (finalAttrs: {

     

       16
       +
         pname = "libgcc";

     

       17
       +
         inherit version;

     

       18
       +
       

     

       19
       +
         src = monorepoSrc;

     

       20
       +
       

     

       21
       +
         outputs = [

     

       22
       +
           "out"

     

       23
       +
           "dev"

     

       24
       +
         ];

     

       25
       +
       

     

       26
       +
         strictDeps = true;

     

       27
       +
       

     

       28
       +
         depsBuildBuild = [

     

       29
       +
           buildPackages.stdenv.cc

     

       30
       +
           buildGccPackages.libiberty

     

       31
       +
         ];

     

       32
       +
       

     

       33
       +
         nativeBuildInputs = [

     

       34
       +
           autoreconfHook269

     

       35
       +
           which

     

       36
       +
           python3

     

       37
       +
         ];

     

       38
       +
       

     

       39
       +
         patches = [

     

       40
       +
           (getVersionFile "gcc/custom-threading-model.patch")

     

       41
       +
         ];

     

       42
       +
       

     

       43
       +
         autoreconfFlags = "--install --force --verbose . libgcc";

     

       44
       +
       

     

       45
       +
         postUnpack = ''

     

       46
       +
           mkdir -p ./build

     

       47
       +
           buildRoot=$(readlink -e "./build")

     

       48
       +
         '';

     

       49
       +
       

     

       50
       +
         postPatch = ''

     

       51
       +
           sourceRoot=$(readlink -e "./libgcc")

     

       52
       +
         '';

     

       53
       +
       

     

       54
       +
         enableParallelBuilding = true;

     

       55
       +
       

     

       56
       +
         preConfigure =

     

       57
       +
           ''

     

       58
       +
             cd "$buildRoot"

     

       59
       +
       

     

       60
       +
             mkdir -p build-${stdenv.buildPlatform.config}/libiberty/

     

       61
       +
             cd build-${stdenv.buildPlatform.config}/libiberty/

     

       62
       +
             ln -s ${buildGccPackages.libiberty}/lib/libiberty.a ./

     

       63
       +
       

     

       64
       +
             mkdir -p "$buildRoot/gcc"

     

       65
       +
             cd "$buildRoot/gcc"

     

       66
       +
       

     

       67
       +
             (

     

       68
       +
             export AS_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$(basename $AS_FOR_BUILD)"}

     

       69
       +
             export CC_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$(basename $CC_FOR_BUILD)"}

     

       70
       +
             export CPP_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$(basename $CPP_FOR_BUILD)"}

     

       71
       +
             export CXX_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$(basename $CXX_FOR_BUILD)"}

     

       72
       +
             export LD_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc.bintools "$(basename $LD_FOR_BUILD)"}

     

       73
       +
       

     

       74
       +
             export AS=$AS_FOR_BUILD

     

       75
       +
             export CC=$CC_FOR_BUILD

     

       76
       +
             export CPP=$CPP_FOR_BUILD

     

       77
       +
             export CXX=$CXX_FOR_BUILD

     

       78
       +
             export LD=$LD_FOR_BUILD

     

       79
       +
       

     

       80
       +
             export AS_FOR_TARGET=${lib.getExe' stdenv.cc "$(basename $AS)"}

     

       81
       +
             export CC_FOR_TARGET=${lib.getExe' stdenv.cc "$(basename $CC)"}

     

       82
       +
             export CPP_FOR_TARGET=${lib.getExe' stdenv.cc "$(basename $CPP)"}

     

       83
       +
             export LD_FOR_TARGET=${lib.getExe' stdenv.cc.bintools "$(basename $LD)"}

     

       84
       +
       

     

       85
       +
             export NIX_CFLAGS_COMPILE_FOR_BUILD+=' -DGENERATOR_FILE=1'

     

       86
       +
       

     

       87
       +
             "$sourceRoot/../gcc/configure" $topLevelConfigureFlags

     

       88
       +
       

     

       89
       +
             sed -e 's,libgcc.mvars:.*$,libgcc.mvars:,' -i Makefile

     

       90
       +
       

     

       91
       +
             make \

     

       92
       +
               config.h \

     

       93
       +
               libgcc.mvars \

     

       94
       +
               tconfig.h \

     

       95
       +
               tm.h \

     

       96
       +
               options.h \

     

       97
       +
               insn-constants.h \

     

       98
       +
               insn-modes.h \

     

       99
       +
               version.h

     

       100
       +
             )

     

       101
       +
             mkdir -p "$buildRoot/gcc/include"

     

       102
       +
       

     

       103
       +
             mkdir -p "$buildRoot/gcc/${stdenv.hostPlatform.config}/libgcc"

     

       104
       +
             cd "$buildRoot/gcc/${stdenv.hostPlatform.config}/libgcc"

     

       105
       +
             configureScript=$sourceRoot/configure

     

       106
       +
             chmod +x "$configureScript"

     

       107
       +
       

     

       108
       +
             export AS_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$(basename $AS_FOR_BUILD)"}

     

       109
       +
             export CC_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$(basename $CC_FOR_BUILD)"}

     

       110
       +
             export CPP_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$(basename $CPP_FOR_BUILD)"}

     

       111
       +
             export CXX_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$(basename $CXX_FOR_BUILD)"}

     

       112
       +
             export LD_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc.bintools "$(basename $LD_FOR_BUILD)"}

     

       113
       +
       

     

       114
       +
             export AS=${lib.getExe' stdenv.cc "$(basename $AS)"}

     

       115
       +
             export CC=${lib.getExe' stdenv.cc "$(basename $CC)"}

     

       116
       +
             export CPP=${lib.getExe' stdenv.cc "$(basename $CPP)"}

     

       117
       +
             export CXX=${lib.getExe' stdenv.cc "$(basename $CXX)"}

     

       118
       +
             export LD=${lib.getExe' stdenv.cc.bintools "$(basename $LD)"}

     

       119
       +
       

     

       120
       +
             export AS_FOR_TARGET=${lib.getExe' stdenv.cc "$(basename $AS_FOR_TARGET)"}

     

       121
       +
             export CC_FOR_TARGET=${lib.getExe' stdenv.cc "$(basename $CC_FOR_TARGET)"}

     

       122
       +
             export CPP_FOR_TARGET=${lib.getExe' stdenv.cc "$(basename $CPP_FOR_TARGET)"}

     

       123
       +
             export LD_FOR_TARGET=${lib.getExe' stdenv.cc.bintools "$(basename $LD_FOR_TARGET)"}

     

       124
       +
           ''

     

       125
       +
           + lib.optionalString stdenv.hostPlatform.isMusl ''

     

       126
       +
             NIX_CFLAGS_COMPILE_OLD=$NIX_CFLAGS_COMPILE

     

       127
       +
             NIX_CFLAGS_COMPILE+=' -isystem ${stdenv.cc.cc}/lib/gcc/${stdenv.hostPlatform.config}/${version}/include-fixed'

     

       128
       +
           '';

     

       129
       +
       

     

       130
       +
         topLevelConfigureFlags =

     

       131
       +
           [

     

       132
       +
             "--build=${stdenv.buildPlatform.config}"

     

       133
       +
             "--host=${stdenv.buildPlatform.config}"

     

       134
       +
             "--target=${stdenv.hostPlatform.config}"

     

       135
       +
       

     

       136
       +
             "--disable-bootstrap"

     

       137
       +
             "--disable-multilib"

     

       138
       +
             "--enable-languages=c"

     

       139
       +
       

     

       140
       +
             "--disable-fixincludes"

     

       141
       +
             "--disable-intl"

     

       142
       +
             "--disable-lto"

     

       143
       +
             "--disable-libatomic"

     

       144
       +
             "--disable-libbacktrace"

     

       145
       +
             "--disable-libcpp"

     

       146
       +
             "--disable-libssp"

     

       147
       +
             "--disable-libquadmath"

     

       148
       +
             "--disable-libgomp"

     

       149
       +
             "--disable-libvtv"

     

       150
       +
             "--disable-vtable-verify"

     

       151
       +
       

     

       152
       +
             "--with-system-zlib"

     

       153
       +
           ]

     

       154
       +
           ++

     

       155
       +
             lib.optional (!stdenv.hostPlatform.isRiscV)

     

       156
       +
               # RISC-V does not like it being empty

     

       157
       +
               "--with-multilib-list="

     

       158
       +
           ++

     

       159
       +
             lib.optional (stdenv.hostPlatform.libc == "glibc")

     

       160
       +
               # Cheat and use previous stage's glibc to avoid infinite recursion. As

     

       161
       +
               # of GCC 11, libgcc only cares if the version is greater than 2.19,

     

       162
       +
               # which is quite ancient, so this little lie should be fine.

     

       163
       +
               "--with-glibc-version=${buildPackages.glibc.version}";

     

       164
       +
       

     

       165
       +
         configurePlatforms = [

     

       166
       +
           "build"

     

       167
       +
           "host"

     

       168
       +
         ];

     

       169
       +
       

     

       170
       +
         configureFlags = [

     

       171
       +
           "--disable-dependency-tracking"

     

       172
       +
           "--with-threads=single"

     

       173
       +
           # $CC cannot link binaries, let alone run then

     

       174
       +
           "cross_compiling=true"

     

       175
       +
           # Do not have dynamic linker without libc

     

       176
       +
           "--enable-static"

     

       177
       +
           "--disable-shared"

     

       178
       +
         ];

     

       179
       +
       

     

       180
       +
         # Set the variable back the way it was, see corresponding code in

     

       181
       +
         # `preConfigure`.

     

       182
       +
         postConfigure = lib.optionalString stdenv.hostPlatform.isMusl ''

     

       183
       +
           NIX_CFLAGS_COMPILE=$NIX_CFLAGS_COMPILE_OLD

     

       184
       +
         '';

     

       185
       +
       

     

       186
       +
         makeFlags = [ "MULTIBUILDTOP:=../" ];

     

       187
       +
       

     

       188
       +
         postInstall = ''

     

       189
       +
           cp gthr-default.h "$out/lib/gcc/${stdenv.hostPlatform.config}/${version}/include"

     

       190
       +
           moveToOutput "lib/gcc/${stdenv.hostPlatform.config}/${version}/include" "$dev"

     

       191
       +
           mkdir -p "$out/lib" "$dev/include"

     

       192
       +
           ln -s "$out/lib/gcc/${stdenv.hostPlatform.config}/${version}"/* "$out/lib"

     

       193
       +
           ln -s "$dev/lib/gcc/${stdenv.hostPlatform.config}/${version}/include"/* "$dev/include/"

     

       194
       +
         '';

     

       195
       +
       

     

       196
       +
         doCheck = true;

     

       197
       +
       

     

       198
       +
         passthru = {

     

       199
       +
           isGNU = true;

     

       200
       +
         };

     

       201
       +
       

     

       202
       +
         meta = gcc_meta // {

     

       203
       +
           homepage = "https://gcc.gnu.org/";

     

       204
       +
         };

     

       205
       +
       })

+190

pkgs/development/compilers/gcc/ng/common/libgfortran/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         gfortran,

     

       5
       +
         gcc_meta,

     

       6
       +
         release_version,

     

       7
       +
         version,

     

       8
       +
         monorepoSrc ? null,

     

       9
       +
         buildPackages,

     

       10
       +
         autoreconfHook269,

     

       11
       +
         libiberty,

     

       12
       +
         libgcc,

     

       13
       +
         libbacktrace,

     

       14
       +
       }:

     

       15
       +
       stdenv.mkDerivation (finalAttrs: {

     

       16
       +
         pname = "libgfortran";

     

       17
       +
         inherit version;

     

       18
       +
       

     

       19
       +
         src = monorepoSrc;

     

       20
       +
       

     

       21
       +
         outputs = [

     

       22
       +
           "out"

     

       23
       +
           "dev"

     

       24
       +
         ];

     

       25
       +
       

     

       26
       +
         strictDeps = true;

     

       27
       +
       

     

       28
       +
         depsBuildBuild = [ buildPackages.stdenv.cc ];

     

       29
       +
         nativeBuildInputs = [

     

       30
       +
           autoreconfHook269

     

       31
       +
           libiberty

     

       32
       +
           gfortran

     

       33
       +
         ];

     

       34
       +
       

     

       35
       +
         autoreconfFlags = "--install --force --verbose . libgfortran";

     

       36
       +
       

     

       37
       +
         postUnpack = ''

     

       38
       +
           mkdir -p ./build

     

       39
       +
           buildRoot=$(readlink -e "./build")

     

       40
       +
         '';

     

       41
       +
       

     

       42
       +
         postPatch = ''

     

       43
       +
           sourceRoot=$(readlink -e "./libgfortran")

     

       44
       +
         '';

     

       45
       +
       

     

       46
       +
         enableParallelBuilding = true;

     

       47
       +
       

     

       48
       +
         preConfigure =

     

       49
       +
           ''

     

       50
       +
             cd "$buildRoot"

     

       51
       +
       

     

       52
       +
             mkdir -p build-${stdenv.buildPlatform.config}/libiberty/

     

       53
       +
             cd build-${stdenv.buildPlatform.config}/libiberty/

     

       54
       +
             ln -s ${libiberty}/lib/libiberty.a ./

     

       55
       +
       

     

       56
       +
             mkdir -p "$buildRoot/gcc"

     

       57
       +
             cd "$buildRoot/gcc"

     

       58
       +
       

     

       59
       +
             (

     

       60
       +
             export AS_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$AS_FOR_BUILD"}

     

       61
       +
             export CC_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$CC_FOR_BUILD"}

     

       62
       +
             export CPP_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$CPP_FOR_BUILD"}

     

       63
       +
             export CXX_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$CXX_FOR_BUILD"}

     

       64
       +
             export LD_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc.bintools "$LD_FOR_BUILD"}

     

       65
       +
       

     

       66
       +
             export AS=$AS_FOR_BUILD

     

       67
       +
             export CC=$CC_FOR_BUILD

     

       68
       +
             export CPP=$CPP_FOR_BUILD

     

       69
       +
             export CXX=$CXX_FOR_BUILD

     

       70
       +
             export LD=$LD_FOR_BUILD

     

       71
       +
       

     

       72
       +
             export AS_FOR_TARGET=${lib.getExe' stdenv.cc "$AS"}

     

       73
       +
             export CC_FOR_TARGET=${lib.getExe' stdenv.cc "$CC"}

     

       74
       +
             export CPP_FOR_TARGET=${lib.getExe' stdenv.cc "$CPP"}

     

       75
       +
             export LD_FOR_TARGET=${lib.getExe' stdenv.cc.bintools "$LD"}

     

       76
       +
       

     

       77
       +
             export NIX_CFLAGS_COMPILE_FOR_BUILD+=' -DGENERATOR_FILE=1'

     

       78
       +
       

     

       79
       +
             "$sourceRoot/../gcc/configure" $topLevelConfigureFlags

     

       80
       +
       

     

       81
       +
             make \

     

       82
       +
               config.h

     

       83
       +
             )

     

       84
       +
             mkdir -p "$buildRoot/gcc/include"

     

       85
       +
       

     

       86
       +
             mkdir -p "$buildRoot/gcc/libbacktrace/.libs"

     

       87
       +
             cp ${libbacktrace}/lib/libbacktrace.a "$buildRoot/gcc/libbacktrace/.libs/libbacktrace.a"

     

       88
       +
             cp -r ${libbacktrace}/lib/*.la "$buildRoot/gcc/libbacktrace"

     

       89
       +
             cp -r ${libbacktrace.dev}/include/*.h "$buildRoot/gcc/libbacktrace"

     

       90
       +
       

     

       91
       +
             mkdir -p "$buildRoot/gcc/libgcc"

     

       92
       +
             ln -s "${libgcc.dev}/include/gthr-default.h" "$buildRoot/gcc/libgcc"

     

       93
       +
       

     

       94
       +
             mkdir -p "$buildRoot/gcc/${stdenv.hostPlatform.config}/libgfortran"

     

       95
       +
             ln -s "$buildRoot/gcc/libbacktrace" "$buildRoot/gcc/${stdenv.buildPlatform.config}/libbacktrace"

     

       96
       +
             ln -s "$buildRoot/gcc/libgcc" "$buildRoot/gcc/${stdenv.buildPlatform.config}/libgcc"

     

       97
       +
             cd "$buildRoot/gcc/${stdenv.hostPlatform.config}/libgfortran"

     

       98
       +
             configureScript=$sourceRoot/configure

     

       99
       +
             chmod +x "$configureScript"

     

       100
       +
       

     

       101
       +
             export AS_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$AS_FOR_BUILD"}

     

       102
       +
             export CC_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$CC_FOR_BUILD"}

     

       103
       +
             export CPP_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$CPP_FOR_BUILD"}

     

       104
       +
             export CXX_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc "$CXX_FOR_BUILD"}

     

       105
       +
             export LD_FOR_BUILD=${lib.getExe' buildPackages.stdenv.cc.bintools "$LD_FOR_BUILD"}

     

       106
       +
       

     

       107
       +
             export AS=${lib.getExe' stdenv.cc "$AS"}

     

       108
       +
             export CC=${lib.getExe' stdenv.cc "$CC"}

     

       109
       +
             export CPP=${lib.getExe' stdenv.cc "$CPP"}

     

       110
       +
             export CXX=${lib.getExe' stdenv.cc "$CXX"}

     

       111
       +
             export LD=${lib.getExe' stdenv.cc.bintools "$LD"}

     

       112
       +
       

     

       113
       +
             export AS_FOR_TARGET=${lib.getExe' stdenv.cc "$AS_FOR_TARGET"}

     

       114
       +
             export CC_FOR_TARGET=${lib.getExe' stdenv.cc "$CC_FOR_TARGET"}

     

       115
       +
             export CPP_FOR_TARGET=${lib.getExe' stdenv.cc "$CPP_FOR_TARGET"}

     

       116
       +
             export LD_FOR_TARGET=${lib.getExe' stdenv.cc.bintools "$LD_FOR_TARGET"}

     

       117
       +
           ''

     

       118
       +
           + lib.optionalString stdenv.hostPlatform.isMusl ''

     

       119
       +
             NIX_CFLAGS_COMPILE_OLD=$NIX_CFLAGS_COMPILE

     

       120
       +
             NIX_CFLAGS_COMPILE+=' -isystem ${stdenv.cc.cc}/lib/gcc/${stdenv.hostPlatform.config}/${version}/include-fixed'

     

       121
       +
           '';

     

       122
       +
       

     

       123
       +
         topLevelConfigureFlags =

     

       124
       +
           [

     

       125
       +
             "--build=${stdenv.buildPlatform.config}"

     

       126
       +
             "--host=${stdenv.buildPlatform.config}"

     

       127
       +
             "--target=${stdenv.hostPlatform.config}"

     

       128
       +
       

     

       129
       +
             "--disable-bootstrap"

     

       130
       +
             "--disable-multilib"

     

       131
       +
             "--with-multilib-list="

     

       132
       +
             "--enable-languages=fortran"

     

       133
       +
       

     

       134
       +
             "--disable-fixincludes"

     

       135
       +
             "--disable-intl"

     

       136
       +
             "--disable-lto"

     

       137
       +
             "--disable-libatomic"

     

       138
       +
             "--disable-libbacktrace"

     

       139
       +
             "--disable-libcpp"

     

       140
       +
             "--disable-libssp"

     

       141
       +
             "--disable-libquadmath"

     

       142
       +
             "--disable-libgomp"

     

       143
       +
             "--disable-libvtv"

     

       144
       +
             "--disable-vtable-verify"

     

       145
       +
       

     

       146
       +
             "--with-system-zlib"

     

       147
       +
           ]

     

       148
       +
           ++ lib.optional (stdenv.hostPlatform.libc == "glibc")

     

       149
       +
             # Cheat and use previous stage's glibc to avoid infinite recursion. As

     

       150
       +
             # of GCC 11, libgcc only cares if the version is greater than 2.19,

     

       151
       +
             # which is quite ancient, so this little lie should be fine.

     

       152
       +
             "--with-glibc-version=${buildPackages.glibc.version}";

     

       153
       +
       

     

       154
       +
         configurePlatforms = [

     

       155
       +
           "build"

     

       156
       +
           "host"

     

       157
       +
         ];

     

       158
       +
       

     

       159
       +
         configureFlags = [

     

       160
       +
           "--disable-dependency-tracking"

     

       161
       +
           "--with-threads=single"

     

       162
       +
           # $CC cannot link binaries, let alone run then

     

       163
       +
           "cross_compiling=true"

     

       164
       +
         ];

     

       165
       +
       

     

       166
       +
         # Set the variable back the way it was, see corresponding code in

     

       167
       +
         # `preConfigure`.

     

       168
       +
         postConfigure = lib.optionalString stdenv.hostPlatform.isMusl ''

     

       169
       +
           NIX_CFLAGS_COMPILE=$NIX_CFLAGS_COMPILE_OLD

     

       170
       +
         '';

     

       171
       +
       

     

       172
       +
         makeFlags = [ "MULTIBUILDTOP:=../" ];

     

       173
       +
       

     

       174
       +
         postInstall = ''

     

       175
       +
           moveToOutput "lib/gcc/${stdenv.hostPlatform.config}/${version}/include" "$dev"

     

       176
       +
           mkdir -p "$out/lib" "$dev/include"

     

       177
       +
           ln -s "$out/lib/gcc/${stdenv.hostPlatform.config}/${version}"/* "$out/lib"

     

       178
       +
           ln -s "$dev/lib/gcc/${stdenv.hostPlatform.config}/${version}/include"/* "$dev/include/"

     

       179
       +
         '';

     

       180
       +
       

     

       181
       +
         doCheck = true;

     

       182
       +
       

     

       183
       +
         passthru = {

     

       184
       +
           isGNU = true;

     

       185
       +
         };

     

       186
       +
       

     

       187
       +
         meta = gcc_meta // {

     

       188
       +
           homepage = "https://gcc.gnu.org/";

     

       189
       +
         };

     

       190
       +
       })

+67

pkgs/development/compilers/gcc/ng/common/libiberty/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         gcc_meta,

     

       5
       +
         release_version,

     

       6
       +
         version,

     

       7
       +
         monorepoSrc ? null,

     

       8
       +
         runCommand,

     

       9
       +
       }:

     

       10
       +
       stdenv.mkDerivation (finalAttrs: {

     

       11
       +
         pname = "libiberty";

     

       12
       +
         inherit version;

     

       13
       +
       

     

       14
       +
         src = runCommand "libiberty-src-${version}" { src = monorepoSrc; } ''

     

       15
       +
           runPhase unpackPhase

     

       16
       +
       

     

       17
       +
           mkdir -p "$out/gcc"

     

       18
       +
           cp gcc/BASE-VER "$out/gcc"

     

       19
       +
           cp gcc/DATESTAMP "$out/gcc"

     

       20
       +
       

     

       21
       +
           cp -r include "$out"

     

       22
       +
           cp -r libiberty "$out"

     

       23
       +
       

     

       24
       +
           cp config.guess "$out"

     

       25
       +
           cp config.rpath "$out"

     

       26
       +
           cp config.sub "$out"

     

       27
       +
           cp config-ml.in "$out"

     

       28
       +
           cp ltmain.sh "$out"

     

       29
       +
           cp install-sh "$out"

     

       30
       +
           cp mkinstalldirs "$out"

     

       31
       +
       

     

       32
       +
           [[ -f MD5SUMS ]]; cp MD5SUMS "$out"

     

       33
       +
         '';

     

       34
       +
       

     

       35
       +
         outputs = [

     

       36
       +
           "out"

     

       37
       +
           "dev"

     

       38
       +
         ];

     

       39
       +
       

     

       40
       +
         enableParallelBuilding = true;

     

       41
       +
       

     

       42
       +
         sourceRoot = "${finalAttrs.src.name}/libiberty";

     

       43
       +
       

     

       44
       +
         preConfigure = ''

     

       45
       +
           mkdir ../../build

     

       46
       +
           cd ../../build

     

       47
       +
           configureScript=../$sourceRoot/configure

     

       48
       +
         '';

     

       49
       +
       

     

       50
       +
         configureFlags = [

     

       51
       +
           "--enable-install-libiberty"

     

       52
       +
         ] ++ lib.optional (!stdenv.hostPlatform.isStatic) "--enable-shared";

     

       53
       +
       

     

       54
       +
         postInstall = ''

     

       55
       +
           cp pic/libiberty.a $out/lib/libiberty_pic.a

     

       56
       +
         '';

     

       57
       +
       

     

       58
       +
         doCheck = true;

     

       59
       +
       

     

       60
       +
         passthru = {

     

       61
       +
           isGNU = true;

     

       62
       +
         };

     

       63
       +
       

     

       64
       +
         meta = gcc_meta // {

     

       65
       +
           homepage = "https://gcc.gnu.org/";

     

       66
       +
         };

     

       67
       +
       })

+51

pkgs/development/compilers/gcc/ng/common/libquadmath/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         gcc_meta,

     

       5
       +
         release_version,

     

       6
       +
         version,

     

       7
       +
         monorepoSrc ? null,

     

       8
       +
         runCommand,

     

       9
       +
       }:

     

       10
       +
       stdenv.mkDerivation (finalAttrs: {

     

       11
       +
         pname = "libquadmath";

     

       12
       +
         inherit version;

     

       13
       +
       

     

       14
       +
         src = runCommand "libquadmath-src-${version}" { src = monorepoSrc; } ''

     

       15
       +
           runPhase unpackPhase

     

       16
       +
       

     

       17
       +
           mkdir -p "$out/gcc"

     

       18
       +
           cp gcc/BASE-VER "$out/gcc"

     

       19
       +
           cp gcc/DATESTAMP "$out/gcc"

     

       20
       +
       

     

       21
       +
           cp -r libquadmath "$out"

     

       22
       +
       

     

       23
       +
           cp config.guess "$out"

     

       24
       +
           cp config.rpath "$out"

     

       25
       +
           cp config.sub "$out"

     

       26
       +
           cp config-ml.in "$out"

     

       27
       +
           cp ltmain.sh "$out"

     

       28
       +
           cp install-sh "$out"

     

       29
       +
           cp mkinstalldirs "$out"

     

       30
       +
       

     

       31
       +
           [[ -f MD5SUMS ]]; cp MD5SUMS "$out"

     

       32
       +
         '';

     

       33
       +
       

     

       34
       +
         sourceRoot = "${finalAttrs.src.name}/libquadmath";

     

       35
       +
       

     

       36
       +
         preConfigure = ''

     

       37
       +
           mkdir ../../build

     

       38
       +
           cd ../../build

     

       39
       +
           configureScript=../$sourceRoot/configure

     

       40
       +
         '';

     

       41
       +
       

     

       42
       +
         doCheck = true;

     

       43
       +
       

     

       44
       +
         passthru = {

     

       45
       +
           isGNU = true;

     

       46
       +
         };

     

       47
       +
       

     

       48
       +
         meta = gcc_meta // {

     

       49
       +
           homepage = "https://gcc.gnu.org/";

     

       50
       +
         };

     

       51
       +
       })

+57

pkgs/development/compilers/gcc/ng/common/libsanitizer/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         libstdcxx,

     

       5
       +
         gcc_meta,

     

       6
       +
         release_version,

     

       7
       +
         version,

     

       8
       +
         monorepoSrc ? null,

     

       9
       +
         runCommand,

     

       10
       +
       }:

     

       11
       +
       stdenv.mkDerivation (finalAttrs: {

     

       12
       +
         pname = "libsanitizer";

     

       13
       +
         inherit version;

     

       14
       +
       

     

       15
       +
         src = runCommand "libsanitizer-src-${version}" { src = monorepoSrc; } ''

     

       16
       +
           runPhase unpackPhase

     

       17
       +
       

     

       18
       +
           mkdir -p "$out/gcc"

     

       19
       +
           cp gcc/BASE-VER "$out/gcc"

     

       20
       +
           cp gcc/DATESTAMP "$out/gcc"

     

       21
       +
       

     

       22
       +
           cp -r libsanitizer "$out"

     

       23
       +
       

     

       24
       +
           cp config.guess "$out"

     

       25
       +
           cp config.rpath "$out"

     

       26
       +
           cp config.sub "$out"

     

       27
       +
           cp config-ml.in "$out"

     

       28
       +
           cp ltmain.sh "$out"

     

       29
       +
           cp install-sh "$out"

     

       30
       +
           cp mkinstalldirs "$out"

     

       31
       +
       

     

       32
       +
           [[ -f MD5SUMS ]]; cp MD5SUMS "$out"

     

       33
       +
         '';

     

       34
       +
       

     

       35
       +
         sourceRoot = "${finalAttrs.src.name}/libsanitizer";

     

       36
       +
       

     

       37
       +
         postUnpack = ''

     

       38
       +
           mkdir -p libstdc++-v3/src/

     

       39
       +
           ln -s ${libstdcxx}/lib/libstdc++.la libstdc++-v3/src/libstdc++.la

     

       40
       +
         '';

     

       41
       +
       

     

       42
       +
         preConfigure = ''

     

       43
       +
           mkdir ../../build

     

       44
       +
           cd ../../build

     

       45
       +
           configureScript=../$sourceRoot/configure

     

       46
       +
         '';

     

       47
       +
       

     

       48
       +
         doCheck = true;

     

       49
       +
       

     

       50
       +
         passthru = {

     

       51
       +
           isGNU = true;

     

       52
       +
         };

     

       53
       +
       

     

       54
       +
         meta = gcc_meta // {

     

       55
       +
           homepage = "https://gcc.gnu.org/";

     

       56
       +
         };

     

       57
       +
       })

+68

pkgs/development/compilers/gcc/ng/common/libssp/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         gcc_meta,

     

       5
       +
         release_version,

     

       6
       +
         version,

     

       7
       +
         monorepoSrc ? null,

     

       8
       +
         runCommand,

     

       9
       +
       }:

     

       10
       +
       stdenv.mkDerivation (finalAttrs: {

     

       11
       +
         pname = "libssp";

     

       12
       +
         inherit version;

     

       13
       +
       

     

       14
       +
         src = runCommand "libssp-src-${version}" { src = monorepoSrc; } ''

     

       15
       +
           runPhase unpackPhase

     

       16
       +
       

     

       17
       +
           mkdir -p "$out/gcc"

     

       18
       +
           cp gcc/BASE-VER "$out/gcc"

     

       19
       +
           cp gcc/DATESTAMP "$out/gcc"

     

       20
       +
       

     

       21
       +
           cp -r libssp "$out"

     

       22
       +
       

     

       23
       +
           cp config.guess "$out"

     

       24
       +
           cp config.rpath "$out"

     

       25
       +
           cp config.sub "$out"

     

       26
       +
           cp config-ml.in "$out"

     

       27
       +
           cp ltmain.sh "$out"

     

       28
       +
           cp install-sh "$out"

     

       29
       +
           cp mkinstalldirs "$out"

     

       30
       +
       

     

       31
       +
           [[ -f MD5SUMS ]]; cp MD5SUMS "$out"

     

       32
       +
         '';

     

       33
       +
       

     

       34
       +
         sourceRoot = "${finalAttrs.src.name}/libssp";

     

       35
       +
       

     

       36
       +
         configurePlatforms = [

     

       37
       +
           "build"

     

       38
       +
           "host"

     

       39
       +
         ];

     

       40
       +
         configureFlags = [

     

       41
       +
           "--disable-dependency-tracking"

     

       42
       +
           "--with-toolexeclibdir=${builtins.placeholder "out" + "/lib"}"

     

       43
       +
           "cross_compiling=true"

     

       44
       +
           "--disable-multilib"

     

       45
       +
         ];

     

       46
       +
       

     

       47
       +
         preConfigure = ''

     

       48
       +
           mkdir ../../build

     

       49
       +
           cd ../../build

     

       50
       +
           configureScript=../$sourceRoot/configure

     

       51
       +
         '';

     

       52
       +
       

     

       53
       +
         hardeningDisable = [

     

       54
       +
           "fortify"

     

       55
       +
           # Because we are building it!

     

       56
       +
           "stackprotector"

     

       57
       +
         ];

     

       58
       +
       

     

       59
       +
         doCheck = true;

     

       60
       +
       

     

       61
       +
         passthru = {

     

       62
       +
           isGNU = true;

     

       63
       +
         };

     

       64
       +
       

     

       65
       +
         meta = gcc_meta // {

     

       66
       +
           homepage = "https://gcc.gnu.org/";

     

       67
       +
         };

     

       68
       +
       })

+87

pkgs/development/compilers/gcc/ng/common/libstdcxx/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         stdenv,

     

       4
       +
         gcc_meta,

     

       5
       +
         release_version,

     

       6
       +
         version,

     

       7
       +
         getVersionFile,

     

       8
       +
         monorepoSrc ? null,

     

       9
       +
         runCommand,

     

       10
       +
         autoreconfHook269,

     

       11
       +
         gettext,

     

       12
       +
       }:

     

       13
       +
       stdenv.mkDerivation (finalAttrs: {

     

       14
       +
         pname = "libstdcxx";

     

       15
       +
         inherit version;

     

       16
       +
       

     

       17
       +
         src = monorepoSrc;

     

       18
       +
       

     

       19
       +
         enableParallelBuilding = true;

     

       20
       +
       

     

       21
       +
         nativeBuildInputs = [

     

       22
       +
           autoreconfHook269

     

       23
       +
           gettext

     

       24
       +
         ];

     

       25
       +
       

     

       26
       +
         patches = [

     

       27
       +
           (getVersionFile "gcc/custom-threading-model.patch")

     

       28
       +
         ];

     

       29
       +
       

     

       30
       +
         postUnpack = ''

     

       31
       +
           mkdir -p ./build

     

       32
       +
           buildRoot=$(readlink -e "./build")

     

       33
       +
         '';

     

       34
       +
       

     

       35
       +
         preAutoreconf = ''

     

       36
       +
           sourceRoot=$(readlink -e "./libstdc++-v3")

     

       37
       +
           cd $sourceRoot

     

       38
       +
         '';

     

       39
       +
       

     

       40
       +
         postPatch = ''

     

       41
       +
           sed -i \

     

       42
       +
             -e 's/AM_ENABLE_MULTILIB(/AM_ENABLE_MULTILIB(NOPE/' \

     

       43
       +
             -e 's#glibcxx_toolexeclibdir=no#glibcxx_toolexeclibdir=${builtins.placeholder "out"}/libexec#' \

     

       44
       +
             configure.ac

     

       45
       +
         '';

     

       46
       +
       

     

       47
       +
         preConfigure = ''

     

       48
       +
           cd "$buildRoot"

     

       49
       +
           configureScript=$sourceRoot/configure

     

       50
       +
           chmod +x "$configureScript"

     

       51
       +
         '';

     

       52
       +
       

     

       53
       +
         configureFlags = [

     

       54
       +
           "--disable-dependency-tracking"

     

       55
       +
           "--with-toolexeclibdir=${builtins.placeholder "out"}/lib"

     

       56
       +
           "--with-threads=posix"

     

       57
       +
           "cross_compiling=true"

     

       58
       +
           "--disable-multilib"

     

       59
       +
       

     

       60
       +
           "--enable-clocale=gnu"

     

       61
       +
           "--disable-libstdcxx-pch"

     

       62
       +
           "--disable-vtable-verify"

     

       63
       +
           "--enable-libstdcxx-visibility"

     

       64
       +
           "--with-default-libstdcxx-abi=new"

     

       65
       +
         ];

     

       66
       +
       

     

       67
       +
         outputs = [

     

       68
       +
           "out"

     

       69
       +
           "dev"

     

       70
       +
         ];

     

       71
       +
       

     

       72
       +
         hardeningDisable = [

     

       73
       +
           # PATH_MAX

     

       74
       +
           "fortify"

     

       75
       +
         ];

     

       76
       +
       

     

       77
       +
         doCheck = true;

     

       78
       +
       

     

       79
       +
         passthru = {

     

       80
       +
           isGNU = true;

     

       81
       +
         };

     

       82
       +
       

     

       83
       +
         meta = gcc_meta // {

     

       84
       +
           homepage = "https://gcc.gnu.org/onlinedocs/libstdc++";

     

       85
       +
           description = "GNU C++ Library";

     

       86
       +
         };

     

       87
       +
       })

+32

pkgs/development/compilers/gcc/ng/common/patches.nix

···

       1
       +
       {

     

       2
       +
         "gcc/fix-collect2-paths.diff" = [

     

       3
       +
           {

     

       4
       +
             after = "15";

     

       5
       +
             path = ../15;

     

       6
       +
           }

     

       7
       +
         ];

     

       8
       +
         "gcc/0001-find_a_program-First-search-with-machine-prefix.patch" = [

     

       9
       +
           {

     

       10
       +
             after = "15";

     

       11
       +
             path = ../15;

     

       12
       +
           }

     

       13
       +
         ];

     

       14
       +
         "gcc/0002-driver-for_each_pass-Pass-to-callback-whether-dir-is.patch" = [

     

       15
       +
           {

     

       16
       +
             after = "15";

     

       17
       +
             path = ../15;

     

       18
       +
           }

     

       19
       +
         ];

     

       20
       +
         "gcc/0003-find_a_program-Only-search-for-prefixed-paths-in-und.patch" = [

     

       21
       +
           {

     

       22
       +
             after = "15";

     

       23
       +
             path = ../15;

     

       24
       +
           }

     

       25
       +
         ];

     

       26
       +
         "gcc/custom-threading-model.patch" = [

     

       27
       +
           {

     

       28
       +
             after = "15";

     

       29
       +
             path = ../15;

     

       30
       +
           }

     

       31
       +
         ];

     

       32
       +
       }

+69

pkgs/development/compilers/gcc/ng/default.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         callPackage,

     

       4
       +
         stdenv,

     

       5
       +
         stdenvAdapters,

     

       6
       +
         recurseIntoAttrs,

     

       7
       +
         gccVersions ? { },

     

       8
       +
         patchesFn ? lib.id,

     

       9
       +
         buildPackages,

     

       10
       +
         targetPackages,

     

       11
       +
         binutilsNoLibc,

     

       12
       +
         binutils,

     

       13
       +
         generateSplicesForMkScope,

     

       14
       +
         ...

     

       15
       +
       }@packageSetArgs:

     

       16
       +
       let

     

       17
       +
         versions = {

     

       18
       +
           "15.1.0".officialRelease.sha256 = "sha256-4rCewhZg8B/s/7cV4BICZSFpQ/A40OSKmGhxPlTwbOo=";

     

       19
       +
         } // gccVersions;

     

       20
       +
       

     

       21
       +
         mkPackage =

     

       22
       +
           {

     

       23
       +
             name ? null,

     

       24
       +
             officialRelease ? null,

     

       25
       +
             gitRelease ? null,

     

       26
       +
             monorepoSrc ? null,

     

       27
       +
             version ? null,

     

       28
       +
           }@args:

     

       29
       +
           let

     

       30
       +
             inherit

     

       31
       +
               (import ./common/common-let.nix {

     

       32
       +
                 inherit

     

       33
       +
                   lib

     

       34
       +
                   gitRelease

     

       35
       +
                   officialRelease

     

       36
       +
                   version

     

       37
       +
                   ;

     

       38
       +
               })

     

       39
       +
               releaseInfo

     

       40
       +
               ;

     

       41
       +
             inherit (releaseInfo) release_version;

     

       42
       +
             attrName =

     

       43
       +
               args.name or (if (gitRelease != null) then "git" else lib.versions.major release_version);

     

       44
       +
           in

     

       45
       +
           lib.nameValuePair attrName (

     

       46
       +
             recurseIntoAttrs (

     

       47
       +
               callPackage ./common (

     

       48
       +
                 {

     

       49
       +
                   inherit (stdenvAdapters) overrideCC;

     

       50
       +
                   inherit

     

       51
       +
                     officialRelease

     

       52
       +
                     gitRelease

     

       53
       +
                     monorepoSrc

     

       54
       +
                     version

     

       55
       +
                     patchesFn

     

       56
       +
                     ;

     

       57
       +
       

     

       58
       +
                   buildGccPackages = buildPackages."gccNGPackages_${attrName}";

     

       59
       +
                   targetGccPackages = targetPackages."gccNGPackages_${attrName}" or gccPackages."${attrName}";

     

       60
       +
                   otherSplices = generateSplicesForMkScope "gccNGPackages_${attrName}";

     

       61
       +
                 }

     

       62
       +
                 // packageSetArgs # Allow overrides.

     

       63
       +
               )

     

       64
       +
             )

     

       65
       +
           );

     

       66
       +
       

     

       67
       +
         gccPackages = lib.mapAttrs' (version: args: mkPackage (args // { inherit version; })) versions;

     

       68
       +
       in

     

       69
       +
       gccPackages // { inherit mkPackage; }

+11

pkgs/top-level/all-packages.nix

···

       5042
        
         gccFun = callPackage ../development/compilers/gcc;

     

       5043
        
         gcc-unwrapped = gcc.cc;

     

       5044
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5045
        
         wrapNonDeterministicGcc =

     

       5046
        
           stdenv: ccWrapper:

     

       5047
        
           if ccWrapper.isGNU then

···

       5042
        
         gccFun = callPackage ../development/compilers/gcc;

     

       5043
        
         gcc-unwrapped = gcc.cc;

     

       5044
        
       

     

       5045
       +
         inherit

     

       5046
       +
           (rec {

     

       5047
       +
             # NOTE: keep this with the "NG" label until we're ready to drop the monolithic GCC

     

       5048
       +
             gccNGPackagesSet = recurseIntoAttrs (callPackages ../development/compilers/gcc/ng { });

     

       5049
       +
             gccNGPackages_15 = gccNGPackagesSet."15";

     

       5050
       +
             mkGCCNGPackages = gccNGPackagesSet.mkPackage;

     

       5051
       +
           })

     

       5052
       +
           gccNGPackages_15

     

       5053
       +
           mkGCCNGPackages

     

       5054
       +
           ;

     

       5055
       +
       

     

       5056
        
         wrapNonDeterministicGcc =

     

       5057
        
           stdenv: ccWrapper:

     

       5058
        
           if ccWrapper.isGNU then