commit aeaa19c4202a587d0c4d95fcd7f55f4328efc170 · pyrox.dev/nixpkgs

-137

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

···

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

     

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

     

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

     

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

     

       5
       5
       -
       

     

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

     

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

     

       8
       8
       -
       ---

     

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

     

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

     

       11
       11
       -
       

     

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

     

       13
       13
       -
       index 4fd87f2c4a1..55738d258b3 100644

     

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

     

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

     

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

     

       17
       17
       -
        

     

       18
       18
       -
        static const char *just_machine_suffix = 0;

     

       19
       19
       -
        

     

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

     

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

     

       22
       22
       -
       +

     

       23
       23
       -
       +static const char *just_machine_prefix = 0;

     

       24
       24
       -
       +

     

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

     

       26
       26
       -
        

     

       27
       27
       -
        static const char *gcc_exec_prefix;

     

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

     

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

     

       30
       30
       -
          len += info->name_len;

     

       31
       31
       -
        

     

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

     

       33
       33
       -
       -     So try appending that first.  */

     

       34
       34
       -
       -  if (info->suffix_len)

     

       35
       35
       -
       -    {

     

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

     

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

     

       38
       38
       -
       -	return path;

     

       39
       39
       -
       -    }

     

       40
       40
       -
       -

     

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

     

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

     

       43
       43
       -
            return path;

     

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

     

       45
       45
       -
        				file_at_path, &info);

     

       46
       46
       -
        }

     

       47
       47
       -
        

     

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

     

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

     

       50
       50
       -
       +

     

       51
       51
       -
       +static void *

     

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

     

       53
       53
       -
       +{

     

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

     

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

     

       56
       56
       -
       +  size_t path_len = strlen (path);

     

       57
       57
       -
       +

     

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

     

       59
       59
       -
       +    {

     

       60
       60
       -
       +      auto len = path_len;

     

       61
       61
       -
       +

     

       62
       62
       -
       +      auto prefix_len = strlen(prefix);

     

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

     

       64
       64
       -
       +      len += prefix_len;

     

       65
       65
       -
       +

     

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

     

       67
       67
       -
       +      len += info->name_len;

     

       68
       68
       -
       +

     

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

     

       70
       70
       -
       +	 So try appending that first.  */

     

       71
       71
       -
       +      if (info->suffix_len)

     

       72
       72
       -
       +	{

     

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

     

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

     

       75
       75
       -
       +	    return path;

     

       76
       76
       -
       +	}

     

       77
       77
       -
       +

     

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

     

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

     

       80
       80
       -
       +	return path;

     

       81
       81
       -
       +    }

     

       82
       82
       -
       +

     

       83
       83
       -
       +  return NULL;

     

       84
       84
       -
       +}

     

       85
       85
       -
       +

     

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

     

       87
       87
       -
           configure-specified default programs. */

     

       88
       88
       -
        

     

       89
       89
       -
        static char*

     

       90
       90
       -
        find_a_program (const char *name)

     

       91
       91
       -
        {

     

       92
       92
       -
       +  const int mode = X_OK;

     

       93
       93
       -
       +

     

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

     

       95
       95
       -
        

     

       96
       96
       -
        #ifdef DEFAULT_ASSEMBLER

     

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

     

       98
       98
       -
            return xstrdup (DEFAULT_DSYMUTIL);

     

       99
       99
       -
        #endif

     

       100
       100
       -
        

     

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

     

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

     

       103
       103
       -
       +

     

       104
       104
       -
       +  if (IS_ABSOLUTE_PATH (name))

     

       105
       105
       -
       +    {

     

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

     

       107
       107
       -
       +	return xstrdup (name);

     

       108
       108
       -
       +

     

       109
       109
       -
       +      return NULL;

     

       110
       110
       -
       +    }

     

       111
       111
       -
       +

     

       112
       112
       -
       +  struct file_at_path_info info;

     

       113
       113
       -
       +

     

       114
       114
       -
       +  info.name = name;

     

       115
       115
       -
       +  info.suffix = HOST_EXECUTABLE_SUFFIX;

     

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

     

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

     

       118
       118
       -
       +  info.mode = mode;

     

       119
       119
       -
       +

     

       120
       120
       -
       +  return (char*) for_each_path (

     

       121
       121
       -
       +    &exec_prefixes, false,

     

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

     

       123
       123
       -
       +    program_at_path, &info);

     

       124
       124
       -
        }

     

       125
       125
       -
        

     

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

     

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

     

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

     

       129
       129
       -
        			   accel_dir_suffix, dir_separator_str, NULL);

     

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

     

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

     

       132
       132
       -
        

     

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

     

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

     

       135
       135
       -
       -- 

     

       136
       136
       -
       2.47.2

     

       137
       137
       -

-103

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

···

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

     

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

     

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

     

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

     

       5
       5
       -
        machine-disambiguated

     

       6
       6
       -
       

     

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

     

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

     

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

     

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

     

       11
       11
       -
       method of keeping targets apart.

     

       12
       12
       -
       ---

     

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

     

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

     

       15
       15
       -
       

     

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

     

       17
       17
       -
       index 55738d258b3..f9f83d1a804 100644

     

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

     

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

     

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

     

       21
       21
       -
        for_each_path (const struct path_prefix *paths,

     

       22
       22
       -
        	       bool do_multi,

     

       23
       23
       -
        	       size_t extra_space,

     

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

     

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

     

       26
       26
       -
        	       void *callback_info)

     

       27
       27
       -
        {

     

       28
       28
       -
          struct prefix_list *pl;

     

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

     

       30
       30
       -
        	  if (!skip_multi_dir)

     

       31
       31
       -
        	    {

     

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

     

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

     

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

     

       35
       35
       -
        	      if (ret)

     

       36
       36
       -
        		break;

     

       37
       37
       -
        	    }

     

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

     

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

     

       40
       40
       -
        	    {

     

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

     

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

     

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

     

       44
       44
       -
        	      if (ret)

     

       45
       45
       -
        		break;

     

       46
       46
       -
        	    }

     

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

     

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

     

       49
       49
       -
        	    {

     

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

     

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

     

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

     

       53
       53
       -
        	      if (ret)

     

       54
       54
       -
        		break;

     

       55
       55
       -
        	    }

     

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

     

       57
       57
       -
        	      else

     

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

     

       59
       59
       -
        

     

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

     

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

     

       62
       62
       -
        	      if (ret)

     

       63
       63
       -
        		break;

     

       64
       64
       -
        	    }

     

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

     

       66
       66
       -
        };

     

       67
       67
       -
        

     

       68
       68
       -
        static void *

     

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

     

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

     

       71
       71
       -
        {

     

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

     

       73
       73
       -
        

     

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

     

       75
       75
       -
        };

     

       76
       76
       -
        

     

       77
       77
       -
        static void *

     

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

     

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

     

       80
       80
       -
        {

     

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

     

       82
       82
       -
          size_t len = strlen (path);

     

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

     

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

     

       85
       85
       -
        

     

       86
       86
       -
        static void *

     

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

     

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

     

       89
       89
       -
        {

     

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

     

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

     

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

     

       93
       93
       -
        };

     

       94
       94
       -
        

     

       95
       95
       -
        static void *

     

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

     

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

     

       98
       98
       -
        {

     

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

     

       100
       100
       -
          size_t len = 0;

     

       101
       101
       -
       -- 

     

       102
       102
       -
       2.47.2

     

       103
       103
       -

-75

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

···

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

     

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

     

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

     

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

     

       5
       5
       -
        undisambiguated dirs

     

       6
       6
       -
       

     

       7
       7
       -
       This means, we might search for:

     

       8
       8
       -
       

     

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

     

       10
       10
       -
       - path/$machine/prog

     

       11
       11
       -
       - path/$machine-prog

     

       12
       12
       -
       

     

       13
       13
       -
       But not

     

       14
       14
       -
       

     

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

     

       16
       16
       -
       

     

       17
       17
       -
       because disambiguating $machine twice is unnecessary.

     

       18
       18
       -
       

     

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

     

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

     

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

     

       22
       22
       -
       when mistakes are not caught early.

     

       23
       23
       -
       ---

     

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

     

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

     

       26
       26
       -
       

     

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

     

       28
       28
       -
       index f9f83d1a804..d837b6ea779 100644

     

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

     

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

     

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

     

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

     

       33
       33
       -
          size_t path_len = strlen (path);

     

       34
       34
       -
        

     

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

     

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

     

       37
       37
       -
            {

     

       38
       38
       -
       -      auto len = path_len;

     

       39
       39
       -
       -

     

       40
       40
       -
       -      auto prefix_len = strlen(prefix);

     

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

     

       42
       42
       -
       -      len += prefix_len;

     

       43
       43
       -
       -

     

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

     

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

     

       46
       46
       -
              len += info->name_len;

     

       47
       47
       -
        

     

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

     

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

     

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

     

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

     

       52
       52
       -
        	return path;

     

       53
       53
       -
       +

     

       54
       54
       -
       +      return NULL;

     

       55
       55
       -
       +    };

     

       56
       56
       -
       +

     

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

     

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

     

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

     

       60
       60
       -
       +  if (!machine_specific)

     

       61
       61
       -
       +    {

     

       62
       62
       -
       +      auto prefix_len = strlen(just_machine_prefix);

     

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

     

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

     

       65
       65
       -
       +      if (res) return res;

     

       66
       66
       -
            }

     

       67
       67
       -
        

     

       68
       68
       -
       -  return NULL;

     

       69
       69
       -
       +  return search(path_len);

     

       70
       70
       -
        }

     

       71
       71
       -
        

     

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

     

       73
       73
       -
       -- 

     

       74
       74
       -
       2.47.2

     

       75
       75
       -

+26 -3

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

···

       5
       5
        
         release_version,

     

       6
       6
        
         version,

     

       7
       7
        
         monorepoSrc ? null,

     

       8
       8
       +
         fetchpatch,

     

       8
       9
        
         langAda ? false,

     

       9
       10
        
         langC ? true,

     

       10
       11
        
         langCC ? true,

     
···

       49
       50
        
         ];

     

       50
       51
        
       

     

       51
       52
        
         patches = [

     

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

     

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

     

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

     

       53
       53
       +
           (fetchpatch {

     

       54
       54
       +
             name = "for_each_path-functional-programming.patch";

     

       55
       55
       +
             url = "https://github.com/gcc-mirror/gcc/commit/f23bac62f46fc296a4d0526ef54824d406c3756c.diff";

     

       56
       56
       +
             hash = "sha256-J7SrypmVSbvYUzxWWvK2EwEbRsfGGLg4vNZuLEe6Xe0=";

     

       57
       57
       +
           })

     

       58
       58
       +
           (fetchpatch {

     

       59
       59
       +
             name = "find_a_program-separate-from-find_a_file.patch";

     

       60
       60
       +
             url = "https://inbox.sourceware.org/gcc-patches/20250822234120.1988059-1-git@JohnEricson.me/raw";

     

       61
       61
       +
             hash = "sha256-0gaWaeFZq+a8q7Bcr3eILNjHh1LfzL/Lz4F+W+H6XIU=";

     

       62
       62
       +
           })

     

       63
       63
       +
           (fetchpatch {

     

       64
       64
       +
             name = "simplify-find_a_program-and-find_a_file.patch";

     

       65
       65
       +
             url = "https://inbox.sourceware.org/gcc-patches/20250822234120.1988059-2-git@JohnEricson.me/raw";

     

       66
       66
       +
             hash = "sha256-ojdyszxLGL+njHK4eAaeBkxAhFTDI57j6lGuAf0A+N0=";

     

       67
       67
       +
           })

     

       68
       68
       +
           (fetchpatch {

     

       69
       69
       +
             name = "for_each_path-pass-machine-specific.patch";

     

       70
       70
       +
             url = "https://inbox.sourceware.org/gcc-patches/20250822234120.1988059-3-git@JohnEricson.me/raw";

     

       71
       71
       +
             hash = "sha256-C5jUSyNchmZcE8RTXc2dHfCqNKuBHeiouLruK9UooSM=";

     

       72
       72
       +
           })

     

       73
       73
       +
           (fetchpatch {

     

       74
       74
       +
             name = "find_a_program-search-with-machine-prefix.patch";

     

       75
       75
       +
             url = "https://inbox.sourceware.org/gcc-patches/20250822234120.1988059-4-git@JohnEricson.me/raw";

     

       76
       76
       +
             hash = "sha256-MwcO4OXPlcdaSYivsh5ru+Cfq6qybeAtgCgTEPGYg40=";

     

       77
       77
       +
           })

     

       55
       78
        
       

     

       56
       79
        
           (getVersionFile "gcc/fix-collect2-paths.diff")

     

       57
       80
        
         ];

-25

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

···

       7
       7
        
           }

     

       8
       8
        
         ];

     

       9
       9
        
       

     

       10
       10
       -
         # Submitted (001--003):

     

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

     

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

     

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

     

       14
       14
       -
         #

     

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

     

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

     

       17
       17
       -
           {

     

       18
       18
       -
             after = "15";

     

       19
       19
       -
             path = ../15;

     

       20
       20
       -
           }

     

       21
       21
       -
         ];

     

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

     

       23
       23
       -
           {

     

       24
       24
       -
             after = "15";

     

       25
       25
       -
             path = ../15;

     

       26
       26
       -
           }

     

       27
       27
       -
         ];

     

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

     

       29
       29
       -
           {

     

       30
       30
       -
             after = "15";

     

       31
       31
       -
             path = ../15;

     

       32
       32
       -
           }

     

       33
       33
       -
         ];

     

       34
       34
       -
       

     

       35
       10
        
         # In Git: https://github.com/Ericson2314/gcc/tree/regular-dirs-in-libgcc-15

     

       36
       11
        
         "libgcc/force-regular-dirs.patch" = [

     

       37
       12
        
           {