notwa/rc
1
0
Fork 0
mirror of https://github.com/notwa/rc synced 2024-10-31 16:54:35 -07:00
Code Issues Releases Wiki Activity
rc/sh/compile
Connor Olding eaa94d66b9 localize iterator variables 
see commit 7d895d2
2022-03-06 13:13:40 -08:00

361 lines
14 KiB
Bash
Executable file
Raw Blame History

#!/usr/bin/env zsh
# YES_ZSH
# NO_BASH
# NO_DASH
# NO_ASH
setup_clang_ubuntu() { ### @-
### print (but don't execute) the commands necessary to install
### a fairly recent version of clang on ubuntu-based distros.
###
### ```sh
### $ setup_clang_ubuntu bionic
### wget -O - http://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -
### echo -n "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic main
### # deb-src http://apt.llvm.org/bionic/ llvm-toolchain-bionic main
### # 12
### deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main
### # deb-src http://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main
### " > /etc/apt/sources.list.d/llvm-toolchain-bionic.list
### apt-get update
### apt-get install clang-12
### apt-get install lld-12
### update-alternatives --install /usr/bin/clang clang /usr/bin/clang-12 1200
### update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-12 1200
### update-alternatives --install /usr/bin/llvm-symbolizer llvm-symbolizer /usr/bin/llvm-symbolizer-12 1200
### ```
local site="http://apt.llvm.org"
local name="$1"
local version=12 # NOTE: no longer decimal-based
local priority=$(( version * 100 ))
[ -n "$name" ] || name="$(lsb_release -c | cut -f2)"
# TODO: use https? this is sketchy
echo wget -O - "$site/llvm-snapshot.gpg.key" \| apt-key add -
echo echo -n \""\
deb $site/$name/ llvm-toolchain-$name main\n\
# deb-src $site/$name/ llvm-toolchain-$name main\n\
# $version\n\
deb $site/$name/ llvm-toolchain-$name-$version main\n\
# deb-src $site/$name/ llvm-toolchain-$name-$version main\n\
"\" \> "/etc/apt/sources.list.d/llvm-toolchain-$name.list"
echo apt-get update
echo apt-get install clang-$version
echo apt-get install lld-$version
echo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-$version $priority
echo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-$version $priority
echo update-alternatives --install /usr/bin/llvm-symbolizer llvm-symbolizer /usr/bin/llvm-symbolizer-$version $priority
}
compile() { ### @-
### compile single-file C and C++ programs, messily.
###
### supports gcc and clang on \*nix, and mingw64 gcc, msvc clang,
### and regular msvc on Windows. tested on x86\_64 and on ARMv7 as well.
### does not support MacOS, maybe someday…
###
### defaults to gnu11 and gnu++1z as C and C++ standards respectively.
### defaults to clang, gcc, and msvc in that order.
###
### `compile` attempts to guess the most sane switches for any program, so that compilation may reduce to:
###
### ```sh
### # debug build
### compile rd.c
### compile debug rd.c
### # debug build with warning/error flags defined in ~/sh/arrays
### # (requires .zshrc for global alias expansion)
### compile WHOA rd.c
### # likewise for C++
### compile WHOA WELP rd.cc
### compile WHOA WELP rd.cpp
### # "derelease" build (release build with debug information)
### compile derelease WHOA rd.c
### # release build (with symbols stripped)
### compile release WHOA rd.c
### # hardened build (only useful on *nix)
### compile hardened WHOA rd.c
### # specifying compiler
### compile gcc WHOA rd.c
### compile msvc WHOA rd.c
### compile release clang WHOA rd.c
### # compile and execute (FIXME: writing to /tmp is a security concern)
### compile derelease rd.c && /tmp/rd
### ```
# FIXME: compile gcc portrend.c -lsdl
# this causes mayhem!
local gcc="$(whence -p gcc 2>/dev/null)"
local clang="$(whence -p clang 2>/dev/null)"
local clang_flags=() # currently just for clang-msvc
local flag= d= # iterator variables
local cl= vc=
if [ -n "$MSYSTEM" ]; then # using msys2?
if [ -z "$clang" ]; then # don't have native clang?
# then maybe we have clang-msvc installed.
local dir=
printf "%s\n" "/c/Program Files/LLVM"*(On/N[1]) | read -r dir
if [ -d "$dir" ] && [ -e "$dir/bin/clang" ]; then
clang="$dir/bin/clang"
# not sure if i'll need this:
#local clang_include=
#printf "%s\n" "$dir/lib/clang/"*(On/N[1]) | read -r clang_include
#[ -n "$clang_include" ] || { echo "failed glob; missing clang include" >&2; return 1 }
#clang_flags+=(-I"$clang_include/include")
export PATH="$PATH:$dir/bin/"
fi
fi
local winkit=
printf "%s\n" "/c/Program Files (x86)/Windows Kits/"*(on/N[1]) | read -r winkit
[ -z "$winkit" ] || printf "%s\n" "$winkit/Lib/"*(On/N[1]) | read -r winkit
if [ -z "$winkit" ]; then
#echo "failed glob; missing winkit" >&2
:
else
# detect MSVC.
local clarch= arch= msvc_dig_deep=
[ "$MSYSTEM" = MINGW64 ] && clarch="/amd64" || clarch=""
[ "$MSYSTEM" = MINGW64 ] && arch="x64" || arch="x86"
if [ -d "/c/Program Files (x86)/Microsoft Visual Studio" ]; then # 2017+
printf "%s\n" "/c/Program Files (x86)/Microsoft Visual Studio/20"*(On/N[1]) | read vc
printf "%s\n" "$vc"/*/VC | read vc
printf "%s\n" "$vc/Tools/MSVC/"*(On/N[1]) | read vc
msvc_dig_deep="yes"
else # older versions
printf "%s\n" "/c/Program Files (x86)/Microsoft Visual Studio "*(On/N[1]) | read vc
vc="$vc/VC"
fi
# setup MSVC.
if [ -n "$msvc_dig_deep" ] && [ -e "$vc/bin/Host$arch/$arch/cl" ]; then
cl="$vc/bin/Host$arch/$arch/cl"
export PATH="$PATH:$vc/bin/Host$arch/$arch"
export LIB="$(cygpath -w "$vc/lib/$arch")"
export LIBPATH="$(cygpath -w "$vc/lib/$arch")"
elif [ -d "$vc/bin$clarch" ] && [ -e "$vc/bin$clarch/$cl" ]; then
cl="$vc/bin$clarch/cl"
export PATH="$PATH:$vc/bin$clarch"
export LIB="$(cygpath -w "$vc/LIB$clarch")"
export LIBPATH="$(cygpath -w "$vc/LIB$clarch")"
fi
# finish up.
if [ -n "$cl" ]; then
export INCLUDE="$(cygpath -w "$vc/INCLUDE")"
export INCLUDE="$INCLUDE;$(cygpath -w "${winkit/Lib/Include}/ucrt")"
export LIB="$LIB;$(cygpath -w "$winkit/um/$arch")"
export LIB="$LIB;$(cygpath -w "$winkit/ucrt/$arch")"
for d in "${(@s/;/)INCLUDE}"; do
clang_flags+=(-I"$d")
done
# ignore MSVC's non-standard deprecation warnings.
clang_flags+=(-D_CRT_SECURE_NO_WARNINGS)
fi
fi
fi
local sep_once=
print_separated() {
echo -n "${sep_once:+|}$1" >&2
sep_once=1
}
if [ $# -eq 0 ]; then
echo -n "usage: compile [" >&2
[ -n "$clang" ] && print_separated "clang"
[ -n "$gcc" ] && print_separated "gcc"
[ -n "$cl" ] && print_separated "msvc"
echo "] [debug|derelease|release|hardened] [flags...] {source file}" >&2
return 1
fi
# set some defaults.
local sepples=0 CC= CXX=
[ -n "$clang" ] && CC=clang || CC=gcc
[ -n "$clang" ] && CXX=clang++ || CXX=g++
local our_flags=(-I.)
# guess if we're compiling C++ by the file extension.
local file=${@[-1]}
[ "${file##*.}" = "c" ] || [ "${file##*.}" = "h" ] || sepples=1
# select the appropriate executable if a compiler name is given.
{ [ "$1" = clang ] && CC="clang" && CXX="clang++" && shift } || \
{ [ "$1" = gcc ] && CC="gcc" && CXX="g++" && shift } || \
{ [ "$1" = msvc ] && CC="cl" && CXX="cl" && shift }
# always color outputs.
[ "$CC" = cl ] || our_flags+=-fdiagnostics-color=always
# add our clang-specific flags. (currently just for clang-msvc)
if [ $CC = clang ] && [ -n "$clang_flags" ]; then
for flag in $clang_flags; do
our_flags+=($flag)
done
fi
# if they exist, include some directories that contain useful headers.
maybe_include() {
[ -d "$1" ] && our_flags+=("-I$1")
}
#maybe_include "$HOME/opt/local/include"
#maybe_include "$HOME/src/ustl"
# set the build flags for each mode.
if [ $CC = cl ]; then
our_flags+=(-nologo -utf-8)
local debug_flags=(-Od -ZI -sdl);
local release_flags=(-Ox)
local dr_flags=(-Ox -Zi)
local hardened_flags=(-Ox -sdl)
else
if [ $CC = clang ]; then
# clang doesn't like -march=native on ARM for some reason.
our_flags+=(-mcpu=native)
else
our_flags+=(-march=native)
fi
local debug_flags=(-O1 -g -D_DEBUG);
local release_flags=(-Ofast -fwhole-program -fweb -mtune=native -g0 -fomit-frame-pointer -s -DNDEBUG)
local dr_flags=(-Ofast -g -fomit-frame-pointer -DNDEBUG)
local hardened_flags=(-O3 -g0 -s
-DNDEBUG -D_FORTIFY_SOURCE=2
-Wformat -Wformat-security -Werror=format-security)
if [ -z "$MSYSTEM" ]; then
hardened_flags+=(-fPIE -pie)
hardened_flags+=(-Wl,-O1,--sort-common,--as-needed,-z,relro,-z,now)
fi
local nomalloc=(-fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free)
if [ -e /usr/bin/pprof ]; then
#debug_flags+=(-ltcmalloc $nomalloc)
dr_flags+=(-lprofiler $nomalloc)
elif [ -e /usr/bin/google-pprof ]; then
#debug_flags+=(-l:libtcmalloc.so.4 $nomalloc)
dr_flags+=(-l:libtcmalloc_and_profiler.so.4 $nomalloc)
fi
fi
# select appropriate version and executable for the language.
local compiler=
if [ $sepples -eq 1 ]; then
compiler=$CXX
[ $CC = cl ] && std="-TP" || std="-std=gnu++1z"
else
compiler=$CC
[ $CC = cl ] && std="-TC" || std="-std=gnu11"
fi
local clang_msvc=0
if [ $CC = clang ]; then
if $compiler --version | grep -q windows-msvc; then
clang_msvc=1
fi
fi
local gold=
# utilize clang's vast debugging and hardening features where available.
if [ $CC = clang ]; then
debug_flags+=(-ftrapv)
[ -z "$MSYSTEM" ] && gold=gold || gold=lld
[ -n "$MSYSTEM" ] && our_flags+=(-fansi-escape-codes) || true
if [ $clang_msvc -eq 1 ] || [ -z "$MSYSTEM" ]; then
debug_flags+=(-fsanitize=undefined) # this SHOULD work with mingw,
# but it fails to link.
debug_flags+=(-fsanitize=address)
debug_flags+=(-fvisibility=hidden -fuse-ld=$gold -flto -fsanitize=cfi)
hardened_flags+=(-fsanitize=safe-stack)
hardened_flags+=(-fstack-protector-strong)
hardened_flags+=(-fvisibility=hidden -fuse-ld=$gold -flto -fsanitize=cfi)
else
fi
fi
# select and merge the flags for our build mode.
# TODO: add static option.
{ [ "$1" = debug ] && our_flags+=($debug_flags) && shift } || \
{ [ "$1" = release ] && our_flags+=($release_flags) && shift } || \
{ [ "$1" = derelease ] && our_flags+=($dr_flags) && shift } || \
{ [ "$1" = hardened ] && our_flags+=($hardened_flags) && shift } || \
{ our_flags+=($debug_flags) } # our default
local flags=(${@[1,-2]})
# drop everything past the first dot and use that as our output filename.
local out=/tmp/${${file##*/}%%.*}
if [ -n "$MSYSTEM" ]; then
# explicitly output as .exe to avoid weirdness.
out="$out.exe"
fi
# TODO: naive idea:
# allow multiple source files (using the firstmost to determine the program name)
# by generating a file that #includes each given file.
local final_flags=() libraries=() warnings=()
for flag in $our_flags $flags; do
# move -l flags to the end because gcc won't respect them otherwise.
if [[ $flag == -l* ]]; then
libraries+=($flag)
# split warning flags so they don't spam the console.
elif [[ $flag == -W* ]] && [[ $flag != -Wl* ]] || [[ $flag == -Wlogical-op ]]; then
warnings+=($flag)
if [ $sepples -eq 0 ] && [[ $flag == -Wextra ]] then
# enable some warnings just for C. too annoying in C++.
warnings+=(-Wshadow -Winline)
# these ones only work with C.
warnings+=(-Wjump-misses-init)
fi
if [ $CC = cl ] && [ $flag = -Wall ]; then
# disable some obnoxious msvc warnings.
warnings+=(
-wd4505 # unreferenced local function has been removed
-wd4514 # unreferenced inline function has been removed
-wd4625 # copy constructor was implicitly defined as deleted because a base class copy constructor is inaccessible or deleted
-wd4626 # assignment operator was implicitly defined as deleted because a base class assignment operator is inaccessible or deleted
-wd4710 # function not inlined
-wd4711 # function selected for automatic inline expansion
)
fi
else
if [ $CC = clang ]; then
# these are specific to gcc. (for now)
if [ $flag = "-findirect-inlining" ] \
|| [ $flag = "-finline-small-functions" ]; then
continue
fi
fi
if [ $clang_msvc -eq 1 ]; then
# remove linker-related flags from our compiler-only clang.
if [ $flag = "-Wl,--gc-sections" ] \
|| [ $flag = "-s" ]; then
continue
fi
fi
final_flags+=($flag)
fi
done
# do the thing!
[ $CC = cl ] && local outflag=-Fe: || local outflag=-o
echo $compiler $std ${final_flags[@]} $file ${libraries[@]} $outflag $out >&2
$compiler $std ${final_flags[@]} $file ${libraries[@]} ${warnings[@]} $outflag $out
}
[ -n "${preload+-}" ] || compile "$@"
Reference in a new issue View git blame Copy permalink