commit 800cb8ae71425a655e34f32dcbdce9fcb3cfe143 · pyrox.dev/nixpkgs

+216 -78

pkgs/build-support/bintools-wrapper/macos-sierra-reexport-hack.bash

···

       2
       2
        
       

     

       3
       3
        
       set -eu -o pipefail

     

       4
       4
        
       

     

       5
       5
       +
       # For cmd | while read; do ...; done

     

       6
       6
       +
       shopt -s lastpipe

     

       7
       7
       +
       

     

       5
       8
        
       path_backup="$PATH"

     

       6
       9
        
       if [ -n "@coreutils_bin@" ]; then

     

       7
       10
        
         PATH="@coreutils_bin@/bin"

     

       8
       11
        
       fi

     

       9
       12
        
       

     

       10
       10
       -
       declare -r recurThreshold=300

     

       13
       13
       +
       declare -ri recurThreshold=200

     

       14
       14
       +
       declare -i overflowCount=0

     

       15
       15
       +
       

     

       16
       16
       +
       declare -ar origArgs=("$@")

     

       17
       17
       +
       

     

       18
       18
       +
       # Throw away what we won't need

     

       19
       19
       +
       declare -a parentArgs=()

     

       11
       20
        
       

     

       12
       12
       -
       declare overflowCount=0

     

       13
       13
       -
       for ((n=0; n < $#; ++n)); do

     

       14
       14
       -
           case "${!n}" in

     

       15
       15
       -
               -l*) let overflowCount+=1 ;;

     

       16
       16
       -
               -reexport-l*) let overflowCount+=1 ;;

     

       17
       17
       -
               *) ;;

     

       21
       21
       +
       while (( $# )); do

     

       22
       22
       +
           case "$1" in

     

       23
       23
       +
               -l)

     

       24
       24
       +
                   echo "cctools LD does not support '-l foo'" >&2

     

       25
       25
       +
                   exit 1

     

       26
       26
       +
                   ;;

     

       27
       27
       +
               -lazy_library | -reexport_library | -upward_library | -weak_library)

     

       28
       28
       +
                   overflowCount+=1

     

       29
       29
       +
                   shift 2

     

       30
       30
       +
                   ;;

     

       31
       31
       +
               -l* | *.so.* | *.dylib | -lazy-l* | -reexport-l* | -upward-l* | -weak-l*)

     

       32
       32
       +
                   overflowCount+=1

     

       33
       33
       +
                   shift 1

     

       34
       34
       +
                   ;;

     

       35
       35
       +
               *.a | *.o)

     

       36
       36
       +
                   shift 1

     

       37
       37
       +
                   ;;

     

       38
       38
       +
               -L | -F)

     

       39
       39
       +
                   # Evidentally ld doesn't like using the child's RPATH, so it still

     

       40
       40
       +
                   # needs these.

     

       41
       41
       +
                   parentArgs+=("$1" "$2")

     

       42
       42
       +
                   shift 2

     

       43
       43
       +
                   ;;

     

       44
       44
       +
               -L?* | -F?*)

     

       45
       45
       +
                   parentArgs+=("$1")

     

       46
       46
       +
                   shift 1

     

       47
       47
       +
                   ;;

     

       48
       48
       +
               -o)

     

       49
       49
       +
                   outputName="$2"

     

       50
       50
       +
                   parentArgs+=("$1" "$2")

     

       51
       51
       +
                   shift 2

     

       52
       52
       +
                   ;;

     

       53
       53
       +
               -install_name | -dylib_install_name | -dynamic-linker | -plugin)

     

       54
       54
       +
                   parentArgs+=("$1" "$2")

     

       55
       55
       +
                   shift 2

     

       56
       56
       +
                   ;;

     

       57
       57
       +
               -rpath)

     

       58
       58
       +
                   # Only an rpath to the child is needed, which we will add

     

       59
       59
       +
                   shift 2

     

       60
       60
       +
                   ;;

     

       61
       61
       +
               *)

     

       62
       62
       +
                   if [[ -f "$1" ]]; then

     

       63
       63
       +
                       # Propabably a non-standard object file like Haskell's

     

       64
       64
       +
                       # `.dyn_o`. Skip it like other inputs

     

       65
       65
       +
                       :

     

       66
       66
       +
                   else

     

       67
       67
       +
                       parentArgs+=("$1")

     

       68
       68
       +
                   fi

     

       69
       69
       +
                   shift 1

     

       70
       70
       +
                   ;;

     

       18
       71
        
           esac

     

       19
       72
        
       done

     

       20
       73
        
       

     

       21
       21
       -
       declare -a allArgs=()

     

       74
       74
       +
       

     

       22
       75
        
       

     

       23
       76
        
       if (( "$overflowCount" <= "$recurThreshold" )); then

     

       24
       24
       -
           allArgs=("$@")

     

       25
       25
       -
       else

     

       26
       26
       -
           declare -a childrenLookup=() childrenLink=()

     

       77
       77
       +
           if [ -n "${NIX_DEBUG:-}" ]; then

     

       78
       78
       +
               echo "ld-wrapper: Only ${overflowCount} inputs counted while ${recurThreshold} is the ceiling, linking normally. " >&2

     

       79
       79
       +
           fi

     

       80
       80
       +
           PATH="$path_backup"

     

       81
       81
       +
           exec @prog@ "${origArgs[@]}"

     

       82
       82
       +
       fi

     

       27
       83
        
       

     

       28
       28
       -
           while (( $# )); do

     

       29
       29
       -
               case "$1" in

     

       30
       30
       -
                   -L/*)

     

       31
       31
       -
                       childrenLookup+=("$1")

     

       32
       32
       -
                       allArgs+=("$1")

     

       33
       33
       -
                       ;;

     

       34
       34
       -
                   -L)

     

       35
       35
       -
                       echo "cctools LD does not support '-L foo' or '-l foo'" >&2

     

       36
       36
       -
                       exit 1

     

       37
       37
       -
                       ;;

     

       38
       38
       -
                   -l)

     

       39
       39
       -
                       echo "cctools LD does not support '-L foo' or '-l foo'" >&2

     

       40
       40
       -
                       exit 1

     

       41
       41
       -
                       ;;

     

       42
       42
       -
                   -lazy_library | -lazy_framework | -lto_library)

     

       43
       43
       -
                       # We aren't linking any "azy_library", "to_library", etc.

     

       44
       44
       -
                       allArgs+=("$1")

     

       45
       45
       -
                       ;;

     

       46
       46
       -
                   -lazy-l | -weak-l)    allArgs+=("$1") ;;

     

       47
       47
       -
                       # We can't so easily prevent header issues from these.

     

       48
       48
       -
                   -lSystem)             allArgs+=("$1") ;;

     

       49
       49
       -
                       # Special case as indirection seems like a bad idea for something

     

       50
       50
       -
                       # so fundamental. Can be removed for simplicity.

     

       51
       51
       -
                   -l?* | -reexport-l?*) childrenLink+=("$1") ;;

     

       52
       52
       -
                   *)                    allArgs+=("$1") ;;

     

       53
       53
       -
               esac

     

       84
       84
       +
       

     

       85
       85
       +
       

     

       86
       86
       +
       if [ -n "${NIX_DEBUG:-}" ]; then

     

       87
       87
       +
           echo "ld-wrapper: ${overflowCount} inputs counted when ${recurThreshold} is the ceiling, inspecting further. " >&2

     

       88
       88
       +
       fi

     

       54
       89
        
       

     

       55
       55
       -
               shift

     

       56
       56
       -
           done

     

       90
       90
       +
       # Collect the normalized linker input

     

       91
       91
       +
       declare -a norm=()

     

       57
       92
        
       

     

       58
       58
       -
           declare n=0

     

       59
       59
       -
           while (( $n < "${#childrenLink[@]}" )); do

     

       60
       60
       -
               if [[ "${childrenLink[n]}" = -l* ]]; then

     

       61
       61
       -
                   childrenLink[n]="-reexport${childrenLink[n]}"

     

       62
       62
       -
               fi

     

       63
       63
       -
               let ++n

     

       93
       93
       +
       # Arguments are null-separated

     

       94
       94
       +
       @prog@ --dump-normalized-lib-args "${origArgs[@]}" |

     

       95
       95
       +
           while IFS= read -r -d '' input; do

     

       96
       96
       +
               norm+=("$input")

     

       64
       97
        
           done

     

       65
       65
       -
           unset n

     

       66
       98
        
       

     

       67
       67
       -
           declare -r outputNameLibless=$(basename $( \

     

       68
       68
       -
               if [[ -z "${outputName:+isUndefined}" ]]; then

     

       69
       69
       -
                   echo unnamed

     

       70
       70
       -
               elif [[ "${outputName:0:3}" = lib ]]; then

     

       71
       71
       -
                   echo "${outputName:3}"

     

       72
       72
       -
               else

     

       73
       73
       -
                   echo "${outputName}"

     

       74
       74
       -
               fi))

     

       75
       75
       -
           declare -ra children=("$outputNameLibless-reexport-delegate-0" \

     

       76
       76
       -
                                 "$outputNameLibless-reexport-delegate-1")

     

       99
       99
       +
       declare -i leafCount=0

     

       100
       100
       +
       declare lastLeaf=''

     

       101
       101
       +
       declare -a childrenInputs=() trailingInputs=()

     

       102
       102
       +
       while (( "${#norm[@]}" )); do

     

       103
       103
       +
           case "${norm[0]}" in

     

       104
       104
       +
               -lazy_library | -upward_library)

     

       105
       105
       +
                   # TODO(@Ericson2314): Don't do that, but intersperse children

     

       106
       106
       +
                   # between such args.

     

       107
       107
       +
                   echo "ld-wrapper: Warning: Potentially changing link order" >&2

     

       108
       108
       +
                   trailingInputs+=("${norm[0]}" "${norm[1]}")

     

       109
       109
       +
                   norm=("${norm[@]:2}")

     

       110
       110
       +
                   ;;

     

       111
       111
       +
               -reexport_library | -weak_library)

     

       112
       112
       +
                   childrenInputs+=("${norm[0]}" "${norm[1]}")

     

       113
       113
       +
                   if [[ "${norm[1]}" != "$lastLeaf" ]]; then

     

       114
       114
       +
                       leafCount+=1

     

       115
       115
       +
                       lastLeaf="${norm[1]}"

     

       116
       116
       +
                   fi

     

       117
       117
       +
                   norm=("${norm[@]:2}")

     

       118
       118
       +
                   ;;

     

       119
       119
       +
               *.so | *.dylib)

     

       120
       120
       +
                   childrenInputs+=(-reexport_library "${norm[0]}")

     

       121
       121
       +
                   if [[ "${norm[0]}" != "$lastLeaf" ]]; then

     

       122
       122
       +
                       leafCount+=1

     

       123
       123
       +
                       lastLeaf="${norm[0]}"

     

       124
       124
       +
                   fi

     

       125
       125
       +
                   norm=("${norm[@]:1}")

     

       126
       126
       +
                   ;;

     

       127
       127
       +
               *.o | *.a)

     

       128
       128
       +
                   # Don't delegate object files or static libs

     

       129
       129
       +
                   parentArgs+=("${norm[0]}")

     

       130
       130
       +
                   norm=("${norm[@]:1}")

     

       131
       131
       +
                   ;;

     

       132
       132
       +
               *)

     

       133
       133
       +
                   if [[ -f "${norm[0]}" ]]; then

     

       134
       134
       +
                       # Propabably a non-standard object file. We'll let it by.

     

       135
       135
       +
                       parentArgs+=("${norm[0]}")

     

       136
       136
       +
                       norm=("${norm[@]:1}")

     

       137
       137
       +
                   else

     

       138
       138
       +
                       echo "ld-wrapper: Internal Error: Invalid normalized argument" >&2

     

       139
       139
       +
                       exit -1

     

       140
       140
       +
                   fi

     

       141
       141
       +
                   ;;

     

       142
       142
       +
           esac

     

       143
       143
       +
       done

     

       77
       144
        
       

     

       78
       78
       -
           mkdir -p "$out/lib"

     

       79
       145
        
       

     

       80
       80
       -
           PATH="$PATH:@out@/bin"

     

       81
       146
        
       

     

       82
       82
       -
           symbolBloatObject=$outputNameLibless-symbol-hack.o

     

       83
       83
       -
           if [[ ! -e $symbolBloatObject ]]; then

     

       84
       84
       -
               # `-Q` means use GNU Assembler rather than Clang, avoiding an awkward

     

       85
       85
       -
               # dependency cycle.

     

       86
       86
       -
               printf '.private_extern _______child_hack_foo\nchild_hack_foo:\n' \

     

       87
       87
       -
                   | @targetPrefix@as -Q -- -o $symbolBloatObject

     

       147
       147
       +
       if (( "$leafCount" <= "$recurThreshold" )); then

     

       148
       148
       +
           if [ -n "${NIX_DEBUG:-}" ]; then

     

       149
       149
       +
               echo "ld-wrapper: Only ${leafCount} *dynamic* inputs counted while ${recurThreshold} is the ceiling, linking normally. " >&2

     

       150
       150
       +
           fi

     

       151
       151
       +
           PATH="$path_backup"

     

       152
       152
       +
           exec @prog@ "${origArgs[@]}"

     

       153
       153
       +
       fi

     

       154
       154
       +
       

     

       155
       155
       +
       

     

       156
       156
       +
       

     

       157
       157
       +
       if [ -n "${NIX_DEBUG:-}" ]; then

     

       158
       158
       +
           echo "ld-wrapper: ${leafCount} *dynamic* inputs counted when ${recurThreshold} is the ceiling, delegating to children. " >&2

     

       159
       159
       +
       fi

     

       160
       160
       +
       

     

       161
       161
       +
       declare -r outputNameLibless=$( \

     

       162
       162
       +
           if [[ -z "${outputName:+isUndefined}" ]]; then

     

       163
       163
       +
               echo unnamed

     

       164
       164
       +
               return 0;

     

       165
       165
       +
           fi

     

       166
       166
       +
           baseName=$(basename ${outputName})

     

       167
       167
       +
           if [[ "$baseName" = lib* ]]; then

     

       168
       168
       +
               baseName="${baseName:3}"

     

       88
       169
        
           fi

     

       170
       170
       +
           echo "$baseName")

     

       89
       171
        
       

     

       90
       90
       -
           # first half of libs

     

       91
       91
       -
           @targetPrefix@ld -macosx_version_min $MACOSX_DEPLOYMENT_TARGET -arch x86_64 -dylib \

     

       92
       92
       -
             -o "$out/lib/lib${children[0]}.dylib" \

     

       93
       93
       -
             -install_name "$out/lib/lib${children[0]}.dylib" \

     

       94
       94
       -
             "${childrenLookup[@]}" "$symbolBloatObject" \

     

       95
       95
       -
             "${childrenLink[@]:0:$((${#childrenLink[@]} / 2 ))}"

     

       172
       172
       +
       declare -ra children=(

     

       173
       173
       +
           "$outputNameLibless-reexport-delegate-0"

     

       174
       174
       +
           "$outputNameLibless-reexport-delegate-1"

     

       175
       175
       +
       )

     

       176
       176
       +
       

     

       177
       177
       +
       mkdir -p "$out/lib"

     

       178
       178
       +
       

     

       179
       179
       +
       symbolBloatObject=$outputNameLibless-symbol-hack.o

     

       180
       180
       +
       if [[ ! -f $symbolBloatObject ]]; then

     

       181
       181
       +
           # `-Q` means use GNU Assembler rather than Clang, avoiding an awkward

     

       182
       182
       +
           # dependency cycle.

     

       183
       183
       +
           printf '.private_extern _______child_hack_foo\nchild_hack_foo:\n' |

     

       184
       184
       +
               PATH="$PATH:@out@/bin" @targetPrefix@as -Q -- -o $symbolBloatObject

     

       185
       185
       +
       fi

     

       186
       186
       +
       

     

       187
       187
       +
       # Split inputs between children

     

       188
       188
       +
       declare -a child0Inputs=() child1Inputs=("${childrenInputs[@]}")

     

       189
       189
       +
       let "countFirstChild = $leafCount / 2" || true

     

       190
       190
       +
       lastLeaf=''

     

       191
       191
       +
       while (( "$countFirstChild" )); do

     

       192
       192
       +
           case "${child1Inputs[0]}" in

     

       193
       193
       +
               -reexport_library | -weak_library)

     

       194
       194
       +
                   child0Inputs+=("${child1Inputs[0]}" "${child1Inputs[1]}")

     

       195
       195
       +
                   if [[ "${child1Inputs[1]}" != "$lastLeaf" ]]; then

     

       196
       196
       +
                       let countFirstChild-=1 || true

     

       197
       197
       +
                       lastLeaf="${child1Inputs[1]}"

     

       198
       198
       +
                   fi

     

       199
       199
       +
                   child1Inputs=("${child1Inputs[@]:2}")

     

       200
       200
       +
                   ;;

     

       201
       201
       +
               *.so | *.dylib)

     

       202
       202
       +
                   child0Inputs+=(-reexport_library "${child1Inputs[0]}")

     

       203
       203
       +
                   if [[ "${child1Inputs[0]}" != "$lastLeaf" ]]; then

     

       204
       204
       +
                       let countFirstChild-=1 || true

     

       205
       205
       +
                       lastLeaf="${child1Inputs[1]}"

     

       206
       206
       +
                   fi

     

       207
       207
       +
                   child1Inputs=("${child1Inputs[@]:2}")

     

       208
       208
       +
                   ;;

     

       209
       209
       +
               *)

     

       210
       210
       +
                   echo "ld-wrapper: Internal Error: Invalid delegated input" >&2

     

       211
       211
       +
                   exit -1

     

       212
       212
       +
                   ;;

     

       213
       213
       +
           esac

     

       214
       214
       +
       done

     

       215
       215
       +
       

     

       216
       216
       +
       

     

       217
       217
       +
       # First half of libs

     

       218
       218
       +
       @out@/bin/@targetPrefix@ld \

     

       219
       219
       +
         -macosx_version_min $MACOSX_DEPLOYMENT_TARGET -arch x86_64 -dylib \

     

       220
       220
       +
         -o "$out/lib/lib${children[0]}.dylib" \

     

       221
       221
       +
         -install_name "$out/lib/lib${children[0]}.dylib" \

     

       222
       222
       +
         "$symbolBloatObject" "${child0Inputs[@]}" "${trailingInputs[@]}"

     

       96
       223
        
       

     

       97
       97
       -
           # second half of libs

     

       98
       98
       -
           @targetPrefix@ld -macosx_version_min $MACOSX_DEPLOYMENT_TARGET -arch x86_64 -dylib \

     

       99
       99
       -
             -o "$out/lib/lib${children[1]}.dylib" \

     

       100
       100
       -
             -install_name "$out/lib/lib${children[1]}.dylib" \

     

       101
       101
       -
             "${childrenLookup[@]}" "$symbolBloatObject" \

     

       102
       102
       -
             "${childrenLink[@]:$((${#childrenLink[@]} / 2 ))}"

     

       224
       224
       +
       # Second half of libs

     

       225
       225
       +
       @out@/bin/@targetPrefix@ld \

     

       226
       226
       +
         -macosx_version_min $MACOSX_DEPLOYMENT_TARGET -arch x86_64 -dylib \

     

       227
       227
       +
         -o "$out/lib/lib${children[1]}.dylib" \

     

       228
       228
       +
         -install_name "$out/lib/lib${children[1]}.dylib" \

     

       229
       229
       +
         "$symbolBloatObject" "${child1Inputs[@]}" "${trailingInputs[@]}"

     

       103
       230
        
       

     

       104
       104
       -
           allArgs+=("-L$out/lib" "-l${children[0]}" "-l${children[1]}")

     

       231
       231
       +
       parentArgs+=("-L$out/lib" -rpath "$out/lib")

     

       232
       232
       +
       if [[ $outputName != *reexport-delegate* ]]; then

     

       233
       233
       +
       	parentArgs+=("-l${children[0]}" "-l${children[1]}")

     

       234
       234
       +
       else

     

       235
       235
       +
           parentArgs+=("-reexport-l${children[0]}" "-reexport-l${children[1]}")

     

       236
       236
       +
       fi

     

       237
       237
       +
       

     

       238
       238
       +
       parentArgs+=("${trailingInputs[@]}")

     

       239
       239
       +
       

     

       240
       240
       +
       if [ -n "${NIX_DEBUG:-}" ]; then

     

       241
       241
       +
           echo "flags using delegated children to @prog@:" >&2

     

       242
       242
       +
           printf "  %q\n" "${parentArgs[@]}" >&2

     

       105
       243
        
       fi

     

       106
       244
        
       

     

       107
       245
        
       PATH="$path_backup"

     

       108
       108
       -
       exec @prog@ "${allArgs[@]}"

     

       246
       246
       +
       exec @prog@ "${parentArgs[@]}"

+10 -4

pkgs/os-specific/darwin/cctools/port.nix

···

       2
       2
        
       , llvm, libcxx, libcxxabi, clang, libuuid

     

       3
       3
        
       , libobjc ? null, maloader ? null, xctoolchain ? null

     

       4
       4
        
       , hostPlatform, targetPlatform

     

       5
       5
       +
       , enableDumpNormalizedLibArgs ? false

     

       5
       6
        
       }:

     

       6
       7
        
       

     

       7
       8
        
       let

     
···

       12
       13
        
           "${targetPlatform.config}-";

     

       13
       14
        
       in

     

       14
       15
        
       

     

       15
       15
       -
       assert targetPlatform.isDarwin;

     

       16
       16
       -
       

     

       17
       16
        
       # Non-Darwin alternatives

     

       18
       17
        
       assert (!hostPlatform.isDarwin) -> (maloader != null && xctoolchain != null);

     

       19
       18
        
       

     
···

       22
       21
        
           name = "${targetPrefix}cctools-port-${version}";

     

       23
       22
        
           version = "895";

     

       24
       23
        
       

     

       25
       25
       -
           src = fetchFromGitHub {

     

       24
       24
       +
           src = fetchFromGitHub (if enableDumpNormalizedLibArgs then {

     

       25
       25
       +
             owner  = "tpoechtrager";

     

       26
       26
       +
             repo   = "cctools-port";

     

       27
       27
       +
             # master with https://github.com/tpoechtrager/cctools-port/pull/34

     

       28
       28
       +
             rev    = "8395d4b2c3350356e2fb02f5e04f4f463c7388df";

     

       29
       29
       +
             sha256 = "10vbf1cfzx02q8chc77s84fp2kydjpx2y682mr6mrbb7sq5rwh8f";

     

       30
       30
       +
           } else {

     

       26
       31
        
             owner  = "tpoechtrager";

     

       27
       32
        
             repo   = "cctools-port";

     

       28
       33
        
             rev    = "2e569d765440b8cd6414a695637617521aa2375b"; # From branch 895-ld64-274.2

     

       29
       34
        
             sha256 = "0l45mvyags56jfi24rawms8j2ihbc45mq7v13pkrrwppghqrdn52";

     

       30
       30
       -
           };

     

       35
       35
       +
           });

     

       31
       36
        
       

     

       32
       37
        
           outputs = [ "out" "dev" ];

     

       33
       38
        
       

     
···

       117
       122
        
           };

     

       118
       123
        
       

     

       119
       124
        
           meta = {

     

       125
       125
       +
             broken = !targetPlatform.isDarwin; # Only supports darwin targets

     

       120
       126
        
             homepage = http://www.opensource.apple.com/source/cctools/;

     

       121
       127
        
             description = "MacOS Compiler Tools (cross-platform port)";

     

       122
       128
        
             license = stdenv.lib.licenses.apsl20;

+6 -1

pkgs/top-level/all-packages.nix

···

       5916
       5916
        
       

     

       5917
       5917
        
         clang-sierraHack = clang.override {

     

       5918
       5918
        
           name = "clang-wrapper-with-reexport-hack";

     

       5919
       5919
       -
           bintools = clang.bintools.override {

     

       5919
       5919
       +
           bintools = darwin.binutils.override {

     

       5920
       5920
        
             useMacosReexportHack = true;

     

       5921
       5921
       +
             bintools = darwin.binutils.bintools.override {

     

       5922
       5922
       +
               cctools = darwin.cctools.override {

     

       5923
       5923
       +
                 enableDumpNormalizedLibArgs = true;

     

       5924
       5924
       +
               };

     

       5925
       5925
       +
             };

     

       5921
       5926
        
           };

     

       5922
       5927
        
         };

     

       5923
       5928