[AOMP] Taskification/control-flow inversion for scripts, part 1

This is an experimental patch to incrementally refactor the build scripts.
The approach taken is particularly relevant to scripts which build
multiple configurations of a component.

There are several ideas here. Firstly, build scripts can be introspected
so you can see what they are doing:

$ ./build_offload.sh list_configs
asan
perf
perf+asan
debug
debug+asan

$ AOMP_BUILD_SANITIZER=0 ./build_offload.sh list_configs
perf
debug

Build steps are split into different tasks, each of which is wrapped in a
"task_foo" function (which is passed the configuration name):

$ ./build_offload.sh list_tasks perf
clean
cmake
build
install

You can list all tasks list this:

$ ./build_offload.sh list
task_precheck
task_patch
task_clean asan
task_cmake asan
task_build asan
task_install asan
task_clean perf
task_cmake perf
task_build perf
task_install perf
task_clean perf+asan
task_cmake perf+asan
task_build perf+asan
task_install perf+asan
task_clean debug
task_cmake debug
task_build debug
task_install debug
task_postinstall debug
task_clean debug+asan
task_cmake debug+asan
task_build debug+asan
task_install debug+asan
task_unpatch

Or e.g. see what will happen for different env var settings:

$ AOMP_BUILD_DEBUG=0 ./build_offload.sh list
task_precheck
task_patch
task_clean asan
task_cmake asan
task_build asan
task_install asan
task_clean perf
task_cmake perf
task_build perf
task_install perf
task_clean perf+asan
task_cmake perf+asan
task_build perf+asan
task_install perf+asan
task_unpatch

You can still invoke the build scripts the same way as at present:

$ ./build_offload.sh
[...builds everything...]

$ ./build_offload.sh cmake
[...just runs cmake steps...]

$ ./build_offload.sh nocmake
[...just runs build steps...]

$ ./build_offload.sh install
[...just runs install steps...]

Only the build_offload.sh script has been done so far, but this
backward compatibility allows other scripts to be refactored in a similar
way incrementally.

The aim (not yet realised) is to then provide a new or alternate front-end
(to build_aomp.sh) using exactly the same build scripts, allowing
fine-grained control over which components to build/rebuild, and so on.

Internally, the refactoring already done on build_offload.sh demonstrates
very much deduplication, particularly around the setting of cmake
options. Further work will allow much of the "boilerplate" in each of
the build scripts to be replaced by a central implementation.

Environment variables used to control the build are now read via two
functions (get_config_var_string and get_config_var_bool).  There are
several reasons for this indirection:

- It allows us to have a single location to check which environment
  variables are being used to control the build.

- (For the alternate frontend) the options can be changed via
  e.g. command-line options instead of environment variables.

- The _bool function emits the string 'true' or 'false'. This allows
  the use of:

    if $Result; then ... fi

  instead of

    if [ "$Result" -eq 1 ]; then ... fi

  which is shorter/somewhat easier to read.

"Actions" (the emulated "nocmake", etc. options, and the new "list",
etc. options) are implemented as functions named "do_{foo}", invoked by
the new "command_dispatcher" function.

There are a few other actions, e.g.:

$ ./build_offload.sh show_build_dir perf
/home/julbrown/git/aomp21.0/build/home/julbrown/git/aomp21.0/offload_perf

These will be more useful once more scripts are "taskified".

Author: jtb20

bin/aomp_utils

@@ -233,6 +233,167 @@ function is_apu(){
   fi
 }
 
+valid_config() {
+  local thiscfg=$1
+  local -a configs
+  local oldlastpipe
+  local cfg
+  oldlastpipe="$(shopt -p lastpipe)"
+  shopt -s lastpipe
+  do_list_configs | mapfile -t configs
+  for cfg in "${configs[@]}"; do
+    if [ "$cfg" = "$thiscfg" ]; then
+      eval "$oldlastpipe"
+      return 0
+    fi
+  done
+  eval "$oldlastpipe"
+  return 1
+}
+
+runcmd() {
+  "$@"
+}
+
+aomp_tasks_filtered() {
+  local filter
+  local cfg
+  local task
+  local cmd
+  if [ "$1" = "--dryrun" ]; then
+    cmd="echo"
+    shift
+  else
+    cmd="runcmd"
+  fi
+  filter=$1
+  do_list_init | while read -r initfn; do
+    $cmd "task_${initfn}"
+  done
+  do_list_configs | while read -r cfg; do
+    do_list_tasks "$cfg" | while read -r task; do
+      if [[ "$task" =~ $filter ]]; then
+        $cmd "task_${task}" "$cfg"
+      fi
+    done
+  done
+  do_list_fini | while read -r finifn; do
+    $cmd "task_${finifn}"
+  done
+}
+
+get_config_var_string() {
+  #local component=$1
+  local -n _varname=$2
+  case "$2" in
+    BUILD_DIR)
+      printf "%s/build" "$_varname"
+      return
+      ;;
+    LLVM_INSTALL_LOC|AOMP_PROC|CUDABIN|CUDAT|CUDAINCLUDE|REPO_DIR|\
+    AOMP_NINJA_BIN|AOMP_JOB_THREADS|LLVM_PROJECT_ROOT)
+      ;;
+    *)
+      >&2 echo "Unknown string configuration variable '$2'"
+      exit 1
+      ;;
+  esac
+  printf "%s" "$_varname"
+}
+
+get_config_var_bool() {
+  #local component=$1
+  local -n _varname=$2
+  case "$2" in
+    AOMP_BUILD_CUDA|AOMP_APPLY_ATD_AMD_STAGING_PATCH|AOMP_USE_NINJA|\
+    AOMP_STANDALONE_BUILD|SANITIZER|AOMP_LEGACY_OPENMP|AOMP_BUILD_SANITIZER|\
+    AOMP_BUILD_PERF|AOMP_BUILD_DEBUG)
+      ;;
+    *)
+      >&2 echo "Unknown bool configuration variable '$2'"
+      exit 1
+      ;;
+  esac
+  if [[ $_varname = 1 ]]; then
+    echo "true"
+  else
+    echo "false"
+  fi
+}
+
+do_aomp_all() {
+  aomp_tasks_filtered '.*'
+}
+
+do_cmake() {
+  aomp_tasks_filtered '^(clean|cmake)'
+}
+
+do_nocmake() {
+  aomp_tasks_filtered 'build'
+}
+
+do_install() {
+  aomp_tasks_filtered '^(install|postinstall)'
+}
+
+do_show_src_dir() {
+  if [ $# -eq 0 ]; then
+    printf "%s\n" "$(get_src_dir)"
+  else
+    local WhichComp=$1
+    "$thisdir/build_${WhichComp}.sh" show_src_dir
+  fi
+}
+
+do_show_build_dir() {
+  local WhichComp
+  local Cfg
+  if [ $# -eq 1 ]; then
+    Cfg=$1
+    printf "%s\n" "$(get_build_dir "$Cfg")"
+  elif [ $# -eq 2 ]; then
+    WhichComp=$1
+    Cfg=$2
+    "$thisdir/build_${WhichComp}.sh" show_build_dir "$Cfg"
+  else
+    >&2 echo "Usage: show_build_dir [<component>] <cfg>"
+    exit 1
+  fi
+}
+
+do_show_install_dir() {
+  local WhichComp
+  local Cfg
+  if [ $# -eq 1 ]; then
+    Cfg=$1
+    printf "%s\n" "$(get_install_dir "$Cfg")"
+  elif [ $# -eq 2 ]; then
+    WhichComp=$1
+    Cfg=$2
+    "$thisdir/build_${WhichComp}.sh" show_install_dir "$Cfg"
+  else
+    >&2 echo "Usage: show_install_dir [<component>] <cfg>"
+    exit 1
+  fi
+}
+
+do_list() {
+  aomp_tasks_filtered --dryrun '.*'
+}
+
+command_dispatcher() {
+  local _proc
+  _proc=$1
+  if [ "$_proc" ]; then
+    shift
+    "do_${_proc}" "$@"
+  else
+    shift
+    do_aomp_all "$@"
+  fi
+}
+
 function help_build_aomp(){
    /bin/cat 2>&1 <<"EOF"