configure.ac

   1 dnl Copyright © 2011-2014 Intel Corporation
   2 dnl Copyright © 2011-2014 Emil Velikov <emil.l.velikov@gmail.com>
   3 dnl Copyright © 2007-2010 Dan Nicholson
   4 dnl Copyright © 2010-2014 Marek Olšák <maraeo@gmail.com>
   5 dnl Copyright © 2010-2014 Christian König
   6 dnl Copyright © 2012-2014 Tom Stellard <tstellar@gmail.com>
   7 dnl Copyright © 2009-2012 Jakob Bornecrantz
   8 dnl Copyright © 2009-2014 Jon TURNEY
   9 dnl Copyright © 2011-2012 Benjamin Franzke
  10 dnl Copyright © 2008-2014 David Airlie
  11 dnl Copyright © 2009-2013 Brian Paul
  12 dnl
  13 dnl Permission is hereby granted, free of charge, to any person obtaining a
  14 dnl copy of this software and associated documentation files (the "Software"),
  15 dnl to deal in the Software without restriction, including without limitation
  16 dnl the rights to use, copy, modify, merge, publish, distribute, sublicense,
  17 dnl and/or sell copies of the Software, and to permit persons to whom the
  18 dnl Software is furnished to do so, subject to the following conditions:
  19 dnl
  20 dnl The above copyright notice and this permission notice (including the next
  21 dnl paragraph) shall be included in all copies or substantial portions of the
  22 dnl Software.
  23 dnl
  24 dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  25 dnl IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  26 dnl FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  27 dnl THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  28 dnl LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  29 dnl FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  30 dnl DEALINGS IN THE SOFTWARE.
  31 dnl
  32 dnl Process this file with autoconf to create configure.
  33
  34 AC_PREREQ([2.60])
  35
  36 dnl Tell the user about autoconf.html in the --help output
  37 m4_divert_once([HELP_END], [
  38 See docs/autoconf.html for more details on the options for Mesa.])
  39
  40 m4_define(MESA_VERSION, m4_normalize(m4_include(VERSION)))
  41 AC_INIT([Mesa], [MESA_VERSION],
  42     [https://bugs.freedesktop.org/enter_bug.cgi?product=Mesa])
  43 AC_CONFIG_AUX_DIR([bin])
  44 AC_CONFIG_MACRO_DIR([m4])
  45 AC_CANONICAL_SYSTEM
  46 AM_INIT_AUTOMAKE([foreign tar-ustar dist-xz subdir-objects])
  47
  48 dnl We only support native Windows builds (MinGW/MSVC) through SCons.
  49 case "$host_os" in
  50 mingw*)
  51     AC_MSG_ERROR([MinGW build not supported through autoconf/automake, use SCons instead])
  52     ;;
  53 esac
  54
  55 # Support silent build rules, requires at least automake-1.11. Disable
  56 # by either passing --disable-silent-rules to configure or passing V=1
  57 # to make
  58 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])],
  59     [AC_SUBST([AM_DEFAULT_VERBOSITY], [1])])
  60
  61 m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
  62
  63 dnl Set internal versions
  64 OSMESA_VERSION=8
  65 AC_SUBST([OSMESA_VERSION])
  66 OPENCL_VERSION=1
  67 AC_SUBST([OPENCL_VERSION])
  68
  69 # The idea is that libdrm is distributed as one cohesive package, even
  70 # though it is composed of multiple libraries. However some drivers
  71 # may have different version requirements than others. This list
  72 # codifies which drivers need which version of libdrm. Any libdrm
  73 # version dependencies in non-driver-specific code should be reflected
  74 # in the first entry.
  75 LIBDRM_REQUIRED=2.4.75
  76 LIBDRM_RADEON_REQUIRED=2.4.71
  77 LIBDRM_AMDGPU_REQUIRED=2.4.88
  78 LIBDRM_INTEL_REQUIRED=2.4.75
  79 LIBDRM_NVVIEUX_REQUIRED=2.4.66
  80 LIBDRM_NOUVEAU_REQUIRED=2.4.66
  81 LIBDRM_FREEDRENO_REQUIRED=2.4.74
  82 LIBDRM_ETNAVIV_REQUIRED=2.4.82
  83
  84 dnl Versions for external dependencies
  85 DRI2PROTO_REQUIRED=2.8
  86 GLPROTO_REQUIRED=1.4.14
  87 LIBOMXIL_BELLAGIO_REQUIRED=0.0
  88 LIBVA_REQUIRED=0.38.0
  89 VDPAU_REQUIRED=1.1
  90 WAYLAND_REQUIRED=1.11
  91 WAYLAND_PROTOCOLS_REQUIRED=1.8
  92 XCB_REQUIRED=1.9.3
  93 XCBDRI2_REQUIRED=1.8
  94 XCBGLX_REQUIRED=1.8.1
  95 XDAMAGE_REQUIRED=1.1
  96 XSHMFENCE_REQUIRED=1.1
  97 XVMC_REQUIRED=1.0.6
  98 PYTHON_MAKO_REQUIRED=0.8.0
  99 LIBSENSORS_REQUIRED=4.0.0
 100 ZLIB_REQUIRED=1.2.3
 101
 102 dnl LLVM versions
 103 LLVM_REQUIRED_GALLIUM=3.3.0
 104 LLVM_REQUIRED_OPENCL=3.9.0
 105 LLVM_REQUIRED_R600=3.9.0
 106 LLVM_REQUIRED_RADEONSI=3.9.0
 107 LLVM_REQUIRED_RADV=3.9.0
 108 LLVM_REQUIRED_SWR=3.9.0
 109
 110 dnl Check for progs
 111 AC_PROG_CPP
 112 AC_PROG_CC
 113 AC_PROG_CXX
 114 dnl add this here, so the help for this environmnet variable is close to
 115 dnl other CC/CXX flags related help
 116 AC_ARG_VAR([CXX11_CXXFLAGS], [Compiler flag to enable C++11 support (only needed if not
 117                               enabled by default and different  from -std=c++11)])
 118 AM_PROG_CC_C_O
 119 AM_PROG_AS
 120 AX_CHECK_GNU_MAKE
 121 AC_CHECK_PROGS([PYTHON2], [python2.7 python2 python])
 122 AC_PROG_SED
 123 AC_PROG_MKDIR_P
 124
 125 AC_SYS_LARGEFILE
 126
 127
 128 LT_PREREQ([2.2])
 129 LT_INIT([disable-static])
 130
 131 AC_CHECK_PROG(RM, rm, [rm -f])
 132
 133 AX_PROG_BISON([],
 134               AS_IF([test ! -f "$srcdir/src/compiler/glsl/glcpp/glcpp-parse.c"],
 135                     [AC_MSG_ERROR([bison not found - unable to compile glcpp-parse.y])]))
 136 AX_PROG_FLEX([],
 137              AS_IF([test ! -f "$srcdir/src/compiler/glsl/glcpp/glcpp-lex.c"],
 138                    [AC_MSG_ERROR([flex not found - unable to compile glcpp-lex.l])]))
 139
 140 AC_CHECK_PROG(INDENT, indent, indent, cat)
 141 if test "x$INDENT" != "xcat"; then
 142     # Only GNU indent is supported
 143     INDENT_VERSION=`indent --version | grep GNU`
 144     if test $? -eq 0; then
 145        AC_SUBST(INDENT_FLAGS, '-i4 -nut -br -brs -npcs -ce -TGLubyte -TGLbyte -TBool')
 146     else
 147        INDENT="cat"
 148     fi
 149 fi
 150
 151 AX_CHECK_PYTHON_MAKO_MODULE($PYTHON_MAKO_REQUIRED)
 152
 153 if test -z "$PYTHON2"; then
 154     if test ! -f "$srcdir/src/util/format_srgb.c"; then
 155         AC_MSG_ERROR([Python not found - unable to generate sources])
 156     fi
 157 else
 158     if test "x$acv_mako_found" = xno; then
 159         if test ! -f "$srcdir/src/mesa/main/format_unpack.c"; then
 160             AC_MSG_ERROR([Python mako module v$PYTHON_MAKO_REQUIRED or higher not found])
 161         fi
 162     fi
 163 fi
 164
 165 AC_PROG_INSTALL
 166
 167 dnl We need a POSIX shell for parts of the build. Assume we have one
 168 dnl in most cases.
 169 case "$host_os" in
 170 solaris*)
 171     # Solaris /bin/sh is too old/non-POSIX compliant
 172     AC_PATH_PROGS(POSIX_SHELL, [ksh93 ksh sh])
 173     SHELL="$POSIX_SHELL"
 174     ;;
 175 esac
 176
 177 dnl clang is mostly GCC-compatible, but its version is much lower,
 178 dnl so we have to check for it.
 179 AC_MSG_CHECKING([if compiling with clang])
 180
 181 AC_COMPILE_IFELSE(
 182 [AC_LANG_PROGRAM([], [[
 183 #ifndef __clang__
 184        not clang
 185 #endif
 186 ]])],
 187 [acv_mesa_CLANG=yes], [acv_mesa_CLANG=no])
 188
 189 AC_MSG_RESULT([$acv_mesa_CLANG])
 190
 191 dnl If we're using GCC, make sure that it is at least version 4.2.0.  Older
 192 dnl versions are explictly not supported.
 193 GEN_ASM_OFFSETS=no
 194 USE_GNU99=no
 195 if test "x$GCC" = xyes -a "x$acv_mesa_CLANG" = xno; then
 196     AC_MSG_CHECKING([whether gcc version is sufficient])
 197     major=0
 198     minor=0
 199
 200     GCC_VERSION=`$CC -dumpversion`
 201     if test $? -eq 0; then
 202         GCC_VERSION_MAJOR=`echo $GCC_VERSION | cut -d. -f1`
 203         GCC_VERSION_MINOR=`echo $GCC_VERSION | cut -d. -f2`
 204     fi
 205
 206     if test $GCC_VERSION_MAJOR -lt 4 -o $GCC_VERSION_MAJOR -eq 4 -a $GCC_VERSION_MINOR -lt 2 ; then
 207         AC_MSG_RESULT([no])
 208         AC_MSG_ERROR([If using GCC, version 4.2.0 or later is required.])
 209     else
 210         AC_MSG_RESULT([yes])
 211     fi
 212
 213     if test $GCC_VERSION_MAJOR -lt 4 -o $GCC_VERSION_MAJOR -eq 4 -a $GCC_VERSION_MINOR -lt 6 ; then
 214         USE_GNU99=yes
 215     fi
 216     if test "x$cross_compiling" = xyes; then
 217         GEN_ASM_OFFSETS=yes
 218     fi
 219 fi
 220
 221 dnl We don't support building Mesa with Sun C compiler
 222 dnl https://bugs.freedesktop.org/show_bug.cgi?id=93189
 223 AC_CHECK_DECL([__SUNPRO_C], [SUNCC=yes], [SUNCC=no])
 224 if test "x$SUNCC" = xyes; then
 225     AC_MSG_ERROR([Building with Sun C compiler is not supported, use GCC instead.])
 226 fi
 227
 228 dnl Check for compiler builtins
 229 AX_GCC_BUILTIN([__builtin_bswap32])
 230 AX_GCC_BUILTIN([__builtin_bswap64])
 231 AX_GCC_BUILTIN([__builtin_clz])
 232 AX_GCC_BUILTIN([__builtin_clzll])
 233 AX_GCC_BUILTIN([__builtin_ctz])
 234 AX_GCC_BUILTIN([__builtin_expect])
 235 AX_GCC_BUILTIN([__builtin_ffs])
 236 AX_GCC_BUILTIN([__builtin_ffsll])
 237 AX_GCC_BUILTIN([__builtin_popcount])
 238 AX_GCC_BUILTIN([__builtin_popcountll])
 239 AX_GCC_BUILTIN([__builtin_unreachable])
 240
 241 AX_GCC_FUNC_ATTRIBUTE([const])
 242 AX_GCC_FUNC_ATTRIBUTE([flatten])
 243 AX_GCC_FUNC_ATTRIBUTE([format])
 244 AX_GCC_FUNC_ATTRIBUTE([malloc])
 245 AX_GCC_FUNC_ATTRIBUTE([packed])
 246 AX_GCC_FUNC_ATTRIBUTE([pure])
 247 AX_GCC_FUNC_ATTRIBUTE([returns_nonnull])
 248 AX_GCC_FUNC_ATTRIBUTE([unused])
 249 AX_GCC_FUNC_ATTRIBUTE([visibility])
 250 AX_GCC_FUNC_ATTRIBUTE([warn_unused_result])
 251 AX_GCC_FUNC_ATTRIBUTE([weak])
 252 AX_GCC_FUNC_ATTRIBUTE([alias])
 253
 254 AM_CONDITIONAL([GEN_ASM_OFFSETS], test "x$GEN_ASM_OFFSETS" = xyes)
 255
 256 dnl Make sure the pkg-config macros are defined
 257 m4_ifndef([PKG_PROG_PKG_CONFIG],
 258     [m4_fatal([Could not locate the pkg-config autoconf macros.
 259   These are usually located in /usr/share/aclocal/pkg.m4. If your macros
 260   are in a different location, try setting the environment variable
 261   ACLOCAL="aclocal -I/other/macro/dir" before running autoreconf.])])
 262 PKG_PROG_PKG_CONFIG()
 263
 264 dnl LIB_DIR - library basename
 265 LIB_DIR=`echo $libdir | $SED 's%.*/%%'`
 266 AC_SUBST([LIB_DIR])
 267
 268 dnl Cache LDFLAGS and CPPFLAGS so we can add to them and restore later
 269 _SAVE_LDFLAGS="$LDFLAGS"
 270 _SAVE_CPPFLAGS="$CPPFLAGS"
 271
 272 dnl Compiler macros
 273 DEFINES="-D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS"
 274 AC_SUBST([DEFINES])
 275 android=no
 276 case "$host_os" in
 277 *-android*)
 278     android=yes
 279     ;;
 280 linux*|*-gnu*|gnu*|cygwin*)
 281     DEFINES="$DEFINES -D_GNU_SOURCE"
 282     ;;
 283 solaris*)
 284     DEFINES="$DEFINES -DSVR4"
 285     ;;
 286 esac
 287
 288 AM_CONDITIONAL(HAVE_ANDROID, test "x$android" = xyes)
 289
 290 dnl
 291 dnl Check compiler flags
 292 dnl
 293 AX_CHECK_COMPILE_FLAG([-Wall],                                 [CFLAGS="$CFLAGS -Wall"])
 294 AX_CHECK_COMPILE_FLAG([-Werror=implicit-function-declaration], [CFLAGS="$CFLAGS -Werror=implicit-function-declaration"])
 295 AX_CHECK_COMPILE_FLAG([-Werror=missing-prototypes],            [CFLAGS="$CFLAGS -Werror=missing-prototypes"])
 296 AX_CHECK_COMPILE_FLAG([-Wmissing-prototypes],                  [CFLAGS="$CFLAGS -Wmissing-prototypes"])
 297 AX_CHECK_COMPILE_FLAG([-fno-math-errno],                       [CFLAGS="$CFLAGS -fno-math-errno"])
 298 AX_CHECK_COMPILE_FLAG([-fno-trapping-math],                    [CFLAGS="$CFLAGS -fno-trapping-math"])
 299 AX_CHECK_COMPILE_FLAG([-fvisibility=hidden],                   [VISIBILITY_CFLAGS="-fvisibility=hidden"])
 300
 301 dnl
 302 dnl Check C++ compiler flags
 303 dnl
 304 AC_LANG_PUSH([C++])
 305 AX_CHECK_COMPILE_FLAG([-Wall],                                 [CXXFLAGS="$CXXFLAGS -Wall"])
 306 AX_CHECK_COMPILE_FLAG([-fno-math-errno],                       [CXXFLAGS="$CXXFLAGS -fno-math-errno"])
 307 AX_CHECK_COMPILE_FLAG([-fno-trapping-math],                    [CXXFLAGS="$CXXFLAGS -fno-trapping-math"])
 308 AX_CHECK_COMPILE_FLAG([-fvisibility=hidden],                   [VISIBILITY_CXXFLAGS="-fvisibility=hidden"])
 309 AC_LANG_POP([C++])
 310
 311 # Flags to help ensure that certain portions of the code -- and only those
 312 # portions -- can be built with MSVC:
 313 # - src/util, src/gallium/auxiliary, rc/gallium/drivers/llvmpipe, and
 314 # - non-Linux/Posix OpenGL portions needs to build on MSVC 2013 (which
 315 #   supports most of C99)
 316 # - the rest has no compiler compiler restrictions
 317 AX_CHECK_COMPILE_FLAG([-Werror=pointer-arith],                 [MSVC2013_COMPAT_CFLAGS="$MSVC2013_COMPAT_CFLAGS -Werror=pointer-arith"])
 318 AX_CHECK_COMPILE_FLAG([-Werror=vla],                           [MSVC2013_COMPAT_CFLAGS="$MSVC2013_COMPAT_CFLAGS -Werror=vla"])
 319 AC_LANG_PUSH([C++])
 320 AX_CHECK_COMPILE_FLAG([-Werror=pointer-arith],                 [MSVC2013_COMPAT_CXXFLAGS="$MSVC2013_COMPAT_CXXFLAGS -Werror=pointer-arith"])
 321 AX_CHECK_COMPILE_FLAG([-Werror=vla],                           [MSVC2013_COMPAT_CXXFLAGS="$MSVC2013_COMPAT_CXXFLAGS -Werror=vla"])
 322 AC_LANG_POP([C++])
 323
 324 AC_SUBST([MSVC2013_COMPAT_CFLAGS])
 325 AC_SUBST([MSVC2013_COMPAT_CXXFLAGS])
 326
 327 if test "x$GCC" = xyes; then
 328     if test "x$USE_GNU99" = xyes; then
 329         CFLAGS="$CFLAGS -std=gnu99"
 330     else
 331         CFLAGS="$CFLAGS -std=c99"
 332     fi
 333 fi
 334
 335 dnl
 336 dnl Check whether C++11 is supported, if the environment variable
 337 dnl CXX11_CXXFLAGS is set it takes precedence.
 338 dnl
 339
 340 AC_LANG_PUSH([C++])
 341
 342 check_cxx11_available() {
 343     output_support=$1
 344     AC_COMPILE_IFELSE(
 345         [AC_LANG_PROGRAM([
 346              #if !(__cplusplus >= 201103L)
 347              #error
 348              #endif
 349              #include <tuple>
 350         ])
 351     ], [
 352          AC_MSG_RESULT(yes)
 353          cxx11_support=yes
 354     ], AC_MSG_RESULT(no))
 355     eval "$output_support=\$cxx11_support"
 356 }
 357
 358 HAVE_CXX11=no
 359 save_CXXFLAGS="$CXXFLAGS"
 360
 361 dnl If the user provides a flag to enable c++11, then we test only this
 362 if test "x$CXX11_CXXFLAGS" != "x"; then
 363    CXXFLAGS="$CXXFLAGS $CXX11_CXXFLAGS"
 364    AC_MSG_CHECKING(whether c++11 is enabled by via $CXX11_CXXFLAGS)
 365    check_cxx11_available HAVE_CXX11
 366 else
 367    dnl test whether c++11 is enabled by default
 368    AC_MSG_CHECKING(whether c++11 is enabled by default)
 369    check_cxx11_available HAVE_CXX11
 370
 371    dnl C++11 not enabled by default, test whether -std=c++11 does the job
 372    if test "x$HAVE_CXX11" != "xyes"; then
 373        CXX11_CXXFLAGS=-std=c++11
 374        CXXFLAGS="$CXXFLAGS $CXX11_CXXFLAGS"
 375        AC_MSG_CHECKING(whether c++11 is enabled by via $CXX11_CXXFLAGS)
 376        check_cxx11_available HAVE_CXX11
 377    fi
 378 fi
 379
 380 CXXFLAGS="$save_CXXFLAGS"
 381 AM_CONDITIONAL(HAVE_STD_CXX11, test "x$HAVE_CXX11" = "xyes")
 382 AC_SUBST(CXX11_CXXFLAGS)
 383 AC_LANG_POP([C++])
 384
 385 dnl even if the compiler appears to support it, using visibility attributes isn't
 386 dnl going to do anything useful currently on cygwin apart from emit lots of warnings
 387 case "$host_os" in
 388 cygwin*)
 389     VISIBILITY_CFLAGS=""
 390     VISIBILITY_CXXFLAGS=""
 391     ;;
 392 esac
 393
 394 AC_SUBST([VISIBILITY_CFLAGS])
 395 AC_SUBST([VISIBILITY_CXXFLAGS])
 396
 397 dnl For some reason, the test for -Wno-foo always succeeds with gcc, even if the
 398 dnl option is not supported. Hence, check for -Wfoo instead.
 399 AX_CHECK_COMPILE_FLAG([-Woverride-init],                    [WNO_OVERRIDE_INIT="$WNO_OVERRIDE_INIT -Wno-override-init"])         # gcc
 400 AX_CHECK_COMPILE_FLAG([-Winitializer-overrides],            [WNO_OVERRIDE_INIT="$WNO_OVERRIDE_INIT -Wno-initializer-overrides"]) # clang
 401 AC_SUBST([WNO_OVERRIDE_INIT])
 402
 403 dnl
 404 dnl Optional flags, check for compiler support
 405 dnl
 406 SSE41_CFLAGS="-msse4.1"
 407 dnl Code compiled by GCC with -msse* assumes a 16 byte aligned
 408 dnl stack, but on x86-32 such alignment is not guaranteed.
 409 case "$target_cpu" in
 410 i?86)
 411     SSE41_CFLAGS="$SSE41_CFLAGS -mstackrealign"
 412     ;;
 413 esac
 414 save_CFLAGS="$CFLAGS"
 415 CFLAGS="$SSE41_CFLAGS $CFLAGS"
 416 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
 417 #include <smmintrin.h>
 418 int param;
 419 int main () {
 420     __m128i a = _mm_set1_epi32 (param), b = _mm_set1_epi32 (param + 1), c;
 421     c = _mm_max_epu32(a, b);
 422     return _mm_cvtsi128_si32(c);
 423 }]])], SSE41_SUPPORTED=1)
 424 CFLAGS="$save_CFLAGS"
 425 if test "x$SSE41_SUPPORTED" = x1; then
 426     DEFINES="$DEFINES -DUSE_SSE41"
 427 fi
 428 AM_CONDITIONAL([SSE41_SUPPORTED], [test x$SSE41_SUPPORTED = x1])
 429 AC_SUBST([SSE41_CFLAGS], $SSE41_CFLAGS)
 430
 431 dnl Check for new-style atomic builtins
 432 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
 433 int main() {
 434     int n;
 435     return __atomic_load_n(&n, __ATOMIC_ACQUIRE);
 436 }]])], GCC_ATOMIC_BUILTINS_SUPPORTED=1)
 437 if test "x$GCC_ATOMIC_BUILTINS_SUPPORTED" = x1; then
 438     DEFINES="$DEFINES -DUSE_GCC_ATOMIC_BUILTINS"
 439     dnl On some platforms, new-style atomics need a helper library
 440     AC_MSG_CHECKING(whether -latomic is needed)
 441     AC_LINK_IFELSE([AC_LANG_SOURCE([[
 442     #include <stdint.h>
 443     uint64_t v;
 444     int main() {
 445         return (int)__atomic_load_n(&v, __ATOMIC_ACQUIRE);
 446     }]])], GCC_ATOMIC_BUILTINS_NEED_LIBATOMIC=no, GCC_ATOMIC_BUILTINS_NEED_LIBATOMIC=yes)
 447     AC_MSG_RESULT($GCC_ATOMIC_BUILTINS_NEED_LIBATOMIC)
 448     if test "x$GCC_ATOMIC_BUILTINS_NEED_LIBATOMIC" = xyes; then
 449         LIBATOMIC_LIBS="-latomic"
 450     fi
 451 fi
 452 AM_CONDITIONAL([GCC_ATOMIC_BUILTINS_SUPPORTED], [test x$GCC_ATOMIC_BUILTINS_SUPPORTED = x1])
 453 AC_SUBST([LIBATOMIC_LIBS])
 454
 455 dnl Check if host supports 64-bit atomics
 456 dnl note that lack of support usually results in link (not compile) error
 457 AC_MSG_CHECKING(whether __sync_add_and_fetch_8 is supported)
 458 AC_LINK_IFELSE([AC_LANG_SOURCE([[
 459 #include <stdint.h>
 460 uint64_t v;
 461 int main() {
 462     return __sync_add_and_fetch(&v, (uint64_t)1);
 463 }]])], GCC_64BIT_ATOMICS_SUPPORTED=yes, GCC_64BIT_ATOMICS_SUPPORTED=no)
 464 if test "x$GCC_64BIT_ATOMICS_SUPPORTED" != xyes; then
 465     DEFINES="$DEFINES -DMISSING_64BIT_ATOMICS"
 466 fi
 467 AC_MSG_RESULT($GCC_64BIT_ATOMICS_SUPPORTED)
 468
 469 dnl Check for Endianness
 470 AC_C_BIGENDIAN(
 471    little_endian=no,
 472    little_endian=yes,
 473    little_endian=no,
 474    little_endian=no
 475 )
 476
 477 dnl Check for POWER8 Architecture
 478 PWR8_CFLAGS="-mpower8-vector"
 479 have_pwr8_intrinsics=no
 480 AC_MSG_CHECKING(whether gcc supports -mpower8-vector)
 481 save_CFLAGS=$CFLAGS
 482 CFLAGS="$PWR8_CFLAGS $CFLAGS"
 483 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
 484 #if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
 485 #error "Need GCC >= 4.8 for sane POWER8 support"
 486 #endif
 487 #include <altivec.h>
 488 int main () {
 489     vector unsigned char r;
 490     vector unsigned int v = vec_splat_u32 (1);
 491     r = __builtin_vec_vgbbd ((vector unsigned char) v);
 492     return 0;
 493 }]])], have_pwr8_intrinsics=yes)
 494 CFLAGS=$save_CFLAGS
 495
 496 AC_ARG_ENABLE(pwr8,
 497    [AS_HELP_STRING([--disable-pwr8],
 498                    [disable POWER8-specific instructions])],
 499    [enable_pwr8=$enableval], [enable_pwr8=auto])
 500
 501 if test "x$enable_pwr8" = xno ; then
 502    have_pwr8_intrinsics=disabled
 503 fi
 504
 505 if test $have_pwr8_intrinsics = yes && test $little_endian = yes ; then
 506    DEFINES="$DEFINES -D_ARCH_PWR8"
 507    CXXFLAGS="$CXXFLAGS $PWR8_CFLAGS"
 508    CFLAGS="$CFLAGS $PWR8_CFLAGS"
 509 else
 510    PWR8_CFLAGS=
 511 fi
 512
 513 AC_MSG_RESULT($have_pwr8_intrinsics)
 514 if test "x$enable_pwr8" = xyes && test $have_pwr8_intrinsics = no ; then
 515    AC_MSG_ERROR([POWER8 compiler support not detected])
 516 fi
 517
 518 if test $have_pwr8_intrinsics = yes && test $little_endian = no ; then
 519    AC_MSG_WARN([POWER8 optimization is enabled only on POWER8 Little-Endian])
 520 fi
 521
 522 AC_SUBST([PWR8_CFLAGS], $PWR8_CFLAGS)
 523
 524 dnl Can't have static and shared libraries, default to static if user
 525 dnl explicitly requested. If both disabled, set to static since shared
 526 dnl was explicitly requested.
 527 case "x$enable_static$enable_shared" in
 528 xyesyes)
 529     AC_MSG_ERROR([Cannot enable both static and shared. Building using --enable-shared is strongly recommended])
 530     ;;
 531 xnono)
 532     AC_MSG_ERROR([Cannot disable both static and shared. Building using --enable-shared is strongly recommended])
 533     ;;
 534 esac
 535
 536 AM_CONDITIONAL(BUILD_SHARED, test "x$enable_shared" = xyes)
 537
 538 dnl
 539 dnl other compiler options
 540 dnl
 541 AC_ARG_ENABLE([debug],
 542     [AS_HELP_STRING([--enable-debug],
 543         [use debug compiler flags and macros @<:@default=disabled@:>@])],
 544     [enable_debug="$enableval"],
 545     [enable_debug=no]
 546 )
 547
 548 AC_ARG_ENABLE([profile],
 549     [AS_HELP_STRING([--enable-profile],
 550         [enable profiling of code @<:@default=disabled@:>@])],
 551     [enable_profile="$enableval"],
 552     [enable_profile=no]
 553 )
 554
 555 AC_ARG_ENABLE([sanitize],
 556     [AS_HELP_STRING([--enable-sanitize@<:@=address|undefined@:>@],
 557         [enable code sanitizer @<:@default=disabled@:>@])],
 558     [enable_sanitize="$enableval"],
 559     [enable_sanitize=no])
 560
 561 if test "x$enable_profile" = xyes; then
 562     DEFINES="$DEFINES -DPROFILE"
 563     if test "x$GCC" = xyes; then
 564         CFLAGS="$CFLAGS -fno-omit-frame-pointer"
 565     fi
 566     if test "x$GXX" = xyes; then
 567         CXXFLAGS="$CXXFLAGS -fno-omit-frame-pointer"
 568     fi
 569 fi
 570
 571 if test "x$enable_debug" = xyes; then
 572     DEFINES="$DEFINES -DDEBUG"
 573     if test "x$enable_profile" = xyes; then
 574         AC_MSG_WARN([Debug and Profile are enabled at the same time])
 575     fi
 576     if test "x$GCC" = xyes; then
 577         if ! echo "$CFLAGS" | grep -q -e '-g'; then
 578             CFLAGS="$CFLAGS -g"
 579         fi
 580         if ! echo "$CFLAGS" | grep -q -e '-O'; then
 581             CFLAGS="$CFLAGS -O0"
 582         fi
 583     fi
 584     if test "x$GXX" = xyes; then
 585         if ! echo "$CXXFLAGS" | grep -q -e '-g'; then
 586             CXXFLAGS="$CXXFLAGS -g"
 587         fi
 588         if ! echo "$CXXFLAGS" | grep -q -e '-O'; then
 589             CXXFLAGS="$CXXFLAGS -O0"
 590         fi
 591     fi
 592 else
 593    DEFINES="$DEFINES -DNDEBUG"
 594 fi
 595
 596 if test "x$enable_sanitize" != xno; then
 597     if test "x$enable_profile" = xyes; then
 598         AC_MSG_WARN([Sanitize and Profile are enabled at the same time])
 599     fi
 600
 601     CFLAGS="$CFLAGS -fsanitize=$enable_sanitize"
 602     CXXFLAGS="$CXXFLAGS -fsanitize=$enable_sanitize"
 603     LDFLAGS="$LDFLAGS -fsanitize=$enable_sanitize"
 604
 605     AC_LINK_IFELSE(
 606         [AC_LANG_SOURCE([int main(){return 0;}])],
 607         [],
 608         [AC_MSG_FAILURE([sanitize flags '$enable_sanitize' not supported])])
 609 fi
 610
 611 dnl
 612 dnl Check if linker supports -Bsymbolic
 613 dnl
 614 save_LDFLAGS=$LDFLAGS
 615 LDFLAGS="$LDFLAGS -Wl,-Bsymbolic"
 616 AC_MSG_CHECKING([if ld supports -Bsymbolic])
 617 AC_LINK_IFELSE(
 618     [AC_LANG_SOURCE([int main() { return 0;}])],
 619     [AC_MSG_RESULT([yes])
 620         BSYMBOLIC="-Wl,-Bsymbolic";],
 621     [AC_MSG_RESULT([no])
 622         BSYMBOLIC="";])
 623 LDFLAGS=$save_LDFLAGS
 624
 625 AC_SUBST([BSYMBOLIC])
 626
 627 dnl
 628 dnl Check if linker supports garbage collection
 629 dnl
 630 save_LDFLAGS=$LDFLAGS
 631 LDFLAGS="$LDFLAGS -Wl,--gc-sections"
 632 AC_MSG_CHECKING([whether ld supports --gc-sections])
 633 AC_LINK_IFELSE(
 634     [AC_LANG_SOURCE([static char UnusedFunc() { return 5; } int main() { return 0;}])],
 635     [AC_MSG_RESULT([yes])
 636         GC_SECTIONS="-Wl,--gc-sections";],
 637     [AC_MSG_RESULT([no])
 638         GC_SECTIONS="";])
 639 LDFLAGS=$save_LDFLAGS
 640
 641 AC_SUBST([GC_SECTIONS])
 642
 643 dnl
 644 dnl OpenBSD does not have DT_NEEDED entries for libc by design
 645 dnl so when these flags are passed to ld via libtool the checks will fail
 646 dnl
 647 case "$host_os" in
 648 openbsd* | darwin* )
 649     LD_NO_UNDEFINED="" ;;
 650 *)
 651     if test "x$enable_sanitize" = xno; then
 652         LD_NO_UNDEFINED="-Wl,--no-undefined"
 653     else
 654         LD_NO_UNDEFINED=""
 655     fi
 656     ;;
 657 esac
 658
 659 AC_SUBST([LD_NO_UNDEFINED])
 660
 661 dnl
 662 dnl Check if linker supports version scripts
 663 dnl
 664 AC_MSG_CHECKING([if the linker supports version-scripts])
 665 save_LDFLAGS=$LDFLAGS
 666 LDFLAGS="$LDFLAGS -Wl,--version-script=$srcdir/build-support/conftest.map"
 667 AC_LINK_IFELSE(
 668     [AC_LANG_SOURCE([int main() { return 0;}])],
 669     [have_ld_version_script=yes;AC_MSG_RESULT(yes)],
 670     [have_ld_version_script=no; AC_MSG_RESULT(no)])
 671 LDFLAGS=$save_LDFLAGS
 672 AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")
 673
 674 dnl
 675 dnl Check if linker supports dynamic list files
 676 dnl
 677 AC_MSG_CHECKING([if the linker supports --dynamic-list])
 678 save_LDFLAGS=$LDFLAGS
 679 LDFLAGS="$LDFLAGS -Wl,--dynamic-list=$srcdir/build-support/conftest.dyn"
 680 AC_LINK_IFELSE(
 681     [AC_LANG_SOURCE([int main() { return 0;}])],
 682     [have_ld_dynamic_list=yes;AC_MSG_RESULT(yes)],
 683     [have_ld_dynamic_list=no; AC_MSG_RESULT(no)])
 684 LDFLAGS=$save_LDFLAGS
 685 AM_CONDITIONAL(HAVE_LD_DYNAMIC_LIST, test "$have_ld_dynamic_list" = "yes")
 686
 687 dnl
 688 dnl compatibility symlinks
 689 dnl
 690 case "$host_os" in
 691 linux* )
 692     HAVE_COMPAT_SYMLINKS=yes ;;
 693 * )
 694     HAVE_COMPAT_SYMLINKS=no ;;
 695 esac
 696
 697 AM_CONDITIONAL(HAVE_COMPAT_SYMLINKS, test "x$HAVE_COMPAT_SYMLINKS" = xyes)
 698
 699 dnl
 700 dnl library names
 701 dnl
 702 dnl Unfortunately we need to do a few things that libtool can't help us with,
 703 dnl so we need some knowledge of shared library filenames:
 704 dnl
 705 dnl LIB_EXT is the extension used when creating symlinks for alternate
 706 dnl filenames for a shared library which will be dynamically loaded
 707 dnl
 708 dnl IMP_LIB_EXT is the extension used when checking for the presence of a
 709 dnl the file for a shared library we wish to link with
 710 dnl
 711 case "$host_os" in
 712 darwin* )
 713     LIB_EXT='dylib'
 714     IMP_LIB_EXT=$LIB_EXT
 715     ;;
 716 cygwin* )
 717     LIB_EXT='dll'
 718     IMP_LIB_EXT='dll.a'
 719     ;;
 720 aix* )
 721     LIB_EXT='a'
 722     IMP_LIB_EXT=$LIB_EXT
 723     ;;
 724 * )
 725     LIB_EXT='so'
 726     IMP_LIB_EXT=$LIB_EXT
 727     ;;
 728 esac
 729
 730 AC_SUBST([LIB_EXT])
 731
 732 dnl
 733 dnl potentially-infringing-but-nobody-knows-for-sure stuff
 734 dnl
 735 AC_ARG_ENABLE([texture-float],
 736     [AS_HELP_STRING([--enable-texture-float],
 737         [enable floating-point textures and renderbuffers @<:@default=disabled@:>@])],
 738     [enable_texture_float="$enableval"],
 739     [enable_texture_float=no]
 740 )
 741 if test "x$enable_texture_float" = xyes; then
 742     AC_MSG_WARN([Floating-point textures enabled.])
 743     AC_MSG_WARN([Please consult docs/patents.txt with your lawyer before building Mesa.])
 744     DEFINES="$DEFINES -DTEXTURE_FLOAT_ENABLED"
 745 fi
 746
 747 dnl
 748 dnl Arch/platform-specific settings
 749 dnl
 750 AC_ARG_ENABLE([asm],
 751     [AS_HELP_STRING([--disable-asm],
 752         [disable assembly usage @<:@default=enabled on supported platforms@:>@])],
 753     [enable_asm="$enableval"],
 754     [enable_asm=yes]
 755 )
 756 asm_arch=""
 757 AC_MSG_CHECKING([whether to enable assembly])
 758 test "x$enable_asm" = xno && AC_MSG_RESULT([no])
 759 # disable if cross compiling on x86/x86_64 since we must run gen_matypes
 760 if test "x$enable_asm" = xyes -a "x$cross_compiling" = xyes; then
 761     case "$host_cpu" in
 762     i?86 | x86_64 | amd64)
 763         if test "x$host_cpu" != "x$target_cpu"; then
 764             enable_asm=no
 765             AC_MSG_RESULT([no, cross compiling])
 766         fi
 767         ;;
 768     esac
 769 fi
 770 # check for supported arches
 771 if test "x$enable_asm" = xyes; then
 772     case "$host_cpu" in
 773     i?86)
 774         case "$host_os" in
 775         linux* | *freebsd* | dragonfly* | *netbsd* | openbsd* | gnu*)
 776             asm_arch=x86
 777             ;;
 778         esac
 779         ;;
 780     x86_64|amd64)
 781         case "$host_os" in
 782         linux* | *freebsd* | dragonfly* | *netbsd* | openbsd*)
 783             asm_arch=x86_64
 784             ;;
 785         esac
 786         ;;
 787     sparc*)
 788         case "$host_os" in
 789         linux*)
 790             asm_arch=sparc
 791             ;;
 792         esac
 793         ;;
 794     powerpc64le)
 795         case "$host_os" in
 796         linux*)
 797             asm_arch=ppc64le
 798             ;;
 799         esac
 800         ;;
 801     aarch64)
 802         case "$host_os" in
 803         linux*)
 804             asm_arch=aarch64
 805             ;;
 806         esac
 807         ;;
 808     arm)
 809         case "$host_os" in
 810         linux*)
 811             asm_arch=arm
 812             ;;
 813         esac
 814         ;;
 815     esac
 816
 817     case "$asm_arch" in
 818     x86)
 819         DEFINES="$DEFINES -DUSE_X86_ASM -DUSE_MMX_ASM -DUSE_3DNOW_ASM -DUSE_SSE_ASM"
 820         AC_MSG_RESULT([yes, x86])
 821         ;;
 822     x86_64|amd64)
 823         DEFINES="$DEFINES -DUSE_X86_64_ASM"
 824         AC_MSG_RESULT([yes, x86_64])
 825         ;;
 826     sparc)
 827         DEFINES="$DEFINES -DUSE_SPARC_ASM"
 828         AC_MSG_RESULT([yes, sparc])
 829         ;;
 830     ppc64le)
 831         DEFINES="$DEFINES -DUSE_PPC64LE_ASM"
 832         AC_MSG_RESULT([yes, ppc64le])
 833         ;;
 834     aarch64)
 835         DEFINES="$DEFINES -DUSE_AARCH64_ASM"
 836         AC_MSG_RESULT([yes, aarch64])
 837         ;;
 838     arm)
 839         DEFINES="$DEFINES -DUSE_ARM_ASM"
 840         AC_MSG_RESULT([yes, arm])
 841         ;;
 842     *)
 843         AC_MSG_RESULT([no, platform not supported])
 844         ;;
 845     esac
 846 fi
 847
 848 AC_HEADER_MAJOR
 849 AC_CHECK_HEADER([xlocale.h], [DEFINES="$DEFINES -DHAVE_XLOCALE_H"])
 850 AC_CHECK_HEADER([sys/sysctl.h], [DEFINES="$DEFINES -DHAVE_SYS_SYSCTL_H"])
 851 AC_CHECK_FUNC([strtof], [DEFINES="$DEFINES -DHAVE_STRTOF"])
 852 AC_CHECK_FUNC([mkostemp], [DEFINES="$DEFINES -DHAVE_MKOSTEMP"])
 853 AC_CHECK_FUNC([timespec_get], [DEFINES="$DEFINES -DHAVE_TIMESPEC_GET"])
 854 AC_CHECK_FUNC([memfd_create], [DEFINES="$DEFINES -DHAVE_MEMFD_CREATE"])
 855
 856 AC_MSG_CHECKING([whether strtod has locale support])
 857 AC_LINK_IFELSE([AC_LANG_SOURCE([[
 858     #define _GNU_SOURCE
 859     #include <stdlib.h>
 860     #include <locale.h>
 861     #ifdef HAVE_XLOCALE_H
 862     #include <xlocale.h>
 863     #endif
 864     int main() {
 865        locale_t loc = newlocale(LC_CTYPE_MASK, "C", NULL);
 866        const char *s = "1.0";
 867        char *end;
 868        double d = strtod_l(s, end, loc);
 869        float f = strtof_l(s, end, loc);
 870        freelocale(loc);
 871        return 0;
 872     }]])],
 873   [DEFINES="$DEFINES -DHAVE_STRTOD_L"];
 874    AC_MSG_RESULT([yes]),
 875    AC_MSG_RESULT([no]))
 876
 877 dnl Check to see if dlopen is in default libraries (like Solaris, which
 878 dnl has it in libc), or if libdl is needed to get it.
 879 AC_CHECK_FUNC([dlopen], [],
 880     [AC_CHECK_LIB([dl], [dlopen],
 881        [DLOPEN_LIBS="-ldl"])])
 882 AC_SUBST([DLOPEN_LIBS])
 883
 884 dnl Check if that library also has dladdr
 885 save_LIBS="$LIBS"
 886 LIBS="$LIBS $DLOPEN_LIBS"
 887 AC_CHECK_FUNCS([dladdr])
 888 LIBS="$save_LIBS"
 889
 890 AC_CHECK_FUNC([dl_iterate_phdr], [DEFINES="$DEFINES -DHAVE_DL_ITERATE_PHDR"])
 891
 892 case "$host_os" in
 893 darwin*)
 894     ;;
 895 *)
 896     AC_CHECK_FUNCS([clock_gettime], [CLOCK_LIB=],
 897                    [AC_CHECK_LIB([rt], [clock_gettime], [CLOCK_LIB=-lrt],
 898                                  [AC_MSG_ERROR([Could not find clock_gettime])])])
 899     AC_SUBST([CLOCK_LIB])
 900     ;;
 901 esac
 902
 903 dnl See if posix_memalign is available
 904 AC_CHECK_FUNC([posix_memalign], [DEFINES="$DEFINES -DHAVE_POSIX_MEMALIGN"])
 905
 906 dnl Check for zlib
 907 PKG_CHECK_MODULES([ZLIB], [zlib >= $ZLIB_REQUIRED])
 908
 909 dnl Check for pthreads
 910 AX_PTHREAD
 911 if test "x$ax_pthread_ok" = xno; then
 912     AC_MSG_ERROR([Building mesa on this platform requires pthreads])
 913 fi
 914 dnl AX_PTHREADS leaves PTHREAD_LIBS empty for gcc and sets PTHREAD_CFLAGS
 915 dnl to -pthread, which causes problems if we need -lpthread to appear in
 916 dnl pkgconfig files.  Since Android doesn't have a pthread lib, this check
 917 dnl is not valid for that platform.
 918 if test "x$android" = xno; then
 919     test -z "$PTHREAD_LIBS" && PTHREAD_LIBS="-lpthread"
 920 fi
 921 dnl According to the manual when using pthreads, one should add -pthread to
 922 dnl both compile and link-time arguments.
 923 dnl In practise that should be sufficient for all platforms, since any
 924 dnl platforms build with GCC and Clang support the flag.
 925 PTHREAD_LIBS="$PTHREAD_LIBS -pthread"
 926
 927 dnl pthread-stubs is mandatory on BSD platforms, due to the nature of the
 928 dnl project. Even then there's a notable issue as described in the project README
 929 case "$host_os" in
 930 linux* | cygwin* | darwin* | solaris* | *-gnu* | gnu*)
 931     pthread_stubs_possible="no"
 932     ;;
 933 * )
 934     pthread_stubs_possible="yes"
 935     ;;
 936 esac
 937
 938 if test "x$pthread_stubs_possible" = xyes; then
 939     PKG_CHECK_MODULES(PTHREADSTUBS, pthread-stubs >= 0.4)
 940 fi
 941
 942 dnl Check for futex for fast inline simple_mtx_t.
 943 AC_CHECK_HEADER([linux/futex.h], [DEFINES="$DEFINES -DHAVE_LINUX_FUTEX_H"])
 944
 945 dnl SELinux awareness.
 946 AC_ARG_ENABLE([selinux],
 947     [AS_HELP_STRING([--enable-selinux],
 948         [Build SELinux-aware Mesa @<:@default=disabled@:>@])],
 949     [MESA_SELINUX="$enableval"],
 950     [MESA_SELINUX=no])
 951 if test "x$enable_selinux" = "xyes"; then
 952     PKG_CHECK_MODULES([SELINUX], [libselinux], [],
 953         [AC_CHECK_HEADER([selinux/selinux.h],[],
 954                          [AC_MSG_ERROR([SELinux headers not found])])
 955          AC_CHECK_LIB([selinux],[is_selinux_enabled],[],
 956                       [AC_MSG_ERROR([SELinux library not found])])
 957          SELINUX_LIBS="-lselinux"])
 958     DEFINES="$DEFINES -DMESA_SELINUX"
 959 fi
 960 AC_SUBST([SELINUX_CFLAGS])
 961 AC_SUBST([SELINUX_LIBS])
 962
 963 dnl
 964 dnl LLVM
 965 dnl
 966 AC_ARG_ENABLE([llvm-shared-libs],
 967     [AS_HELP_STRING([--enable-llvm-shared-libs],
 968         [link with LLVM shared libraries @<:@default=enabled@:>@])],
 969     [enable_llvm_shared_libs="$enableval"],
 970     [enable_llvm_shared_libs=yes])
 971
 972 AC_ARG_WITH([llvm-prefix],
 973     [AS_HELP_STRING([--with-llvm-prefix],
 974         [Prefix for LLVM installations in non-standard locations])],
 975     [llvm_prefix="$withval"],
 976     [llvm_prefix=''])
 977
 978 PKG_CHECK_MODULES([LIBELF], [libelf], [have_libelf=yes], [have_libelf=no])
 979 if test "x$have_libelf" = xno; then
 980    LIBELF_LIBS=''
 981    LIBELF_CFLAGS=''
 982    AC_CHECK_LIB([elf], [elf_memory], [have_libelf=yes;LIBELF_LIBS=-lelf], [have_libelf=no])
 983    AC_SUBST([LIBELF_LIBS])
 984    AC_SUBST([LIBELF_CFLAGS])
 985 fi
 986
 987 if test -z "$LLVM_CONFIG"; then
 988     if test -n "$llvm_prefix"; then
 989         AC_PATH_TOOL([LLVM_CONFIG], [llvm-config], [no], ["$llvm_prefix/bin"])
 990     else
 991         AC_PATH_TOOL([LLVM_CONFIG], [llvm-config], [no])
 992     fi
 993 fi
 994
 995 llvm_add_component() {
 996     new_llvm_component=$1
 997     driver_name=$2
 998
 999     if $LLVM_CONFIG --components | grep -iqw $new_llvm_component ; then
1000         LLVM_COMPONENTS="${LLVM_COMPONENTS} ${new_llvm_component}"
1001     else
1002         AC_MSG_ERROR([LLVM component '$new_llvm_component' not enabled in your LLVM build. Required by $driver_name.])
1003     fi
1004 }
1005
1006 llvm_add_optional_component() {
1007     new_llvm_component=$1
1008     driver_name=$2
1009
1010     if $LLVM_CONFIG --components | grep -iqw $new_llvm_component ; then
1011         LLVM_COMPONENTS="${LLVM_COMPONENTS} ${new_llvm_component}"
1012     fi
1013 }
1014
1015 llvm_add_default_components() {
1016     driver_name=$1
1017
1018     # Required default components
1019     llvm_add_component "bitwriter" $driver_name
1020     llvm_add_component "engine" $driver_name
1021     llvm_add_component "mcdisassembler" $driver_name
1022     llvm_add_component "mcjit" $driver_name
1023
1024     # Optional default components
1025     llvm_add_optional_component "inteljitevents" $driver_name
1026 }
1027
1028 llvm_add_target() {
1029     new_llvm_target=$1
1030     driver_name=$2
1031
1032     if $LLVM_CONFIG --targets-built | grep -iqw $new_llvm_target ; then
1033         llvm_add_component $new_llvm_target $driver_name
1034     else
1035         AC_MSG_ERROR([LLVM target '$new_llvm_target' not enabled in your LLVM build. Required by $driver_name.])
1036     fi
1037 }
1038
1039 # Call this inside ` ` to get the return value.
1040 # $1 is the llvm-config command with arguments.
1041 strip_unwanted_llvm_flags() {
1042     echo " `$1` " | sed -E \
1043         -e 's/[[[:space:]]]+-m[[^[:space:]]]*//g' \
1044         -e 's/[[[:space:]]]+-DNDEBUG[[[:space:]]]/ /g' \
1045         -e 's/[[[:space:]]]+-D_GNU_SOURCE[[[:space:]]]/ /g' \
1046         -e 's/[[[:space:]]]+-pedantic[[[:space:]]]/ /g' \
1047         -e 's/[[[:space:]]]+-W[[^[:space:]]]*//g' \
1048         -e 's/[[[:space:]]]+-O[[^[:space:]]]*//g' \
1049         -e 's/[[[:space:]]]+-g[[^[:space:]]]*//g' \
1050         -e 's/-fno-rtti[[[:space:]]]/-Fno-rtti /g' \
1051         -e 's/[[[:space:]]]+-f[[^[:space:]]]*//g' \
1052         -e 's/-Fno-rtti[[[:space:]]]/-fno-rtti /g' \
1053         -e 's/^[[[:space:]]]//' \
1054         -e 's/[[[:space:]]]$//'
1055 }
1056
1057 llvm_set_environment_variables() {
1058     if test "x$LLVM_CONFIG" != xno; then
1059         LLVM_VERSION=`$LLVM_CONFIG --version | egrep -o '^[[0-9.]]+'`
1060         LLVM_CPPFLAGS=`strip_unwanted_llvm_flags "$LLVM_CONFIG --cppflags"`
1061         LLVM_INCLUDEDIR=`$LLVM_CONFIG --includedir`
1062         LLVM_LIBDIR=`$LLVM_CONFIG --libdir`
1063
1064         # We need to respect LLVM_CPPFLAGS when compiling LLVM headers.
1065         save_CFLAGS="$CFLAGS"
1066         CFLAGS="$CFLAGS $LLVM_CPPFLAGS"
1067
1068         AC_COMPUTE_INT([LLVM_VERSION_MAJOR], [LLVM_VERSION_MAJOR],
1069             [#include "${LLVM_INCLUDEDIR}/llvm/Config/llvm-config.h"])
1070         AC_COMPUTE_INT([LLVM_VERSION_MINOR], [LLVM_VERSION_MINOR],
1071             [#include "${LLVM_INCLUDEDIR}/llvm/Config/llvm-config.h"])
1072         AC_COMPUTE_INT([LLVM_VERSION_PATCH], [LLVM_VERSION_PATCH],
1073             [#include "${LLVM_INCLUDEDIR}/llvm/Config/llvm-config.h"])
1074
1075         CFLAGS="$save_CFLAGS"
1076
1077         # Only needed for LLVM < 3.6.0
1078         if test -z "$LLVM_VERSION_PATCH"; then
1079             LLVM_VERSION_PATCH=0
1080         fi
1081
1082         LLVM_VERSION_INT="${LLVM_VERSION_MAJOR}0${LLVM_VERSION_MINOR}"
1083
1084         FOUND_LLVM=yes
1085     else
1086         FOUND_LLVM=no
1087         LLVM_VERSION_INT=0
1088     fi
1089 }
1090
1091 require_llvm() {
1092     if test "x$enable_llvm" != "xyes"; then
1093         AC_MSG_ERROR([--enable-llvm is required when building $1])
1094     fi
1095 }
1096
1097 llvm_require_version() {
1098     require_llvm $2
1099
1100     llvm_target_version_major=`echo $1 | cut -d. -f1 | egrep -o '^[[0-9]]+'`
1101     llvm_target_version_minor=`echo $1 | cut -d. -f2 | egrep -o '^[[0-9]]+'`
1102     llvm_target_version_patch=`echo $1 | cut -d. -f3 | egrep -o '^[[0-9]]+'`
1103
1104     if test "$LLVM_VERSION_MAJOR" -gt "$llvm_target_version_major"; then
1105         # major > required major
1106         #  --> OK
1107         return
1108     fi
1109
1110     if test "$LLVM_VERSION_MAJOR" -eq "$llvm_target_version_major"; then
1111         if test "$LLVM_VERSION_MINOR" -gt "$llvm_target_version_minor"; then
1112             # major = required major and
1113             # minor > required minor
1114             #  --> OK
1115             return
1116         else
1117             if test "$LLVM_VERSION_MINOR" -eq "$llvm_target_version_minor"; then
1118                 if test "$LLVM_VERSION_PATCH" -ge "$llvm_target_version_patch"; then
1119                     # major = required major and
1120                     # minor = required minor and
1121                     # patch >= required patch
1122                     #  --> OK
1123                     return
1124                 fi
1125             fi
1126         fi
1127     fi
1128
1129     AC_MSG_ERROR([LLVM $1 or newer is required for $2])
1130 }
1131
1132 radeon_llvm_check() {
1133     if test ${LLVM_VERSION_INT} -lt 307; then
1134         amdgpu_llvm_target_name='r600'
1135     else
1136         amdgpu_llvm_target_name='amdgpu'
1137     fi
1138
1139     llvm_require_version $*
1140
1141     llvm_add_target $amdgpu_llvm_target_name $2
1142
1143     llvm_add_default_components $2
1144     llvm_add_component "bitreader" $2
1145     llvm_add_component "ipo" $2
1146
1147     if test "x$have_libelf" != xyes; then
1148        AC_MSG_ERROR([$2 requires libelf when using llvm])
1149     fi
1150 }
1151
1152 llvm_set_environment_variables
1153
1154 AC_SUBST([LLVM_CFLAGS])
1155 AC_SUBST([LLVM_CXXFLAGS])
1156 AC_SUBST([LLVM_LIBS])
1157 AC_SUBST([LLVM_LDFLAGS])
1158 AC_SUBST([LLVM_INCLUDEDIR])
1159
1160 dnl
1161 dnl libunwind
1162 dnl
1163 PKG_CHECK_EXISTS(libunwind, [HAVE_LIBUNWIND=yes], [HAVE_LIBUNWIND=no])
1164 AC_ARG_ENABLE([libunwind],
1165     [AS_HELP_STRING([--enable-libunwind],
1166             [Use libunwind for backtracing (default: auto)])],
1167         [LIBUNWIND="$enableval"],
1168         [LIBUNWIND="$HAVE_LIBUNWIND"])
1169
1170 if test "x$LIBUNWIND" = "xyes"; then
1171     PKG_CHECK_MODULES(LIBUNWIND, libunwind)
1172     AC_DEFINE(HAVE_LIBUNWIND, 1, [Have libunwind support])
1173 fi
1174
1175
1176 dnl Options for APIs
1177 AC_ARG_ENABLE([opengl],
1178     [AS_HELP_STRING([--disable-opengl],
1179         [disable support for standard OpenGL API @<:@default=enabled@:>@])],
1180     [enable_opengl="$enableval"],
1181     [enable_opengl=yes])
1182 AC_ARG_ENABLE([gles1],
1183     [AS_HELP_STRING([--disable-gles1],
1184         [disable support for OpenGL ES 1.x API @<:@default=enabled@:>@])],
1185     [enable_gles1="$enableval"],
1186     [enable_gles1=yes])
1187 AC_ARG_ENABLE([gles2],
1188     [AS_HELP_STRING([--disable-gles2],
1189         [disable support for OpenGL ES 2.x API @<:@default=enabled@:>@])],
1190     [enable_gles2="$enableval"],
1191     [enable_gles2=yes])
1192
1193 AC_ARG_ENABLE([dri],
1194     [AS_HELP_STRING([--enable-dri],
1195         [enable DRI modules @<:@default=enabled@:>@])],
1196     [enable_dri="$enableval"],
1197     [enable_dri=yes])
1198
1199 AC_ARG_ENABLE([gallium-extra-hud],
1200     [AS_HELP_STRING([--enable-gallium-extra-hud],
1201         [enable HUD block/NIC I/O HUD stats support @<:@default=disabled@:>@])],
1202     [enable_gallium_extra_hud="$enableval"],
1203     [enable_gallium_extra_hud=no])
1204 AM_CONDITIONAL(HAVE_GALLIUM_EXTRA_HUD, test "x$enable_gallium_extra_hud" = xyes)
1205 if test "x$enable_gallium_extra_hud" = xyes ; then
1206     DEFINES="${DEFINES} -DHAVE_GALLIUM_EXTRA_HUD=1"
1207 fi
1208
1209 #TODO: no pkgconfig .pc available for libsensors.
1210 #PKG_CHECK_MODULES([LIBSENSORS], [libsensors >= $LIBSENSORS_REQUIRED], [enable_lmsensors=yes], [enable_lmsensors=no])
1211 AC_ARG_ENABLE([lmsensors],
1212     [AS_HELP_STRING([--enable-lmsensors],
1213         [enable HUD lmsensor support @<:@default=disabled@:>@])],
1214     [enable_lmsensors="$enableval"],
1215     [enable_lmsensors=no])
1216 AM_CONDITIONAL(HAVE_LIBSENSORS, test "x$enable_lmsensors" = xyes)
1217 if test "x$enable_lmsensors" = xyes ; then
1218     DEFINES="${DEFINES} -DHAVE_LIBSENSORS=1"
1219     LIBSENSORS_LIBS="-lsensors"
1220 else
1221     LIBSENSORS_LIBS=""
1222 fi
1223 AC_SUBST(LIBSENSORS_LIBS)
1224
1225 case "$host_os" in
1226 linux*)
1227     dri3_default=yes
1228     ;;
1229 *)
1230     dri3_default=no
1231     ;;
1232 esac
1233
1234 if test "x$enable_dri" = xno; then
1235     dri3_default=no
1236 fi
1237
1238 AC_ARG_ENABLE([dri3],
1239     [AS_HELP_STRING([--enable-dri3],
1240         [enable DRI3 @<:@default=auto@:>@])],
1241     [enable_dri3="$enableval"],
1242     [enable_dri3="$dri3_default"])
1243 AC_ARG_ENABLE([glx],
1244     [AS_HELP_STRING([--enable-glx@<:@=dri|xlib|gallium-xlib@:>@],
1245         [enable the GLX library and choose an implementation @<:@default=auto@:>@])],
1246     [enable_glx="$enableval"],
1247     [enable_glx=yes])
1248 AC_ARG_ENABLE([osmesa],
1249     [AS_HELP_STRING([--enable-osmesa],
1250         [enable OSMesa library @<:@default=disabled@:>@])],
1251     [enable_osmesa="$enableval"],
1252     [enable_osmesa=no])
1253 AC_ARG_ENABLE([gallium-osmesa],
1254     [AS_HELP_STRING([--enable-gallium-osmesa],
1255         [enable Gallium implementation of the OSMesa library @<:@default=disabled@:>@])],
1256     [enable_gallium_osmesa="$enableval"],
1257     [enable_gallium_osmesa=no])
1258 AC_ARG_ENABLE([egl],
1259     [AS_HELP_STRING([--disable-egl],
1260         [disable EGL library @<:@default=enabled@:>@])],
1261     [enable_egl="$enableval"],
1262     [enable_egl=yes])
1263
1264 AC_ARG_ENABLE([xa],
1265     [AS_HELP_STRING([--enable-xa],
1266         [enable build of the XA X Acceleration API @<:@default=disabled@:>@])],
1267     [enable_xa="$enableval"],
1268     [enable_xa=no])
1269 AC_ARG_ENABLE([gbm],
1270    [AS_HELP_STRING([--enable-gbm],
1271          [enable gbm library @<:@default=yes except cygwin@:>@])],
1272    [enable_gbm="$enableval"],
1273    [case "$host_os" in
1274        cygwin*)
1275           enable_gbm=no
1276           ;;
1277        *)
1278           enable_gbm=yes
1279           ;;
1280     esac])
1281 AC_ARG_ENABLE([nine],
1282     [AS_HELP_STRING([--enable-nine],
1283         [enable build of the nine Direct3D9 API @<:@default=no@:>@])],
1284     [enable_nine="$enableval"],
1285     [enable_nine=no])
1286
1287 AC_ARG_ENABLE([xvmc],
1288    [AS_HELP_STRING([--enable-xvmc],
1289          [enable xvmc library @<:@default=auto@:>@])],
1290    [enable_xvmc="$enableval"],
1291    [enable_xvmc=auto])
1292 AC_ARG_ENABLE([vdpau],
1293    [AS_HELP_STRING([--enable-vdpau],
1294          [enable vdpau library @<:@default=auto@:>@])],
1295    [enable_vdpau="$enableval"],
1296    [enable_vdpau=auto])
1297 AC_ARG_ENABLE([omx],
1298    [AS_HELP_STRING([--enable-omx],
1299          [DEPRECATED: Use --enable-omx-bellagio instead @<:@default=auto@:>@])],
1300    [AC_MSG_ERROR([--enable-omx is deprecated. Use --enable-omx-bellagio instead.])],
1301    [])
1302 AC_ARG_ENABLE([omx-bellagio],
1303    [AS_HELP_STRING([--enable-omx-bellagio],
1304          [enable OpenMAX Bellagio library @<:@default=disabled@:>@])],
1305    [enable_omx_bellagio="$enableval"],
1306    [enable_omx_bellagio=no])
1307 AC_ARG_ENABLE([va],
1308    [AS_HELP_STRING([--enable-va],
1309          [enable va library @<:@default=auto@:>@])],
1310    [enable_va="$enableval"],
1311    [enable_va=auto])
1312 AC_ARG_ENABLE([opencl],
1313    [AS_HELP_STRING([--enable-opencl],
1314          [enable OpenCL library @<:@default=disabled@:>@])],
1315    [enable_opencl="$enableval"],
1316    [enable_opencl=no])
1317 AC_ARG_ENABLE([opencl_icd],
1318    [AS_HELP_STRING([--enable-opencl-icd],
1319           [Build an OpenCL ICD library to be loaded by an ICD implementation
1320            @<:@default=enabled@:>@])],
1321     [enable_opencl_icd="$enableval"],
1322     [enable_opencl_icd=yes])
1323
1324 AC_ARG_ENABLE([gallium-tests],
1325     [AS_HELP_STRING([--enable-gallium-tests],
1326         [Enable optional Gallium tests) @<:@default=disabled@:>@])],
1327     [enable_gallium_tests="$enableval"],
1328     [enable_gallium_tests=no])
1329
1330 # Option for Gallium drivers
1331
1332 # Keep this in sync with the --with-gallium-drivers help string default value
1333 GALLIUM_DRIVERS_DEFAULT="r300,r600,svga,swrast"
1334
1335 AC_ARG_WITH([gallium-drivers],
1336     [AS_HELP_STRING([--with-gallium-drivers@<:@=DIRS...@:>@],
1337         [comma delimited Gallium drivers list, e.g.
1338         "i915,nouveau,r300,r600,radeonsi,freedreno,pl111,svga,swrast,swr,vc4,vc5,virgl,etnaviv,imx"
1339         @<:@default=r300,r600,svga,swrast@:>@])],
1340     [with_gallium_drivers="$withval"],
1341     [with_gallium_drivers="$GALLIUM_DRIVERS_DEFAULT"])
1342
1343 # Doing '--without-gallium-drivers' will set this variable to 'no'.  Clear it
1344 # here so that the script doesn't choke on an unknown driver name later.
1345 case "$with_gallium_drivers" in
1346     yes) with_gallium_drivers="$GALLIUM_DRIVERS_DEFAULT" ;;
1347     no) with_gallium_drivers='' ;;
1348 esac
1349
1350 if test "x$enable_opengl" = xno -a \
1351         "x$enable_gles1" = xno -a \
1352         "x$enable_gles2" = xno -a \
1353         "x$enable_nine" = xno -a \
1354         "x$enable_xa" = xno -a \
1355         "x$enable_xvmc" = xno -a \
1356         "x$enable_vdpau" = xno -a \
1357         "x$enable_omx_bellagio" = xno -a \
1358         "x$enable_va" = xno -a \
1359         "x$enable_opencl" = xno; then
1360     AC_MSG_ERROR([at least one API should be enabled])
1361 fi
1362
1363 # Building OpenGL ES1 and/or ES2 without OpenGL is not supported on mesa 9.0.x
1364 if test "x$enable_opengl" = xno -a \
1365         "x$enable_gles1" = xyes; then
1366     AC_MSG_ERROR([Building OpenGL ES1 without OpenGL is not supported])
1367 fi
1368
1369 if test "x$enable_opengl" = xno -a \
1370         "x$enable_gles2" = xyes; then
1371     AC_MSG_ERROR([Building OpenGL ES2 without OpenGL is not supported])
1372 fi
1373
1374 AM_CONDITIONAL(HAVE_OPENGL, test "x$enable_opengl" = xyes)
1375 AM_CONDITIONAL(HAVE_OPENGL_ES1, test "x$enable_gles1" = xyes)
1376 AM_CONDITIONAL(HAVE_OPENGL_ES2, test "x$enable_gles2" = xyes)
1377 AM_CONDITIONAL(NEED_OPENGL_COMMON, test "x$enable_opengl" = xyes -o \
1378                                         "x$enable_gles1" = xyes -o \
1379                                         "x$enable_gles2" = xyes)
1380 AM_CONDITIONAL(NEED_KHRPLATFORM, test "x$enable_egl" = xyes -o \
1381                                       "x$enable_gles1" = xyes -o \
1382                                       "x$enable_gles2" = xyes)
1383
1384 # Validate GLX options
1385 if test "x$enable_glx" = xyes; then
1386     if test "x$enable_dri" = xyes; then
1387         enable_glx=dri
1388     elif test -n "$with_gallium_drivers"; then
1389         enable_glx=gallium-xlib
1390     else
1391         enable_glx=xlib
1392     fi
1393 fi
1394 case "x$enable_glx" in
1395 xdri | xxlib | xgallium-xlib)
1396     # GLX requires OpenGL
1397     if test "x$enable_opengl" = xno; then
1398         AC_MSG_ERROR([GLX cannot be built without OpenGL])
1399     fi
1400
1401     # Check individual dependencies
1402     case "x$enable_glx" in
1403     xdri)
1404         if test "x$enable_dri" = xno; then
1405             AC_MSG_ERROR([DRI-based GLX requires DRI to be enabled])
1406         fi
1407         ;;
1408     xxlib)
1409         if test "x$enable_dri" = xyes; then
1410             AC_MSG_ERROR([Xlib-based GLX cannot be built with DRI enabled])
1411         fi
1412         ;;
1413     xgallium-xlib )
1414         if test "x$enable_dri" = xyes; then
1415             AC_MSG_ERROR([Xlib-based (Gallium) GLX cannot be built with DRI enabled])
1416         fi
1417         if test -z "$with_gallium_drivers"; then
1418             AC_MSG_ERROR([Xlib-based (Gallium) GLX cannot be built without Gallium enabled])
1419         fi
1420         ;;
1421     esac
1422     ;;
1423 xno)
1424     ;;
1425 *)
1426     AC_MSG_ERROR([Illegal value for --enable-glx: $enable_glx])
1427     ;;
1428 esac
1429
1430 AM_CONDITIONAL(HAVE_GLX, test "x$enable_glx" != xno)
1431 AM_CONDITIONAL(HAVE_DRI_GLX, test "x$enable_glx" = xdri)
1432 AM_CONDITIONAL(HAVE_XLIB_GLX, test "x$enable_glx" = xxlib)
1433 AM_CONDITIONAL(HAVE_GALLIUM_XLIB_GLX, test "x$enable_glx" = xgallium-xlib)
1434
1435 DEFAULT_GL_LIB_NAME=GL
1436
1437 dnl
1438 dnl Libglvnd configuration
1439 dnl
1440 AC_ARG_ENABLE([libglvnd],
1441     [AS_HELP_STRING([--enable-libglvnd],
1442         [Build GLX and EGL for libglvnd @<:@default=disabled@:>@])],
1443     [enable_libglvnd="$enableval"],
1444     [enable_libglvnd=no])
1445 AM_CONDITIONAL(USE_LIBGLVND, test "x$enable_libglvnd" = xyes)
1446
1447 if test "x$enable_libglvnd" = xyes ; then
1448     case "x$enable_glx" in
1449     xxlib | xgallium-xlib )
1450         AC_MSG_ERROR([cannot build libgvnd when Xlib-GLX or Gallium-Xlib-GLX is enabled])
1451         ;;
1452     esac
1453
1454     PKG_CHECK_MODULES([GLVND], libglvnd >= 0.2.0)
1455     LIBGLVND_DATADIR=`$PKG_CONFIG --variable=datadir libglvnd`
1456     AC_SUBST([LIBGLVND_DATADIR])
1457
1458     DEFINES="${DEFINES} -DUSE_LIBGLVND=1"
1459     DEFAULT_GL_LIB_NAME=GLX_mesa
1460
1461     if test "x$enable_glx" = xno -a "x$enable_egl" = xno; then
1462         AC_MSG_ERROR([cannot build libglvnd without GLX or EGL])
1463     fi
1464 fi
1465
1466 AC_ARG_WITH([gl-lib-name],
1467   [AS_HELP_STRING([--with-gl-lib-name@<:@=NAME@:>@],
1468     [specify GL library name @<:@default=GL@:>@])],
1469   [GL_LIB=$withval],
1470   [GL_LIB="$DEFAULT_GL_LIB_NAME"])
1471 AC_ARG_WITH([osmesa-lib-name],
1472   [AS_HELP_STRING([--with-osmesa-lib-name@<:@=NAME@:>@],
1473     [specify OSMesa library name @<:@default=OSMesa@:>@])],
1474   [OSMESA_LIB=$withval],
1475   [OSMESA_LIB=OSMesa])
1476 AS_IF([test "x$GL_LIB" = xyes], [GL_LIB="$DEFAULT_GL_LIB_NAME"])
1477 AS_IF([test "x$OSMESA_LIB" = xyes], [OSMESA_LIB=OSMesa])
1478
1479 dnl
1480 dnl Mangled Mesa support
1481 dnl
1482 AC_ARG_ENABLE([mangling],
1483   [AS_HELP_STRING([--enable-mangling],
1484     [enable mangled symbols and library name @<:@default=disabled@:>@])],
1485   [enable_mangling="${enableval}"],
1486   [enable_mangling=no]
1487 )
1488 if test "x${enable_mangling}" = "xyes" ; then
1489   DEFINES="${DEFINES} -DUSE_MGL_NAMESPACE"
1490   GL_LIB="Mangled${GL_LIB}"
1491   OSMESA_LIB="Mangled${OSMESA_LIB}"
1492 fi
1493 AC_SUBST([GL_LIB])
1494 AC_SUBST([OSMESA_LIB])
1495
1496 # Check for libdrm
1497 PKG_CHECK_MODULES([LIBDRM], [libdrm >= $LIBDRM_REQUIRED],
1498                   [have_libdrm=yes], [have_libdrm=no])
1499 if test "x$have_libdrm" = xyes; then
1500     DEFINES="$DEFINES -DHAVE_LIBDRM"
1501 fi
1502
1503 require_libdrm() {
1504     if test "x$have_libdrm" != xyes; then
1505        AC_MSG_ERROR([$1 requires libdrm >= $LIBDRM_REQUIRED])
1506     fi
1507 }
1508
1509
1510 # Select which platform-dependent DRI code gets built
1511 case "$host_os" in
1512 darwin*)
1513     dri_platform='apple' ;;
1514 cygwin*)
1515     dri_platform='windows' ;;
1516 gnu*)
1517     dri_platform='none' ;;
1518 *)
1519     dri_platform='drm' ;;
1520 esac
1521
1522 if test "x$enable_dri" = xyes -a "x$dri_platform" = xdrm -a "x$have_libdrm" = xyes; then
1523     have_drisw_kms='yes'
1524 fi
1525
1526 AM_CONDITIONAL(HAVE_DRICOMMON, test "x$enable_dri" = xyes )
1527 AM_CONDITIONAL(HAVE_DRISW, test "x$enable_dri" = xyes )
1528 AM_CONDITIONAL(HAVE_DRISW_KMS, test "x$have_drisw_kms" = xyes )
1529 AM_CONDITIONAL(HAVE_DRI2, test "x$enable_dri" = xyes -a "x$dri_platform" = xdrm -a "x$have_libdrm" = xyes )
1530 AM_CONDITIONAL(HAVE_DRI3, test "x$enable_dri3" = xyes -a "x$dri_platform" = xdrm -a "x$have_libdrm" = xyes )
1531 AM_CONDITIONAL(HAVE_APPLEDRI, test "x$enable_dri" = xyes -a "x$dri_platform" = xapple )
1532 AM_CONDITIONAL(HAVE_LMSENSORS, test "x$enable_lmsensors" = xyes )
1533 AM_CONDITIONAL(HAVE_GALLIUM_EXTRA_HUD, test "x$enable_gallium_extra_hud" = xyes )
1534 AM_CONDITIONAL(HAVE_WINDOWSDRI, test "x$enable_dri" = xyes -a "x$dri_platform" = xwindows )
1535
1536 AC_ARG_ENABLE([shared-glapi],
1537     [AS_HELP_STRING([--enable-shared-glapi],
1538         [Enable shared glapi for OpenGL @<:@default=enabled@:>@])],
1539     [enable_shared_glapi="$enableval"],
1540     [enable_shared_glapi=yes])
1541
1542 case "x$enable_opengl$enable_gles1$enable_gles2" in
1543 x*yes*yes*)
1544     if test "x$enable_shared_glapi" = xno; then
1545         AC_MSG_ERROR([shared GLAPI required when building two or more of
1546                       the following APIs - opengl, gles1 gles2])
1547     fi
1548     ;;
1549 esac
1550
1551 AM_CONDITIONAL(HAVE_SHARED_GLAPI, test "x$enable_shared_glapi" = xyes)
1552
1553 # Build the pipe-drivers as separate libraries/modules.
1554 # Do not touch this unless you know what you are doing.
1555 # XXX: Expose via configure option ?
1556 enable_shared_pipe_drivers=no
1557
1558 dnl
1559 dnl Driver specific build directories
1560 dnl
1561
1562 if test "x$enable_gallium_osmesa" = xyes; then
1563     if ! echo "$with_gallium_drivers" | grep -q 'swrast'; then
1564         AC_MSG_ERROR([gallium_osmesa requires the gallium swrast driver])
1565     fi
1566     if test "x$enable_osmesa" = xyes; then
1567         AC_MSG_ERROR([Cannot enable both classic and Gallium OSMesa implementations])
1568     fi
1569 fi
1570
1571 require_dri_shared_libs_and_glapi() {
1572     if test "x$enable_static" = xyes; then
1573         AC_MSG_ERROR([$1 cannot be build as static library])
1574     fi
1575
1576     if test "x$enable_dri" != xyes; then
1577         # There is only a single backend which won't be build/used otherwise.
1578         # XXX: Revisit this as the egl/haiku is a thing.
1579         AC_MSG_ERROR([$1 requires --enable-dri])
1580     fi
1581
1582     if test "x$enable_shared_glapi" != xyes; then
1583         AC_MSG_ERROR([$1 requires --enable-shared-glapi])
1584     fi
1585 }
1586
1587 if test "x$enable_dri" = xyes; then
1588     require_dri_shared_libs_and_glapi "DRI"
1589
1590     # not a hard requirement as swrast does not depend on it
1591     if test "x$have_libdrm" = xyes; then
1592         DRI_PC_REQ_PRIV="libdrm >= $LIBDRM_REQUIRED"
1593     fi
1594 fi
1595
1596 AC_ARG_ENABLE([driglx-direct],
1597     [AS_HELP_STRING([--disable-driglx-direct],
1598         [disable direct rendering in GLX and EGL for DRI \
1599             @<:@default=auto@:>@])],
1600     [driglx_direct="$enableval"],
1601     [driglx_direct="yes"])
1602
1603 dnl
1604 dnl libGL configuration per driver
1605 dnl
1606 if test "x$enable_glx" != xno; then
1607     PKG_CHECK_MODULES([GLPROTO], [glproto >= $GLPROTO_REQUIRED])
1608 fi
1609 case "x$enable_glx" in
1610 xxlib | xgallium-xlib)
1611     # Xlib-based GLX
1612     dri_modules="x11 xext xcb"
1613     PKG_CHECK_MODULES([XLIBGL], [$dri_modules])
1614     GL_PC_REQ_PRIV="$GL_PC_REQ_PRIV $dri_modules"
1615     X11_INCLUDES="$X11_INCLUDES $XLIBGL_CFLAGS"
1616     GL_LIB_DEPS="$XLIBGL_LIBS"
1617     GL_LIB_DEPS="$GL_LIB_DEPS $SELINUX_LIBS -lm $PTHREAD_LIBS $DLOPEN_LIBS"
1618     GL_PC_LIB_PRIV="$GL_PC_LIB_PRIV $SELINUX_LIBS -lm $PTHREAD_LIBS"
1619     ;;
1620 xdri)
1621     # DRI-based GLX
1622
1623     # find the DRI deps for libGL
1624     dri_modules="x11 xext xdamage >= $XDAMAGE_REQUIRED xfixes x11-xcb xcb xcb-glx >= $XCBGLX_REQUIRED"
1625
1626     if test x"$driglx_direct" = xyes; then
1627         if test x"$dri_platform" = xdrm ; then
1628             DEFINES="$DEFINES -DGLX_USE_DRM"
1629             require_libdrm "Direct rendering"
1630
1631             PKG_CHECK_MODULES([DRI2PROTO], [dri2proto >= $DRI2PROTO_REQUIRED])
1632             GL_PC_REQ_PRIV="$GL_PC_REQ_PRIV libdrm >= $LIBDRM_REQUIRED"
1633
1634             if test x"$enable_dri" = xyes; then
1635                dri_modules="$dri_modules xcb-dri2 >= $XCBDRI2_REQUIRED"
1636             fi
1637         fi
1638         if test x"$dri_platform" = xapple ; then
1639             DEFINES="$DEFINES -DGLX_USE_APPLEGL"
1640         fi
1641         if test x"$dri_platform" = xwindows ; then
1642             DEFINES="$DEFINES -DGLX_USE_WINDOWSGL"
1643         fi
1644     fi
1645
1646     # add xf86vidmode if available
1647     PKG_CHECK_MODULES([XF86VIDMODE], [xxf86vm], HAVE_XF86VIDMODE=yes, HAVE_XF86VIDMODE=no)
1648     if test "$HAVE_XF86VIDMODE" = yes ; then
1649         dri_modules="$dri_modules xxf86vm"
1650     fi
1651
1652     PKG_CHECK_MODULES([DRIGL], [$dri_modules])
1653     GL_PC_REQ_PRIV="$GL_PC_REQ_PRIV $dri_modules"
1654     X11_INCLUDES="$X11_INCLUDES $DRIGL_CFLAGS"
1655     GL_LIB_DEPS="$DRIGL_LIBS"
1656
1657     # need DRM libs, $PTHREAD_LIBS, etc.
1658     GL_LIB_DEPS="$GL_LIB_DEPS $LIBDRM_LIBS -lm $PTHREAD_LIBS $DLOPEN_LIBS"
1659     GL_PC_LIB_PRIV="-lm $PTHREAD_LIBS $DLOPEN_LIBS"
1660     ;;
1661 esac
1662
1663 # This is outside the case (above) so that it is invoked even for non-GLX
1664 # builds.
1665 AM_CONDITIONAL(HAVE_XF86VIDMODE, test "x$HAVE_XF86VIDMODE" = xyes)
1666
1667 GLESv1_CM_LIB_DEPS="$LIBDRM_LIBS -lm $PTHREAD_LIBS $DLOPEN_LIBS"
1668 GLESv1_CM_PC_LIB_PRIV="-lm $PTHREAD_LIBS $DLOPEN_LIBS"
1669 GLESv2_LIB_DEPS="$LIBDRM_LIBS -lm $PTHREAD_LIBS $DLOPEN_LIBS"
1670 GLESv2_PC_LIB_PRIV="-lm $PTHREAD_LIBS $DLOPEN_LIBS"
1671
1672 AC_SUBST([X11_INCLUDES])
1673 AC_SUBST([GL_LIB_DEPS])
1674 AC_SUBST([GL_PC_REQ_PRIV])
1675 AC_SUBST([GL_PC_LIB_PRIV])
1676 AC_SUBST([GL_PC_CFLAGS])
1677 AC_SUBST([DRI_PC_REQ_PRIV])
1678 AC_SUBST([GLESv1_CM_LIB_DEPS])
1679 AC_SUBST([GLESv1_CM_PC_LIB_PRIV])
1680 AC_SUBST([GLESv2_LIB_DEPS])
1681 AC_SUBST([GLESv2_PC_LIB_PRIV])
1682
1683 AC_SUBST([HAVE_XF86VIDMODE])
1684
1685 dnl
1686 dnl More GLX setup
1687 dnl
1688 case "x$enable_glx" in
1689 xxlib | xgallium-xlib)
1690     DEFINES="$DEFINES -DUSE_XSHM"
1691     ;;
1692 xdri)
1693     DEFINES="$DEFINES -DGLX_INDIRECT_RENDERING"
1694     if test "x$driglx_direct" = xyes; then
1695         DEFINES="$DEFINES -DGLX_DIRECT_RENDERING"
1696     fi
1697     ;;
1698 esac
1699
1700 dnl
1701 dnl TLS detection
1702 dnl
1703
1704 AC_ARG_ENABLE([glx-tls],
1705     [AS_HELP_STRING([--enable-glx-tls],
1706         [enable TLS support in GLX @<:@default=enabled@:>@])],
1707     [GLX_USE_TLS="$enableval"],
1708     [GLX_USE_TLS=yes])
1709 AC_SUBST(GLX_TLS, ${GLX_USE_TLS})
1710
1711 if test "x$GLX_USE_TLS" = xyes; then
1712     DEFINES="$DEFINES -DGLX_USE_TLS"
1713 fi
1714
1715 dnl Read-only text section on x86 hardened platforms
1716 AC_ARG_ENABLE([glx-read-only-text],
1717     [AS_HELP_STRING([--enable-glx-read-only-text],
1718         [Disable writable .text section on x86 (decreases performance) @<:@default=disabled@:>@])],
1719     [enable_glx_read_only_text="$enableval"],
1720     [enable_glx_read_only_text=no])
1721 if test "x$enable_glx_read_only_text" = xyes; then
1722     DEFINES="$DEFINES -DGLX_X86_READONLY_TEXT"
1723 fi
1724
1725 dnl
1726 dnl DEPRECATED: EGL Platforms configuration
1727 dnl
1728 AC_ARG_WITH([egl-platforms],
1729     [AS_HELP_STRING([--with-egl-platforms@<:@=DIRS...@:>@],
1730         [DEPRECATED: use --with-platforms instead@<:@default=auto@:>@])],
1731     [with_egl_platforms="$withval"],
1732     [with_egl_platforms=auto])
1733
1734 if test "x$with_egl_platforms" = xauto; then
1735     with_egl_platforms="x11,surfaceless"
1736     if test "x$enable_gbm" = xyes; then
1737         with_egl_platforms="$with_egl_platforms,drm"
1738     fi
1739 else
1740     AC_MSG_WARN([--with-egl-platforms is deprecated. Use --with-platforms instead.])
1741 fi
1742
1743 dnl
1744 dnl Platforms configuration
1745 dnl
1746 AC_ARG_WITH([platforms],
1747     [AS_HELP_STRING([--with-platforms@<:@=DIRS...@:>@],
1748         [comma delimited native platforms libEGL/Vulkan/other supports, e.g.
1749         "x11,drm,wayland,surfaceless..." @<:@default=auto@:>@])],
1750     [with_platforms="$withval"],
1751     [with_platforms=auto])
1752
1753 # Reuse the autodetection rather than duplicating it.
1754 if test "x$with_platforms" = xauto; then
1755     with_platforms=$with_egl_platforms
1756 fi
1757
1758 PKG_CHECK_MODULES([WAYLAND_SCANNER], [wayland-scanner],
1759         WAYLAND_SCANNER=`$PKG_CONFIG --variable=wayland_scanner wayland-scanner`,
1760         WAYLAND_SCANNER='')
1761 if test "x$WAYLAND_SCANNER" = x; then
1762     AC_PATH_PROG([WAYLAND_SCANNER], [wayland-scanner], [:])
1763 fi
1764
1765 PKG_CHECK_EXISTS([wayland-protocols >= $WAYLAND_PROTOCOLS_REQUIRED], [have_wayland_protocols=yes], [have_wayland_protocols=no])
1766 if test "x$have_wayland_protocols" = xyes; then
1767     ac_wayland_protocols_pkgdatadir=`$PKG_CONFIG --variable=pkgdatadir wayland-protocols`
1768 fi
1769 AC_SUBST(WAYLAND_PROTOCOLS_DATADIR, $ac_wayland_protocols_pkgdatadir)
1770
1771 # Do per platform setups and checks
1772 platforms=`IFS=', '; echo $with_platforms`
1773 for plat in $platforms; do
1774     case "$plat" in
1775     wayland)
1776
1777         PKG_CHECK_MODULES([WAYLAND_CLIENT], [wayland-client >= $WAYLAND_REQUIRED])
1778         PKG_CHECK_MODULES([WAYLAND_SERVER], [wayland-server >= $WAYLAND_REQUIRED])
1779
1780         if test "x$WAYLAND_SCANNER" = "x:"; then
1781                 AC_MSG_ERROR([wayland-scanner is needed to compile the wayland platform])
1782         fi
1783         if test "x$have_wayland_protocols" = xno; then
1784                 AC_MSG_ERROR([wayland-protocols >= $WAYLAND_PROTOCOLS_REQUIRED is needed to compile the wayland platform])
1785         fi
1786         DEFINES="$DEFINES -DHAVE_WAYLAND_PLATFORM -DWL_HIDE_DEPRECATED"
1787         ;;
1788
1789     x11)
1790         PKG_CHECK_MODULES([XCB_DRI2], [x11-xcb xcb xcb-dri2 >= $XCBDRI2_REQUIRED xcb-xfixes])
1791         DEFINES="$DEFINES -DHAVE_X11_PLATFORM"
1792         ;;
1793
1794     drm)
1795         test "x$enable_gbm" = "xno" &&
1796                 AC_MSG_ERROR([EGL platform drm needs gbm])
1797         DEFINES="$DEFINES -DHAVE_DRM_PLATFORM"
1798         ;;
1799
1800     surfaceless)
1801         DEFINES="$DEFINES -DHAVE_SURFACELESS_PLATFORM"
1802         ;;
1803
1804     android)
1805         PKG_CHECK_MODULES([ANDROID], [cutils hardware sync])
1806         DEFINES="$DEFINES -DHAVE_ANDROID_PLATFORM"
1807         ;;
1808
1809     *)
1810         AC_MSG_ERROR([platform '$plat' does not exist])
1811         ;;
1812     esac
1813
1814     case "$plat" in
1815     wayland|drm|surfaceless)
1816         require_libdrm "Platform $plat"
1817         ;;
1818     esac
1819 done
1820
1821 if test "x$enable_glx" != xno; then
1822     if ! echo "$platforms" | grep -q 'x11'; then
1823         AC_MSG_ERROR([Building GLX without the x11 platform is not supported])
1824     fi
1825 fi
1826
1827 if test x"$enable_dri3" = xyes; then
1828     DEFINES="$DEFINES -DHAVE_DRI3"
1829
1830     dri3_modules="x11-xcb xcb >= $XCB_REQUIRED xcb-dri3 xcb-xfixes xcb-present xcb-sync xshmfence >= $XSHMFENCE_REQUIRED"
1831     PKG_CHECK_MODULES([XCB_DRI3], [$dri3_modules])
1832 fi
1833
1834 AM_CONDITIONAL(HAVE_PLATFORM_X11, echo "$platforms" | grep -q 'x11')
1835 AM_CONDITIONAL(HAVE_PLATFORM_WAYLAND, echo "$platforms" | grep -q 'wayland')
1836 AM_CONDITIONAL(HAVE_PLATFORM_DRM, echo "$platforms" | grep -q 'drm')
1837 AM_CONDITIONAL(HAVE_PLATFORM_SURFACELESS, echo "$platforms" | grep -q 'surfaceless')
1838 AM_CONDITIONAL(HAVE_PLATFORM_ANDROID, echo "$platforms" | grep -q 'android')
1839
1840 dnl
1841 dnl More DRI setup
1842 dnl
1843 dnl Directory for DRI drivers
1844 AC_ARG_WITH([dri-driverdir],
1845     [AS_HELP_STRING([--with-dri-driverdir=DIR],
1846         [directory for the DRI drivers @<:@${libdir}/dri@:>@])],
1847     [DRI_DRIVER_INSTALL_DIR="$withval"],
1848     [DRI_DRIVER_INSTALL_DIR='${libdir}/dri'])
1849 AC_SUBST([DRI_DRIVER_INSTALL_DIR])
1850 dnl Extra search path for DRI drivers
1851 AC_ARG_WITH([dri-searchpath],
1852     [AS_HELP_STRING([--with-dri-searchpath=DIRS...],
1853         [semicolon delimited DRI driver search directories @<:@${libdir}/dri@:>@])],
1854     [DRI_DRIVER_SEARCH_DIR="$withval"],
1855     [DRI_DRIVER_SEARCH_DIR='${DRI_DRIVER_INSTALL_DIR}'])
1856 AC_SUBST([DRI_DRIVER_SEARCH_DIR])
1857 dnl Which drivers to build - default is chosen by platform
1858 AC_ARG_WITH([dri-drivers],
1859     [AS_HELP_STRING([--with-dri-drivers@<:@=DIRS...@:>@],
1860         [comma delimited classic DRI drivers list, e.g.
1861         "i915,i965,nouveau,radeon,r200,swrast" @<:@default=auto@:>@])],
1862     [with_dri_drivers="$withval"],
1863     [with_dri_drivers=auto])
1864
1865 if test "x$with_dri_drivers" = xauto; then
1866     if test "x$enable_opengl" = xyes -a "x$enable_dri" = xyes; then
1867         with_dri_drivers="yes"
1868     else
1869         with_dri_drivers="no"
1870     fi
1871 fi
1872 if test "x$with_dri_drivers" = xno; then
1873     with_dri_drivers=''
1874 fi
1875
1876 # Check for expat
1877 PKG_CHECK_MODULES([EXPAT], [expat],,
1878     [PKG_CHECK_MODULES([EXPAT], [expat21])]
1879 )
1880
1881 dnl If $with_dri_drivers is yes, drivers will be added through
1882 dnl platform checks. Set DEFINES and LIB_DEPS
1883 if test "x$enable_dri" = xyes; then
1884     # Platform specific settings and drivers to build
1885     case "$host_os" in
1886     linux*)
1887         case "$host_cpu" in
1888         powerpc* | sparc*)
1889             # Build only the drivers for cards that exist on PowerPC/sparc
1890             if test "x$with_dri_drivers" = "xyes"; then
1891                 with_dri_drivers="r200 radeon swrast"
1892             fi
1893             ;;
1894         esac
1895         ;;
1896     cygwin*)
1897         if test "x$with_dri_drivers" = "xyes"; then
1898             with_dri_drivers="swrast"
1899         fi
1900         ;;
1901     darwin*)
1902         DEFINES="$DEFINES -DBUILDING_MESA"
1903         if test "x$with_dri_drivers" = "xyes"; then
1904             with_dri_drivers="swrast"
1905         fi
1906         ;;
1907     esac
1908
1909     # default drivers
1910     if test "x$with_dri_drivers" = "xyes"; then
1911         with_dri_drivers="i915 i965 nouveau r200 radeon swrast"
1912     fi
1913
1914     # put all the necessary libs together
1915     DRI_LIB_DEPS="$DRI_LIB_DEPS $SELINUX_LIBS $LIBDRM_LIBS $EXPAT_LIBS -lm $PTHREAD_LIBS $DLOPEN_LIBS"
1916 fi
1917
1918 AC_SUBST([DRI_LIB_DEPS])
1919
1920 DRI_DIRS=''
1921 dnl Duplicates in DRI_DIRS are removed by sorting it at the end of this block
1922 if test -n "$with_dri_drivers"; then
1923     if test "x$enable_opengl" != xyes; then
1924         AC_MSG_ERROR([--with-dri-drivers requires OpenGL])
1925     fi
1926
1927     dri_drivers=`IFS=', '; echo $with_dri_drivers`
1928     for driver in $dri_drivers; do
1929         DRI_DIRS="$DRI_DIRS $driver"
1930         case "x$driver" in
1931         xi915)
1932             require_libdrm "i915"
1933             HAVE_I915_DRI=yes
1934             PKG_CHECK_MODULES([I915], [libdrm >= $LIBDRM_INTEL_REQUIRED libdrm_intel >= $LIBDRM_INTEL_REQUIRED])
1935             ;;
1936         xi965)
1937             require_libdrm "i965"
1938             HAVE_I965_DRI=yes
1939             ;;
1940         xnouveau)
1941             require_libdrm "nouveau"
1942             HAVE_NOUVEAU_DRI=yes
1943             PKG_CHECK_MODULES([NVVIEUX], [libdrm >= $LIBDRM_NVVIEUX_REQUIRED libdrm_nouveau >= $LIBDRM_NVVIEUX_REQUIRED])
1944             ;;
1945         xradeon)
1946             require_libdrm "radeon"
1947             HAVE_RADEON_DRI=yes;
1948             PKG_CHECK_MODULES([RADEON], [libdrm >= $LIBDRM_RADEON_REQUIRED libdrm_radeon >= $LIBDRM_RADEON_REQUIRED])
1949             ;;
1950         xr200)
1951             require_libdrm "r200"
1952             HAVE_R200_DRI=yes
1953             PKG_CHECK_MODULES([RADEON], [libdrm >= $LIBDRM_RADEON_REQUIRED libdrm_radeon >= $LIBDRM_RADEON_REQUIRED])
1954             ;;
1955         xswrast)
1956             HAVE_SWRAST_DRI=yes
1957             ;;
1958         *)
1959             AC_MSG_ERROR([classic DRI driver '$driver' does not exist])
1960             ;;
1961         esac
1962     done
1963     DRI_DIRS=`echo $DRI_DIRS|tr " " "\n"|sort -u|tr "\n" " "`
1964 fi
1965
1966
1967 dnl
1968 dnl Gallium LLVM
1969 dnl Deprecated: kept for backwards compatibility
1970 dnl
1971 AC_ARG_ENABLE([gallium-llvm],
1972     [AS_HELP_STRING([--enable-gallium-llvm],
1973         [DEPRECATED: use --enable-llvm instead])],
1974     [enable_gallium_llvm="$enableval"],
1975     [enable_gallium_llvm=auto])
1976
1977 if test "x$enable_gallium_llvm" != xauto; then
1978    AC_MSG_WARN([The --enable-gallium-llvm option has been deprecated. Use --enable-llvm instead.])
1979    enable_llvm=$enable_gallium_llvm
1980 fi
1981
1982 dnl
1983 dnl LLVM
1984 dnl
1985 AC_ARG_ENABLE([llvm],
1986     [AS_HELP_STRING([--enable-llvm],
1987         [build with LLVM support @<:@default=enabled on x86/x86_64@:>@])],
1988     [enable_llvm="$enableval"],
1989     [enable_llvm=auto])
1990
1991 if test "x$enable_llvm" = xauto -a "x$FOUND_LLVM" = xyes; then
1992     if test "x$FOUND_LLVM" = xyes; then
1993         case "$host_cpu" in
1994         i*86|x86_64|amd64) enable_llvm=yes;;
1995         *) enable_llvm=no;;
1996         esac
1997     else
1998         enable_llvm=no
1999     fi
2000 fi
2001
2002 if test "x$enable_llvm" = xyes -a "x$FOUND_LLVM" = xno; then
2003     AC_MSG_ERROR([--enable-llvm selected but llvm-config is not found])
2004 fi
2005
2006 #
2007 # Vulkan driver configuration
2008 #
2009
2010 AC_ARG_WITH([vulkan-drivers],
2011     [AS_HELP_STRING([--with-vulkan-drivers@<:@=DIRS...@:>@],
2012         [comma delimited Vulkan drivers list, e.g.
2013         "intel,radeon"
2014         @<:@default=no@:>@])],
2015     [with_vulkan_drivers="$withval"],
2016     [with_vulkan_drivers="no"])
2017
2018 # Doing '--without-vulkan-drivers' will set this variable to 'no'.  Clear it
2019 # here so that the script doesn't choke on an unknown driver name later.
2020 case "x$with_vulkan_drivers" in
2021     xyes) with_vulkan_drivers="$VULKAN_DRIVERS_DEFAULT" ;;
2022     xno) with_vulkan_drivers='' ;;
2023 esac
2024
2025 AC_ARG_WITH([vulkan-icddir],
2026     [AS_HELP_STRING([--with-vulkan-icddir=DIR],
2027         [directory for the Vulkan driver icd files @<:@${datarootdir}/vulkan/icd.d@:>@])],
2028     [VULKAN_ICD_INSTALL_DIR="$withval"],
2029     [VULKAN_ICD_INSTALL_DIR='${datarootdir}/vulkan/icd.d'])
2030 AC_SUBST([VULKAN_ICD_INSTALL_DIR])
2031
2032 require_x11_dri3() {
2033     if echo "$platforms" | grep -q 'x11'; then
2034         if test "x$enable_dri3" != xyes; then
2035             AC_MSG_ERROR([$1 Vulkan driver requires DRI3 when built with X11])
2036         fi
2037     fi
2038 }
2039
2040 if test -n "$with_vulkan_drivers"; then
2041     if test "x$ac_cv_func_dl_iterate_phdr" = xno; then
2042         AC_MSG_ERROR([Vulkan drivers require the dl_iterate_phdr function])
2043     fi
2044
2045     VULKAN_DRIVERS=`IFS=', '; echo $with_vulkan_drivers`
2046     for driver in $VULKAN_DRIVERS; do
2047         case "x$driver" in
2048         xintel)
2049             require_libdrm "ANV"
2050             require_x11_dri3 "ANV"
2051             HAVE_INTEL_VULKAN=yes
2052             ;;
2053         xradeon)
2054             require_libdrm "radv"
2055             PKG_CHECK_MODULES([AMDGPU], [libdrm >= $LIBDRM_AMDGPU_REQUIRED libdrm_amdgpu >= $LIBDRM_AMDGPU_REQUIRED])
2056             radeon_llvm_check $LLVM_REQUIRED_RADV "radv"
2057             require_x11_dri3 "radv"
2058             HAVE_RADEON_VULKAN=yes
2059             ;;
2060         *)
2061             AC_MSG_ERROR([Vulkan driver '$driver' does not exist])
2062             ;;
2063         esac
2064     done
2065     VULKAN_DRIVERS=`echo $VULKAN_DRIVERS|tr " " "\n"|sort -u|tr "\n" " "`
2066 fi
2067
2068
2069 DEFINES="$DEFINES -DENABLE_SHADER_CACHE"
2070 AM_CONDITIONAL(NEED_MEGADRIVER, test -n "$DRI_DIRS")
2071 AM_CONDITIONAL(NEED_LIBMESA, test "x$enable_glx" = xxlib -o \
2072                                   "x$enable_osmesa" = xyes -o \
2073                                   -n "$DRI_DIRS")
2074
2075 dnl
2076 dnl OSMesa configuration
2077 dnl
2078
2079 dnl Configure the channel bits for OSMesa (libOSMesa, libOSMesa16, ...)
2080 AC_ARG_WITH([osmesa-bits],
2081     [AS_HELP_STRING([--with-osmesa-bits=BITS],
2082         [OSMesa channel bits and library name: 8, 16, 32 @<:@default=8@:>@])],
2083     [osmesa_bits="$withval"],
2084     [osmesa_bits=8])
2085 if test "x$osmesa_bits" != x8; then
2086     if test "x$enable_dri" = xyes -o "x$enable_glx" != xno; then
2087         AC_MSG_WARN([Ignoring OSMesa channel bits because of non-OSMesa driver])
2088         osmesa_bits=8
2089     fi
2090 fi
2091 case "x$osmesa_bits" in
2092 x8)
2093     OSMESA_LIB="${OSMESA_LIB}"
2094     ;;
2095 x16|x32)
2096     OSMESA_LIB="${OSMESA_LIB}$osmesa_bits"
2097     DEFINES="$DEFINES -DCHAN_BITS=$osmesa_bits -DDEFAULT_SOFTWARE_DEPTH_BITS=31"
2098     ;;
2099 *)
2100     AC_MSG_ERROR([OSMesa bits '$osmesa_bits' is not a valid option])
2101     ;;
2102 esac
2103
2104 if test "x$enable_osmesa" = xyes -o "x$enable_gallium_osmesa" = xyes; then
2105     # only link libraries with osmesa if shared
2106     if test "$enable_static" = no; then
2107         OSMESA_LIB_DEPS="-lm $PTHREAD_LIBS $SELINUX_LIBS $DLOPEN_LIBS"
2108     else
2109         OSMESA_LIB_DEPS=""
2110     fi
2111     OSMESA_PC_LIB_PRIV="-lm $PTHREAD_LIBS $SELINUX_LIBS $DLOPEN_LIBS"
2112 fi
2113
2114 AC_SUBST([OSMESA_LIB_DEPS])
2115 AC_SUBST([OSMESA_PC_REQ])
2116 AC_SUBST([OSMESA_PC_LIB_PRIV])
2117
2118 dnl
2119 dnl gbm configuration
2120 dnl
2121 if test "x$enable_gbm" = xyes; then
2122     require_dri_shared_libs_and_glapi "gbm"
2123 fi
2124 AM_CONDITIONAL(HAVE_GBM, test "x$enable_gbm" = xyes)
2125 # FINISHME: GBM has a number of dependencies which we should add below
2126 GBM_PC_REQ_PRIV=""
2127 GBM_PC_LIB_PRIV="$DLOPEN_LIBS"
2128 AC_SUBST([GBM_PC_REQ_PRIV])
2129 AC_SUBST([GBM_PC_LIB_PRIV])
2130
2131 dnl
2132 dnl EGL configuration
2133 dnl
2134
2135 if test "x$enable_egl" = xyes; then
2136     EGL_LIB_DEPS="$DLOPEN_LIBS $SELINUX_LIBS $PTHREAD_LIBS"
2137
2138     AC_CHECK_FUNC(mincore, [DEFINES="$DEFINES -DHAVE_MINCORE"])
2139
2140     require_dri_shared_libs_and_glapi "egl"
2141 fi
2142 AM_CONDITIONAL(HAVE_EGL, test "x$enable_egl" = xyes)
2143 AC_SUBST([EGL_LIB_DEPS])
2144
2145 gallium_st="mesa"
2146
2147 dnl
2148 dnl XA configuration
2149 dnl
2150 if test "x$enable_xa" = xyes; then
2151     if test "x$with_gallium_drivers" = xswrast; then
2152        AC_MSG_ERROR([
2153           Building xa requires at least one non swrast gallium driver.
2154           If you are looking to use libxatracker.so with the VMware driver,
2155           make sure to include svga in the gallium drivers list, apart from
2156           enabling XA.
2157           Example: ./configure --enable-xa --with-gallium-drivers=svga...])
2158     fi
2159     gallium_st="$gallium_st xa"
2160 fi
2161 AM_CONDITIONAL(HAVE_ST_XA, test "x$enable_xa" = xyes)
2162
2163 if echo $platforms | grep -q "x11"; then
2164     have_xvmc_platform=yes
2165 else
2166     have_xvmc_platform=no
2167 fi
2168
2169 if echo $platforms | grep -q "x11"; then
2170     have_vdpau_platform=yes
2171 else
2172     have_vdpau_platform=no
2173 fi
2174
2175 if echo $platforms | grep -q "x11\|drm"; then
2176     have_omx_platform=yes
2177 else
2178     have_omx_platform=no
2179 fi
2180
2181 if echo $platforms | grep -q "x11\|drm\|wayland"; then
2182     have_va_platform=yes
2183 else
2184     have_va_platform=no
2185 fi
2186
2187 dnl
2188 dnl Gallium G3DVL configuration
2189 dnl
2190 if test -n "$with_gallium_drivers" -a "x$with_gallium_drivers" != xswrast; then
2191     if test "x$enable_xvmc" = xauto -a "x$have_xvmc_platform" = xyes; then
2192         PKG_CHECK_EXISTS([xvmc >= $XVMC_REQUIRED], [enable_xvmc=yes], [enable_xvmc=no])
2193     fi
2194
2195     if test "x$enable_vdpau" = xauto -a "x$have_vdpau_platform" = xyes; then
2196         PKG_CHECK_EXISTS([vdpau >= $VDPAU_REQUIRED], [enable_vdpau=yes], [enable_vdpau=no])
2197     fi
2198
2199     if test "x$enable_omx_bellagio" = xauto -a "x$have_omx_platform" = xyes; then
2200         PKG_CHECK_EXISTS([libomxil-bellagio >= $LIBOMXIL_BELLAGIO_REQUIRED], [enable_omx_bellagio=yes], [enable_omx_bellagio=no])
2201     fi
2202
2203     if test "x$enable_va" = xauto -a "x$have_va_platform" = xyes; then
2204         PKG_CHECK_EXISTS([libva >= $LIBVA_REQUIRED], [enable_va=yes], [enable_va=no])
2205     fi
2206 fi
2207
2208 if test "x$enable_dri" = xyes -o \
2209         "x$enable_xvmc" = xyes -o \
2210         "x$enable_vdpau" = xyes -o \
2211         "x$enable_omx_bellagio" = xyes -o \
2212         "x$enable_va" = xyes; then
2213     need_gallium_vl=yes
2214 fi
2215 AM_CONDITIONAL(NEED_GALLIUM_VL, test "x$need_gallium_vl" = xyes)
2216
2217 if test "x$enable_xvmc" = xyes -o \
2218         "x$enable_vdpau" = xyes -o \
2219         "x$enable_omx_bellagio" = xyes -o \
2220         "x$enable_va" = xyes; then
2221     if echo $platforms | grep -q "x11"; then
2222         PKG_CHECK_MODULES([VL], [x11-xcb xcb xcb-dri2 >= $XCBDRI2_REQUIRED])
2223     fi
2224     need_gallium_vl_winsys=yes
2225 fi
2226 AM_CONDITIONAL(NEED_GALLIUM_VL_WINSYS, test "x$need_gallium_vl_winsys" = xyes)
2227
2228 if test "x$enable_xvmc" = xyes; then
2229     if test "x$have_xvmc_platform" != xyes; then
2230         AC_MSG_ERROR([XVMC requires the x11 platforms])
2231     fi
2232     PKG_CHECK_MODULES([XVMC], [xvmc >= $XVMC_REQUIRED])
2233     gallium_st="$gallium_st xvmc"
2234 fi
2235 AM_CONDITIONAL(HAVE_ST_XVMC, test "x$enable_xvmc" = xyes)
2236
2237 if test "x$enable_vdpau" = xyes; then
2238     if test "x$have_vdpau_platform" != xyes; then
2239         AC_MSG_ERROR([VDPAU requires the x11 platforms])
2240     fi
2241     PKG_CHECK_MODULES([VDPAU], [vdpau >= $VDPAU_REQUIRED])
2242     gallium_st="$gallium_st vdpau"
2243     DEFINES="$DEFINES -DHAVE_ST_VDPAU"
2244 fi
2245 AM_CONDITIONAL(HAVE_ST_VDPAU, test "x$enable_vdpau" = xyes)
2246
2247 if test "x$enable_omx_bellagio" = xyes; then
2248     if test "x$have_omx_platform" != xyes; then
2249         AC_MSG_ERROR([OMX requires at least one of the x11 or drm platforms])
2250     fi
2251     PKG_CHECK_MODULES([OMX_BELLAGIO], [libomxil-bellagio >= $LIBOMXIL_BELLAGIO_REQUIRED])
2252     gallium_st="$gallium_st omx_bellagio"
2253 fi
2254 AM_CONDITIONAL(HAVE_ST_OMX_BELLAGIO, test "x$enable_omx_bellagio" = xyes)
2255
2256 if test "x$enable_va" = xyes; then
2257     if test "x$have_va_platform" != xyes; then
2258         AC_MSG_ERROR([VA requires at least one of the x11 drm or wayland platforms])
2259     fi
2260     PKG_CHECK_MODULES([VA], [libva >= $LIBVA_REQUIRED])
2261     gallium_st="$gallium_st va"
2262 fi
2263 AM_CONDITIONAL(HAVE_ST_VA, test "x$enable_va" = xyes)
2264
2265 dnl
2266 dnl Nine Direct3D9 configuration
2267 dnl
2268 if test "x$enable_nine" = xyes; then
2269     if ! echo "$with_gallium_drivers" | grep -q 'swrast'; then
2270         AC_MSG_ERROR([nine requires the gallium swrast driver])
2271     fi
2272     if test "x$with_gallium_drivers" = xswrast; then
2273         AC_MSG_ERROR([nine requires at least one non-swrast gallium driver])
2274     fi
2275     if test $GCC_VERSION_MAJOR -lt 4 -o $GCC_VERSION_MAJOR -eq 4 -a $GCC_VERSION_MINOR -lt 6; then
2276         AC_MSG_ERROR([gcc >= 4.6 is required to build nine])
2277     fi
2278
2279     if test "x$enable_dri3" = xno; then
2280         AC_MSG_WARN([using nine together with wine requires DRI3 enabled system])
2281     fi
2282
2283     gallium_st="$gallium_st nine"
2284 fi
2285 AM_CONDITIONAL(HAVE_ST_NINE, test "x$enable_nine" = xyes)
2286
2287 dnl
2288 dnl OpenCL configuration
2289 dnl
2290
2291 AC_ARG_WITH([clang-libdir],
2292    [AS_HELP_STRING([--with-clang-libdir],
2293          [Path to Clang libraries @<:@default=llvm-config --libdir@:>@])],
2294    [CLANG_LIBDIR="$withval"],
2295    [CLANG_LIBDIR=''])
2296
2297 PKG_CHECK_EXISTS([libclc], [have_libclc=yes], [have_libclc=no])
2298
2299 if test "x$enable_opencl" = xyes; then
2300     if test -z "$with_gallium_drivers"; then
2301         AC_MSG_ERROR([cannot enable OpenCL without Gallium])
2302     fi
2303
2304     if test "x$HAVE_CXX11" != "xyes"; then
2305        AC_MSG_ERROR([clover requires c++11 support])
2306     fi
2307
2308     if test "x$have_libclc" = xno; then
2309         AC_MSG_ERROR([pkg-config cannot find libclc.pc which is required to build clover.
2310                     Make sure the directory containing libclc.pc is specified in your
2311                     PKG_CONFIG_PATH environment variable.
2312                     By default libclc.pc is installed to /usr/local/share/pkgconfig/])
2313     else
2314         LIBCLC_INCLUDEDIR=`$PKG_CONFIG --variable=includedir libclc`
2315         LIBCLC_LIBEXECDIR=`$PKG_CONFIG --variable=libexecdir libclc`
2316         AC_SUBST([LIBCLC_INCLUDEDIR])
2317         AC_SUBST([LIBCLC_LIBEXECDIR])
2318     fi
2319
2320     gallium_st="$gallium_st clover"
2321
2322     if test "x$enable_opencl_icd" = xyes; then
2323         OPENCL_LIBNAME="MesaOpenCL"
2324     else
2325         OPENCL_LIBNAME="OpenCL"
2326     fi
2327
2328     if test "x$have_libelf" != xyes; then
2329        AC_MSG_ERROR([Clover requires libelf])
2330     fi
2331
2332     if test "x${ac_cv_cxx_compiler_gnu}" = xyes; then
2333         altivec_enabled=no
2334         AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2335         #if !defined(__VEC__) || !defined(__ALTIVEC__)
2336         #error "AltiVec not enabled"
2337         #endif
2338         ])], altivec_enabled=yes)
2339
2340         if test "$altivec_enabled" = yes; then
2341             CLOVER_STD_OVERRIDE="-std=gnu++11"
2342         fi
2343         AC_SUBST([CLOVER_STD_OVERRIDE])
2344     fi
2345
2346     llvm_require_version $LLVM_REQUIRED_OPENCL "opencl"
2347
2348     llvm_add_default_components "opencl"
2349     llvm_add_component "all-targets" "opencl"
2350     llvm_add_component "coverage" "opencl"
2351     llvm_add_component "linker" "opencl"
2352     llvm_add_component "instrumentation" "opencl"
2353     llvm_add_component "ipo" "opencl"
2354     llvm_add_component "irreader" "opencl"
2355     llvm_add_component "lto" "opencl"
2356     llvm_add_component "option" "opencl"
2357     llvm_add_component "objcarcopts" "opencl"
2358     llvm_add_component "profiledata" "opencl"
2359     llvm_add_optional_component "coroutines" "opencl"
2360
2361     dnl Check for Clang internal headers
2362     if test -z "$CLANG_LIBDIR"; then
2363         CLANG_LIBDIR=${LLVM_LIBDIR}
2364     fi
2365     CLANG_RESOURCE_DIR=$CLANG_LIBDIR/clang/${LLVM_VERSION}
2366     AS_IF([test ! -f "$CLANG_RESOURCE_DIR/include/stddef.h"],
2367         [AC_MSG_ERROR([Could not find clang internal header stddef.h in $CLANG_RESOURCE_DIR Use --with-clang-libdir to specify the correct path to the clang libraries.])])
2368 fi
2369 AM_CONDITIONAL(HAVE_CLOVER, test "x$enable_opencl" = xyes)
2370 AM_CONDITIONAL(HAVE_CLOVER_ICD, test "x$enable_opencl_icd" = xyes)
2371 AC_SUBST([OPENCL_LIBNAME])
2372 AC_SUBST([CLANG_RESOURCE_DIR])
2373
2374 dnl
2375 dnl Gallium configuration
2376 dnl
2377 AM_CONDITIONAL(HAVE_GALLIUM, test -n "$with_gallium_drivers")
2378
2379 # libEGL wants to default to the first platform specified in
2380 # ./configure.  parse that here.
2381 if test "x$platforms" != "x"; then
2382     FIRST_PLATFORM_CAPS=`echo $platforms | sed 's| .*||' | tr '[[a-z]]' '[[A-Z]]'`
2383     EGL_NATIVE_PLATFORM="_EGL_PLATFORM_$FIRST_PLATFORM_CAPS"
2384 else
2385     EGL_NATIVE_PLATFORM="_EGL_INVALID_PLATFORM"
2386 fi
2387
2388 AC_SUBST([EGL_NATIVE_PLATFORM])
2389 AC_SUBST([EGL_CFLAGS])
2390
2391 # If we don't have the X11 platform, set this define so we don't try to include
2392 # the X11 headers.
2393 if ! echo "$platforms" | grep -q 'x11'; then
2394     DEFINES="$DEFINES -DMESA_EGL_NO_X11_HEADERS"
2395     GL_PC_CFLAGS="$GL_PC_CFLAGS -DMESA_EGL_NO_X11_HEADERS"
2396 fi
2397
2398 dnl Directory for XVMC libs
2399 AC_ARG_WITH([xvmc-libdir],
2400     [AS_HELP_STRING([--with-xvmc-libdir=DIR],
2401         [directory for the XVMC libraries @<:@default=${libdir}@:>@])],
2402     [XVMC_LIB_INSTALL_DIR="$withval"],
2403     [XVMC_LIB_INSTALL_DIR='${libdir}'])
2404 AC_SUBST([XVMC_LIB_INSTALL_DIR])
2405
2406 dnl
2407 dnl Gallium Tests
2408 dnl
2409 AM_CONDITIONAL(HAVE_GALLIUM_TESTS, test "x$enable_gallium_tests" = xyes)
2410
2411 dnl Directory for VDPAU libs
2412 AC_ARG_WITH([vdpau-libdir],
2413     [AS_HELP_STRING([--with-vdpau-libdir=DIR],
2414         [directory for the VDPAU libraries @<:@default=${libdir}/vdpau@:>@])],
2415     [VDPAU_LIB_INSTALL_DIR="$withval"],
2416     [VDPAU_LIB_INSTALL_DIR='${libdir}/vdpau'])
2417 AC_SUBST([VDPAU_LIB_INSTALL_DIR])
2418
2419 dnl Directory for OMX_BELLAGIO libs
2420
2421 AC_ARG_WITH([omx-bellagio-libdir],
2422     [AS_HELP_STRING([--with-omx-bellagio-libdir=DIR],
2423         [directory for the OMX_BELLAGIO libraries])],
2424     [OMX_BELLAGIO_LIB_INSTALL_DIR="$withval"],
2425     [OMX_BELLAGIO_LIB_INSTALL_DIR=`$PKG_CONFIG --exists libomxil-bellagio && \
2426                                    $PKG_CONFIG --define-variable=libdir=\$libdir --variable=pluginsdir libomxil-bellagio`])
2427 AC_SUBST([OMX_BELLAGIO_LIB_INSTALL_DIR])
2428
2429 dnl Directory for VA libs
2430
2431 AC_ARG_WITH([va-libdir],
2432     [AS_HELP_STRING([--with-va-libdir=DIR],
2433         [directory for the VA libraries @<:@${libdir}/dri@:>@])],
2434     [VA_LIB_INSTALL_DIR="$withval"],
2435     [VA_LIB_INSTALL_DIR="${libdir}/dri"])
2436 AC_SUBST([VA_LIB_INSTALL_DIR])
2437
2438 AC_ARG_WITH([d3d-libdir],
2439     [AS_HELP_STRING([--with-d3d-libdir=DIR],
2440         [directory for the D3D modules @<:@${libdir}/d3d@:>@])],
2441     [D3D_DRIVER_INSTALL_DIR="$withval"],
2442     [D3D_DRIVER_INSTALL_DIR="${libdir}/d3d"])
2443 AC_SUBST([D3D_DRIVER_INSTALL_DIR])
2444
2445 dnl Architectures to build SWR library for
2446
2447 AC_ARG_WITH([swr-archs],
2448     [AS_HELP_STRING([--with-swr-archs@<:@=DIRS...@:>@],
2449         [comma delimited swr architectures list, e.g.
2450         "avx,avx2,knl,skx" @<:@default="avx,avx2"@:>@])],
2451     [with_swr_archs="$withval"],
2452     [with_swr_archs="avx,avx2"])
2453
2454 dnl
2455 dnl r300 doesn't strictly require LLVM, but for performance reasons we
2456 dnl highly recommend LLVM usage. So require it at least on x86 and x86_64
2457 dnl architectures.
2458 dnl
2459 r300_require_llvm() {
2460     case "$host" in *gnux32) return;; esac
2461     case "$host_cpu" in
2462     i*86|x86_64|amd64) require_llvm $1
2463         ;;
2464     esac
2465 }
2466
2467 dnl
2468 dnl DRM is needed by X, Wayland, and offscreen rendering.
2469 dnl Surfaceless is an alternative for the last one.
2470 dnl
2471 require_basic_egl() {
2472     case "$with_platforms" in
2473         *drm*|*surfaceless*|*android*)
2474             ;;
2475         *)
2476             AC_MSG_ERROR([$1 requires one of these:
2477                   1) --with-platforms=drm (X, Wayland, offscreen rendering based on DRM)
2478                   2) --with-platforms=surfaceless (offscreen only)
2479                   3) --with-platforms=android (Android only)
2480                   Recommended options: drm,x11])
2481             ;;
2482     esac
2483 }
2484
2485 swr_require_cxx_feature_flags() {
2486     feature_name="$1"
2487     preprocessor_test="$2"
2488     option_list="$3"
2489     output_var="$4"
2490
2491     AC_MSG_CHECKING([whether $CXX supports $feature_name])
2492     AC_LANG_PUSH([C++])
2493     save_CXXFLAGS="$CXXFLAGS"
2494     save_IFS="$IFS"
2495     IFS=","
2496     found=0
2497     for opts in $option_list
2498     do
2499         unset IFS
2500         CXXFLAGS="$opts $save_CXXFLAGS"
2501         AC_COMPILE_IFELSE(
2502             [AC_LANG_PROGRAM(
2503                 [   #if !($preprocessor_test)
2504                     #error
2505                     #endif
2506                 ])],
2507             [found=1; break],
2508             [])
2509         IFS=","
2510     done
2511     IFS="$save_IFS"
2512     CXXFLAGS="$save_CXXFLAGS"
2513     AC_LANG_POP([C++])
2514     if test $found -eq 1; then
2515         AC_MSG_RESULT([$opts])
2516         eval "$output_var=\$opts"
2517         return 0
2518     fi
2519     AC_MSG_RESULT([no])
2520     AC_MSG_ERROR([swr requires $feature_name support])
2521     return 1
2522 }
2523
2524 dnl Duplicates in GALLIUM_DRIVERS_DIRS are removed by sorting it after this block
2525 if test -n "$with_gallium_drivers"; then
2526     gallium_drivers=`IFS=', '; echo $with_gallium_drivers`
2527     for driver in $gallium_drivers; do
2528         case "x$driver" in
2529         xsvga)
2530             HAVE_GALLIUM_SVGA=yes
2531             require_libdrm "svga"
2532             ;;
2533         xi915)
2534             HAVE_GALLIUM_I915=yes
2535             PKG_CHECK_MODULES([I915], [libdrm >= $LIBDRM_INTEL_REQUIRED libdrm_intel >= $LIBDRM_INTEL_REQUIRED])
2536             require_libdrm "Gallium i915"
2537             ;;
2538         xr300)
2539             HAVE_GALLIUM_R300=yes
2540             PKG_CHECK_MODULES([RADEON], [libdrm >= $LIBDRM_RADEON_REQUIRED libdrm_radeon >= $LIBDRM_RADEON_REQUIRED])
2541             require_libdrm "r300"
2542             r300_require_llvm "r300"
2543             ;;
2544         xr600)
2545             HAVE_GALLIUM_R600=yes
2546             PKG_CHECK_MODULES([RADEON], [libdrm >= $LIBDRM_RADEON_REQUIRED libdrm_radeon >= $LIBDRM_RADEON_REQUIRED])
2547             require_libdrm "r600"
2548             if test "x$enable_llvm" = xyes; then
2549                 radeon_llvm_check $LLVM_REQUIRED_R600 "r600"
2550
2551                 llvm_add_component "asmparser" "r600"
2552                 llvm_add_component "bitreader" "r600"
2553             fi
2554             ;;
2555         xradeonsi)
2556             HAVE_GALLIUM_RADEONSI=yes
2557             PKG_CHECK_MODULES([RADEON], [libdrm >= $LIBDRM_RADEON_REQUIRED libdrm_radeon >= $LIBDRM_RADEON_REQUIRED])
2558             PKG_CHECK_MODULES([AMDGPU], [libdrm >= $LIBDRM_AMDGPU_REQUIRED libdrm_amdgpu >= $LIBDRM_AMDGPU_REQUIRED])
2559             require_libdrm "radeonsi"
2560             radeon_llvm_check $LLVM_REQUIRED_RADEONSI "radeonsi"
2561             if test "x$enable_egl" = xyes; then
2562                 require_basic_egl "radeonsi"
2563             fi
2564             ;;
2565         xnouveau)
2566             HAVE_GALLIUM_NOUVEAU=yes
2567             PKG_CHECK_MODULES([NOUVEAU], [libdrm >= $LIBDRM_NOUVEAU_REQUIRED libdrm_nouveau >= $LIBDRM_NOUVEAU_REQUIRED])
2568             require_libdrm "nouveau"
2569             ;;
2570         xfreedreno)
2571             HAVE_GALLIUM_FREEDRENO=yes
2572             PKG_CHECK_MODULES([FREEDRENO], [libdrm >= $LIBDRM_FREEDRENO_REQUIRED libdrm_freedreno >= $LIBDRM_FREEDRENO_REQUIRED])
2573             require_libdrm "freedreno"
2574             ;;
2575         xetnaviv)
2576             HAVE_GALLIUM_ETNAVIV=yes
2577             PKG_CHECK_MODULES([ETNAVIV], [libdrm >= $LIBDRM_ETNAVIV_REQUIRED libdrm_etnaviv >= $LIBDRM_ETNAVIV_REQUIRED])
2578             require_libdrm "etnaviv"
2579             ;;
2580        ximx)
2581             HAVE_GALLIUM_IMX=yes
2582             ;;
2583         xswrast)
2584             HAVE_GALLIUM_SOFTPIPE=yes
2585             if test "x$enable_llvm" = xyes; then
2586                 HAVE_GALLIUM_LLVMPIPE=yes
2587             fi
2588             ;;
2589         xswr)
2590             llvm_require_version $LLVM_REQUIRED_SWR "swr"
2591
2592             if test "x$HAVE_CXX11" != "xyes"; then
2593                 AC_MSG_ERROR([swr requires c++11 support])
2594             fi
2595
2596             swr_require_cxx_feature_flags "AVX" "defined(__AVX__)" \
2597                 ",-target-cpu=sandybridge,-mavx,-march=core-avx,-tp=sandybridge" \
2598                 SWR_AVX_CXXFLAGS
2599             AC_SUBST([SWR_AVX_CXXFLAGS])
2600
2601             swr_archs=`IFS=', '; echo $with_swr_archs`
2602             for arch in $swr_archs; do
2603                 case "x$arch" in
2604                 xavx)
2605                     HAVE_SWR_AVX=yes
2606                     ;;
2607                 xavx2)
2608                     swr_require_cxx_feature_flags "AVX2" "defined(__AVX2__)" \
2609                         ",-target-cpu=haswell,-mavx2 -mfma -mbmi2 -mf16c,-march=core-avx2,-tp=haswell" \
2610                         SWR_AVX2_CXXFLAGS
2611                     AC_SUBST([SWR_AVX2_CXXFLAGS])
2612                     HAVE_SWR_AVX2=yes
2613                     ;;
2614                 xknl)
2615                     swr_require_cxx_feature_flags "KNL" "defined(__AVX512F__) && defined(__AVX512ER__)" \
2616                         ",-target-cpu=mic-knl,-march=knl,-xMIC-AVX512" \
2617                         SWR_KNL_CXXFLAGS
2618                     AC_SUBST([SWR_KNL_CXXFLAGS])
2619                     HAVE_SWR_KNL=yes
2620                     ;;
2621                 xskx)
2622                     swr_require_cxx_feature_flags "SKX" "defined(__AVX512F__) && defined(__AVX512BW__)" \
2623                         ",-target-cpu=x86-skylake,-march=skylake-avx512,-xCORE-AVX512" \
2624                         SWR_SKX_CXXFLAGS
2625                     AC_SUBST([SWR_SKX_CXXFLAGS])
2626                     HAVE_SWR_SKX=yes
2627                     ;;
2628                 *)
2629                     AC_MSG_ERROR([unknown SWR build architecture '$arch'])
2630                     ;;
2631                 esac
2632             done
2633
2634             if test "x$HAVE_SWR_AVX" != xyes -a \
2635                     "x$HAVE_SWR_AVX2" != xyes -a \
2636                     "x$HAVE_SWR_KNL" != xyes -a \
2637                     "x$HAVE_SWR_SKX" != xyes; then
2638                AC_MSG_ERROR([swr enabled but no swr architectures selected])
2639             fi
2640
2641             HAVE_GALLIUM_SWR=yes
2642             ;;
2643         xvc4)
2644             HAVE_GALLIUM_VC4=yes
2645             require_libdrm "vc4"
2646
2647             PKG_CHECK_MODULES([SIMPENROSE], [simpenrose],
2648                               [USE_VC4_SIMULATOR=yes;
2649                                DEFINES="$DEFINES -DUSE_VC4_SIMULATOR"],
2650                               [USE_VC4_SIMULATOR=no])
2651             ;;
2652         xvc5)
2653             HAVE_GALLIUM_VC5=yes
2654
2655             PKG_CHECK_MODULES([VC5_SIMULATOR], [v3dv3],
2656                               [USE_VC5_SIMULATOR=yes;
2657                                DEFINES="$DEFINES -DUSE_VC5_SIMULATOR"],
2658                               [AC_MSG_ERROR([vc5 requires the simulator])])
2659             ;;
2660         xpl111)
2661             HAVE_GALLIUM_PL111=yes
2662             ;;
2663         xvirgl)
2664             HAVE_GALLIUM_VIRGL=yes
2665             require_libdrm "virgl"
2666             if test "x$enable_egl" = xyes; then
2667                 require_basic_egl "virgl"
2668             fi
2669             ;;
2670         *)
2671             AC_MSG_ERROR([Unknown Gallium driver: $driver])
2672             ;;
2673         esac
2674     done
2675 fi
2676
2677 # XXX: Keep in sync with LLVM_REQUIRED_SWR
2678 AM_CONDITIONAL(SWR_INVALID_LLVM_VERSION, test "x$LLVM_VERSION" != x3.9.0 -a \
2679                                               "x$LLVM_VERSION" != x3.9.1)
2680
2681 if test "x$enable_llvm" = "xyes" -a "$with_gallium_drivers"; then
2682     llvm_require_version $LLVM_REQUIRED_GALLIUM "gallium"
2683     llvm_add_default_components "gallium"
2684 fi
2685
2686 AM_CONDITIONAL(HAVE_SWR_AVX, test "x$HAVE_SWR_AVX" = xyes)
2687 AM_CONDITIONAL(HAVE_SWR_AVX2, test "x$HAVE_SWR_AVX2" = xyes)
2688 AM_CONDITIONAL(HAVE_SWR_KNL, test "x$HAVE_SWR_KNL" = xyes)
2689 AM_CONDITIONAL(HAVE_SWR_SKX, test "x$HAVE_SWR_SKX" = xyes)
2690
2691 dnl We need to validate some needed dependencies for renderonly drivers.
2692
2693 if test "x$HAVE_GALLIUM_ETNAVIV" != xyes -a "x$HAVE_GALLIUM_IMX" = xyes  ; then
2694     AC_MSG_ERROR([Building with imx requires etnaviv])
2695 fi
2696
2697 if test "x$HAVE_GALLIUM_VC4" != xyes -a "x$HAVE_GALLIUM_PL111" = xyes  ; then
2698     AC_MSG_ERROR([Building with pl111 requires vc4])
2699 fi
2700
2701
2702 detect_old_buggy_llvm() {
2703     dnl llvm-config may not give the right answer when llvm is a built as a
2704     dnl single shared library, so we must work the library name out for
2705     dnl ourselves.
2706     dnl (See https://llvm.org/bugs/show_bug.cgi?id=6823)
2707     dnl We can't use $LLVM_VERSION because it has 'svn' stripped out,
2708     LLVM_SO_NAME=LLVM-`$LLVM_CONFIG --version`
2709     AS_IF([test -f "$LLVM_LIBDIR/lib$LLVM_SO_NAME.$IMP_LIB_EXT"], [llvm_have_one_so=yes])
2710
2711     if test "x$llvm_have_one_so" = xyes; then
2712         dnl LLVM was built using auto*, so there is only one shared object.
2713         LLVM_LIBS="-l$LLVM_SO_NAME"
2714     else
2715         dnl If LLVM was built with CMake, there will be one shared object per
2716         dnl component.
2717         AS_IF([test ! -f "$LLVM_LIBDIR/libLLVMTarget.$IMP_LIB_EXT"],
2718                [AC_MSG_ERROR([Could not find llvm shared libraries:
2719                 Please make sure you have built llvm with the --enable-shared option
2720                 and that your llvm libraries are installed in $LLVM_LIBDIR
2721                 If you have installed your llvm libraries to a different directory you
2722                 can use the --with-llvm-prefix= configure flag to specify this directory.
2723                 NOTE: Mesa is attempting to use llvm shared libraries by default.
2724                 If you do not want to build with llvm shared libraries and instead want to
2725                 use llvm static libraries then add --disable-llvm-shared-libs to your configure
2726                 invocation and rebuild.])])
2727
2728         dnl We don't need to update LLVM_LIBS in this case because the LLVM
2729         dnl install uses a shared object for each component and we have
2730         dnl already added all of these objects to LLVM_LIBS.
2731     fi
2732 }
2733
2734 dnl
2735 dnl Set defines and buildtime variables only when using LLVM.
2736 dnl
2737 if test "x$enable_llvm" = xyes; then
2738     DEFINES="${DEFINES} -DHAVE_LLVM=0x0$LLVM_VERSION_INT -DMESA_LLVM_VERSION_PATCH=$LLVM_VERSION_PATCH"
2739
2740     LLVM_LDFLAGS=`$LLVM_CONFIG --ldflags`
2741     LLVM_CFLAGS=$LLVM_CPPFLAGS   # CPPFLAGS seem to be sufficient
2742     LLVM_CXXFLAGS=`strip_unwanted_llvm_flags "$LLVM_CONFIG --cxxflags"`
2743
2744     dnl Set LLVM_LIBS - This is done after the driver configuration so
2745     dnl that drivers can add additional components to LLVM_COMPONENTS.
2746     dnl Previously, gallium drivers were updating LLVM_LIBS directly
2747     dnl by calling llvm-config --libs ${DRIVER_LLVM_COMPONENTS}, but
2748     dnl this was causing the same libraries to be appear multiple times
2749     dnl in LLVM_LIBS.
2750
2751     if test $LLVM_VERSION_MAJOR -ge 4 -o $LLVM_VERSION_MAJOR -eq 3 -a $LLVM_VERSION_MINOR -ge 9; then
2752         if test "x$enable_llvm_shared_libs" = xyes; then
2753             LLVM_LIBS="`$LLVM_CONFIG --link-shared --libs ${LLVM_COMPONENTS}`"
2754         else
2755             dnl Invoking llvm-config with both -libs and --system-libs produces the
2756             dnl two separate lines - each for the set of libraries.
2757                 dnl Call the program twice, effectively folding them into a single line.
2758             LLVM_LIBS="`$LLVM_CONFIG --link-static --libs ${LLVM_COMPONENTS}`"
2759             dnl We need to link to llvm system libs when using static libs
2760             LLVM_LIBS="$LLVM_LIBS `$LLVM_CONFIG --link-static --system-libs`"
2761         fi
2762     else
2763         LLVM_LIBS="`$LLVM_CONFIG --libs ${LLVM_COMPONENTS}`"
2764         if test "x$enable_llvm_shared_libs" = xyes; then
2765             detect_old_buggy_llvm
2766         else
2767             AC_MSG_WARN([Building mesa with statically linked LLVM may cause compilation issues])
2768             dnl We need to link to llvm system libs when using static libs
2769             dnl However, only llvm 3.5+ provides --system-libs
2770             if test $LLVM_VERSION_MAJOR -ge 4 -o $LLVM_VERSION_MAJOR -eq 3 -a $LLVM_VERSION_MINOR -ge 5; then
2771                 LLVM_LIBS="$LLVM_LIBS `$LLVM_CONFIG --system-libs`"
2772             fi
2773         fi
2774     fi
2775 fi
2776
2777 AM_CONDITIONAL(HAVE_GALLIUM_SVGA, test "x$HAVE_GALLIUM_SVGA" = xyes)
2778 AM_CONDITIONAL(HAVE_GALLIUM_I915, test "x$HAVE_GALLIUM_I915" = xyes)
2779 AM_CONDITIONAL(HAVE_GALLIUM_PL111, test "x$HAVE_GALLIUM_PL111" = xyes)
2780 AM_CONDITIONAL(HAVE_GALLIUM_R300, test "x$HAVE_GALLIUM_R300" = xyes)
2781 AM_CONDITIONAL(HAVE_GALLIUM_R600, test "x$HAVE_GALLIUM_R600" = xyes)
2782 AM_CONDITIONAL(HAVE_GALLIUM_RADEONSI, test "x$HAVE_GALLIUM_RADEONSI" = xyes)
2783 AM_CONDITIONAL(HAVE_GALLIUM_RADEON_COMMON, test "x$HAVE_GALLIUM_RADEONSI" = xyes)
2784 AM_CONDITIONAL(HAVE_GALLIUM_NOUVEAU, test "x$HAVE_GALLIUM_NOUVEAU" = xyes)
2785 AM_CONDITIONAL(HAVE_GALLIUM_FREEDRENO, test "x$HAVE_GALLIUM_FREEDRENO" = xyes)
2786 AM_CONDITIONAL(HAVE_GALLIUM_ETNAVIV, test "x$HAVE_GALLIUM_ETNAVIV" = xyes)
2787 AM_CONDITIONAL(HAVE_GALLIUM_IMX, test "x$HAVE_GALLIUM_IMX" = xyes)
2788 AM_CONDITIONAL(HAVE_GALLIUM_SOFTPIPE, test "x$HAVE_GALLIUM_SOFTPIPE" = xyes)
2789 AM_CONDITIONAL(HAVE_GALLIUM_LLVMPIPE, test "x$HAVE_GALLIUM_LLVMPIPE" = xyes)
2790 AM_CONDITIONAL(HAVE_GALLIUM_SWR, test "x$HAVE_GALLIUM_SWR" = xyes)
2791 AM_CONDITIONAL(HAVE_GALLIUM_SWRAST, test "x$HAVE_GALLIUM_SOFTPIPE" = xyes -o \
2792                                          "x$HAVE_GALLIUM_LLVMPIPE" = xyes -o \
2793                                          "x$HAVE_GALLIUM_SWR" = xyes)
2794 AM_CONDITIONAL(HAVE_GALLIUM_VC4, test "x$HAVE_GALLIUM_VC4" = xyes)
2795 AM_CONDITIONAL(HAVE_GALLIUM_VC5, test "x$HAVE_GALLIUM_VC5" = xyes)
2796 AM_CONDITIONAL(HAVE_GALLIUM_VIRGL, test "x$HAVE_GALLIUM_VIRGL" = xyes)
2797
2798 AM_CONDITIONAL(HAVE_GALLIUM_STATIC_TARGETS, test "x$enable_shared_pipe_drivers" = xno)
2799
2800 if test "x$enable_dri" = xyes; then
2801     GALLIUM_PIPE_LOADER_DEFINES="$GALLIUM_PIPE_LOADER_DEFINES -DHAVE_PIPE_LOADER_DRI"
2802 fi
2803
2804 if test "x$have_drisw_kms" = xyes; then
2805     GALLIUM_PIPE_LOADER_DEFINES="$GALLIUM_PIPE_LOADER_DEFINES -DHAVE_PIPE_LOADER_KMS"
2806 fi
2807 AC_SUBST([GALLIUM_PIPE_LOADER_DEFINES])
2808
2809 AM_CONDITIONAL(HAVE_I915_DRI, test x$HAVE_I915_DRI = xyes)
2810 AM_CONDITIONAL(HAVE_I965_DRI, test x$HAVE_I965_DRI = xyes)
2811 AM_CONDITIONAL(HAVE_NOUVEAU_DRI, test x$HAVE_NOUVEAU_DRI = xyes)
2812 AM_CONDITIONAL(HAVE_R200_DRI, test x$HAVE_R200_DRI = xyes)
2813 AM_CONDITIONAL(HAVE_RADEON_DRI, test x$HAVE_RADEON_DRI = xyes)
2814 AM_CONDITIONAL(HAVE_SWRAST_DRI, test x$HAVE_SWRAST_DRI = xyes)
2815
2816 AM_CONDITIONAL(HAVE_RADEON_VULKAN, test "x$HAVE_RADEON_VULKAN" = xyes)
2817 AM_CONDITIONAL(HAVE_INTEL_VULKAN, test "x$HAVE_INTEL_VULKAN" = xyes)
2818
2819 AM_CONDITIONAL(HAVE_AMD_DRIVERS, test "x$HAVE_GALLIUM_RADEONSI" = xyes -o \
2820                                       "x$HAVE_RADEON_VULKAN" = xyes)
2821
2822 AM_CONDITIONAL(HAVE_BROADCOM_DRIVERS, test "x$HAVE_GALLIUM_VC4" = xyes -o \
2823                                       "x$HAVE_GALLIUM_VC5" = xyes)
2824
2825 AM_CONDITIONAL(HAVE_INTEL_DRIVERS, test "x$HAVE_INTEL_VULKAN" = xyes -o \
2826                                         "x$HAVE_I965_DRI" = xyes)
2827
2828 AM_CONDITIONAL(NEED_RADEON_DRM_WINSYS, test "x$HAVE_GALLIUM_R300" = xyes -o \
2829                                             "x$HAVE_GALLIUM_R600" = xyes -o \
2830                                             "x$HAVE_GALLIUM_RADEONSI" = xyes)
2831 AM_CONDITIONAL(NEED_WINSYS_XLIB, test "x$enable_glx" = xgallium-xlib)
2832 AM_CONDITIONAL(HAVE_GALLIUM_COMPUTE, test x$enable_opencl = xyes)
2833 AM_CONDITIONAL(HAVE_GALLIUM_LLVM, test "x$enable_llvm" = xyes)
2834 AM_CONDITIONAL(USE_VC4_SIMULATOR, test x$USE_VC4_SIMULATOR = xyes)
2835 AM_CONDITIONAL(USE_VC5_SIMULATOR, test x$USE_VC5_SIMULATOR = xyes)
2836
2837 AM_CONDITIONAL(HAVE_LIBDRM, test "x$have_libdrm" = xyes)
2838 AM_CONDITIONAL(HAVE_OSMESA, test "x$enable_osmesa" = xyes)
2839 AM_CONDITIONAL(HAVE_GALLIUM_OSMESA, test "x$enable_gallium_osmesa" = xyes)
2840 AM_CONDITIONAL(HAVE_COMMON_OSMESA, test "x$enable_osmesa" = xyes -o \
2841                                         "x$enable_gallium_osmesa" = xyes)
2842
2843 AM_CONDITIONAL(HAVE_X86_ASM, test "x$asm_arch" = xx86 -o "x$asm_arch" = xx86_64)
2844 AM_CONDITIONAL(HAVE_X86_64_ASM, test "x$asm_arch" = xx86_64)
2845 AM_CONDITIONAL(HAVE_SPARC_ASM, test "x$asm_arch" = xsparc)
2846 AM_CONDITIONAL(HAVE_PPC64LE_ASM, test "x$asm_arch" = xppc64le)
2847 AM_CONDITIONAL(HAVE_AARCH64_ASM, test "x$asm_arch" = xaarch64)
2848 AM_CONDITIONAL(HAVE_ARM_ASM, test "x$asm_arch" = xarm)
2849
2850 AC_SUBST([NINE_MAJOR], 1)
2851 AC_SUBST([NINE_MINOR], 0)
2852 AC_SUBST([NINE_PATCH], 0)
2853 AC_SUBST([NINE_VERSION], "$NINE_MAJOR.$NINE_MINOR.$NINE_PATCH")
2854
2855 AC_SUBST([VDPAU_MAJOR], 1)
2856 AC_SUBST([VDPAU_MINOR], 0)
2857
2858 if test "x$enable_va" = xyes; then
2859     VA_MAJOR=`$PKG_CONFIG --modversion libva | $SED -n 's/\([[^\.]]*\)\..*$/\1/p'`
2860     VA_MINOR=`$PKG_CONFIG --modversion libva | $SED -n 's/.*\.\(.*\)\..*$/\1/p'`
2861 fi
2862 AC_SUBST([VA_MAJOR], $VA_MAJOR)
2863 AC_SUBST([VA_MINOR], $VA_MINOR)
2864
2865 AM_CONDITIONAL(HAVE_VULKAN_COMMON, test "x$VULKAN_DRIVERS" != "x")
2866
2867 AC_SUBST([XVMC_MAJOR], 1)
2868 AC_SUBST([XVMC_MINOR], 0)
2869
2870 AC_SUBST([XA_MAJOR], 2)
2871 AC_SUBST([XA_MINOR], 3)
2872 AC_SUBST([XA_PATCH], 0)
2873 AC_SUBST([XA_VERSION], "$XA_MAJOR.$XA_MINOR.$XA_PATCH")
2874
2875 AC_ARG_ENABLE(valgrind,
2876               [AS_HELP_STRING([--enable-valgrind],
2877                              [Build mesa with valgrind support (default: auto)])],
2878                              [VALGRIND=$enableval], [VALGRIND=auto])
2879 if test "x$VALGRIND" != xno; then
2880     PKG_CHECK_MODULES(VALGRIND, [valgrind], [have_valgrind=yes], [have_valgrind=no])
2881 fi
2882 AC_MSG_CHECKING([whether to enable Valgrind support])
2883 if test "x$VALGRIND" = xauto; then
2884     VALGRIND="$have_valgrind"
2885 fi
2886
2887 if test "x$VALGRIND" = "xyes"; then
2888     if ! test "x$have_valgrind" = xyes; then
2889         AC_MSG_ERROR([Valgrind support required but not present])
2890     fi
2891     AC_DEFINE([HAVE_VALGRIND], 1, [Use valgrind intrinsics to suppress false warnings])
2892 fi
2893
2894 AC_MSG_RESULT([$VALGRIND])
2895
2896 dnl Restore LDFLAGS and CPPFLAGS
2897 LDFLAGS="$_SAVE_LDFLAGS"
2898 CPPFLAGS="$_SAVE_CPPFLAGS"
2899
2900 dnl Suppress clang's warnings about unused CFLAGS and CXXFLAGS
2901 if test "x$acv_mesa_CLANG" = xyes; then
2902     CFLAGS="$CFLAGS -Qunused-arguments"
2903     CXXFLAGS="$CXXFLAGS -Qunused-arguments"
2904 fi
2905
2906 dnl Add user CFLAGS and CXXFLAGS
2907 CFLAGS="$CFLAGS $USER_CFLAGS"
2908 CXXFLAGS="$CXXFLAGS $USER_CXXFLAGS"
2909
2910 dnl Substitute the config
2911 AC_CONFIG_FILES([Makefile
2912                  src/Makefile
2913                  src/amd/Makefile
2914                  src/amd/vulkan/Makefile
2915                  src/broadcom/Makefile
2916                  src/compiler/Makefile
2917                  src/egl/Makefile
2918                  src/egl/main/egl.pc
2919                  src/egl/wayland/wayland-drm/Makefile
2920                  src/egl/wayland/wayland-egl/Makefile
2921                  src/egl/wayland/wayland-egl/wayland-egl.pc
2922                  src/gallium/Makefile
2923                  src/gallium/auxiliary/Makefile
2924                  src/gallium/auxiliary/pipe-loader/Makefile
2925                  src/gallium/drivers/freedreno/Makefile
2926                  src/gallium/drivers/ddebug/Makefile
2927                  src/gallium/drivers/i915/Makefile
2928                  src/gallium/drivers/llvmpipe/Makefile
2929                  src/gallium/drivers/noop/Makefile
2930                  src/gallium/drivers/nouveau/Makefile
2931                  src/gallium/drivers/pl111/Makefile
2932                  src/gallium/drivers/r300/Makefile
2933                  src/gallium/drivers/r600/Makefile
2934                  src/gallium/drivers/radeon/Makefile
2935                  src/gallium/drivers/radeonsi/Makefile
2936                  src/gallium/drivers/rbug/Makefile
2937                  src/gallium/drivers/softpipe/Makefile
2938                  src/gallium/drivers/svga/Makefile
2939                  src/gallium/drivers/swr/Makefile
2940                  src/gallium/drivers/trace/Makefile
2941                  src/gallium/drivers/etnaviv/Makefile
2942                  src/gallium/drivers/imx/Makefile
2943                  src/gallium/drivers/vc4/Makefile
2944                  src/gallium/drivers/vc5/Makefile
2945                  src/gallium/drivers/virgl/Makefile
2946                  src/gallium/state_trackers/clover/Makefile
2947                  src/gallium/state_trackers/dri/Makefile
2948                  src/gallium/state_trackers/glx/xlib/Makefile
2949                  src/gallium/state_trackers/nine/Makefile
2950                  src/gallium/state_trackers/omx_bellagio/Makefile
2951                  src/gallium/state_trackers/osmesa/Makefile
2952                  src/gallium/state_trackers/va/Makefile
2953                  src/gallium/state_trackers/vdpau/Makefile
2954                  src/gallium/state_trackers/xa/Makefile
2955                  src/gallium/state_trackers/xa/xa_tracker.h
2956                  src/gallium/state_trackers/xvmc/Makefile
2957                  src/gallium/targets/d3dadapter9/Makefile
2958                  src/gallium/targets/d3dadapter9/d3d.pc
2959                  src/gallium/targets/dri/Makefile
2960                  src/gallium/targets/libgl-xlib/Makefile
2961                  src/gallium/targets/omx-bellagio/Makefile
2962                  src/gallium/targets/opencl/Makefile
2963                  src/gallium/targets/opencl/mesa.icd
2964                  src/gallium/targets/osmesa/Makefile
2965                  src/gallium/targets/osmesa/osmesa.pc
2966                  src/gallium/targets/pipe-loader/Makefile
2967                  src/gallium/targets/va/Makefile
2968                  src/gallium/targets/vdpau/Makefile
2969                  src/gallium/targets/xa/Makefile
2970                  src/gallium/targets/xa/xatracker.pc
2971                  src/gallium/targets/xvmc/Makefile
2972                  src/gallium/tests/trivial/Makefile
2973                  src/gallium/tests/unit/Makefile
2974                  src/gallium/winsys/etnaviv/drm/Makefile
2975                  src/gallium/winsys/imx/drm/Makefile
2976                  src/gallium/winsys/freedreno/drm/Makefile
2977                  src/gallium/winsys/i915/drm/Makefile
2978                  src/gallium/winsys/nouveau/drm/Makefile
2979                  src/gallium/winsys/pl111/drm/Makefile
2980                  src/gallium/winsys/radeon/drm/Makefile
2981                  src/gallium/winsys/amdgpu/drm/Makefile
2982                  src/gallium/winsys/svga/drm/Makefile
2983                  src/gallium/winsys/sw/dri/Makefile
2984                  src/gallium/winsys/sw/kms-dri/Makefile
2985                  src/gallium/winsys/sw/null/Makefile
2986                  src/gallium/winsys/sw/wrapper/Makefile
2987                  src/gallium/winsys/sw/xlib/Makefile
2988                  src/gallium/winsys/vc4/drm/Makefile
2989                  src/gallium/winsys/vc5/drm/Makefile
2990                  src/gallium/winsys/virgl/drm/Makefile
2991                  src/gallium/winsys/virgl/vtest/Makefile
2992                  src/gbm/Makefile
2993                  src/gbm/main/gbm.pc
2994                  src/glx/Makefile
2995                  src/glx/apple/Makefile
2996                  src/glx/tests/Makefile
2997                  src/glx/windows/Makefile
2998                  src/glx/windows/windowsdriproto.pc
2999                  src/gtest/Makefile
3000                  src/intel/Makefile
3001                  src/loader/Makefile
3002                  src/mapi/Makefile
3003                  src/mapi/es1api/glesv1_cm.pc
3004                  src/mapi/es2api/glesv2.pc
3005                  src/mapi/glapi/gen/Makefile
3006                  src/mesa/Makefile
3007                  src/mesa/gl.pc
3008                  src/mesa/drivers/dri/dri.pc
3009                  src/mesa/drivers/dri/common/Makefile
3010                  src/mesa/drivers/dri/i915/Makefile
3011                  src/mesa/drivers/dri/i965/Makefile
3012                  src/mesa/drivers/dri/Makefile
3013                  src/mesa/drivers/dri/nouveau/Makefile
3014                  src/mesa/drivers/dri/r200/Makefile
3015                  src/mesa/drivers/dri/radeon/Makefile
3016                  src/mesa/drivers/dri/swrast/Makefile
3017                  src/mesa/drivers/osmesa/Makefile
3018                  src/mesa/drivers/osmesa/osmesa.pc
3019                  src/mesa/drivers/x11/Makefile
3020                  src/mesa/main/tests/Makefile
3021                  src/mesa/state_tracker/tests/Makefile
3022                  src/util/Makefile
3023                  src/util/tests/hash_table/Makefile
3024                  src/util/tests/string_buffer/Makefile
3025                  src/util/xmlpool/Makefile
3026                  src/vulkan/Makefile])
3027
3028 AC_OUTPUT
3029
3030 # Fix up dependencies in *.Plo files, where we changed the extension of a
3031 # source file
3032 $SED -i -e 's/brw_blorp.cpp/brw_blorp.c/' src/mesa/drivers/dri/i965/.deps/brw_blorp.Plo
3033
3034 rm -f src/compiler/spirv/spirv_info.lo
3035 echo "# dummy" > src/compiler/spirv/.deps/spirv_info.Plo
3036
3037 dnl
3038 dnl Output some configuration info for the user
3039 dnl
3040 echo ""
3041 echo "        prefix:          $prefix"
3042 echo "        exec_prefix:     $exec_prefix"
3043 echo "        libdir:          $libdir"
3044 echo "        includedir:      $includedir"
3045
3046 dnl API info
3047 echo ""
3048 echo "        OpenGL:          $enable_opengl (ES1: $enable_gles1 ES2: $enable_gles2)"
3049
3050 dnl Driver info
3051 echo ""
3052 case "x$enable_osmesa$enable_gallium_osmesa" in
3053 xnoyes)
3054         echo "        OSMesa:          lib$OSMESA_LIB (Gallium)"
3055         ;;
3056 xyesno)
3057         echo "        OSMesa:          lib$OSMESA_LIB"
3058         ;;
3059 xnono)
3060         echo "        OSMesa:          no"
3061         ;;
3062 esac
3063
3064 echo ""
3065 if test "x$enable_dri" != xno; then
3066         echo "        DRI platform:    $dri_platform"
3067         if test -z "$DRI_DIRS"; then
3068             echo "        DRI drivers:     no"
3069         else
3070             echo "        DRI drivers:     $DRI_DIRS"
3071         fi
3072         echo "        DRI driver dir:  $DRI_DRIVER_INSTALL_DIR"
3073 fi
3074
3075 case "x$enable_glx" in
3076 xdri)
3077     echo "        GLX:             DRI-based"
3078     ;;
3079 xxlib)
3080     echo "        GLX:             Xlib-based"
3081     ;;
3082 xgallium-xlib)
3083     echo "        GLX:             Xlib-based (Gallium)"
3084     ;;
3085 *)
3086     echo "        GLX:             $enable_glx"
3087     ;;
3088 esac
3089
3090 dnl EGL
3091 echo ""
3092 echo "        EGL:             $enable_egl"
3093 if test "$enable_egl" = yes; then
3094
3095     egl_drivers=""
3096     if test "x$enable_dri" != "xno"; then
3097         egl_drivers="$egl_drivers builtin:egl_dri2"
3098     fi
3099     if test "x$enable_dri3" != "xno"; then
3100         egl_drivers="$egl_drivers builtin:egl_dri3"
3101     fi
3102
3103     echo "        EGL drivers:    $egl_drivers"
3104 fi
3105 if test "x$enable_gbm" = xyes; then
3106     echo "        GBM:             yes"
3107 else
3108     echo "        GBM:             no"
3109 fi
3110
3111     echo "        EGL/Vulkan/VL platforms:   $platforms"
3112
3113 # Vulkan
3114 echo ""
3115 if test "x$VULKAN_DRIVERS" != x; then
3116     echo "        Vulkan drivers:  $VULKAN_DRIVERS"
3117     echo "        Vulkan ICD dir:  $VULKAN_ICD_INSTALL_DIR"
3118 else
3119     echo "        Vulkan drivers:  no"
3120 fi
3121
3122 echo ""
3123 if test "x$enable_llvm" = xyes; then
3124     echo "        llvm:            yes"
3125     echo "        llvm-config:     $LLVM_CONFIG"
3126     echo "        llvm-version:    $LLVM_VERSION"
3127 else
3128     echo "        llvm:            no"
3129 fi
3130
3131 echo ""
3132 if test -n "$with_gallium_drivers"; then
3133     echo "        Gallium drivers: $gallium_drivers"
3134     echo "        Gallium st:      $gallium_st"
3135 else
3136     echo "        Gallium:         no"
3137 fi
3138
3139 echo ""
3140 if test "x$enable_gallium_extra_hud" != xyes; then
3141     echo "        HUD extra stats: no"
3142 else
3143     echo "        HUD extra stats: yes"
3144 fi
3145
3146 if test "x$enable_lmsensors" != xyes; then
3147     echo "        HUD lmsensors:   no"
3148 else
3149     echo "        HUD lmsensors:   yes"
3150 fi
3151
3152 echo ""
3153 if test "x$HAVE_GALLIUM_SWR" != x; then
3154     echo "        SWR archs:       $swr_archs"
3155 fi
3156
3157 dnl Libraries
3158 echo ""
3159 echo "        Shared libs:     $enable_shared"
3160 echo "        Static libs:     $enable_static"
3161 echo "        Shared-glapi:    $enable_shared_glapi"
3162
3163 dnl Compiler options
3164 # cleanup the CFLAGS/CXXFLAGS/LDFLAGS/DEFINES vars
3165 cflags=`echo $CFLAGS | \
3166     $SED 's/^ *//;s/  */ /;s/ *$//'`
3167 cxxflags=`echo $CXXFLAGS | \
3168     $SED 's/^ *//;s/  */ /;s/ *$//'`
3169 ldflags=`echo $LDFLAGS | $SED 's/^ *//;s/  */ /;s/ *$//'`
3170 defines=`echo $DEFINES | $SED 's/^ *//;s/  */ /;s/ *$//'`
3171 echo ""
3172 echo "        CFLAGS:          $cflags"
3173 echo "        CXXFLAGS:        $cxxflags"
3174 echo "        CXX11_CXXFLAGS:  $CXX11_CXXFLAGS"
3175 echo "        LDFLAGS:         $ldflags"
3176 echo "        Macros:          $defines"
3177 echo ""
3178 if test "x$enable_llvm" = xyes; then
3179     echo "        LLVM_CFLAGS:     $LLVM_CFLAGS"
3180     echo "        LLVM_CXXFLAGS:   $LLVM_CXXFLAGS"
3181     echo "        LLVM_CPPFLAGS:   $LLVM_CPPFLAGS"
3182     echo "        LLVM_LDFLAGS:    $LLVM_LDFLAGS"
3183     echo ""
3184 fi
3185 echo "        PYTHON2:         $PYTHON2"
3186
3187 echo ""
3188 echo "        Run '${MAKE-make}' to build Mesa"
3189 echo ""