291 lines
8.9 KiB
Bash
291 lines
8.9 KiB
Bash
#! @shell@
|
|
# NOTE: This wrapper is derived from cc-wrapper.sh, and is hopefully somewhat
|
|
# diffable with the original, so changes can be merged if necessary.
|
|
set -eu -o pipefail +o posix
|
|
shopt -s nullglob
|
|
|
|
if (( "${NIX_DEBUG:-0}" >= 7 )); then
|
|
set -x
|
|
fi
|
|
|
|
cc_wrapper="${NIX_CC:-@default_cc_wrapper@}"
|
|
|
|
source $cc_wrapper/nix-support/utils.bash
|
|
|
|
expandResponseParams "$@"
|
|
|
|
# Check if we should wrap this Swift invocation at all, and how. Specifically,
|
|
# there are some internal tools we don't wrap, plus swift-frontend doesn't link
|
|
# and doesn't understand linker flags. This follows logic in
|
|
# `lib/DriverTool/driver.cpp`.
|
|
prog=@prog@
|
|
progName="$(basename "$prog")"
|
|
firstArg="${params[0]:-}"
|
|
isFrontend=0
|
|
isRepl=0
|
|
|
|
# These checks follow `shouldRunAsSubcommand`.
|
|
if [[ "$progName" == swift ]]; then
|
|
case "$firstArg" in
|
|
"" | -* | *.* | */* | repl)
|
|
;;
|
|
*)
|
|
exec "swift-$firstArg" "${params[@]:1}"
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
# These checks follow the first part of `run_driver`.
|
|
#
|
|
# NOTE: The original function short-circuits, but we can't here, because both
|
|
# paths must be wrapped. So we use an 'isFrontend' flag instead.
|
|
case "$firstArg" in
|
|
-frontend)
|
|
isFrontend=1
|
|
# Ensure this stays the first argument.
|
|
params=( "${params[@]:1}" )
|
|
extraBefore+=( "-frontend" )
|
|
;;
|
|
-modulewrap)
|
|
# Don't wrap this integrated tool.
|
|
exec "$prog" "${params[@]}"
|
|
;;
|
|
repl)
|
|
isRepl=1
|
|
params=( "${params[@]:1}" )
|
|
;;
|
|
--driver-mode=*)
|
|
;;
|
|
*)
|
|
if [[ "$progName" == swift-frontend ]]; then
|
|
isFrontend=1
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
# For many tasks, Swift reinvokes swift-driver, the new driver implementation
|
|
# written in Swift. It needs some help finding the executable, though, and
|
|
# reimplementing the logic here is little effort. These checks follow
|
|
# `shouldDisallowNewDriver`.
|
|
if [[
|
|
$isFrontend = 0 &&
|
|
-n "@swiftDriver@" &&
|
|
-z "${SWIFT_USE_OLD_DRIVER:-}" &&
|
|
( "$progName" == "swift" || "$progName" == "swiftc" )
|
|
]]; then
|
|
prog=@swiftDriver@
|
|
# Driver mode must be the very first argument.
|
|
extraBefore+=( "--driver-mode=$progName" )
|
|
if [[ $isRepl = 1 ]]; then
|
|
extraBefore+=( "-repl" )
|
|
fi
|
|
|
|
# Ensure swift-driver invokes the unwrapped frontend (instead of finding
|
|
# the wrapped one via PATH), because we don't have to wrap a second time.
|
|
export SWIFT_DRIVER_SWIFT_FRONTEND_EXEC="@swift@/bin/swift-frontend"
|
|
|
|
# Ensure swift-driver can find the LLDB with Swift support for the REPL.
|
|
export SWIFT_DRIVER_LLDB_EXEC="@swift@/bin/lldb"
|
|
fi
|
|
|
|
path_backup="$PATH"
|
|
|
|
# That @-vars are substituted separately from bash evaluation makes
|
|
# shellcheck think this, and others like it, are useless conditionals.
|
|
# shellcheck disable=SC2157
|
|
if [[ -n "@coreutils_bin@" && -n "@gnugrep_bin@" ]]; then
|
|
PATH="@coreutils_bin@/bin:@gnugrep_bin@/bin"
|
|
fi
|
|
|
|
# Parse command line options and set several variables.
|
|
# For instance, figure out if linker flags should be passed.
|
|
# GCC prints annoying warnings when they are not needed.
|
|
isCxx=0
|
|
dontLink=$isFrontend
|
|
|
|
for p in "${params[@]}"; do
|
|
case "$p" in
|
|
-enable-cxx-interop)
|
|
isCxx=1 ;;
|
|
esac
|
|
done
|
|
|
|
# NOTE: We don't modify these for Swift, but sourced scripts may use them.
|
|
cxxInclude=1
|
|
cxxLibrary=1
|
|
cInclude=1
|
|
|
|
linkType=$(checkLinkType "${params[@]}")
|
|
|
|
# Optionally filter out paths not refering to the store.
|
|
if [[ "${NIX_ENFORCE_PURITY:-}" = 1 && -n "$NIX_STORE" ]]; then
|
|
kept=()
|
|
nParams=${#params[@]}
|
|
declare -i n=0
|
|
while (( "$n" < "$nParams" )); do
|
|
p=${params[n]}
|
|
p2=${params[n+1]:-} # handle `p` being last one
|
|
n+=1
|
|
|
|
skipNext=false
|
|
path=""
|
|
case "$p" in
|
|
-[IL]/*) path=${p:2} ;;
|
|
-[IL]) path=$p2 skipNext=true ;;
|
|
esac
|
|
|
|
if [[ -n $path ]] && badPath "$path"; then
|
|
skip "$path"
|
|
$skipNext && n+=1
|
|
continue
|
|
fi
|
|
|
|
kept+=("$p")
|
|
done
|
|
# Old bash empty array hack
|
|
params=(${kept+"${kept[@]}"})
|
|
fi
|
|
|
|
# Flirting with a layer violation here.
|
|
if [ -z "${NIX_BINTOOLS_WRAPPER_FLAGS_SET_@suffixSalt@:-}" ]; then
|
|
source @bintools@/nix-support/add-flags.sh
|
|
fi
|
|
|
|
# Put this one second so libc ldflags take priority.
|
|
if [ -z "${NIX_CC_WRAPPER_FLAGS_SET_@suffixSalt@:-}" ]; then
|
|
source $cc_wrapper/nix-support/add-flags.sh
|
|
fi
|
|
|
|
if [[ "$isCxx" = 1 ]]; then
|
|
if [[ "$cxxInclude" = 1 ]]; then
|
|
NIX_CFLAGS_COMPILE_@suffixSalt@+=" $NIX_CXXSTDLIB_COMPILE_@suffixSalt@"
|
|
fi
|
|
if [[ "$cxxLibrary" = 1 ]]; then
|
|
NIX_CFLAGS_LINK_@suffixSalt@+=" $NIX_CXXSTDLIB_LINK_@suffixSalt@"
|
|
fi
|
|
fi
|
|
|
|
source $cc_wrapper/nix-support/add-hardening.sh
|
|
|
|
# Add the flags for the C compiler proper.
|
|
addCFlagsToList() {
|
|
declare -n list="$1"
|
|
shift
|
|
|
|
for ((i = 1; i <= $#; i++)); do
|
|
local val="${!i}"
|
|
case "$val" in
|
|
# Pass through using -Xcc, but also convert to Swift -I.
|
|
# These have slightly different meaning for Clang, but Swift
|
|
# doesn't have exact equivalents.
|
|
-isystem | -idirafter)
|
|
i=$((i + 1))
|
|
list+=("-Xcc" "$val" "-Xcc" "${!i}" "-I" "${!i}")
|
|
;;
|
|
# Simple rename.
|
|
-iframework)
|
|
i=$((i + 1))
|
|
list+=("-Fsystem" "${!i}")
|
|
;;
|
|
# Pass through verbatim.
|
|
-I | -Fsystem)
|
|
i=$((i + 1))
|
|
list+=("${val}" "${!i}")
|
|
;;
|
|
-I* | -L* | -F*)
|
|
list+=("${val}")
|
|
;;
|
|
# Pass through using -Xcc.
|
|
*)
|
|
list+=("-Xcc" "$val")
|
|
;;
|
|
esac
|
|
done
|
|
}
|
|
for i in ${NIX_SWIFTFLAGS_COMPILE:-}; do
|
|
extraAfter+=("$i")
|
|
done
|
|
for i in ${NIX_SWIFTFLAGS_COMPILE_BEFORE:-}; do
|
|
extraBefore+=("$i")
|
|
done
|
|
addCFlagsToList extraAfter $NIX_CFLAGS_COMPILE_@suffixSalt@
|
|
addCFlagsToList extraBefore ${hardeningCFlags[@]+"${hardeningCFlags[@]}"} $NIX_CFLAGS_COMPILE_BEFORE_@suffixSalt@
|
|
|
|
if [ "$dontLink" != 1 ]; then
|
|
|
|
# Add the flags that should only be passed to the compiler when
|
|
# linking.
|
|
addCFlagsToList extraAfter $(filterRpathFlags "$linkType" $NIX_CFLAGS_LINK_@suffixSalt@)
|
|
|
|
# Add the flags that should be passed to the linker (and prevent
|
|
# `ld-wrapper' from adding NIX_LDFLAGS_@suffixSalt@ again).
|
|
for i in $(filterRpathFlags "$linkType" $NIX_LDFLAGS_BEFORE_@suffixSalt@); do
|
|
extraBefore+=("-Xlinker" "$i")
|
|
done
|
|
if [[ "$linkType" == dynamic && -n "$NIX_DYNAMIC_LINKER_@suffixSalt@" ]]; then
|
|
extraBefore+=("-Xlinker" "-dynamic-linker=$NIX_DYNAMIC_LINKER_@suffixSalt@")
|
|
fi
|
|
for i in $(filterRpathFlags "$linkType" $NIX_LDFLAGS_@suffixSalt@); do
|
|
if [ "${i:0:3}" = -L/ ]; then
|
|
extraAfter+=("$i")
|
|
else
|
|
extraAfter+=("-Xlinker" "$i")
|
|
fi
|
|
done
|
|
export NIX_LINK_TYPE_@suffixSalt@=$linkType
|
|
fi
|
|
|
|
# TODO: If we ever need to expand functionality of this hook, it may no longer
|
|
# be compatible with Swift. Right now, it is only used on Darwin to force
|
|
# -target, which also happens to work with Swift.
|
|
if [[ -e $cc_wrapper/nix-support/add-local-cc-cflags-before.sh ]]; then
|
|
source $cc_wrapper/nix-support/add-local-cc-cflags-before.sh
|
|
fi
|
|
|
|
# May need to transform the triple injected by the above.
|
|
for ((i = 1; i < ${#extraBefore[@]}; i++)); do
|
|
if [[ "${extraBefore[i]}" = -target ]]; then
|
|
i=$((i + 1))
|
|
# On Darwin only, need to change 'aarch64' to 'arm64'.
|
|
extraBefore[i]="${extraBefore[i]/aarch64-apple-/arm64-apple-}"
|
|
# On Darwin, Swift requires the triple to be annotated with a version.
|
|
# TODO: Assumes macOS.
|
|
extraBefore[i]="${extraBefore[i]/-apple-darwin/-apple-macosx${MACOSX_DEPLOYMENT_TARGET:-11.0}}"
|
|
break
|
|
fi
|
|
done
|
|
|
|
# As a very special hack, if the arguments are just `-v', then don't
|
|
# add anything. This is to prevent `gcc -v' (which normally prints
|
|
# out the version number and returns exit code 0) from printing out
|
|
# `No input files specified' and returning exit code 1.
|
|
if [ "$*" = -v ]; then
|
|
extraAfter=()
|
|
extraBefore=()
|
|
fi
|
|
|
|
# Optionally print debug info.
|
|
if (( "${NIX_DEBUG:-0}" >= 1 )); then
|
|
# Old bash workaround, see ld-wrapper for explanation.
|
|
echo "extra flags before to $prog:" >&2
|
|
printf " %q\n" ${extraBefore+"${extraBefore[@]}"} >&2
|
|
echo "original flags to $prog:" >&2
|
|
printf " %q\n" ${params+"${params[@]}"} >&2
|
|
echo "extra flags after to $prog:" >&2
|
|
printf " %q\n" ${extraAfter+"${extraAfter[@]}"} >&2
|
|
fi
|
|
|
|
PATH="$path_backup"
|
|
# Old bash workaround, see above.
|
|
|
|
if (( "${NIX_CC_USE_RESPONSE_FILE:-@use_response_file_by_default@}" >= 1 )); then
|
|
exec "$prog" @<(printf "%q\n" \
|
|
${extraBefore+"${extraBefore[@]}"} \
|
|
${params+"${params[@]}"} \
|
|
${extraAfter+"${extraAfter[@]}"})
|
|
else
|
|
exec "$prog" \
|
|
${extraBefore+"${extraBefore[@]}"} \
|
|
${params+"${params[@]}"} \
|
|
${extraAfter+"${extraAfter[@]}"}
|
|
fi
|