Mesa git amdgpu build 64-bit and 32-bit for Debian testing and unstable, and possibly Ubuntu, Mint, PopOS, etc

mesa-build.sh

#!/bin/bash

# A simple script to build 64-bit and 32-bit Mesa and vkpipeline-db
# on amd64 Debian testing, Debian unstable, and possibly some Ubuntu
# with some tweaks.
#
# A situation with LLVM on Ubuntu was (is?) not perfect, so you are on your own.
#
# If you do not want to or can not use it, modify the script to install and use
# other LLVM and update LLVMVERSION variable below.
#
# It is too complex to handle fully automatically and be future proof. So just
# edit the script accordingly.
#
# By default only drivers for AMD, Intel and software rendering will be built.
# That will build radeon driver, radv (with ACO and LLVM), llvmpipe, swr,
# lavapipe, and zink, with few other minor things.
#
# No Nvidia drivers will be compiled. This is to speed up compilation
# a bit. Modify COMMON_OPTS to change that.
#
# OpenCL support with clover will be built for 64-bit, but you should know
# the OpenCL support in Mesa still has some bugs, so be aware.
# Valgrind extra support will be built for 64-bit only too.
# Otherwise rest (Mesa, OpenGL, Vulkan, Mesa overlay layer, Mesa device selection
# layer, gallium-nine, zink, lavapipe, vkpipeline-db), will be built for both
# 64-bit and 32-bit versions.
#
# No OpenGL ES (GLES), or EGL will be built. It is simply to save a bit of time
# compiling Mesa. You can enable it in COMMON_OPTS below.
#
# Similarlly a Wayland support is untested, and probably not enabled.
# Modify COMMON_OPTS if needed.
#
# Check variable BUILDDEBUG below to enable also debug builds, which can build
# together with optimized builds.
#
# The build will be performed in ~/mesa-git directory for you.
#
# The source tree will live in ~/mesa-git
# Built libraries and binaries will be in ~/mesa-git/builddir/build-{amd64,i386}-{dbg,opt}/
# Libraries and binaries will be installed into ~/mesa-git/installdir/build-{amd64,i386}-{dbg,opt}/
#
# After compilation is done, the script will perform a small test with glxinfo,
# vulkaninfo and vkcube for 2 seconds.
#
#
# After compilation is done, use '. ~/enable-new-mesa-opt.source'
# (without quotes) in your terminal to enable it.
# You can add it to your ~/.profile or ~/.bashrc file too.
#
# You need to use this '. ~/enable-new-mesa-opt.source' before any other
# OpenGL / Vulkan app is started from the same terminal. It is not enough to
# simply do '. ~/enable-new-mesa-opt.source' in a terminal, and the launch
# steam or some game via desktop shorcut, or other terminal. The changes are
# local to the terminal / shell you used it to. You can use it in many terminals
# as you wish.
#
# Note that `enable-new-mesa-opt.source` will also automatically enable ACO if
# available and enable Vulkan Mesa overlay, Gallium HUD, and DXVK HUD.
# Feel free to modify this script below (line ~280 and ~328) to not do that.
# Or source the `disable-new-mesa-hud.source` script to undo the HUD stuff.
#
# This script will not install libraries system wide, so it is safe to use in
# parallel with your distro libraries. And even have applications using one
# or another, or some using optimized libraries and some using debug libraries.
#
# To get rid of it simply run:
#
# rm -rf ~/mesa-git ~/vkpipeline-db ~/enable-new-mesa-*.source ~/disable-new-mesa-hud.source ~/mesa-{opt,dbg} ~/zink-{opt,dbg}
#
# If you want to use this Mesa's OpenGL / Vulkan for your desktop manager, like
# Gnome Shell, you are on your own, but it can be probably done some way by
# putting needed variables in /etc/environment. Maybe...
# Or tweak INSTALLDIR variable. But few more variables (`-Dprefix` for example)
# will be needed to be changed. See https://www.mesa3d.org/meson.html for details.
#
# Rerunning this script will cleanup builddir and installdirs from scratch,
# so it will take some time.
# If you want a bit faster updates, you can do "git pull", then go into proper
# build subdirectory and recompile, i.e. using:
#  cd ~/mesa-git/builddir/build-amd64-opt/ && ninja && ninja install
#
# Copyright: Witold Baryluk <[email protected]>, 2019, 2020, 2021
# License: MIT style license

# Stop execution on first error, and don't continue.
set -e

if [ "x${DEBUG}" = "x1" ]; then
set -x
fi

export LC_ALL=C.UTF-8

# Show less output, but also do fully automatic apt-get setup not needing any confirmations.
QUIET="${QUIET:-0}"

if [ $(whoami) = "root" ]; then
  echo "Do not run this script under root or using sudo!" >&2
  exit 1
fi

if [ "x${QUIET}" = "x1" ]; then
  echo
fi

cd "${HOME}"

BUILDDIR="${PWD}/mesa-git/builddir"
# Aka prefix, but we put each build into separate subprefix.
# So in total there will be 4 subprefixes (64-bit optimized, 32-bit optimized,
# 64-bit debug, 32-bit debug)
INSTALLDIR="${PWD}/mesa-git/installdir"

# Build optimized (-march=native -O2) binaries. If not, only separate debug
# build is built.
BUILDOPT="${BUILDOPT:-1}"
# Use heavy optimizations (-march=native -O3 -free-vectorize -flto -g0) in
# optimized build. This will take about twice as long to compile, might
# expose extra bugs in Mesa or GCC, and will make debugging a bit harder.
# I personally didn't notice any significant performance improvements,
# but in theory they are slightly faster.
HEAVYOPT="${HEAVYOPT:-0}"
# Build separate debug builds with -O1 -ggdb and Mesa debugging code (extra
# runtime checks and asserts) present. You can have both BUILDOPT and
# BUILDDEBUG enabled, and two versions of Mesa will be built, and you can
# switch between them per-app quickly. It is not recommended to use it in
# general unless you find an issue in some apps, crashes, or glitches.
# It is safe to enable building debug builds, even if you are only going to
# use optimized built. They are completly independent.
BUILDDEBUG="${BUILDDEBUG:-0}"
# Build Clover / OpenCL / OpenCL-SpirV support for 64-bit. This flag is ignored
# for 32-bit builds at the moment.
BUILDOPENCL="${BUILDOPENCL:-1}"

BUILD64="${BUILD64:-1}"
BUILD32="${BUILD32:-1}"

DRIVERS="amd,intel,zink,virgl,software"

GIT_REPO="${GIT_REPO:-https://gitlab.freedesktop.org/mesa/mesa.git}"
GIT_DEPTH="${GIT_DEPTH:-1}"
GIT_BRANCH="${GIT_BRANCH}"

# GIT_REPO=https://gitlab.freedesktop.org/zmike/mesa.git; GIT_DEPTH=1000; GIT_BRANCH=zink-wip
# GIT_REPO=https://gitlab.freedesktop.org/Venemo/mesa.git; GIT_BRANCH=aco-navi

usage () {
  echo "$0 usage:"
  echo "--help                 Show this message and exit"
  echo "--quiet                Run in quiet and automated mode. Default: ${QUIET}"
  echo "--debug=[0|1]          Run in debug mode. Default: ${DEBUG}"
  echo "--git-repo=URL         If sourcedir doesn't exist, clone the repo with URL. Default: ${GIT_REPO}"
  echo "--git-branch=B         For --git-repo which branch to checkout. Default: ${GIT_BRANCH}"
  echo "--git-depth=N          For --git-repo what --depth=N to use. Default: ${GIT_DEPTH}"
  #echo "--git-full-depth=N     For the clone, use full clone, instead of using --depth=1000. Default: no."
  #echo "--no-clean             Don't remove builddir and installdir at the start. Default: no (full clean)."
  #echo "--sourcedir=D          Where to put mesa sources. Default: ~/mesa-git"
  #echo "--builddir=D           Base for the build location. Default: ${BUILDDIR}"
  #echo "--installdir=D         Base for the install location. Default: ${INSTALLDIR}"
  echo "--build64=[0|1]        Build 64-bit version. Default: ${BUILD64}"
  echo "--build32=[0|1]        Build 32-bit version. Default: ${BUILD32}"
  echo "--buildopt=[0|1]       Build optimized (-O2 -march=native + debug code disabled) version. Default: ${BUILDOPT}"
  echo "--builddebug=[0|1]     Build debug (-O1 -ggdb -g3 + asserts / checks enabled) version. Default: ${BUILDDEBUG}"
  echo "--heavyopt=[0|1]       Use additionally -O3 -march=native -flto -g -mf16c -mfpmath=sse ... et al for --buildopt. Default: ${HEAVYOPT}"
  echo "--buildopencl=[0|1]    Include OpenCL support (Clover). Default: ${BUILDOPENCL}"
  #echo "--buildextras=[0|1]    Build extras (i.e. fossilize, shader-db). Default: 1"
  echo "--drivers=LIST         Drivers to include. Default: ${DRIVERS}"
  #echo "--endchecks=[0|1]      Perform post-install tests / sanity checks. Default: 1"
  #echo "--uninstall            Cleanup everything, sourcedir, builddir, installdir, and generated files, and exit. (Remember to pass --*dir options first, if needed). Default: no"
  echo
  echo "It is valid to have both --buildopt and --builddbg enabled at the same time."
  echo "It will build two separate builds in own directories"
  echo
  exit 0
}

#[ $# -eq 0 ] && usage
opts=$(env --unset=GETOPT_COMPATIBLE getopt --name "$0" --options "" --longoptions "help,quiet,debug:,git-repo:,git-branch:,git-depth:,sourcedir:,builddir:,installdir:,build32:,build64:,builddebug:,buildopt:,heavyopt:,buildopencl:,buildextras:,drivers:" -- "$@")
eval set -- "${opts}"

while [[ $# -gt 0 ]]; do
  case "$1" in
    --help)
        usage
        exit 0
        ;;
    --quiet)
        QUIET=1
        ;;
    --debug)
        shift
        DEBUG="$1"
        ;;
    --git-repo)
        shift
        GIT_REPO="$1"
        ;;
    --git-branch)
        shift
        GIT_BRANCH="$1"
        ;;
    --git-depth)
        shift
        GIT_DEPTH="$1"
        ;;
    --build64)
        shift
        BUILD64="$1"
        ;;
    --build32)
        shift
        BUILD32="$1"
        ;;
    --buildopt)
        shift
        BUILDOPT="$1"
        ;;
    --builddebug)
        shift
        BUILDDEBUG="$1"
        ;;
    --heavyopt)
        shift
        HEAVYOPT="$1"
        ;;
    --buildopencl)
        shift
        BUILDOPENCL="$1"
        ;;
    --drivers)
        shift
        DRIVERS="$1"
        ;;
    --)
        break
        ;;
    *)
        echo "$0: Unknown option $1" >&2
        echo
        usage
        exit 1
        ;;
  esac
  shift
done

# If needed enabled / disable debug mode.
if [ "x${DEBUG}" = "x1" ]; then
set -x
else
set +x
fi


if [ "$BUILDOPT" != 1 ] && [ "$BUILDDEBUG" != 1 ]; then
  echo "$0: At least one of the --buildopt and --builddbg is required" 2>&1
  exit 1
fi
if [ "$BUILD32" != 1 ] && [ "$BUILD64" != 1 ]; then
  echo "$0: At least one of the --build32 and --build64 is required" 2>&1
  exit 1
fi


echo "Checking multiarch support ..."
echo

if [ "x$(dpkg --print-foreign-architectures | egrep ^i386)" != "xi386" ]; then
  echo "No multiarch enabled. Please run (as root) below command and retry:"
  echo "dpkg --add-architecture i386 && apt-get update"
  exit 2
fi

if [ "x${QUIET}" = "x1" ]; then
  APT_INSTALL=("apt-get" "install" "--option" "APT::Get::HideAutoRemove=1" "--option" "quiet::NoProgress=1" "-qq" "--assume-yes" "--no-remove" "--no-install-recommends" "--option" "Dpkg::Use-Pty=0")
else
  APT_INSTALL=("apt-get" "install" "--option" "APT::Get::HideAutoRemove=1" "--option" "quiet::NoProgress=1" "--no-install-recommends")
fi

echo
echo "Checking base dependency versions on amd64 and i386 ..."
echo

sudo "${APT_INSTALL[@]}" libc6-dev:amd64 libc6-dev:i386

# Sometimes some packages might reach only one architecture first, and it might
# be really hard to coinstall some package on both amd64 and i386, when they are
# out of sync. Check they are in sync first.
# Note: This can be done nicer using dctrl-tools package, but it is not
# installed by default or needed.
if [ "$(dpkg -s linux-libc-dev:amd64 | grep ^Version:)" !=  "$(dpkg -s linux-libc-dev:i386 | grep ^Version:)" ]; then
  echo "linux-libc-dev:amd64 and linux-libc-dev:i386 do have different versions!"
  echo "Please fix first and then retry."
  exit 2
fi
if [ "$(dpkg -s libc6-dev:amd64 | grep ^Version:)" !=  "$(dpkg -s libc6-dev:i386 | grep ^Version:)" ]; then
  echo "libc6-dev:amd64 and libc6-dev:i386 do have different versions!"
  echo "Please fix first and then retry."
  exit 2
fi

DIST_VERSION="$(lsb_release -is)_$(lsb_release -sr)"

LLVMVERSION=11

GCCVERSION=10

# Directly in Debian testing (bullseye, future Debian 11) LLVMVERSION=9 is available.
# But for Debian testing I recommend using LLVMVERSION=10 with experimental repo
# enabled. See above.

LLVMREPO=( )

case "$DIST_VERSION" in
    Debian_9*)       LLVMVERSION=7 ; GCCVERSION=6 ;;  # Stretch
    Debian_10*)      LLVMVERSION=8 ; GCCVERSION=8 ;;  # Buster backports.
    Debian_11*)      LLVMVERSION=11 ; GCCVERSION=10 ;;  # Bullseye
    Debian_testing)  LLVMVERSION=11 ; GCCVERSION=10 ;;
    Debian_unstable) LLVMVERSION=11 ; GCCVERSION=10 ;;
    Ubuntu_16.04)    LLVMVERSION=5.0 ; GCCVERSION=5 ;;  # Good luck with that.
    Ubuntu_18.04)    LLVMVERSION=6.0 ; GCCVERSION=8 ;;  # or with that.
    Ubuntu_18.10)    LLVMVERSION=7 ; GCCVERSION=8 ;;
    Ubuntu_19.04)    LLVMVERSION=8 ; GCCVERSION=9 ;;
    Ubuntu_19.10)    LLVMVERSION=9 ; GCCVERSION=9 ;;
    Ubuntu_20.04)    LLVMVERSION=10 ; GCCVERSION=10 ;;
    Ubuntu_20.10)    LLVMVERSION=11 ; GCCVERSION=10 ;;
    Ubuntu_21.04)    LLVMVERSION=11 ; GCCVERSION=10 ;;
    *) echo "Warning: Distribution '$DIST_VERSION' is not supported by this script"
       LLVMVERSION=10
       GCCVERSION=9
esac


# Main Mesa dependencies which we will install both on amd64 and i386
#
# wayland-protocols is :all, and dpkg will install no issues.
# But bison, flex, pkg-config, glslang-tools we only want amd64 for build.
#
# We keep the order in the list same as Meson configure output.
MAINDEPS=(
  linux-libc-dev  # Probably will be pulled by gcc & co.
  # linux-libc-dev is not libc-dev. It has Linux kernel headers,
  # for use by userspace, 'uapi'.

  libvdpau-dev

  libvulkan-dev
  # glslang-tools  # We only want to install amd64 binary version.

  libxvmc-dev
  libxv-dev
  # libomxil-bellagio-dev  # Optional. Can't coinstall on amd64 and i386 at the moment.
  libva-dev
  zlib1g-dev
  libzstd-dev
  libexpat1-dev

  libdrm-dev

  # LLVM stuff

  libelf-dev
  libglvnd-dev
  # libglvnd-core-dev
  # bison  # We only want to install amd64 binary version.
  # flex  # We only want to install amd64 binary version.
  libunwind-dev

  # pkg-config stuff  # We install it separately, because it is a bit more complex.

  # libwayland-bin  # For wayland-scanner. Technically dependency of libwayland-dev
                    # We only want to install amd64 binary version.

  wayland-protocols
  libwayland-dev
  libwayland-egl-backend-dev

  libx11-dev
  libxext-dev
  libxfixes-dev
  libxcb-glx0-dev
  libxcb-shm0-dev
  libxcb1-dev
  libx11-xcb-dev
  libxcb-dri2-0-dev
  libxcb-dri3-dev
  libxcb-present-dev
  libxcb-sync-dev
  libxshmfence-dev
  x11proto-dev  # For glproto and dri2proto. Technically dependency of other libx* packages.
  libxxf86vm-dev
  libxcb-xfixes0-dev
  libxcb-randr0-dev
  libxrandr-dev

  libxdamage-dev  # I don't see it Meson output, but I think is needed. Debian Build-Depends has it.
  libxcb-sync-dev  # I don't see it Meson output, but it is in Debian Build-Depends.

  libsensors-dev
)


MAINDEPS64=()
MAINDEPS32=()
for d in "${MAINDEPS[@]}"; do
  MAINDEPS64+=("$d:amd64")
  MAINDEPS32+=("$d:i386")
done

# For OpenCL support, one might need libclc-dev and libclang-XYZ-dev, to add a parser
# and some passes from LLVM. (See https://libclc.llvm.org for details). This is AFAIK
# for Clover subproject in Mesa, which is disabled, but might go forward, especially
# for Novoue driver, and possibly in the future as a SPIR-V target, which is then
# consumed by LLVM or by ACO, via NIR again.
OPENCL_DEPS=()
if [ "x${BUILDOPENCL}" = "x1" ]; then
  OPENCL_DEPS=("libclang-${LLVMVERSION}-dev:amd64" "libclang-cpp${LLVMVERSION}-dev" "libclc-dev")
fi

echo
echo "Ensuring dependencies for Mesa build are installed ..."
echo

# Note: We need glslangValidator to compile trivial GLSL code into SPV for Vulkan Mesa overlay.
# Compilers and cross compilers. Will automatically install binutils (for ar, strip, etc.).
sudo "${APT_INSTALL[@]}" \
  git \
  "gcc-${GCCVERSION}" "g++-${GCCVERSION}" \
  "gcc-${GCCVERSION}-i686-linux-gnu" "g++-${GCCVERSION}-i686-linux-gnu" \
  pkg-config \
  meson ninja-build \
  cmake \
  gettext \
  python3 python3-setuptools \
  python3-distutils python3-mako \
  valgrind \
  bison flex \
  dpkg-dev \
  wayland-protocols \
  libwayland-bin \
  glslang-tools \
  "${OPENCL_DEPS[@]}" \
  "${MAINDEPS64[@]}" "${MAINDEPS32[@]}" \
  libomxil-bellagio-dev:amd64
# dpkg-dev is needed by multi-arch-aware pkg-config when cross-compiling
# cmake is neede for building vkpipeline-db
# libomxil-bellagio-dev can't coinstall on amd64 and i386 at the moment.

echo
echo
echo "Attempting to install llvm${LLVMVERSION} ... If it fails, please read the source code how to add proper repos..."
echo
echo
sudo "${APT_INSTALL[@]}" "${LLVMREPO[@]}" "libllvm${LLVMVERSION}" "libllvm${LLVMVERSION}:amd64" "libllvm${LLVMVERSION}:i386" "llvm-${LLVMVERSION}-dev" "libllvm${LLVMVERSION}:i386" "llvm-${LLVMVERSION}-dev" # "llvm-${LLVMVERSION}:i386"
sudo "${APT_INSTALL[@]}" "libllvm${LLVMVERSION}-dbgsym:amd64" "libllvm${LLVMVERSION}-dbgsym:i386" || echo "Warning: Can't install debug symbols. Enable them: https://wiki.debian.org/HowToGetABacktrace"

# No need to install pkg-config:i386, it would conflict with pkg-config:amd64.
# Debian's pkg-config will automatically create symlinks to all supported
# archs to proper wrapper that sets proper paths.

# A 32-bit version of pkg-config, that actually is a wrapper, that knows how to
# filter various libraries and multiple versions of them.
# removes pkg-config:amd64, but kind of fine for a moment. We still can use the
# properly prefixed versions all the time!

echo
echo "Checking mesa git repo ..."
echo

if ! [ -d "${HOME}/mesa-git" ]; then
  git clone ${GIT_DEPTH} "${GIT_REPO}" "${HOME}/mesa-git"
  if [ "x${GIT_BRANCH}" != "x" ]; then
    git -C "${HOME}/mesa-git" checkout "${GIT_BRANCH}"
  fi
else
  echo "mesa-git repo already present. To update, run \"cd ~/mesa-git && git pull\" manually."
fi
echo

cd "${HOME}/mesa-git"

rm -rf "${BUILDDIR}"
rm -rf "${INSTALLDIR}"

#OPENCL_SUPPORT=("-Dgallium-opencl=icd" "-Dopencl-spirv=true")
# For "-Dopencl-spirv=true". Also in Debian this version is based on LLVM8 at
# the moment.
#sudo "${APT_INSTALL[@]}" libllvmspirvlib-dev

# Required for parsing OpenCL when gallium-opencl is enabled.
# The clang-cpp component can be skipped, but helps with some stuff apparently.
sudo "${APT_INSTALL[@]}" "libclang-${LLVMVERSION}-dev" "libclang-cpp${LLVMVERSION}-dev:amd64"

COMMON_OPTS=("-Dplatforms=x11,wayland"
             "-Ddri-drivers=[]"
             "-Ddri3=enabled"
             "-Dgallium-extra-hud=true"
             "-Dvulkan-drivers=['amd','intel','swrast']"  # RADV + ANV + lavapipe
             "-Dshader-cache=enabled"
             "-Dvulkan-layers=device-select,overlay"
             "-Dopengl=true"
             "-Dgles1=disabled"
             "-Dgles2=disabled"
             "-Degl=disabled"
             "-Dllvm=enabled"
             "-Dlmsensors=enabled"
             "-Dtools=glsl,nir"
             "-Dopencl-spirv=true"
             "-Dgallium-vdpau=enabled"
             "-Dgallium-xvmc=enabled"
             "-Dgallium-va=enabled"
             "-Dglvnd=true"
             "-Dgbm=enabled"
             #"-Dglx=gallium-xlib"
             "-Dlibunwind=enabled"
             "-Dosmesa=true"
             "-Dgallium-nine=true")

# Interesingly enough, "-Dopencl-spirv=true" compiles even without
# libllvmspirvlib-dev installed.

if false; then  # Compile SWR or not?
  COMMON_OPTS+=("-Dgallium-drivers=['radeonsi','r600','zink','virgl','swrast','swr']" "-Dswr-arches=['avx','avx2','knl','skx']")
  # "-Dosmesa=gallium"
else
  COMMON_OPTS+=("-Dgallium-drivers=['radeonsi','r600','zink','virgl','swrast']" "-Dswr-arches=[]")
fi

# At the moment it is not possible to install valgrind i386 and amd64 at the
# same time in Debian, as it is using monolithic package.
# See https://bugs.debian.org/941160 for details
COMMON_OPTS_64=("-Dvalgrind=enabled")
COMMON_OPTS_32=("-Dvalgrind=disabled")

if [ "x${BUILDOPENCL}" = "x1" ]; then
  # Compile Clover/OpenCL only for 64-bit. 32-bit would require installing
  # "libclang1-${LLVMVERSION}:i386", but it removes the
  # "libclang1-${LLVMVERSION}:amd64" and header files!
  # See https://bugs.debian.org/941755 for details.
  COMMON_OPTS_64+=("-Dgallium-opencl=icd" "-Dopencl-spirv=false") 
fi


COMMON_OPTS_OPT=("--buildtype=plain")
COMMON_OPTS_OPT+=("-Db_ndebug=true")
# If you really care about library size and maybe improve performance by 0.1%,
# enable stripping. We already are compiling with -g0, so stripping will save
# very little, and make stack traces or use in gdb / valgrind way harder.
# COMMON_OPTS_OPT+=("--strip")
#
# We explicitly pass -mfpmath=sse, otherwise when compiling 32-bit version,
# it will use x87 / non-see for almost everything, which is slower, and
# can't be vectorized, even when using -march=native -msse2, etc.
# With -mfpmath=sse, it will use sse and sse2 almost everywhere, modulo
# few places where the calling conventions (i.e. to glibc) requires passing
# stuff on x87 stack / registers.
if [ "x${HEAVYOPT}" = "x1" ]; then
  COMPILERFLAGS_OPT="-pipe -march=native -O3 -mfpmath=sse -ftree-vectorize -flto -flto=$(nproc --ignore=2) -g0 -fno-semantic-interposition"
  COMMON_OPTS_OPT+=("-Dc_args=${COMPILERFLAGS_OPT}" "-Dcpp_args=-std=c++17 ${COMPILERFLAGS_OPT}")
else
  COMPILERFLAGS_OPT="-pipe -march=native -O2 -mfpmath=sse"
  COMMON_OPTS_OPT+=("-Dc_args=${COMPILERFLAGS_OPT}" "-Dcpp_args=-std=c++17 ${COMPILERFLAGS_OPT}")
fi
# For i387, one can also use -mpc64, to set the 387 in "reduced precision" mode (32 or 64 bit).
# It could be faster than full 80-bit, but that is anecdotal.

COMMON_OPTS_DBG=("--buildtype=debug")
COMMON_OPTS_DBG+=("-Db_ndebug=false")
#COMMON_OPTS_DBG+=("-Db_sanitize=thread")
COMPILERFLAGS_DBG="-pipe -march=native -O1 -mfpmath=sse -ggdb -g3 -gz"
# Note: This is working when doing 'meson configure', but I am not 100% sure
# this is correct when passing everything just to initial 'meson'.
# From testing it appears to be working.
COMMON_OPTS_DBG+=("-Dc_args=${COMPILERFLAGS_DBG}" "-Dcpp_args=-std=c++17 ${COMPILERFLAGS_DBG}")



# Build tests.
# COMMON_OPTS+=("-Dbuild-tests=true")


#-Ddri-drivers=r100,r200,swrast # Note that dri swrast, is different than gallium
# swrast. It is older rasterizer. the softpipe, llvmpipe are newer ones.
# swr (openswr) it the most newest one, high performance LLVM JIT rasterizer,
# but it might be still referenced in logs as swrast!

if [ "x${BUILD64}" = "x1" ]; then

echo
echo "Configuring and building 64-bit Mesa ..."
echo

# TODO(baryluk): Add option to build with clang, and with thread / address
# sanitizers.

cat > llvm.ini <<EOF
[binaries]
c = '/usr/bin/x86_64-linux-gnu-gcc-${GCCVERSION}'
cpp = '/usr/bin/x86_64-linux-gnu-g++-${GCCVERSION}'
llvm-config = '/usr/bin/llvm-config-${LLVMVERSION}'
strip = '/usr/bin/x86_64-linux-gnu-strip'
EOF


if [ "x${BUILDOPT}" = "x1" ]; then
  echo
  echo "Configuring and building 64-bit optimized build ..."
  echo
  CC="gcc-${GCCVERSION}" \
  CXX="g++-${GCCVERSION}" \
  PKG_CONFIG="x86_64-linux-gnu-pkg-config" \
    meson "${BUILDDIR}/build-amd64-opt/" \
    --prefix="${INSTALLDIR}/build-amd64-opt/install" \
    --cross-file=llvm.ini \
    "${COMMON_OPTS[@]}" "${COMMON_OPTS_64[@]}" "${COMMON_OPTS_OPT[@]}"
  # meson configure ${BUILDDIR}/build-amd64-opt/ "${COMMON_OPTS[@]}" "${COMMON_OPTS_64[@]}" "${COMMON_OPTS_OPT[@]}"
  ninja -C ${BUILDDIR}/build-amd64-opt/ # or cd build-amd64-opt && ninja
  ninja -C ${BUILDDIR}/build-amd64-opt/ install
fi

if [ "x${BUILDDEBUG}" = "x1" ]; then
  echo
  echo "Configuring and building 64-bit debug build ..."
  echo
  CC="gcc-${GCCVERSION}" \
  CXX="g++-${GCCVERSION}" \
  PKG_CONFIG="x86_64-linux-gnu-pkg-config" \
    meson "${BUILDDIR}/build-amd64-dbg/" \
    --prefix="${INSTALLDIR}/build-amd64-dbg/install" \
    --cross-file=llvm.ini \
    "${COMMON_OPTS[@]}" "${COMMON_OPTS_64[@]}" "${COMMON_OPTS_DBG[@]}"
  # "-Db_sanitize=thread"
  # meson configure "${BUILDDIR}/build-amd64-dbg/" "${COMMON_OPTS[@]}" "${COMMON_OPTS_64[@]}" "${COMMON_OPTS_DBG[@]}"
  ninja -C ${BUILDDIR}/build-amd64-dbg/
  ninja -C ${BUILDDIR}/build-amd64-dbg/ install
fi

fi

if [ "x${BUILD32}" = "x1" ]; then

echo
echo "Configuring and building 32-bit Mesa ..."
echo

cat > meson-cross-i386.ini <<EOF
[binaries]
c = '/usr/bin/i686-linux-gnu-gcc-${GCCVERSION}'
cpp = '/usr/bin/i686-linux-gnu-g++-${GCCVERSION}'
ar = '/usr/bin/i686-linux-gnu-gcc-ar-${GCCVERSION}'
strip = '/usr/bin/i686-linux-gnu-strip'
pkgconfig = '/usr/bin/i686-linux-gnu-pkg-config'
; We are cheating here. We are using 64-bit llvm-config. But we stars align
; it should work (same compiler and linker flags will be used).
llvm-config = '/usr/bin/llvm-config-${LLVMVERSION}'
; llvm-config = '/usr/lib/llvm-${LLVMVERSION}/bin/llvm-config'

[properties]
c_args = ['-m32']
c_link_args = ['-m32']
cpp_args = ['-m32']
cpp_link_args = ['-m32']

[host_machine]
system = 'linux'
cpu_family = 'x86'
cpu = 'i686'
endian = 'little'
EOF

# ar is symlink to x86_64-linux-gnu-ar
# gcc-ar is symlink to gcc-ar-10, and it is symlink to x86_64-linux-gnu-gcc-ar-10


if [ "x${BUILDOPT}" = "x1" ]; then
  echo
  echo "Configuring and building 32-bit optimized build ..."
  echo
  CC="i686-linux-gnu-gcc-${GCCVERSION}" \
  CXX="i686-linux-gnu-g++-${GCCVERSION}" \
  PKG_CONFIG="i686-linux-gnu-pkg-config" \
    meson "${BUILDDIR}/build-i386-opt/" \
    --prefix="${INSTALLDIR}/build-i386-opt/install" \
    --cross-file=meson-cross-i386.ini \
    "${COMMON_OPTS[@]}" "${COMMON_OPTS_32[@]}" "${COMMON_OPTS_OPT[@]}"
  # meson configure "${BUILDDIR}/build-i386-opt/" "${COMMON_OPTS[@]}" "${COMMON_OPTS_32[@]}" "${COMMON_OPTS_OPT[@]}"
  ninja -C "${BUILDDIR}/build-i386-opt/"
  ninja -C "${BUILDDIR}/build-i386-opt/" install
fi

if [ "x${BUILDDEBUG}" = "x1" ]; then
  echo
  echo "Configuring and building 32-bit debug build ..."
  echo
  CC="i686-linux-gnu-gcc-${GCCVERSION}" \
  CXX="i686-linux-gnu-g++-${GCCVERSION}" \
  PKG_CONFIG="i686-linux-gnu-pkg-config" \
   meson "${BUILDDIR}/build-i386-dbg/" \
    --prefix="${INSTALLDIR}/build-i386-dbg/install" \
    --cross-file=meson-cross-i386.ini \
    "${COMMON_OPTS[@]}" "${COMMON_OPTS_32[@]}" "${COMMON_OPTS_DBG[@]}"
  # meson configure "${BUILDDIR}/build-i386-dbg/" "${COMMON_OPTS[@]}" "${COMMON_OPTS_32[@]}" "${COMMON_OPTS_DBG[@]}"
  ninja -C "${BUILDDIR}/build-i386-dbg/"
  ninja -C "${BUILDDIR}/build-i386-dbg/" install
fi

fi


echo
echo "Checking vkpipeline-db repo ..."
echo

if ! [ -d "${HOME}/vkpipeline-db" ]; then
  cd "${HOME}" && git clone https://gitlab.freedesktop.org/mesa/vkpipeline-db.git "${HOME}/vkpipeline-db"
fi

if [ "x${BUILD64}" = "x1" ]; then
(
echo
echo "Configuring and building 64-bit vkpipeline-db ..."
echo
cd "${HOME}/vkpipeline-db"
mkdir build-amd64 || true
cd build-amd64
cmake ..
make "-j$(nproc)"
)
fi

if [ "x${BUILD32}" = "x1" ]; then
(
echo
echo "Configuring and building 32-bit vkpipeline-db ..."
echo
# We need to install i386 version of headers for pkg-config files.
cd "${HOME}/vkpipeline-db"
mkdir build-i386 || true
cd build-i386
# I am not sure if the PKG_CONFIG{,_EXECUTABLE} works here or not. It works even
# when mistyped. So I guess it picks up the 64-bit CCFLAGS and LDFLAGS, but
# because they are the same as 32-bit ones it just works, and gcc knows how to
# search for includes in standard locations.
CC="i686-linux-gnu-gcc-${GCCVERSION}" \
CXX="i686-linux-gnu-g++-${GCCVERSION}" \
PKG_CONFIG="i686-linux-gnu-pkg-config" \
PKG_CONFIG_EXECUTABLE="i686-linux-gnu-pkg-config" \
  cmake ..
make "-j$(nproc)"
)
fi

echo
echo "Generating source files with environmental variable overrides ..."
echo

# TODO(baryluk): Make paths only include 64-bit or/and 32-bit paths, depending on BUILD64 and BUILD32 variables.

if [ "x${BUILDOPT}" != "x" ]; then
cat > "${HOME}/enable-new-mesa-opt.source" <<EOF
#!/bin/sh

# Do not execute this file in your shell, instead "source" it using:
#   . ~/enable-new-mesa-opt.source
# or
#   source ~/enable-new-mesa-opt.source
#
# This will have effects only once in the current shell. It will not apply to
# other shells, terminals, users, whole desktop, other running programs, or once
# you close this shell, logout, reboot, etc. It is temporary.
#
# If you want you get remove eventually. It will be regenerated every time you
# run "mesa-build.sh" script to build new Mesa.

echo "Warning: Will remove existing LD_LIBRARY_PATH." >&2
export LD_LIBRARY_PATH="${INSTALLDIR}/build-amd64-opt/install/lib:${INSTALLDIR}/build-i386-opt/install/lib:${INSTALLDIR}/build-amd64-opt/install/lib/vdpau:${INSTALLDIR}/build-i386-opt/install/lib/vdpau"
export LIBGL_DRIVERS_PATH="${INSTALLDIR}/build-amd64-opt/install/lib/dri:${INSTALLDIR}/build-i386-opt/install/lib/dri"
export VK_LAYER_PATH="${INSTALLDIR}/build-amd64-opt/install/share/vulkan/explicit_layer.d:${INSTALLDIR}/build-i386-opt/install/share/vulkan/explicit_layer.d:/usr/share/vulkan/explicit_layer.d"
export VK_ICD_FILENAMES="${INSTALLDIR}/build-amd64-opt/install/share/vulkan/icd.d/radeon_icd.x86_64.json:${INSTALLDIR}/build-i386-opt/install/share/vulkan/icd.d/radeon_icd.i686.json:${INSTALLDIR}/build-amd64-opt/install/share/vulkan/icd.d/lvp_icd.x86_64.json:${INSTALLDIR}/build-i386-opt/install/share/vulkan/icd.d/lvp_icd.i686.json"
export OCL_ICD_VENDORS="${INSTALLDIR}/build-amd64-opt/install/etc/OpenCL/vendors/mesa.icd:${INSTALLDIR}/build-i386-opt/install/etc/OpenCL/vendors/mesa.icd"
export VK_INSTANCE_LAYERS=VK_LAYER_MESA_overlay
# To enable frametime outputs uncommend next line. It requires modified Mesa.
#export VK_LAYER_MESA_OVERLAY_CONFIG=output_relative_time,fps,frame,frame_timing,gpu_timing,pipeline_graphics,graph_y_zero,output_csv=0,output_per_frame=1,output_flush=0,position=top-right,width=300,output_file=/tmp/mesa_overlay_%T_%p.txt
# This uses some extra modified features, but they will only produce warnings in
# normal Mesa.
# export VK_LAYER_MESA_OVERLAY_CONFIG=output_relative_time,fps,frame,frame_timing,gpu_timing,pipeline_graphics,graph_y_zero,output_csv=0,output_per_frame=1,output_flush=0,position=top-right,width=300
export VK_LAYER_MESA_OVERLAY_CONFIG=fps,frame,frame_timing,gpu_timing,pipeline_graphics,position=top-right,width=300

export GALLIUM_HUD=fps
export DXVK_HUD=full

# If one wishes to use exported dev files, one can use /home/user/mesa/build-i386/install/lib/pkgconfig
# And possible /home/user/mesa/build-i386/install/include , for some state trackers, vulkan_intel.h,
# GL, GLEX, KHR headers.

CAPTURE_DIR="\${HOME}/vkpipeline-db-capture"

# Create directory for pipeline capture files.
if ! [ -d "\${CAPTURE_DIR}" ]; then
  mkdir "\${CAPTURE_DIR}"
fi

export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:\${HOME}/vkpipeline-db/build-amd64:\${HOME}/vkpipeline-db/build-i386"
export VK_LAYER_PATH="\${VK_LAYER_PATH}:\${HOME}/vkpipeline-db"
# To enable vkpipeline-db layer uncommend next line.
#export VK_INSTANCE_LAYERS="\${VK_INSTANCE_LAYERS}:VK_LAYER_vkpipeline_db"

# Set up the pipeline capture directory.
export VKPIPELINE_DB_CAPTURE_PATH="\${CAPTURE_DIR}"
EOF

cat > "${HOME}/mesa-opt" <<EOF
#!/bin/sh

# We keep the existing LD_LIBRARY_PATH and VK_LAYER_PATH, and not erase it unconditionally.
# This is beacuse user might have other libs and layers installed, and want to use them.
# Also, a steam often will provide its own very verbose LD_LIBRARY_PATH to own runtime libraries,
# and they might be required for games to work properly.

export LD_LIBRARY_PATH="${INSTALLDIR}/build-amd64-opt/install/lib:${INSTALLDIR}/build-i386-opt/install/lib:${INSTALLDIR}/build-amd64-opt/install/lib/vdpau:${INSTALLDIR}/build-i386-opt/install/lib/vdpau:\${LD_LIBRARY_PATH}"
export LIBGL_DRIVERS_PATH="${INSTALLDIR}/build-amd64-opt/install/lib/dri:${INSTALLDIR}/build-i386-opt/install/lib/dri"
export VK_LAYER_PATH="${INSTALLDIR}/build-amd64-opt/install/share/vulkan/explicit_layer.d:${INSTALLDIR}/build-i386-opt/install/share/vulkan/explicit_layer.d:/usr/share/vulkan/explicit_layer.d:\${VK_LAYER_PATH}"
export VK_ICD_FILENAMES="${INSTALLDIR}/build-amd64-opt/install/share/vulkan/icd.d/radeon_icd.x86_64.json:${INSTALLDIR}/build-i386-opt/install/share/vulkan/icd.d/radeon_icd.i686.json:${INSTALLDIR}/build-amd64-opt/install/share/vulkan/icd.d/lvp_icd.x86_64.json:${INSTALLDIR}/build-i386-opt/install/share/vulkan/icd.d/lvp_icd.i686.json"
export OCL_ICD_VENDORS="${INSTALLDIR}/build-amd64-opt/install/etc/OpenCL/vendors/mesa.icd:${INSTALLDIR}/build-i386-opt/install/etc/OpenCL/vendors/mesa.icd"

export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:\${HOME}/vkpipeline-db/build-amd64:\${HOME}/vkpipeline-db/build-i386"
export VK_LAYER_PATH="\${VK_LAYER_PATH}:\${HOME}/vkpipeline-db"

# TODO(baryluk): If the path has no "/", maybe use 'env'?

exec "\$@"
EOF
chmod +x "${HOME}/mesa-opt"

# A handy wrapper to run with zink.
cat > "${HOME}/zink-opt" <<EOF
#!/bin/sh
exec env MESA_LOADER_DRIVER_OVERRIDE=zink "\${HOME}/mesa-opt" "\$@"
EOF
chmod +x "${HOME}/zink-opt"

fi


if  [ "x${BUILDDEBUG}" = "x1" ]; then
cat > "${HOME}/enable-new-mesa-dbg.source" <<EOF
#!/bin/sh

# Do not execute this file in your shell, instead "source" it using:
#   . ~/enable-new-mesa-dbg.source
# or
#   source ~/enable-new-mesa-dbg.source
#
# This will have effects only once in the current shell. It will not apply to
# other shells, terminals, users, whole desktop, other running programs, or once
# you close this shell, logout, reboot, etc. It is temporary.
#
# If you want you get remove eventually. It will be regenerated every time you
# run "mesa-build.sh" script to build new Mesa.

echo "Warning: Will remove existing LD_LIBRARY_PATH." >&2
export LD_LIBRARY_PATH="${INSTALLDIR}/build-amd64-dbg/install/lib:${INSTALLDIR}/build-i386-dbg/install/lib:${INSTALLDIR}/build-amd64-dbg/install/lib/vdpau:${INSTALLDIR}/build-i386-dbg/install/lib/vdpau"
export LIBGL_DRIVERS_PATH="${INSTALLDIR}/build-amd64-dbg/install/lib/dri:${INSTALLDIR}/build-i386-dbg/install/lib/dri"
export VK_LAYER_PATH="${INSTALLDIR}/build-amd64-dbg/install/share/vulkan/explicit_layer.d:${INSTALLDIR}/build-i386-dbg/install/share/vulkan/explicit_layer.d:/usr/share/vulkan/explicit_layer.d"
export VK_ICD_FILENAMES="${INSTALLDIR}/build-amd64-dbg/install/share/vulkan/icd.d/radeon_icd.x86_64.json:${INSTALLDIR}/build-i386-dbg/install/share/vulkan/icd.d/radeon_icd.i686.json:${INSTALLDIR}/build-amd64-dbg/install/share/vulkan/icd.d/lvp_icd.x86_64.json:${INSTALLDIR}/build-i386-dbg/install/share/vulkan/icd.d/lvp_icd.i686.json"
export OCL_ICD_VENDORS="${INSTALLDIR}/build-amd64-dbg/install/etc/OpenCL/vendors/mesa.icd:${INSTALLDIR}/build-i386-dbg/install/etc/OpenCL/vendors/mesa.icd"
export VK_INSTANCE_LAYERS=VK_LAYER_MESA_overlay
# To enable frametime outputs uncommend next line. It requires modified Mesa.
#export VK_LAYER_MESA_OVERLAY_CONFIG=output_relative_time,fps,frame,frame_timing,gpu_timing,pipeline_graphics,graph_y_zero,output_csv=0,output_per_frame=1,output_flush=0,position=top-right,width=300,output_file=/tmp/mesa_overlay_%T_%p.txt
# This uses some extra modified features, but they will only produce warnings in
# normal Mesa.
#export VK_LAYER_MESA_OVERLAY_CONFIG=output_relative_time,fps,frame,frame_timing,gpu_timing,pipeline_graphics,graph_y_zero,output_csv=0,output_per_frame=1,output_flush=0,position=top-right,width=300
export VK_LAYER_MESA_OVERLAY_CONFIG=fps,frame,frame_timing,gpu_timing,pipeline_graphics,position=top-right,width=300
export GALLIUM_HUD=fps
export DXVK_HUD=full

# If one wishes to use exported dev files, one can use /home/user/mesa/build-i386/install/lib/pkgconfig
# And possible /home/user/mesa/build-i386/install/include , for some state trackers, vulkan_intel.h,
# GL, GLEX, KHR headers.

CAPTURE_DIR="\${HOME}/vkpipeline-db-capture"

# Create directory for pipeline capture files.
if ! [ -d "\${CAPTURE_DIR}" ]; then
  mkdir "\${CAPTURE_DIR}"
fi

export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:\${HOME}/vkpipeline-db/build-amd64:\${HOME}/vkpipeline-db/build-i386"
export VK_LAYER_PATH="\${VK_LAYER_PATH}:\${HOME}/vkpipeline-db"
# To enable vkpipeline-db layer uncommend next line.
#export VK_INSTANCE_LAYERS="\${VK_INSTANCE_LAYERS}:VK_LAYER_vkpipeline_db"

# Set up the pipeline capture directory.
export VKPIPELINE_DB_CAPTURE_PATH="\${CAPTURE_DIR}"
EOF

cat > "${HOME}/mesa-dbg" <<EOF
#!/bin/sh

# We keep the existing LD_LIBRARY_PATH and VK_LAYER_PATH, and not erase it unconditionally.
# This is beacuse user might have other libs and layers installed, and want to use them.
# Also, a steam often will provide its own very verbose LD_LIBRARY_PATH to own runtime libraries,
# and they might be required for games to work properly.

export LD_LIBRARY_PATH="${INSTALLDIR}/build-amd64-dbg/install/lib:${INSTALLDIR}/build-i386-dbg/install/lib:${INSTALLDIR}/build-amd64-dbg/install/lib/vdpau:${INSTALLDIR}/build-i386-dbg/install/lib/vdpau:\${LD_LIBRARY_PATH}"
export LIBGL_DRIVERS_PATH="${INSTALLDIR}/build-amd64-dbg/install/lib/dri:${INSTALLDIR}/build-i386-dbg/install/lib/dri"
export VK_LAYER_PATH="${INSTALLDIR}/build-amd64-dbg/install/share/vulkan/explicit_layer.d:${INSTALLDIR}/build-i386-dbg/install/share/vulkan/explicit_layer.d:/usr/share/vulkan/explicit_layer.d:\${VK_LAYER_PATH}"
export VK_ICD_FILENAMES="${INSTALLDIR}/build-amd64-dbg/install/share/vulkan/icd.d/radeon_icd.x86_64.json:${INSTALLDIR}/build-i386-dbg/install/share/vulkan/icd.d/radeon_icd.i686.json:${INSTALLDIR}/build-amd64-dbg/install/share/vulkan/icd.d/lvp_icd.x86_64.json:${INSTALLDIR}/build-i386-dbg/install/share/vulkan/icd.d/lvp_icd.i686.json"
export OCL_ICD_VENDORS="${INSTALLDIR}/build-amd64-dbg/install/etc/OpenCL/vendors/mesa.icd:${INSTALLDIR}/build-i386-dbg/install/etc/OpenCL/vendors/mesa.icd"

export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:\${HOME}/vkpipeline-db/build-amd64:\${HOME}/vkpipeline-db/build-i386"
export VK_LAYER_PATH="\${VK_LAYER_PATH}:\${HOME}/vkpipeline-db"

# TODO(baryluk): If the path has no "/", maybe use 'env'?

exec "\$@"
EOF
chmod +x "${HOME}/mesa-dbg"

# A handy wrapper to run with zink.
cat > "${HOME}/zink-dbg" <<EOF
#!/bin/sh
exec env MESA_LOADER_DRIVER_OVERRIDE=zink "\${HOME}/mesa-dbg" "\$@"
EOF
chmod +x "${HOME}/zink-dbg"

fi


cat > "${HOME}/disable-new-mesa-hud.source" <<EOF
#!/bin/sh

unset DXVK_HUD
unset GALLIUM_HUD
unset VK_LAYER_MESA_OVERLAY_CONFIG
unset VK_INSTANCE_LAYERS
EOF


if [ "x${DISPLAY}" != "x" ]; then
  echo
  echo "Testing installation ..."
  echo

  if [ "x${BUILDOPT}" = "x1" ]; then
    . "${HOME}/enable-new-mesa-opt.source"
  elif  [ "x${BUILDDEBUG}" = "x1" ]; then
    . "${HOME}/enable-new-mesa-dbg.source"
  else
    echo "No BUILDOPT or BUILDDEBUG enabled." >&2
    exit 1
  fi

  if ! glxinfo >/dev/null; then
    echo
    echo "glxinfo failed! Bad installation of DRI, gallium or other component." >&2
    echo
    # exit 2  # See https://gitlab.freedesktop.org/mesa/mesa/-/issues/4236 and https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96817#c17 for details.
  fi

  glxinfo | grep 'OpenGL renderer string' || true

  vulkaninfo 2>&1 | grep 'GPU id' | head --lines=2 || true
  RADV_DEBUG=llvm vulkaninfo 2>&1 | grep 'GPU id' | head --lines=2 || true

  if ! VK_INSTANCE_LAYERS=VK_LAYER_MESA_overlay vkcube --c 120; then
    echo
    echo "vkcube failed! Bad installation of vulkan drivers or Mesa overlay layer." >&2
    echo
    # exit 2
  fi

  #export VK_INSTANCE_LAYERS=VK_LAYER_KHRONOS_validation
else  # if [ "x${DISPLAY}" != "x" ]
  echo
  echo "Skipping testing because we are running headless (no X server running?)"
  echo
fi

# Testing SSE, AVX support:

# $ objdump -d "${INSTALLDIR}/install-amd64-opt/install/lib/libvulkan_radeon.so" | grep %ymm | wc -l
# 12225
# $ objdump -d "${INSTALLDIR}/install-amd64-opt/install/lib/libvulkan_radeon.so" | grep %xmm | wc -l
# 41859
# $ objdump -d "${INSTALLDIR}/install-amd64-opt/install/lib/libvulkan_radeon.so" | grep %ymm | grep %xmm | wc -l
# 966
# $ 
# Good.

# $ objdump -d "${INSTALLDIR}/install-i386-opt/install/lib/libvulkan_radeon.so" | grep %xmm | wc -l
# 0
# $ 
# BAD.


#cd $HOME && git clone git://anongit.freedesktop.org/mesa/rbug-gui rbug-gui
#sudo "${APT_INSTALL[@]}" libgtkgl2.0-dev libgtkglext1-dev

#sudo apt-get clean

echo
echo "Build complete and passed basic tests!"
echo "Execute one of the following shell commands to enable proper Mesa"
echo "library paths and variables in the current shell:"

if [ "x${BUILDOPT}" = "x1" ]; then
  echo
  echo ". \"${HOME}/enable-new-mesa-opt.source\"  # Optimized Mesa build"
fi
if  [ "x${BUILDDEBUG}" = "x1" ]; then
  echo
  echo ". \"${HOME}/enable-new-mesa-dbg.source\"  # Debug Mesa build"
fi
echo
echo
echo "To disable GALLIUM_HUD , DXVK_HUD and MESA_OVERLAY execute (AFTER above):"
echo ". \"${HOME}/disable-new-mesa-hud.source\""
echo
echo
echo "Alternative run your application with one of these wrapper scripts:"
echo
if [ "x${BUILDOPT}" = "x1" ]; then
  echo "${HOME}/mesa-opt"
  echo "${HOME}/zink-opt"
fi
if  [ "x${BUILDDEBUG}" = "x1" ]; then
  echo "${HOME}/mesa-dbg"
  echo "${HOME}/zink-dbg"
fi
echo
echo
echo "All generated scripts use absolute paths, so you can move / relocate them as you wish (i.e. into your PATH, like ~/bin, or ~/.local/bin). Or safely remove."
echo
echo
echo "Bye!"
exit 0