tools/test.sh

   1 #!/bin/sh
   2
   3 dir=`cd $(dirname "$0"); pwd`
   4 bin=$dir/../qbe
   5 binref=$dir/../qbe.ref
   6
   7 tmp=/tmp/qbe.zzzz
   8
   9 drv=$tmp.c
  10 asm=$tmp.s
  11 asmref=$tmp.ref.s
  12 exe=$tmp.exe
  13 out=$tmp.out
  14
  15 testcc() {
  16         echo "int main() { }" | $1 -x c -o /dev/null - >/dev/null 2>&1
  17         return $?
  18 }
  19
  20 init() {
  21         case "$TARGET" in
  22         arm64)
  23                 for p in aarch64-linux-musl aarch64-linux-gnu
  24                 do
  25                         cc="$p-gcc -no-pie -static"
  26                         qemu="qemu-aarch64"
  27                         if
  28                                 $cc -v >/dev/null 2>&1 &&
  29                                 $qemu -version >/dev/null 2>&1
  30                         then
  31                                 if sysroot=$($cc -print-sysroot) && test -n "$sysroot"
  32                                 then
  33                                         qemu="$qemu -L $sysroot"
  34                                 fi
  35                                 break
  36                         fi
  37                         cc=
  38                 done
  39                 if test -z "$cc"
  40                 then
  41                         echo "Cannot find arm64 compiler or qemu."
  42                         exit 1
  43                 fi
  44                 bin="$bin -t arm64"
  45                 ;;
  46         rv64)
  47                 for p in riscv64-linux-musl riscv64-linux-gnu
  48                 do
  49                         cc="$p-gcc -no-pie -static"
  50                         qemu="qemu-riscv64"
  51                         if
  52                                 $cc -v >/dev/null 2>&1 &&
  53                                 $qemu -version >/dev/null 2>&1
  54                         then
  55                                 if sysroot=$($cc -print-sysroot) && test -n "$sysroot"
  56                                 then
  57                                         qemu="$qemu -L $sysroot"
  58                                 fi
  59                                 break
  60                         fi
  61                         cc=
  62                 done
  63                 if test -z "$cc"
  64                 then
  65                         echo "Cannot find riscv64 compiler or qemu."
  66                         exit 1
  67                 fi
  68                 bin="$bin -t rv64"
  69                 ;;
  70         "")
  71                 case `uname` in
  72                 *Darwin*)
  73                         cc="cc"
  74                         ;;
  75                 *OpenBSD*)
  76                         cc="cc -nopie -lpthread"
  77                         ;;
  78                 *FreeBSD*)
  79                         cc="cc -lpthread"
  80                         ;;
  81                 *)
  82                         cc="${CC:-cc} -lpthread"
  83                         testcc "$cc" || cc="${CC:-cc}"
  84                         ;;
  85                 esac
  86                 TARGET=`$bin -t?`
  87                 ;;
  88         *)
  89                 echo "Unknown target '$TARGET'."
  90                 exit 1
  91                 ;;
  92         esac
  93 }
  94
  95 cleanup() {
  96         rm -f $drv $asm $exe $out
  97 }
  98
  99 extract() {
 100         WHAT="$1"
 101         FILE="$2"
 102
 103         awk "
 104                 /^# >>> $WHAT/ {
 105                         p = 1
 106                         next
 107                 }
 108                 /^# <<</ {
 109                         p = 0
 110                 }
 111                 p
 112         " $FILE \
 113         | sed -e 's/# //' \
 114         | sed -e 's/#$//'
 115 }
 116
 117 once() {
 118         t="$1"
 119
 120         if ! test -f $t
 121         then
 122                 echo "invalid test file $t" >&2
 123                 exit 1
 124         fi
 125
 126         if
 127                 sed -e 1q $t |
 128                 grep "skip.* $TARGET\( .*\)\?$" \
 129                 >/dev/null
 130         then
 131                 return 0
 132         fi
 133
 134         printf "%-45s" "$(basename $t)..."
 135
 136         if ! $bin -o $asm $t
 137         then
 138                 echo "[qbe fail]"
 139                 return 1
 140         fi
 141
 142         if test -x $binref
 143         then
 144                 $binref -o $asmref $t 2>/dev/null
 145         fi
 146
 147         extract driver $t > $drv
 148         extract output $t > $out
 149
 150         if test -s $drv
 151         then
 152                 src="$drv $asm"
 153         else
 154                 src="$asm"
 155         fi
 156
 157         if ! $cc -g -o $exe $src
 158         then
 159                 echo "[cc fail]"
 160                 return 1
 161         fi
 162
 163         if test -s $out
 164         then
 165                 $qemu $exe a b c | diff -u - $out
 166                 ret=$?
 167                 reason="output"
 168         else
 169                 $qemu $exe a b c
 170                 ret=$?
 171                 reason="returned $ret"
 172         fi
 173
 174         if test $ret -ne 0
 175         then
 176                 echo "[$reason fail]"
 177                 return 1
 178         fi
 179
 180         echo "[ok]"
 181
 182         if test -f $asmref && ! cmp -s $asm $asmref
 183         then
 184                 loc0=`wc -l $asm    | cut -d' ' -f1`
 185                 loc1=`wc -l $asmref | cut -d' ' -f1`
 186                 printf "    asm diff: %+d\n" $(($loc0 - $loc1))
 187                 return 0
 188         fi
 189 }
 190
 191 #trap cleanup TERM QUIT
 192
 193 init
 194
 195 if test -z "$1"
 196 then
 197         echo "usage: tools/test.sh {all, SSAFILE}" 2>&1
 198         exit 1
 199 fi
 200
 201 case "$1" in
 202 "all")
 203         fail=0
 204         for t in $dir/../test/[!_]*.ssa
 205         do
 206                 once $t
 207                 fail=`expr $fail + $?`
 208         done
 209         if test $fail -ge 1
 210         then
 211                 echo
 212                 echo "$fail test(s) failed!"
 213         else
 214                 echo
 215                 echo "All is fine!"
 216         fi
 217         exit $fail
 218         ;;
 219 *)
 220         once $1
 221         exit $?
 222         ;;
 223 esac