#!/bin/sh

#

# Find the compiler fixed point and update the seed binary.

#

# Iterates self-compilation stages starting from the current seed until a fixed

# point is reached, then copies the result back to the seed.

#

# Usage: seed/update [--seed <path>] [--from-s0]

#

# Options:

#   --seed <path>            Use <path> as the seed binary instead of seed/radiance.rv64

#   --from-s0                Run the seed as a native binary (stage 0) instead of

#                            through the emulator

#

# Environment variables:

#   EMULATOR_MEMORY_SIZE     Emulator memory in KB (default: 385024)

#   EMULATOR_DATA_SIZE       Emulator data segment in KB (default: 348160)

#

set -eu

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"

ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"

cd "${ROOT_DIR}"

# ---------------------------------------------------------------------------

# Helpers

# ---------------------------------------------------------------------------

step() {

  printf "\n==> %s\n" "$*"

}

fail() {

  printf "!! %s\n" "$*" >&2

  exit 1

}

# ---------------------------------------------------------------------------

# Command line flags for Radiance compiler

# ---------------------------------------------------------------------------

STD_MODS="$(sed 's/^/-mod /' std.lib | tr '\n' ' ')"

OPTS="-pkg std ${STD_MODS} -pkg radiance -mod compiler/radiance.rad -mod compiler/radiance/codegen.rad -entry radiance"

# ---------------------------------------------------------------------------

# Emulator settings

# ---------------------------------------------------------------------------

MEMORY_SIZE="${EMULATOR_MEMORY_SIZE:-385024}"

DATA_SIZE="${EMULATOR_DATA_SIZE:-348160}"

EMU="${RAD_EMULATOR:-emulator} -debug -no-validate \

    -memory-size=${MEMORY_SIZE} -data-size=${DATA_SIZE} \

    -count-instructions -run"

# ---------------------------------------------------------------------------

# Compile one self-hosted stage.

#   stage <input> <output>

# ---------------------------------------------------------------------------

stage() {

  time -p $EMU "$1" $OPTS -o "$2"

}

# ---------------------------------------------------------------------------

# Compile one stage using a native (s0) binary.

#   stageS0 <input> <output>

# ---------------------------------------------------------------------------

stageS0() {

  time -p "$1" compiler/radiance.rad $OPTS -o "$2"

}

# ---------------------------------------------------------------------------

# Compare two stage binaries. Returns 0 if identical, 1 if they differ.

# ---------------------------------------------------------------------------

compareStages() {

  if cmp -s "$1" "$2"; then

    printf " IDENTICAL\n  sha256: %s\n" "$(sha256sum "$2" | cut -d' ' -f1)"

    return 0

  else

    printf " DIFFERENT\n"

    return 1

  fi

}

# ---------------------------------------------------------------------------

# Copy the fixed-point binary to the seed.

# ---------------------------------------------------------------------------

updateSeed() {

  [ "$1" != seed/radiance.rv64 ] && cp "$1" seed/radiance.rv64

  git rev-parse HEAD > seed/radiance.rv64.git

  printf "\n"

  printf "Fixed point reached at %s\n" "$2"

  printf "Seed updated (commit $(git rev-parse --short HEAD))\n"

}

# ---------------------------------------------------------------------------

# Parse arguments

# ---------------------------------------------------------------------------

SEED="seed/radiance.rv64"

FROM_S0=0

while [ $# -gt 0 ]; do

  case "$1" in

    --seed)

      [ $# -ge 2 ] || fail "--seed requires an argument"

      SEED="$(realpath "$2")"

      shift 2

      ;;

    --from-s0)

      FROM_S0=1

      shift

      ;;

    *)

      fail "unknown option: $1"

      ;;

  esac

done

command -v "${RAD_EMULATOR:-emulator}" >/dev/null 2>&1 \

  || fail "emulator not found: set RAD_EMULATOR or add 'emulator' to PATH"

[ -f "${SEED}" ] || fail "seed binary not found: ${SEED}"

# ---------------------------------------------------------------------------

# Stage 1: seed compiles source

# ---------------------------------------------------------------------------

S1=seed/radiance.rv64.s1

S2=seed/radiance.rv64.s2

S3=seed/radiance.rv64.s3

S4=seed/radiance.rv64.s4

step "Stage 1: S0 builds S1"

if [ "${FROM_S0}" -eq 1 ]; then

  stageS0 "${SEED}" "${S1}"

else

  stage "${SEED}" "${S1}"

fi

printf "\nComparing S0 and S1 ..."

if compareStages "${SEED}" "${S1}"; then

  updateSeed "${SEED}" "S0"

  exit 0

fi

# ---------------------------------------------------------------------------

# Stage 2: S1 compiles source

# ---------------------------------------------------------------------------

step "Stage 2: S1 builds S2"

stage "${S1}" "${S2}"

printf "\nComparing S1 and S2 ..."

if compareStages "${S1}" "${S2}"; then

  updateSeed "${S1}" "S1"

  exit 0

fi

# ---------------------------------------------------------------------------

# Stage 3: S2 compiles source

# ---------------------------------------------------------------------------

step "Stage 3: S2 builds S3"

stage "${S2}" "${S3}"

printf "\nComparing S2 and S3 ..."

if compareStages "${S2}" "${S3}"; then

  updateSeed "${S2}" "S2"

  exit 0

fi

fail "No fixed point reached after 3 stages"