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