libk  build.sh at [5560c2725b]

File build.sh artifact d7b4907031 part of check-in 5560c2725b


#!/usr/bin/env bash
# build.sh - libk build script

# TODO when compiling C code, first check
#      if an assembly override exists for
#      the target platform and if there's
#      one, ignore the C and assemble the
#      override file instead.

export to=${to:-out}
source global/common.sh

if test "$os$arch$bits" = ""; then
	say "set the following environment variables to the appropriate atoms describing your system. for help determining the appropriate atoms, see libk.md"
	say ' - $os={lin|fbsd|hai|osx…}'
	say ' - $arch={x86|arm|ia64|mips…}'
	say ' - $bits={|32|64…}'
	exit 1
fi

if test "$1" = "-C"; then
	say "precleaning repo"
	./clean.sh
fi

# TODO: make it possible for user to change
#       default set with environment vars
modules=(kcore kmem kstr kio kgraft kfile)

# compose an arch tuple. this is used in
# places, mostly to select the correct
# version of assembly files for a given
# platform (each has an arch tuple in its
# name, following the linkage specifier)
target=$arch.$os
if test "$bits" != ""; then
	target=$target.$bits
fi

# determine whether we have unix or posix
# APIs depending on the operating system.
# presumably if the user is running a bash
# script there is some degree of posix
# support available, but we might still be
# building for windows from within cygwin
# or whatever
case $os in
	lin|?bsd|and|dar|osx|nix) posix=yes; unix=yes;;
	hai) posix=yes; unix=no;;
	*) posix=no; unix=no;;
esac

case $os.$bits in
	win.32) bin_fmt=win32;;
	win.64) bin_fmt=win64;;
	osx.32|dar.32) bin_fmt=macho32;;
	osx.64|dar.64) bin_fmt=macho64;;
	dos.*) bin_fmt=dosexe;;
	none.*) bin_fmt=bin;;
	*.32) bin_fmt=elf32;;
	*.64) bin_fmt=elf64;;
	*) say "cannot determine correct binary format to use for target $target"; exit 1;;
esac

# first, we establish the
# parameters of the build
has cc && _cc=cc
has clang && _cc=clang 
has gcc && _cc=gcc # prefer gcc
cc=${cc:-$_cc}
has m4 && _m4=m4
m4=${m4:-$_m4}
has nasm && asm=nasm
has yasm && asm=yasm # prefer yasm
export cc
export m4
export gen=${gen:-gen}
library=${library:-static} # {static|shared|both}
export verbose=${verbose:-quiet} # {no|quiet|loud}

doc=${doc:-yes}
export doc_html=${doc_html:-yes}
export doc_pdf=${doc_pdf:-yes}
export doc_man=${doc_man:-yes}

case $library in
	static) build_static_library=yes
	        build_shared_library=no;;

	shared) build_static_library=no
	        build_shared_library=yes;;

	  both) build_static_library=yes
	        build_shared_library=yes;;
esac

check cc "your C compiler of choice"
check asm "an assembler that takes Intel syntax and nasm-style-macros"
check m4 "the path to your m4 installation"

export build=$(global/build-id.sh)

if test "$p_headers_errno" = ""; then
	case $os in
		lin) p_headers_errno="${p_headers_errno:-/usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h}";;

		fbsd) p_headers_errno="${p_headers_errno:-/usr/include/errno.h}";;
	esac
fi

check p_headers_errno \
	'the location of a header defining the values of each errno symbol'

macro_compile_env="-Datom_target_arch=$arch -Datom_target_os=$os -Dtarget_posix=$posix -Dtarget_unix=$unix"

if test "$bits" != ""; then
	macro_compile_env="$macro_compile_env -Datom_target_bits=$bits"
fi

comp_mac() {
	local src=$1
	local output=$2
	local flags=$3
	if test -e "$output"; then
		if test ! "$output" -ot "$src"; then
			return
		fi 
	fi
	if test "$debug" = yes; then
		local dflag=-Dcompile_debug=yes
	fi
	         $m4 $macro_compile_env $dflag -I "$gen" $flags "$src"  > "$output"
	announce $m4 $macro_compile_env $dflag -I "$gen" $flags "$src" \> "$output"
	# yes, this is incredibly stupid. if you know a better way, feel
	# free to submit a fix. the problem is there's no way to pass >
	# to report in such a way that it'll do the right thing, and if
	# you just write > it redirects *report's* output, instead of
	# m4's. piece of shit that it is, m4 doesn't have any way to emit
	# output into a fille - stdout only apparently. tl;dr i hate bash.
}
comp_asm() {
	local src=$1
	local output=$2
	local flags=$3
	if test -e "$output"; then
		if test ! "$output" -ot "$src"; then
			return
		fi
	fi
	if test "$debug" = yes; then
		local dflag="-g dwarf2"
	fi
	report $asm $flags $dflag "-f$bin_fmt" -i "$gen" "$src" -o "$output";
}
comp_co()  { comp_c $1 $2 "-c -fPIC"; }
comp_c(){
	local src=$1
	local output=$2
	local flags=$3
	if test -e "$output"; then
		if test ! "$output" -ot "$src"; then
			return
		fi
	fi
	# only rebuild the file if the source file is newer
	if test "$debug" = yes; then
		local dflag="-g"
	else
		local dflag="-O4"
	fi
	if test "$assembly" = yes; then
		report $cc $src $3 $dflag -std=c11 -isystem "$to" -isystem "$gen" -isystem "arch/" -ffreestanding -nostdlib "-L$to" -masm=intel -fverbose-asm -S "-o$output.s"
	else
		report $cc $src $3 $dflag -std=c11 -isystem "$to" -isystem "$gen" -isystem "arch/" -ffreestanding -nostdlib "-L$to" "-o$output"
	fi
}

say "commencing libk build $build at $(timestamp)"
# set -x

# get type data
mkdir -p $gen
report $cc -D_emit_m4_include arch/typesize.c -o $gen/typesize 
$gen/typesize > gen/typesize.m

# generate syscall tables
if test $posix = yes; then
	# on posix, we simply abuse CPP to garner a list of syscalls;
	# the file arch/posix/syscalls contains a list of syscalls
	# we wish to import; we use sed to transform this into a form
	# that cpp will fill out for us, producing a table that the
	# awk scripts can handle and turn into a list of constants.
	echo '#include <sys/syscall.h>' > $gen/system_calls.t.1 # this is the magic part
	cat arch/posix/syscalls > $gen/system_calls.t.2
	sed -e 's;^\(.*\)$;\1 SYS_\1;' -i $gen/system_calls.t.2
	cat $gen/system_calls.t.1 $gen/system_calls.t.2 | cpp -P >$gen/system_calls.tbl

	# generate errno tables the same way
	echo '#include <errno.h>' > $gen/error_codes.t.1 # this is the magic part
	cat arch/posix/errnos > $gen/error_codes.t.2
	sed -e 's;^\(.*\)$;k_platform_error_\1 \1;' -i $gen/error_codes.t.2
	cat $gen/error_codes.t.1 $gen/error_codes.t.2 | cpp -P | grep "^k_platform_error" >$gen/error_codes.tbl # haaaack
else
	case $os in
		*) noimpl 'system call table generation';;
	esac
fi

# take the OS-specific system call tables that have been prepared
# for us above and feed them into awk scripts to generate C headers
awk -f arch/syscall.awk -v out=s <$gen/system_calls.tbl>$gen/system_calls.s
awk -f arch/syscall.awk -v out=h <$gen/system_calls.tbl>$gen/system_calls.h

# do the same with our error codes table
awk -f arch/errtbl.awk <$gen/error_codes.tbl >$gen/error_table.h

# generate symbol tables for error handling functions
mkdir -p "$to/k"
awk -f global/gen-conds.awk <global/modules >$to/k/internal.egroup.h
awk -f global/gen-ident.awk <global/modules >$gen/internal.ident.c
comp_co $gen/internal.ident.c $to/internal.ident.o

# first pass: copy all headers into place,
# including ones we need to generate

for mod in ${modules[@]}; do
	for h in $(scan mod/$mod '*.h'); do
		base=$(basename $h)
		cp "$h" "$to/k/$base"
	done

	for h in $(scan mod/$mod '*.h.m'); do
		base=$(basename $h)
		dest=${base%%.m}
		comp_mac "$h" "$to/k/$dest"
	done
done

# second pass: generate manpage, html, and pdf
# versions of the documentation from the md src

if test "$doc" = "yes"; then
	global/build-manpage.sh libk.md
	for mod in ${modules[@]}; do
		for doc in $(scan mod/$mod '*.md'); do
			base="$(basename $doc)"
			stem="${base%%.md}"
			report global/build-manpage.sh "$doc"
		done
	done
fi

# third pass: compile sources and save the
# resulting object files to $to, tracking
# which is a runtime or function unit. exe's
# will not be compiled until a later pass

fn_objects=()
rt_objects=()
data_objects=( $to/internal.ident.o )
for mod in ${modules[@]}; do
	for fn in $(scan mod/$mod '*.fn.c'); do
		base="$(basename $fn)"
		dest="$to/$mod.${base%%.c}.o"
		comp_co "$fn" "$dest"
		fn_objects+=("$dest")
	done

	for rt in $(scan mod/$mod '*.rt.c'); do
		base="$(basename $rt)"
		dest="$to/$mod.${base%%.c}.o"
		comp_co "$rt" "$dest"
		rt_objects+=("$dest")
	done

	for fn in $(scan mod/$mod "*.fn.$target.s"); do
		base="$(basename $fn)"
		dest="$to/$mod.${base%%.s}.o"
		comp_asm "$fn" "$dest"
		fn_objects+=("$dest")
	done

	for rt in $(scan mod/$mod "*.rt.$target.s"); do
		base="$(basename $rt)"
		dest="$to/$mod.${base%%.s}.o"
		comp_asm "$rt" "$dest"
		rt_objects+=("$dest")
	done
done

# fourth pass: link the libraries that are
# configured to be built

if test $build_static_library == yes; then
	for obj in ${fn_objects[@]} ${rt_objects[@]} ${data_objects[@]}; do
		report ar rc $to/libk.a $obj
	done
	report ranlib $to/libk.a
fi

if test $build_shared_library == yes; then
	report ld -r ${rt_objects[@]} -o $to/boot.o
	report ld -shared ${fn_objects[@]} -o $to/libk.so
fi

# fifth pass: compile the executable tools
# against the libraries created in pass 5

for mod in ${modules[@]}; do
	for exe in $(scan mod/$mod '*.exe.c'); do
		base="$(basename $exe)"
		dest="$to/$mod.${base%%.exe.c}"
		if test $build_shared_library == yes; then
			comp_c "$to/boot.o $exe" "$dest" -lk
		else
			comp_c "$exe" "$dest" -lk
		fi
	done
done

set +x
say "all passes finished; build $build complete at $(timestamp)"