meson.build

   1 # Copyright © 2017-2019 Intel Corporation
   2
   3 # Permission is hereby granted, free of charge, to any person obtaining a copy
   4 # of this software and associated documentation files (the "Software"), to deal
   5 # in the Software without restriction, including without limitation the rights
   6 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7 # copies of the Software, and to permit persons to whom the Software is
   8 # furnished to do so, subject to the following conditions:
   9
  10 # The above copyright notice and this permission notice shall be included in
  11 # all copies or substantial portions of the Software.
  12
  13 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  19 # SOFTWARE.
  20
  21 project(
  22   'mesa',
  23   ['c', 'cpp'],
  24   version : run_command(
  25     [find_program('python', 'python2', 'python3'), 'bin/meson_get_version.py']
  26   ).stdout(),
  27   license : 'MIT',
  28   meson_version : '>= 0.46',
  29   default_options : ['buildtype=debugoptimized', 'b_ndebug=if-release', 'c_std=c99', 'cpp_std=c++14']
  30 )
  31
  32 cc = meson.get_compiler('c')
  33 cpp = meson.get_compiler('cpp')
  34
  35 null_dep = dependency('', required : false)
  36
  37 # Arguments for the preprocessor, put these in a separate array from the C and
  38 # C++ (cpp in meson terminology) arguments since they need to be added to the
  39 # default arguments for both C and C++.
  40 pre_args = [
  41   '-D__STDC_CONSTANT_MACROS',
  42   '-D__STDC_FORMAT_MACROS',
  43   '-D__STDC_LIMIT_MACROS',
  44   '-DPACKAGE_VERSION="@0@"'.format(meson.project_version()),
  45   '-DPACKAGE_BUGREPORT="https://gitlab.freedesktop.org/mesa/mesa/issues"',
  46 ]
  47
  48 with_vulkan_icd_dir = get_option('vulkan-icd-dir')
  49 with_tests = get_option('build-tests')
  50 with_valgrind = get_option('valgrind')
  51 with_libunwind = get_option('libunwind')
  52 with_glx_read_only_text = get_option('glx-read-only-text')
  53 with_glx_direct = get_option('glx-direct')
  54 with_osmesa = get_option('osmesa')
  55 with_swr_arches = get_option('swr-arches')
  56 with_tools = get_option('tools')
  57 if with_tools.contains('all')
  58   with_tools = [
  59     'drm-shim',
  60     'etnaviv',
  61     'freedreno',
  62     'glsl',
  63     'intel',
  64     'intel-ui',
  65     'lima',
  66     'nir',
  67     'nouveau',
  68     'xvmc',
  69   ]
  70 endif
  71
  72 dri_drivers_path = get_option('dri-drivers-path')
  73 if dri_drivers_path == ''
  74   dri_drivers_path = join_paths(get_option('prefix'), get_option('libdir'), 'dri')
  75 endif
  76 dri_search_path = get_option('dri-search-path')
  77 if dri_search_path == ''
  78   dri_search_path = dri_drivers_path
  79 endif
  80
  81 with_gles1 = get_option('gles1')
  82 with_gles2 = get_option('gles2')
  83 if host_machine.system() == 'windows'
  84   if with_gles1 == 'auto'
  85     with_gles1 = 'false'
  86   endif
  87   if with_gles2 == 'auto'
  88     with_gles2 = 'false'
  89   endif
  90 endif
  91 with_opengl = get_option('opengl')
  92
  93 # Default shared glapi off for windows, on elsewhere.
  94 _sg = get_option('shared-glapi')
  95 if _sg == 'auto'
  96   with_shared_glapi = host_machine.system() != 'windows'
  97 else
  98   with_shared_glapi = _sg == 'true'
  99 endif
 100
 101 # shared-glapi is required if at least two OpenGL APIs are being built
 102 if not with_shared_glapi
 103   if ((with_gles1 == 'true' and with_gles2 == 'true') or
 104       (with_gles1 == 'true' and with_opengl) or
 105       (with_gles2 == 'true' and with_opengl))
 106     error('shared-glapi required for building two or more of OpenGL, OpenGL ES 1.x, OpenGL ES 2.x')
 107   endif
 108   with_gles1 = 'false'
 109   with_gles2 = 'false'
 110 endif
 111
 112 # We require OpenGL for OpenGL ES
 113 if not with_opengl
 114   if (with_gles1 == 'true' or with_gles2 == 'true') and not with_opengl
 115     error('building OpenGL ES without OpenGL is not supported.')
 116   endif
 117   with_gles1 = 'false'
 118   with_gles2 = 'false'
 119 endif
 120
 121 with_gles1 = with_gles1 != 'false'
 122 with_gles2 = with_gles2 != 'false'
 123 with_any_opengl = with_opengl or with_gles1 or with_gles2
 124 # Only build shared_glapi if at least one OpenGL API is enabled
 125 with_shared_glapi = with_shared_glapi and with_any_opengl
 126
 127 system_has_kms_drm = ['openbsd', 'netbsd', 'freebsd', 'gnu/kfreebsd', 'dragonfly', 'linux', 'sunos'].contains(host_machine.system())
 128
 129 dri_drivers = get_option('dri-drivers')
 130 if dri_drivers.contains('auto')
 131   if system_has_kms_drm
 132     # TODO: PPC, Sparc
 133     if ['x86', 'x86_64'].contains(host_machine.cpu_family())
 134       dri_drivers = ['i915', 'i965', 'r100', 'r200', 'nouveau']
 135     elif ['arm', 'aarch64'].contains(host_machine.cpu_family())
 136       dri_drivers = []
 137     else
 138       error('Unknown architecture @0@. Please pass -Ddri-drivers to set driver options. Patches gladly accepted to fix this.'.format(
 139             host_machine.cpu_family()))
 140     endif
 141   elif ['darwin', 'windows', 'cygwin', 'haiku'].contains(host_machine.system())
 142     # only swrast would make sense here, but gallium swrast is a much better default
 143     dri_drivers = []
 144   else
 145     error('Unknown OS @0@. Please pass -Ddri-drivers to set driver options. Patches gladly accepted to fix this.'.format(
 146           host_machine.system()))
 147   endif
 148 endif
 149
 150 with_dri_i915 = dri_drivers.contains('i915')
 151 with_dri_i965 = dri_drivers.contains('i965')
 152 with_dri_r100 = dri_drivers.contains('r100')
 153 with_dri_r200 = dri_drivers.contains('r200')
 154 with_dri_nouveau = dri_drivers.contains('nouveau')
 155 with_dri_swrast = dri_drivers.contains('swrast')
 156
 157 with_dri = dri_drivers.length() != 0 and dri_drivers != ['']
 158
 159 gallium_drivers = get_option('gallium-drivers')
 160 if gallium_drivers.contains('auto')
 161   if system_has_kms_drm
 162     # TODO: PPC, Sparc
 163     if ['x86', 'x86_64'].contains(host_machine.cpu_family())
 164       gallium_drivers = [
 165         'r300', 'r600', 'radeonsi', 'nouveau', 'virgl', 'svga', 'swrast'
 166       ]
 167     elif ['arm', 'aarch64'].contains(host_machine.cpu_family())
 168       gallium_drivers = [
 169         'kmsro', 'v3d', 'vc4', 'freedreno', 'etnaviv', 'nouveau',
 170         'tegra', 'virgl', 'lima', 'panfrost', 'swrast'
 171       ]
 172     else
 173       error('Unknown architecture @0@. Please pass -Dgallium-drivers to set driver options. Patches gladly accepted to fix this.'.format(
 174             host_machine.cpu_family()))
 175     endif
 176   elif ['darwin', 'windows', 'cygwin', 'haiku'].contains(host_machine.system())
 177     gallium_drivers = ['swrast']
 178   else
 179     error('Unknown OS @0@. Please pass -Dgallium-drivers to set driver options. Patches gladly accepted to fix this.'.format(
 180           host_machine.system()))
 181   endif
 182 endif
 183 with_gallium_kmsro = gallium_drivers.contains('kmsro')
 184 with_gallium_radeonsi = gallium_drivers.contains('radeonsi')
 185 with_gallium_r300 = gallium_drivers.contains('r300')
 186 with_gallium_r600 = gallium_drivers.contains('r600')
 187 with_gallium_nouveau = gallium_drivers.contains('nouveau')
 188 with_gallium_freedreno = gallium_drivers.contains('freedreno')
 189 with_gallium_softpipe = gallium_drivers.contains('swrast')
 190 with_gallium_vc4 = gallium_drivers.contains('vc4')
 191 with_gallium_v3d = gallium_drivers.contains('v3d')
 192 with_gallium_panfrost = gallium_drivers.contains('panfrost')
 193 with_gallium_etnaviv = gallium_drivers.contains('etnaviv')
 194 with_gallium_tegra = gallium_drivers.contains('tegra')
 195 with_gallium_iris = gallium_drivers.contains('iris')
 196 with_gallium_i915 = gallium_drivers.contains('i915')
 197 with_gallium_svga = gallium_drivers.contains('svga')
 198 with_gallium_virgl = gallium_drivers.contains('virgl')
 199 with_gallium_swr = gallium_drivers.contains('swr')
 200 with_gallium_lima = gallium_drivers.contains('lima')
 201
 202 if cc.get_id() == 'intel'
 203   if meson.version().version_compare('< 0.49.0')
 204     error('Meson does not have sufficient support of ICC before 0.49.0 to compile mesa')
 205   elif with_gallium_swr and meson.version().version_compare('== 0.49.0')
 206     warning('Meson as of 0.49.0 is sufficient for compiling mesa with ICC, but there are some caveats with SWR. 0.49.1 should resolve all of these')
 207   endif
 208 endif
 209
 210 with_gallium = gallium_drivers.length() != 0 and gallium_drivers != ['']
 211
 212 if with_gallium and system_has_kms_drm
 213   _glx = get_option('glx')
 214   _egl = get_option('egl')
 215   if _glx == 'dri' or _egl == 'true' or (_glx == 'disabled' and _egl != 'false')
 216     with_dri = true
 217   endif
 218 endif
 219
 220 _vulkan_drivers = get_option('vulkan-drivers')
 221 if _vulkan_drivers.contains('auto')
 222   if system_has_kms_drm
 223     if host_machine.cpu_family().startswith('x86')
 224       _vulkan_drivers = ['amd', 'intel']
 225     elif ['arm', 'aarch64'].contains(host_machine.cpu_family())
 226       _vulkan_drivers = []
 227     else
 228       error('Unknown architecture @0@. Please pass -Dvulkan-drivers to set driver options. Patches gladly accepted to fix this.'.format(
 229             host_machine.cpu_family()))
 230     endif
 231   elif ['darwin', 'windows', 'cygwin', 'haiku'].contains(host_machine.system())
 232     # No vulkan driver supports windows or macOS currently
 233     _vulkan_drivers = []
 234   else
 235     error('Unknown OS @0@. Please pass -Dvulkan-drivers to set driver options. Patches gladly accepted to fix this.'.format(
 236           host_machine.system()))
 237   endif
 238 endif
 239
 240 with_intel_vk = _vulkan_drivers.contains('intel')
 241 with_amd_vk = _vulkan_drivers.contains('amd')
 242 with_freedreno_vk = _vulkan_drivers.contains('freedreno')
 243 with_any_vk = _vulkan_drivers.length() != 0 and _vulkan_drivers != ['']
 244
 245 if with_freedreno_vk and get_option('I-love-half-baked-turnips') != true
 246   error('Cannot enable freedreno vulkan driver')
 247 endif
 248
 249 if with_dri_swrast and (with_gallium_softpipe or with_gallium_swr)
 250   error('Only one swrast provider can be built')
 251 endif
 252 if with_dri_i915 and with_gallium_i915
 253   error('Only one i915 provider can be built')
 254 endif
 255 if with_gallium_kmsro and not (with_gallium_v3d or with_gallium_vc4 or with_gallium_etnaviv or with_gallium_freedreno or with_gallium_panfrost or with_gallium_lima)
 256   error('kmsro driver requires one or more renderonly drivers (vc4, etnaviv, freedreno, panfrost, lima)')
 257 endif
 258 if with_gallium_tegra and not with_gallium_nouveau
 259   error('tegra driver requires nouveau driver')
 260 endif
 261
 262 if host_machine.system() == 'darwin'
 263   with_dri_platform = 'apple'
 264   pre_args += '-DBUILDING_MESA'
 265 elif ['windows', 'cygwin'].contains(host_machine.system())
 266   with_dri_platform = 'windows'
 267 elif system_has_kms_drm
 268   with_dri_platform = 'drm'
 269 else
 270   # FIXME: haiku doesn't use dri, and xlib doesn't use dri, probably should
 271   # assert here that one of those cases has been met.
 272   # FIXME: illumos ends up here as well
 273   with_dri_platform = 'none'
 274 endif
 275
 276 _platforms = get_option('platforms')
 277 if _platforms.contains('auto')
 278   if system_has_kms_drm
 279     _platforms = ['x11', 'wayland', 'drm', 'surfaceless']
 280   elif ['darwin', 'cygwin'].contains(host_machine.system())
 281     _platforms = ['x11', 'surfaceless']
 282   elif ['haiku'].contains(host_machine.system())
 283     _platforms = ['haiku']
 284   elif host_machine.system() == 'windows'
 285     _platforms = ['windows']
 286   else
 287     error('Unknown OS @0@. Please pass -Dplatforms to set platforms. Patches gladly accepted to fix this.'.format(
 288           host_machine.system()))
 289   endif
 290 endif
 291
 292 with_platform_android = _platforms.contains('android')
 293 with_platform_x11 = _platforms.contains('x11')
 294 with_platform_wayland = _platforms.contains('wayland')
 295 with_platform_drm = _platforms.contains('drm')
 296 with_platform_haiku = _platforms.contains('haiku')
 297 with_platform_surfaceless = _platforms.contains('surfaceless')
 298 with_platform_windows = _platforms.contains('windows')
 299
 300 with_platforms = false
 301 if _platforms.length() != 0 and _platforms != ['']
 302   # sanity check that list contains no empty strings
 303   if _platforms.contains('')
 304     error('Invalid argument list given to -Dplatforms, please fix.')
 305   endif
 306   with_platforms = true
 307   egl_native_platform = _platforms[0]
 308 endif
 309
 310 _xlib_lease = get_option('xlib-lease')
 311 if _xlib_lease == 'auto'
 312   with_xlib_lease = with_platform_x11 and with_platform_drm
 313 else
 314   with_xlib_lease = _xlib_lease == 'true'
 315 endif
 316
 317 with_glx = get_option('glx')
 318 if with_glx == 'auto'
 319   if with_dri
 320     with_glx = 'dri'
 321   elif with_platform_haiku
 322     with_glx = 'disabled'
 323   elif host_machine.system() == 'windows'
 324     with_glx = 'disabled'
 325   elif with_gallium
 326     # Even when building just gallium drivers the user probably wants dri
 327     with_glx = 'dri'
 328   elif with_platform_x11 and with_any_opengl and not with_any_vk
 329     # The automatic behavior should not be to turn on xlib based glx when
 330     # building only vulkan drivers
 331     with_glx = 'xlib'
 332   else
 333     with_glx = 'disabled'
 334   endif
 335 endif
 336 if with_glx == 'dri'
 337    if with_gallium
 338       with_dri = true
 339    endif
 340 endif
 341
 342 if not (with_dri or with_gallium or with_glx != 'disabled')
 343   with_gles1 = false
 344   with_gles2 = false
 345   with_opengl = false
 346   with_any_opengl = false
 347   with_shared_glapi = false
 348 endif
 349
 350 _gbm = get_option('gbm')
 351 if _gbm == 'auto'
 352   with_gbm = system_has_kms_drm and with_dri
 353 else
 354   with_gbm = _gbm == 'true'
 355 endif
 356 if with_gbm and not system_has_kms_drm
 357   error('GBM only supports DRM/KMS platforms')
 358 endif
 359
 360 _egl = get_option('egl')
 361 if _egl == 'auto'
 362   with_egl = (
 363     not ['darwin', 'windows'].contains(host_machine.system()) and
 364     with_dri and with_shared_glapi and with_platforms
 365   )
 366 elif _egl == 'true'
 367   if not with_dri
 368     error('EGL requires dri')
 369   elif not with_shared_glapi
 370     error('EGL requires shared-glapi')
 371   elif not with_platforms
 372     error('No platforms specified, consider -Dplatforms=drm,x11,surfaceless at least')
 373   elif not ['disabled', 'dri'].contains(with_glx)
 374     error('EGL requires dri, but a GLX is being built without dri')
 375   elif ['darwin', 'windows'].contains(host_machine.system())
 376     error('EGL is not available on Windows or MacOS')
 377   endif
 378   with_egl = true
 379 else
 380   with_egl = false
 381 endif
 382
 383 if with_egl and not (with_platform_drm or with_platform_surfaceless or with_platform_android)
 384   if with_gallium_radeonsi
 385     error('RadeonSI requires the drm, surfaceless or android platform when using EGL')
 386   endif
 387   if with_gallium_virgl
 388     error('Virgl requires the drm, surfaceless or android platform when using EGL')
 389   endif
 390 endif
 391
 392 # Android uses emutls for versions <= P/28. For USE_ELF_TLS we need ELF TLS.
 393 if host_machine.system() != 'windows' and (not with_platform_android or get_option('platform-sdk-version') >= 29)
 394   pre_args += '-DUSE_ELF_TLS'
 395 endif
 396
 397 if with_glx != 'disabled'
 398   if not (with_platform_x11 and with_any_opengl)
 399     error('Cannot build GLX support without X11 platform support and at least one OpenGL API')
 400   elif with_glx == 'gallium-xlib'
 401     if not with_gallium
 402       error('Gallium-xlib based GLX requires at least one gallium driver')
 403     elif not with_gallium_softpipe
 404       error('Gallium-xlib based GLX requires softpipe or llvmpipe.')
 405     elif with_dri
 406       error('gallium-xlib conflicts with any dri driver')
 407     endif
 408   elif with_glx == 'xlib'
 409     if with_dri
 410       error('xlib conflicts with any dri driver')
 411     endif
 412   elif with_glx == 'dri'
 413     if not with_shared_glapi
 414       error('dri based GLX requires shared-glapi')
 415     endif
 416   endif
 417 endif
 418
 419 with_glvnd = get_option('glvnd')
 420 if with_glvnd
 421   if with_platform_windows
 422     error('glvnd cannot be used on Windows')
 423   elif with_glx == 'xlib' or with_glx == 'gallium-xlib'
 424     error('Cannot build glvnd support for GLX that is not DRI based.')
 425   elif with_glx == 'disabled' and not with_egl
 426     error('glvnd requires DRI based GLX and/or EGL')
 427   endif
 428   if get_option('egl-lib-suffix') != ''
 429     error('''EGL lib suffix can't be used with libglvnd''')
 430   endif
 431 endif
 432
 433 if with_vulkan_icd_dir == ''
 434   with_vulkan_icd_dir = join_paths(get_option('datadir'), 'vulkan/icd.d')
 435 endif
 436
 437 with_dri2 = (with_dri or with_any_vk) and (with_dri_platform == 'drm' or
 438   host_machine.system() == 'gnu')
 439 _dri3 = get_option('dri3')
 440 if _dri3 == 'auto'
 441   with_dri3 = system_has_kms_drm and with_dri2
 442 else
 443   with_dri3 = _dri3 == 'true'
 444 endif
 445
 446 if with_any_vk and (with_platform_x11 and not with_dri3)
 447   error('Vulkan drivers require dri3 for X11 support')
 448 endif
 449 if with_dri
 450   if with_glx == 'disabled' and not with_egl and not with_gbm and with_osmesa != 'classic'
 451     error('building dri drivers require at least one windowing system or classic osmesa')
 452   endif
 453 endif
 454
 455 prog_pkgconfig = find_program('pkg-config')
 456
 457 _vdpau = get_option('gallium-vdpau')
 458 if not system_has_kms_drm
 459   if _vdpau == 'true'
 460     error('VDPAU state tracker can only be build on unix-like OSes.')
 461   else
 462     _vdpau = 'false'
 463   endif
 464 elif not with_platform_x11
 465   if _vdpau == 'true'
 466     error('VDPAU state tracker requires X11 support.')
 467   else
 468     _vdpau = 'false'
 469   endif
 470 elif not (with_gallium_r300 or with_gallium_r600 or with_gallium_radeonsi or
 471           with_gallium_nouveau)
 472   if _vdpau == 'true'
 473     error('VDPAU state tracker requires at least one of the following gallium drivers: r300, r600, radeonsi, nouveau.')
 474   else
 475     _vdpau = 'false'
 476   endif
 477 endif
 478 dep_vdpau = null_dep
 479 with_gallium_vdpau = false
 480 if _vdpau != 'false'
 481   dep_vdpau = dependency('vdpau', version : '>= 1.1', required : _vdpau == 'true')
 482   if dep_vdpau.found()
 483     dep_vdpau = declare_dependency(
 484       compile_args : run_command(prog_pkgconfig, ['vdpau', '--cflags']).stdout().split()
 485     )
 486     with_gallium_vdpau = true
 487   endif
 488 endif
 489
 490 if with_gallium_vdpau
 491   pre_args += '-DHAVE_ST_VDPAU'
 492 endif
 493 vdpau_drivers_path = get_option('vdpau-libs-path')
 494 if vdpau_drivers_path == ''
 495   vdpau_drivers_path = join_paths(get_option('libdir'), 'vdpau')
 496 endif
 497
 498 _xvmc = get_option('gallium-xvmc')
 499 if not system_has_kms_drm
 500   if _xvmc == 'true'
 501     error('XVMC state tracker can only be build on unix-like OSes.')
 502   else
 503     _xvmc = 'false'
 504   endif
 505 elif not with_platform_x11
 506   if _xvmc == 'true'
 507     error('XVMC state tracker requires X11 support.')
 508   else
 509     _xvmc = 'false'
 510   endif
 511 elif not (with_gallium_r600 or with_gallium_nouveau)
 512   if _xvmc == 'true'
 513     error('XVMC state tracker requires at least one of the following gallium drivers: r600, nouveau.')
 514   else
 515     _xvmc = 'false'
 516   endif
 517 endif
 518 dep_xvmc = null_dep
 519 dep_xv = null_dep
 520 with_gallium_xvmc = false
 521 if _xvmc != 'false'
 522   dep_xvmc = dependency('xvmc', version : '>= 1.0.6', required : _xvmc == 'true')
 523   dep_xv = dependency('xv', required : _xvmc == 'true')
 524   with_gallium_xvmc = dep_xvmc.found() and dep_xv.found()
 525 endif
 526
 527 xvmc_drivers_path = get_option('xvmc-libs-path')
 528 if xvmc_drivers_path == ''
 529   xvmc_drivers_path = get_option('libdir')
 530 endif
 531
 532 _omx = get_option('gallium-omx')
 533 if not system_has_kms_drm
 534   if ['auto', 'disabled'].contains(_omx)
 535     _omx = 'disabled'
 536   else
 537     error('OMX state tracker can only be built on unix-like OSes.')
 538   endif
 539 elif not (with_gallium_r600 or with_gallium_radeonsi or with_gallium_nouveau)
 540   if ['auto', 'disabled'].contains(_omx)
 541     _omx = 'disabled'
 542   else
 543     error('OMX state tracker requires at least one of the following gallium drivers: r600, radeonsi, nouveau.')
 544   endif
 545 endif
 546 with_gallium_omx = _omx
 547 dep_omx = null_dep
 548 dep_omx_other = []
 549 if ['auto', 'bellagio'].contains(_omx)
 550   dep_omx = dependency(
 551     'libomxil-bellagio', required : _omx == 'bellagio'
 552   )
 553   if dep_omx.found()
 554     with_gallium_omx = 'bellagio'
 555   endif
 556 endif
 557 if ['auto', 'tizonia'].contains(_omx)
 558   if with_dri and with_egl
 559     dep_omx = dependency(
 560       'libtizonia', version : '>= 0.10.0',
 561       required : _omx == 'tizonia',
 562     )
 563     dep_omx_other = [
 564       dependency('libtizplatform', required : _omx == 'tizonia'),
 565       dependency('tizilheaders', required : _omx == 'tizonia'),
 566     ]
 567     if dep_omx.found() and dep_omx_other[0].found() and dep_omx_other[1].found()
 568       with_gallium_omx = 'tizonia'
 569     endif
 570   elif _omx == 'tizonia'
 571     error('OMX-Tizonia state tracker requires dri and egl')
 572   endif
 573 endif
 574 if _omx == 'auto'
 575   with_gallium_omx = 'disabled'
 576 else
 577   with_gallium_omx = _omx
 578 endif
 579
 580 pre_args += [
 581   '-DENABLE_ST_OMX_BELLAGIO=' + (with_gallium_omx == 'bellagio' ? '1' : '0'),
 582   '-DENABLE_ST_OMX_TIZONIA=' + (with_gallium_omx == 'tizonia' ? '1' : '0'),
 583 ]
 584
 585
 586 omx_drivers_path = get_option('omx-libs-path')
 587
 588 if with_gallium_omx != 'disabled'
 589   # Figure out where to put the omx driver.
 590   # FIXME: this could all be vastly simplified by adding a 'defined_variable'
 591   # argument to meson's get_pkgconfig_variable method.
 592   if omx_drivers_path == ''
 593     _omx_libdir = dep_omx.get_pkgconfig_variable('libdir')
 594     _omx_drivers_dir = dep_omx.get_pkgconfig_variable('pluginsdir')
 595     if _omx_libdir == get_option('libdir')
 596       omx_drivers_path = _omx_drivers_dir
 597     else
 598       _omx_base_dir = []
 599       # This will fail on windows. Does OMX run on windows?
 600       _omx_libdir = _omx_libdir.split('/')
 601       _omx_drivers_dir = _omx_drivers_dir.split('/')
 602       foreach o : _omx_drivers_dir
 603         if not _omx_libdir.contains(o)
 604           _omx_base_dir += o
 605         endif
 606       endforeach
 607       omx_drivers_path = join_paths(get_option('libdir'), _omx_base_dir)
 608     endif
 609   endif
 610 endif
 611
 612 _va = get_option('gallium-va')
 613 if not system_has_kms_drm
 614   if _va == 'true'
 615     error('VA state tracker can only be built on unix-like OSes.')
 616   else
 617     _va = 'false'
 618   endif
 619 elif not (with_gallium_r600 or with_gallium_radeonsi or with_gallium_nouveau)
 620   if _va == 'true'
 621     error('VA state tracker requires at least one of the following gallium drivers: r600, radeonsi, nouveau.')
 622   else
 623     _va = 'false'
 624   endif
 625 endif
 626 with_gallium_va = false
 627 dep_va = null_dep
 628 if _va != 'false'
 629   dep_va = dependency('libva', version : '>= 0.38.0', required : _va == 'true')
 630   if dep_va.found()
 631     dep_va_headers = declare_dependency(
 632       compile_args : run_command(prog_pkgconfig, ['libva', '--cflags']).stdout().split()
 633     )
 634     with_gallium_va = true
 635   endif
 636 endif
 637
 638 va_drivers_path = get_option('va-libs-path')
 639 if va_drivers_path == ''
 640   va_drivers_path = join_paths(get_option('libdir'), 'dri')
 641 endif
 642
 643 _xa = get_option('gallium-xa')
 644 if not system_has_kms_drm
 645   if _xa == 'true'
 646     error('XA state tracker can only be built on unix-like OSes.')
 647   else
 648     _xa = 'false'
 649   endif
 650 elif not (with_gallium_nouveau or with_gallium_freedreno or with_gallium_i915
 651           or with_gallium_svga)
 652   if _xa == 'true'
 653     error('XA state tracker requires at least one of the following gallium drivers: nouveau, freedreno, i915, svga.')
 654   else
 655     _xa = 'false'
 656   endif
 657 endif
 658 with_gallium_xa = _xa != 'false'
 659
 660 d3d_drivers_path = get_option('d3d-drivers-path')
 661 if d3d_drivers_path == ''
 662   d3d_drivers_path = join_paths(get_option('prefix'), get_option('libdir'), 'd3d')
 663 endif
 664
 665 with_gallium_st_nine =  get_option('gallium-nine')
 666 if with_gallium_st_nine
 667   if not with_gallium_softpipe
 668     error('The nine state tracker requires gallium softpipe/llvmpipe.')
 669   elif not (with_gallium_radeonsi or with_gallium_nouveau or with_gallium_r600
 670             or with_gallium_r300 or with_gallium_svga or with_gallium_i915
 671             or with_gallium_iris)
 672     error('The nine state tracker requires at least one non-swrast gallium driver.')
 673   endif
 674   if not with_dri3
 675     error('Using nine with wine requires dri3')
 676   endif
 677 endif
 678
 679 if get_option('power8') != 'false'
 680   # on old versions of meson the cpu family would return as ppc64le on little
 681   # endian power8, this was changed in 0.48 such that the family would always
 682   # be ppc64 regardless of endianness, and then the machine.endian() value
 683   # should be checked. Since we support versions < 0.48 we need to use
 684   # startswith.
 685   if host_machine.cpu_family().startswith('ppc64') and host_machine.endian() == 'little'
 686     if cc.get_id() == 'gcc' and cc.version().version_compare('< 4.8')
 687       error('Altivec is not supported with gcc version < 4.8.')
 688     endif
 689     if cc.compiles('''
 690         #include <altivec.h>
 691         int main() {
 692           vector unsigned char r;
 693           vector unsigned int v = vec_splat_u32 (1);
 694           r = __builtin_vec_vgbbd ((vector unsigned char) v);
 695           return 0;
 696         }''',
 697         args : '-mpower8-vector',
 698         name : 'POWER8 intrinsics')
 699       pre_args += ['-D_ARCH_PWR8', '-mpower8-vector']
 700     elif get_option('power8') == 'true'
 701       error('POWER8 intrinsic support required but not found.')
 702     endif
 703   endif
 704 endif
 705
 706 _opencl = get_option('gallium-opencl')
 707 clover_cpp_std = []
 708 if _opencl != 'disabled'
 709   if not with_gallium
 710     error('OpenCL Clover implementation requires at least one gallium driver.')
 711   endif
 712
 713   dep_clc = dependency('libclc')
 714   with_gallium_opencl = true
 715   with_opencl_icd = _opencl == 'icd'
 716
 717   with_opencl_spirv = get_option('opencl-spirv')
 718   if with_opencl_spirv
 719     dep_spirv_tools = dependency('SPIRV-Tools', required : true, version : '>= 2018.0')
 720     # LLVMSPIRVLib is available at https://github.com/KhronosGroup/SPIRV-LLVM-Translator
 721     dep_llvmspirvlib = dependency('LLVMSPIRVLib', required : true, version : '>= 0.2.1')
 722   else
 723     dep_spirv_tools = null_dep
 724     dep_llvmspirvlib = null_dep
 725   endif
 726
 727   if host_machine.cpu_family().startswith('ppc') and cpp.compiles('''
 728       #if !defined(__VEC__) || !defined(__ALTIVEC__)
 729       #error "AltiVec not enabled"
 730       #endif''',
 731       name : 'Altivec')
 732     clover_cpp_std += ['cpp_std=gnu++11']
 733   endif
 734 else
 735   dep_clc = null_dep
 736   dep_spirv_tools = null_dep
 737   dep_llvmspirvlib = null_dep
 738   with_gallium_opencl = false
 739   with_opencl_icd = false
 740   with_opencl_spirv = false
 741 endif
 742
 743 gl_pkgconfig_c_flags = []
 744 if with_platform_x11
 745   if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
 746     pre_args += '-DHAVE_X11_PLATFORM'
 747   endif
 748   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
 749     pre_args += '-DUSE_XSHM'
 750   else
 751     pre_args += '-DGLX_INDIRECT_RENDERING'
 752     if with_glx_direct
 753       pre_args += '-DGLX_DIRECT_RENDERING'
 754     endif
 755     if with_dri_platform == 'drm'
 756       pre_args += '-DGLX_USE_DRM'
 757     elif with_dri_platform == 'apple'
 758       pre_args += '-DGLX_USE_APPLEGL'
 759     elif with_dri_platform == 'windows'
 760       pre_args += '-DGLX_USE_WINDOWSGL'
 761     endif
 762   endif
 763 else
 764   pre_args += '-DEGL_NO_X11'
 765   gl_pkgconfig_c_flags += '-DEGL_NO_X11'
 766 endif
 767 if with_platform_drm
 768   if with_egl and not with_gbm
 769     error('EGL drm platform requires gbm')
 770   endif
 771   pre_args += '-DHAVE_DRM_PLATFORM'
 772 endif
 773 if with_platform_surfaceless
 774   pre_args += '-DHAVE_SURFACELESS_PLATFORM'
 775 endif
 776 if with_platform_android
 777   dep_android = [
 778     dependency('cutils'),
 779     dependency('hardware'),
 780     dependency('sync'),
 781   ]
 782   if get_option('platform-sdk-version') >= 26
 783     dep_android += dependency('nativewindow')
 784   endif
 785   pre_args += '-DHAVE_ANDROID_PLATFORM'
 786 endif
 787 if with_platform_haiku
 788   pre_args += '-DHAVE_HAIKU_PLATFORM'
 789 endif
 790
 791 if meson.version().version_compare('>=0.50')
 792   prog_python = import('python').find_installation('python3')
 793 else
 794   prog_python = import('python3').find_python()
 795 endif
 796 has_mako = run_command(
 797   prog_python, '-c',
 798   '''
 799 from distutils.version import StrictVersion
 800 import mako
 801 assert StrictVersion(mako.__version__) > StrictVersion("0.8.0")
 802   ''')
 803 if has_mako.returncode() != 0
 804   error('Python (3.x) mako module >= 0.8.0 required to build mesa.')
 805 endif
 806
 807 if cc.get_id() == 'gcc' and cc.version().version_compare('< 4.4.6')
 808   error('When using GCC, version 4.4.6 or later is required.')
 809 endif
 810
 811 # Support systems without ETIME (e.g. FreeBSD)
 812 if cc.get_define('ETIME', prefix : '#include <errno.h>') == ''
 813   pre_args += '-DETIME=ETIMEDOUT'
 814 endif
 815
 816 # Define DEBUG for debug builds only (debugoptimized is not included on this one)
 817 if get_option('buildtype') == 'debug'
 818   pre_args += '-DDEBUG'
 819 endif
 820
 821 with_shader_cache = false
 822 _shader_cache = get_option('shader-cache')
 823 if _shader_cache != 'false'
 824   if host_machine.system() == 'windows'
 825     if _shader_cache == 'true'
 826       error('Shader Cache does not currently work on Windows')
 827     endif
 828   else
 829     pre_args += '-DENABLE_SHADER_CACHE'
 830     with_shader_cache = true
 831   endif
 832 endif
 833 if with_amd_vk and not with_shader_cache
 834   error('Radv requires shader cache support')
 835 endif
 836
 837 # Check for GCC style builtins
 838 foreach b : ['bswap32', 'bswap64', 'clz', 'clzll', 'ctz', 'expect', 'ffs',
 839              'ffsll', 'popcount', 'popcountll', 'unreachable']
 840   if cc.has_function(b)
 841     pre_args += '-DHAVE___BUILTIN_@0@'.format(b.to_upper())
 842   endif
 843 endforeach
 844
 845 # check for GCC __attribute__
 846 foreach a : ['const', 'flatten', 'malloc', 'pure', 'unused',
 847              'warn_unused_result', 'weak',]
 848   if cc.compiles('int foo(void) __attribute__((@0@));'.format(a),
 849                  name : '__attribute__((@0@))'.format(a))
 850     pre_args += '-DHAVE_FUNC_ATTRIBUTE_@0@'.format(a.to_upper())
 851   endif
 852 endforeach
 853 if cc.compiles('int foo(const char *p, ...) __attribute__((format(printf, 1, 2)));',
 854                name : '__attribute__((format(...)))')
 855   pre_args += '-DHAVE_FUNC_ATTRIBUTE_FORMAT'
 856 endif
 857 if cc.compiles('struct __attribute__((packed)) foo { int bar; };',
 858                name : '__attribute__((packed))')
 859   pre_args += '-DHAVE_FUNC_ATTRIBUTE_PACKED'
 860 endif
 861 if cc.compiles('int *foo(void) __attribute__((returns_nonnull));',
 862                name : '__attribute__((returns_nonnull))')
 863   pre_args += '-DHAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL'
 864 endif
 865 if cc.compiles('''int foo_def(void) __attribute__((visibility("default")));
 866                   int foo_hid(void) __attribute__((visibility("hidden")));
 867                   int foo_int(void) __attribute__((visibility("internal")));
 868                   int foo_pro(void) __attribute__((visibility("protected")));''',
 869                name : '__attribute__((visibility(...)))')
 870   pre_args += '-DHAVE_FUNC_ATTRIBUTE_VISIBILITY'
 871 endif
 872 if cc.compiles('int foo(void) { return 0; } int bar(void) __attribute__((alias("foo")));',
 873                name : '__attribute__((alias(...)))')
 874   pre_args += '-DHAVE_FUNC_ATTRIBUTE_ALIAS'
 875 endif
 876 if cc.compiles('int foo(void) __attribute__((__noreturn__));',
 877                name : '__attribute__((__noreturn__))')
 878   pre_args += '-DHAVE_FUNC_ATTRIBUTE_NORETURN'
 879 endif
 880 if cc.compiles('__uint128_t foo(void) { return 0; }',
 881                name : '__uint128_t')
 882   pre_args += '-DHAVE_UINT128'
 883 endif
 884
 885 # TODO: this is very incomplete
 886 if ['linux', 'cygwin', 'gnu', 'gnu/kfreebsd'].contains(host_machine.system())
 887   pre_args += '-D_GNU_SOURCE'
 888 elif host_machine.system() == 'sunos'
 889   pre_args += '-D__EXTENSIONS__'
 890 elif host_machine.system() == 'windows'
 891   pre_args += [
 892     '-D_WINDOWS', '-D_WIN32_WINNT=0x0601', '-D_WINVER=0x0601',
 893     '-DPIPE_SUBSYSTEM_WINDOWS_USER',
 894     '-D_USE_MATH_DEFINES',  # XXX: scons doesn't use this for mingw
 895   ]
 896   if cc.get_id() == 'msvc'
 897     pre_args += [
 898       '-DVC_EXTRALEAN',
 899       '-D_CRT_SECURE_NO_WARNINGS',
 900       '-D_CRT_SECURE_NO_DEPRECATE',
 901       '-D_SCL_SECURE_NO_WARNINGS',
 902       '-D_SCL_SECURE_NO_DEPRECATE',
 903       '-D_ALLOW_KEYWORD_MACROS',
 904       '-D_HAS_EXCEPTIONS=0', # Tell C++ STL to not use exceptions
 905     ]
 906   else
 907     pre_args += ['-D__MSVCRT_VERSION__=0x0700']
 908   endif
 909 endif
 910
 911 # Check for generic C arguments
 912 c_args = []
 913 c_vis_args = []
 914 c_msvc_compat_args = []
 915 no_override_init_args = []
 916 cpp_args = []
 917 cpp_vis_args = []
 918 cpp_msvc_compat_args = []
 919 if cc.get_id() == 'msvc'
 920   foreach a : ['/wd4018',  # signed/unsigned mismatch
 921                '/wd4056',  # overflow in floating-point constant arithmetic
 922                '/wd4244',  # conversion from 'type1' to 'type2', possible loss of data
 923                '/wd4267',  # 'var' : conversion from 'size_t' to 'type', possible loss of data
 924                '/wd4305',  # trancation from 'type1' to 'type2'
 925                '/wd4351',  # new behavior: elements of array 'array' will be default initialized
 926                '/wd4756',  # overflow in constant arithmetic
 927                '/wd4800',  # forcing value to bool 'true' or 'false' (performance warning)
 928                '/wd4996',  # disabled deprecated POSIX name warnings
 929                '/wd4291']  # no matching operator delete found
 930     if cc.has_argument(a)
 931       c_args += a
 932     endif
 933     if cpp.has_argument(a)
 934       cpp_args += a
 935     endif
 936   endforeach
 937   if cc.has_argument('-Wmicrosoft-enum-value')  # Clang
 938     c_args += '-Wno-microsoft-enum-value'
 939     cpp_args += '-Wno-microsoft-enum-value'
 940   endif
 941 else
 942   _trial = [
 943     '-Werror=implicit-function-declaration',
 944     '-Werror=missing-prototypes',
 945     '-Werror=return-type',
 946     '-Werror=incompatible-pointer-types',
 947     '-Wno-missing-field-initializers',
 948     '-Wno-format-truncation',
 949     '-fno-math-errno',
 950     '-fno-trapping-math',
 951     '-Qunused-arguments',
 952   ]
 953   # MinGW chokes on format specifiers and I can't get it all working
 954   if not (cc.get_id() == 'gcc' and host_machine.system() == 'windows')
 955     _trial += ['-Werror=format', '-Wformat-security']
 956   endif
 957   foreach a : _trial
 958     if cc.has_argument(a)
 959       c_args += a
 960     endif
 961   endforeach
 962
 963   _trial = [
 964     '-Werror=return-type',
 965     '-Wno-non-virtual-dtor',
 966     '-Wno-missing-field-initializers',
 967     '-Wno-format-truncation',
 968     '-fno-math-errno',
 969     '-fno-trapping-math',
 970     '-Qunused-arguments',
 971   ]
 972   # MinGW chokes on format specifiers and I can't get it all working
 973   if not (cc.get_id() == 'gcc' and host_machine.system() == 'windows')
 974     _trial += ['-Werror=format', '-Wformat-security']
 975   endif
 976   foreach a : _trial
 977     if cpp.has_argument(a)
 978       cpp_args += a
 979     endif
 980   endforeach
 981
 982   foreach a : ['-Wno-override-init', '-Wno-initializer-overrides']
 983     if cc.has_argument(a)
 984       no_override_init_args += a
 985     endif
 986   endforeach
 987
 988   if cc.has_argument('-fvisibility=hidden')
 989     c_vis_args += '-fvisibility=hidden'
 990   endif
 991
 992   # Check for C and C++ arguments for MSVC2013 compatibility. These are only
 993   # used in parts of the mesa code base that need to compile with old versions
 994   # of MSVC, mainly common code
 995   foreach a : ['-Werror=pointer-arith', '-Werror=vla']
 996     if cc.has_argument(a)
 997       c_msvc_compat_args += a
 998     endif
 999     if cpp.has_argument(a)
1000       cpp_msvc_compat_args += a
1001     endif
1002   endforeach
1003
1004   if cpp.has_argument('-fvisibility=hidden')
1005     cpp_vis_args += '-fvisibility=hidden'
1006   endif
1007
1008 endif
1009
1010 # set linker arguments
1011 if host_machine.system() == 'windows'
1012   if cc.get_id() == 'msvc'
1013     add_project_link_arguments(
1014       '/fixed:no',
1015       '/incremental:no',
1016       '/dynamicbase',
1017       '/nxcompat',
1018       language : ['c', 'cpp'],
1019     )
1020   else
1021     add_project_link_arguments(
1022       '-Wl,--nxcompat',
1023       '-Wl,--dynamicbase',
1024       '-static-libgcc',
1025       '-static-libstdc++',
1026       language : ['c', 'cpp'],
1027     )
1028   endif
1029 endif
1030
1031 if host_machine.cpu_family().startswith('x86') and cc.get_id() != 'msvc'
1032   pre_args += '-DUSE_SSE41'
1033   with_sse41 = true
1034   sse41_args = ['-msse4.1']
1035
1036   # GCC on x86 (not x86_64) with -msse* assumes a 16 byte aligned stack, but
1037   # that's not guaranteed
1038   if host_machine.cpu_family() == 'x86'
1039     sse41_args += '-mstackrealign'
1040   endif
1041 else
1042   with_sse41 = false
1043   sse41_args = []
1044 endif
1045
1046 # Check for GCC style atomics
1047 dep_atomic = null_dep
1048
1049 if cc.compiles('''#include <stdint.h>
1050                   int main() {
1051                     struct {
1052                       uint64_t *v;
1053                     } x;
1054                     return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
1055                            (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
1056
1057                   }''',
1058                name : 'GCC atomic builtins')
1059   pre_args += '-DUSE_GCC_ATOMIC_BUILTINS'
1060
1061   # Not all atomic calls can be turned into lock-free instructions, in which
1062   # GCC will make calls into the libatomic library. Check whether we need to
1063   # link with -latomic.
1064   #
1065   # This can happen for 64-bit atomic operations on 32-bit architectures such
1066   # as ARM.
1067   if not cc.links('''#include <stdint.h>
1068                      int main() {
1069                        struct {
1070                          uint64_t *v;
1071                        } x;
1072                        return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
1073                               (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
1074                      }''',
1075                   name : 'GCC atomic builtins required -latomic')
1076     dep_atomic = cc.find_library('atomic')
1077   endif
1078 endif
1079 if not cc.links('''#include <stdint.h>
1080                    uint64_t v;
1081                    int main() {
1082                      return __sync_add_and_fetch(&v, (uint64_t)1);
1083                    }''',
1084                 dependencies : dep_atomic,
1085                 name : 'GCC 64bit atomics')
1086   pre_args += '-DMISSING_64BIT_ATOMICS'
1087 endif
1088
1089 dep_ws2_32 = cc.find_library('ws2_32', required : with_platform_windows)
1090
1091 # TODO: shared/static? Is this even worth doing?
1092
1093 with_asm_arch = ''
1094 if host_machine.cpu_family() == 'x86'
1095   if system_has_kms_drm or host_machine.system() == 'gnu'
1096     with_asm_arch = 'x86'
1097     pre_args += ['-DUSE_X86_ASM', '-DUSE_MMX_ASM', '-DUSE_3DNOW_ASM',
1098                  '-DUSE_SSE_ASM']
1099
1100     if with_glx_read_only_text
1101       pre_args += ['-DGLX_X86_READONLY_TEXT']
1102     endif
1103   endif
1104 elif host_machine.cpu_family() == 'x86_64'
1105   if system_has_kms_drm
1106     with_asm_arch = 'x86_64'
1107     pre_args += ['-DUSE_X86_64_ASM']
1108   endif
1109 elif host_machine.cpu_family() == 'arm'
1110   if system_has_kms_drm
1111     with_asm_arch = 'arm'
1112     pre_args += ['-DUSE_ARM_ASM']
1113   endif
1114 elif host_machine.cpu_family() == 'aarch64'
1115   if system_has_kms_drm
1116     with_asm_arch = 'aarch64'
1117     pre_args += ['-DUSE_AARCH64_ASM']
1118   endif
1119 elif host_machine.cpu_family() == 'sparc64'
1120   if system_has_kms_drm
1121     with_asm_arch = 'sparc'
1122     pre_args += ['-DUSE_SPARC_ASM']
1123   endif
1124 elif host_machine.cpu_family().startswith('ppc64') and host_machine.endian() == 'little'
1125   if system_has_kms_drm
1126     with_asm_arch = 'ppc64le'
1127     pre_args += ['-DUSE_PPC64LE_ASM']
1128   endif
1129 endif
1130
1131 # Check for standard headers and functions
1132 if (cc.has_header_symbol('sys/sysmacros.h', 'major') and
1133   cc.has_header_symbol('sys/sysmacros.h', 'minor') and
1134   cc.has_header_symbol('sys/sysmacros.h', 'makedev'))
1135   pre_args += '-DMAJOR_IN_SYSMACROS'
1136 endif
1137 if (cc.has_header_symbol('sys/mkdev.h', 'major') and
1138   cc.has_header_symbol('sys/mkdev.h', 'minor') and
1139   cc.has_header_symbol('sys/mkdev.h', 'makedev'))
1140   pre_args += '-DMAJOR_IN_MKDEV'
1141 endif
1142
1143 foreach h : ['xlocale.h', 'sys/sysctl.h', 'linux/futex.h', 'endian.h', 'dlfcn.h', 'execinfo.h', 'sys/shm.h', 'cet.h']
1144   if cc.compiles('#include <@0@>'.format(h), name : '@0@'.format(h))
1145     pre_args += '-DHAVE_@0@'.format(h.to_upper().underscorify())
1146   endif
1147 endforeach
1148
1149 foreach f : ['strtof', 'mkostemp', 'timespec_get', 'memfd_create', 'random_r', 'flock']
1150   if cc.has_function(f)
1151     pre_args += '-DHAVE_@0@'.format(f.to_upper())
1152   endif
1153 endforeach
1154
1155 if cc.has_header_symbol('errno.h', 'program_invocation_name',
1156                         args : '-D_GNU_SOURCE')
1157    pre_args += '-DHAVE_PROGRAM_INVOCATION_NAME'
1158 elif with_tools.contains('intel')
1159   error('Intel tools require the program_invocation_name variable')
1160 endif
1161
1162 # MinGW provides a __builtin_posix_memalign function, but not a posix_memalign.
1163 # This means that this check will succeed, but then compilation will later
1164 # fail. MSVC doesn't have this function at all, so only check for it on
1165 # non-windows platforms.
1166 if host_machine.system() != 'windows'
1167   if cc.has_function('posix_memalign')
1168     pre_args += '-DHAVE_POSIX_MEMALIGN'
1169   endif
1170 endif
1171
1172 # strtod locale support
1173 if cc.links('''
1174     #define _GNU_SOURCE
1175     #include <stdlib.h>
1176     #include <locale.h>
1177     #ifdef HAVE_XLOCALE_H
1178     #include <xlocale.h>
1179     #endif
1180     int main() {
1181       locale_t loc = newlocale(LC_CTYPE_MASK, "C", NULL);
1182       const char *s = "1.0";
1183       char *end;
1184       double d = strtod_l(s, end, loc);
1185       float f = strtof_l(s, end, loc);
1186       freelocale(loc);
1187       return 0;
1188     }''',
1189     args : pre_args,
1190     name : 'strtod has locale support')
1191   pre_args += '-DHAVE_STRTOD_L'
1192 endif
1193
1194 # Check for some linker flags
1195 ld_args_bsymbolic = []
1196 if cc.links('int main() { return 0; }', args : '-Wl,-Bsymbolic', name : 'Bsymbolic')
1197   ld_args_bsymbolic += '-Wl,-Bsymbolic'
1198 endif
1199 ld_args_gc_sections = []
1200 if cc.links('static char unused() { return 5; } int main() { return 0; }',
1201             args : '-Wl,--gc-sections', name : 'gc-sections')
1202   ld_args_gc_sections += '-Wl,--gc-sections'
1203 endif
1204 with_ld_version_script = false
1205 if cc.links('int main() { return 0; }',
1206             args : '-Wl,--version-script=@0@'.format(
1207               join_paths(meson.source_root(), 'build-support/conftest.map')),
1208             name : 'version-script')
1209   with_ld_version_script = true
1210 endif
1211 with_ld_dynamic_list = false
1212 if cc.links('int main() { return 0; }',
1213             args : '-Wl,--dynamic-list=@0@'.format(
1214               join_paths(meson.source_root(), 'build-support/conftest.dyn')),
1215             name : 'dynamic-list')
1216   with_ld_dynamic_list = true
1217 endif
1218
1219 ld_args_build_id = cc.get_supported_link_arguments('-Wl,--build-id=sha1')
1220
1221 # check for dl support
1222 dep_dl = null_dep
1223 if host_machine.system() != 'windows'
1224   if not cc.has_function('dlopen')
1225     dep_dl = cc.find_library('dl')
1226   endif
1227   if cc.has_function('dladdr', dependencies : dep_dl)
1228     # This is really only required for megadrivers
1229     pre_args += '-DHAVE_DLADDR'
1230   endif
1231 endif
1232
1233 if cc.has_function('dl_iterate_phdr')
1234   pre_args += '-DHAVE_DL_ITERATE_PHDR'
1235 elif with_intel_vk
1236   error('Intel "Anvil" Vulkan driver requires the dl_iterate_phdr function')
1237 elif with_dri_i965 and with_shader_cache
1238   error('Intel i965 GL driver requires dl_iterate_phdr when built with shader caching.')
1239 endif
1240
1241 # Determine whether or not the rt library is needed for time functions
1242 if host_machine.system() == 'windows' or cc.has_function('clock_gettime')
1243   dep_clock = null_dep
1244 else
1245   dep_clock = cc.find_library('rt')
1246 endif
1247
1248 # TODO: some of these may be conditional
1249 dep_zlib = dependency('zlib', version : '>= 1.2.3', fallback : ['zlib', 'zlib_dep'])
1250 pre_args += '-DHAVE_ZLIB'
1251 dep_thread = dependency('threads')
1252 if dep_thread.found() and host_machine.system() != 'windows'
1253   pre_args += '-DHAVE_PTHREAD'
1254   if cc.has_function(
1255       'pthread_setaffinity_np',
1256       dependencies : dep_thread,
1257       prefix : '#include <pthread.h>',
1258       args : '-D_GNU_SOURCE')
1259     pre_args += '-DHAVE_PTHREAD_SETAFFINITY'
1260   endif
1261   if cc.has_function(
1262       'pthread_setaffinity_np',
1263       dependencies : dep_thread,
1264       prefix : '#include <pthread_np.h>')
1265     pre_args += '-DPTHREAD_SETAFFINITY_IN_NP_HEADER'
1266   endif
1267 endif
1268 if host_machine.system() != 'windows'
1269   dep_expat = dependency('expat', fallback : ['expat', 'expat_dep'])
1270 else
1271   dep_expat = null_dep
1272 endif
1273 # this only exists on linux so either this is linux and it will be found, or
1274 # it's not linux and wont
1275 dep_m = cc.find_library('m', required : false)
1276
1277 # Check for libdrm. Various drivers have different libdrm version requirements,
1278 # but we always want to use the same version for all libdrm modules. That means
1279 # even if driver foo requires 2.4.0 and driver bar requires 2.4.3, if foo and
1280 # bar are both on use 2.4.3 for both of them
1281 dep_libdrm_amdgpu = null_dep
1282 dep_libdrm_radeon = null_dep
1283 dep_libdrm_nouveau = null_dep
1284 dep_libdrm_intel = null_dep
1285
1286 _drm_amdgpu_ver = '2.4.99'
1287 _drm_radeon_ver = '2.4.71'
1288 _drm_nouveau_ver = '2.4.66'
1289 _drm_intel_ver = '2.4.75'
1290 _drm_ver = '2.4.81'
1291
1292 _libdrm_checks = [
1293   ['intel', with_dri_i915 or with_gallium_i915],
1294   ['amdgpu', with_amd_vk or with_gallium_radeonsi],
1295   ['radeon', (with_gallium_radeonsi or with_dri_r100 or with_dri_r200 or
1296               with_gallium_r300 or with_gallium_r600)],
1297   ['nouveau', (with_gallium_nouveau or with_dri_nouveau)],
1298 ]
1299
1300 # VC4 only needs core libdrm support of this version, not a libdrm_vc4
1301 # library.
1302 if with_gallium_vc4
1303   _drm_ver = '2.4.89'
1304 endif
1305
1306 # etnaviv only needs core libdrm
1307 if with_gallium_etnaviv
1308   _drm_ver = '2.4.89'
1309 endif
1310
1311 # Loop over the enables versions and get the highest libdrm requirement for all
1312 # active drivers.
1313 _drm_blame = ''
1314 foreach d : _libdrm_checks
1315   ver = get_variable('_drm_@0@_ver'.format(d[0]))
1316   if d[1] and ver.version_compare('>' + _drm_ver)
1317     _drm_ver = ver
1318     _drm_blame = d[0]
1319   endif
1320 endforeach
1321 if _drm_blame != ''
1322   message('libdrm @0@ needed because @1@ has the highest requirement'.format(_drm_ver, _drm_blame))
1323 endif
1324
1325 # Then get each libdrm module
1326 foreach d : _libdrm_checks
1327   if d[1]
1328     set_variable(
1329       'dep_libdrm_' + d[0],
1330       dependency('libdrm_' + d[0], version : '>=' + _drm_ver)
1331     )
1332   endif
1333 endforeach
1334
1335 with_gallium_drisw_kms = false
1336 dep_libdrm = dependency(
1337   'libdrm', version : '>=' + _drm_ver,
1338   required : with_dri2 or with_dri3
1339 )
1340 if dep_libdrm.found()
1341   pre_args += '-DHAVE_LIBDRM'
1342   if with_dri_platform == 'drm' and with_dri
1343     with_gallium_drisw_kms = true
1344   endif
1345 endif
1346
1347 llvm_modules = ['bitwriter', 'engine', 'mcdisassembler', 'mcjit']
1348 llvm_optional_modules = ['coroutines']
1349 if with_amd_vk or with_gallium_radeonsi or with_gallium_r600
1350   llvm_modules += ['amdgpu', 'native', 'bitreader', 'ipo']
1351   if with_gallium_r600
1352     llvm_modules += 'asmparser'
1353   endif
1354 endif
1355 if with_gallium_opencl
1356   llvm_modules += [
1357     'all-targets', 'linker', 'coverage', 'instrumentation', 'ipo', 'irreader',
1358     'lto', 'option', 'objcarcopts', 'profiledata',
1359   ]
1360 endif
1361
1362 if with_amd_vk or with_gallium_radeonsi
1363   _llvm_version = '>= 8.0.0'
1364 elif with_gallium_swr
1365   _llvm_version = '>= 6.0.0'
1366 else
1367   _llvm_version = '>= 3.9.0'
1368 endif
1369
1370 _shared_llvm = get_option('shared-llvm')
1371
1372 _llvm = get_option('llvm')
1373 dep_llvm = null_dep
1374 with_llvm = false
1375 if _llvm != 'false'
1376   dep_llvm = dependency(
1377     'llvm',
1378     version : _llvm_version,
1379     modules : llvm_modules,
1380     optional_modules : llvm_optional_modules,
1381     required : (
1382       with_amd_vk or with_gallium_radeonsi or with_gallium_swr or
1383       with_gallium_opencl or _llvm == 'true'
1384     ),
1385     static : not _shared_llvm,
1386     method : 'config-tool',
1387   )
1388   with_llvm = dep_llvm.found()
1389 endif
1390 if with_llvm
1391   pre_args += '-DLLVM_AVAILABLE'
1392   pre_args += '-DMESA_LLVM_VERSION_STRING="@0@"'.format(dep_llvm.version())
1393
1394   # LLVM can be built without rtti, turning off rtti changes the ABI of C++
1395   # programs, so we need to build all C++ code in mesa without rtti as well to
1396   # ensure that linking works.
1397   if dep_llvm.get_configtool_variable('has-rtti') == 'NO'
1398     if with_gallium_nouveau
1399       error('The Nouveau driver requires rtti. You either need to turn off nouveau or use an LLVM built with LLVM_ENABLE_RTTI.')
1400     elif with_gallium_opencl
1401       error('The Clover OpenCL state tracker requires rtti, you need to turn off clover or use an LLVM built with LLVM_ENABLE_RTTI.')
1402     endif
1403     if cc.get_id() == 'msvc'
1404       cpp_args += '/GR-'
1405     else
1406       cpp_args += '-fno-rtti'
1407     endif
1408   endif
1409 elif with_amd_vk or with_gallium_radeonsi or with_gallium_swr
1410   error('The following drivers require LLVM: Radv, RadeonSI, SWR. One of these is enabled, but LLVM is disabled.')
1411 elif with_gallium_opencl
1412   error('The OpenCL "Clover" state tracker requires LLVM, but LLVM is disabled.')
1413 endif
1414
1415 if (with_amd_vk or with_gallium_radeonsi or with_gallium_opencl or
1416     (with_gallium_r600 and with_llvm))
1417   dep_elf = dependency('libelf', required : false)
1418   if not dep_elf.found()
1419     dep_elf = cc.find_library('elf')
1420   endif
1421 else
1422   dep_elf = null_dep
1423 endif
1424
1425 dep_glvnd = null_dep
1426 glvnd_has_headers_and_pc_files = false
1427 if with_glvnd
1428   dep_glvnd = dependency('libglvnd', version : '>= 0.2.0')
1429   # GLVND before 1.2 was missing its pkg-config and header files, forcing every
1430   # vendor to provide them and the distro maintainers to resolve the conflict.
1431   glvnd_has_headers_and_pc_files = dep_glvnd.version().version_compare('>= 1.2.0')
1432   pre_args += '-DUSE_LIBGLVND=1'
1433 endif
1434
1435 if with_valgrind != 'false'
1436   dep_valgrind = dependency('valgrind', required : with_valgrind == 'true')
1437   if dep_valgrind.found()
1438     pre_args += '-DHAVE_VALGRIND'
1439   endif
1440 else
1441   dep_valgrind = null_dep
1442 endif
1443
1444 # pthread stubs. Lets not and say we didn't
1445
1446 if host_machine.system() == 'windows'
1447   # Prefer the winflexbison versions, they're much easier to install and have
1448   # better windows support.
1449
1450   prog_flex = find_program('win_flex', required : false)
1451   if prog_flex.found()
1452     # windows compatibility (uses <io.h> instead of <unistd.h> and _isatty,
1453     # _fileno functions)
1454     prog_flex = [prog_flex, '--wincompat']
1455   else
1456     prog_flex = [find_program('lex', 'flex', required : with_any_opengl)]
1457   endif
1458   # Force flex to use const keyword in prototypes, as relies on __cplusplus or
1459   # __STDC__ macro to determine whether it's safe to use const keyword, but
1460   # MSVC never defines __STDC__ unless we disable all MSVC extensions.
1461   prog_flex += '-DYY_USE_CONST='
1462
1463   prog_bison = find_program('win_bison', required : false)
1464   if not prog_bison.found()
1465     prog_bison = find_program('yacc', 'bison', required : with_any_opengl)
1466   endif
1467 else
1468   prog_bison = find_program('bison', required : with_any_opengl)
1469   prog_flex = find_program('flex', required : with_any_opengl)
1470 endif
1471
1472 dep_selinux = null_dep
1473 if get_option('selinux')
1474   dep_selinux = dependency('libselinux')
1475   pre_args += '-DMESA_SELINUX'
1476 endif
1477
1478 if with_libunwind != 'false'
1479   dep_unwind = dependency('libunwind', required : with_libunwind == 'true')
1480   if dep_unwind.found()
1481     pre_args += '-DHAVE_LIBUNWIND'
1482   endif
1483 else
1484   dep_unwind = null_dep
1485 endif
1486
1487 if with_osmesa != 'none'
1488   if with_osmesa == 'gallium' and not with_gallium_softpipe
1489     error('OSMesa gallium requires gallium softpipe or llvmpipe.')
1490   endif
1491   if host_machine.system() == 'windows'
1492     osmesa_lib_name = 'osmesa'
1493   else
1494     osmesa_lib_name = 'OSMesa'
1495   endif
1496   osmesa_bits = get_option('osmesa-bits')
1497   if osmesa_bits != '8'
1498     if with_dri or with_glx != 'disabled'
1499       error('OSMesa bits must be 8 if building glx or dir based drivers')
1500     endif
1501     osmesa_lib_name = osmesa_lib_name + osmesa_bits
1502     pre_args += [
1503       '-DCHAN_BITS=@0@'.format(osmesa_bits), '-DDEFAULT_SOFTWARE_DEPTH_BITS=31'
1504     ]
1505   endif
1506 endif
1507
1508 # TODO: symbol mangling
1509
1510 if with_platform_wayland
1511   dep_wl_scanner = dependency('wayland-scanner', native: true)
1512   prog_wl_scanner = find_program(dep_wl_scanner.get_pkgconfig_variable('wayland_scanner'))
1513   if dep_wl_scanner.version().version_compare('>= 1.15')
1514     wl_scanner_arg = 'private-code'
1515   else
1516     wl_scanner_arg = 'code'
1517   endif
1518   dep_wl_protocols = dependency('wayland-protocols', version : '>= 1.8')
1519   dep_wayland_client = dependency('wayland-client', version : '>=1.11')
1520   dep_wayland_server = dependency('wayland-server', version : '>=1.11')
1521   if with_egl
1522     dep_wayland_egl = dependency('wayland-egl-backend', version : '>= 3')
1523     dep_wayland_egl_headers = declare_dependency(
1524       compile_args : run_command(prog_pkgconfig, ['wayland-egl-backend', '--cflags']).stdout().split())
1525   endif
1526   wayland_dmabuf_xml = join_paths(
1527     dep_wl_protocols.get_pkgconfig_variable('pkgdatadir'), 'unstable',
1528     'linux-dmabuf', 'linux-dmabuf-unstable-v1.xml'
1529   )
1530   pre_args += ['-DHAVE_WAYLAND_PLATFORM', '-DWL_HIDE_DEPRECATED']
1531 endif
1532
1533 dep_x11 = null_dep
1534 dep_xext = null_dep
1535 dep_xdamage = null_dep
1536 dep_xfixes = null_dep
1537 dep_x11_xcb = null_dep
1538 dep_xcb = null_dep
1539 dep_xcb_glx = null_dep
1540 dep_xcb_dri2 = null_dep
1541 dep_xcb_dri3 = null_dep
1542 dep_dri2proto = null_dep
1543 dep_glproto = null_dep
1544 dep_xxf86vm = null_dep
1545 dep_xcb_dri3 = null_dep
1546 dep_xcb_present = null_dep
1547 dep_xcb_sync = null_dep
1548 dep_xcb_xfixes = null_dep
1549 dep_xshmfence = null_dep
1550 dep_xcb_xrandr = null_dep
1551 dep_xlib_xrandr = null_dep
1552 if with_platform_x11
1553   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1554     dep_x11 = dependency('x11')
1555     dep_xext = dependency('xext')
1556     dep_xcb = dependency('xcb')
1557   elif with_glx == 'dri'
1558     dep_x11 = dependency('x11')
1559     dep_xext = dependency('xext')
1560     dep_xdamage = dependency('xdamage', version : '>= 1.1')
1561     dep_xfixes = dependency('xfixes')
1562     dep_xcb_glx = dependency('xcb-glx', version : '>= 1.8.1')
1563   endif
1564   if (with_any_vk or with_glx == 'dri' or with_egl or
1565        (with_gallium_vdpau or with_gallium_xvmc or with_gallium_va or
1566         with_gallium_omx != 'disabled'))
1567     dep_xcb = dependency('xcb')
1568     dep_x11_xcb = dependency('x11-xcb')
1569     if with_dri_platform == 'drm' and not dep_libdrm.found()
1570       error('libdrm required for gallium video statetrackers when using x11')
1571     endif
1572   endif
1573   if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
1574     dep_xcb_dri2 = dependency('xcb-dri2', version : '>= 1.8')
1575
1576     if with_dri3
1577       pre_args += '-DHAVE_DRI3'
1578       dep_xcb_dri3 = dependency('xcb-dri3')
1579       dep_xcb_present = dependency('xcb-present')
1580       # until xcb-dri3 has been around long enough to make a hard-dependency:
1581       if (dep_xcb_dri3.version().version_compare('>= 1.13') and
1582           dep_xcb_present.version().version_compare('>= 1.13'))
1583         pre_args += '-DHAVE_DRI3_MODIFIERS'
1584       endif
1585       dep_xcb_sync = dependency('xcb-sync')
1586       dep_xshmfence = dependency('xshmfence', version : '>= 1.1')
1587     endif
1588   endif
1589   if with_glx == 'dri' or with_glx == 'gallium-xlib'
1590     dep_glproto = dependency('glproto', version : '>= 1.4.14')
1591   endif
1592   if with_glx == 'dri'
1593     if with_dri_platform == 'drm'
1594       dep_dri2proto = dependency('dri2proto', version : '>= 2.8')
1595       dep_xxf86vm = dependency('xxf86vm')
1596     endif
1597   endif
1598   if (with_egl or (
1599       with_gallium_vdpau or with_gallium_xvmc or with_gallium_xa or
1600       with_gallium_omx != 'disabled'))
1601     dep_xcb_xfixes = dependency('xcb-xfixes')
1602   endif
1603   if with_xlib_lease
1604     dep_xcb_xrandr = dependency('xcb-randr')
1605     dep_xlib_xrandr = dependency('xrandr', version : '>= 1.3')
1606   endif
1607 endif
1608
1609 if get_option('gallium-extra-hud')
1610   pre_args += '-DHAVE_GALLIUM_EXTRA_HUD=1'
1611 endif
1612
1613 _sensors = get_option('lmsensors')
1614 if _sensors != 'false'
1615   dep_lmsensors = cc.find_library('sensors', required : _sensors == 'true')
1616   if dep_lmsensors.found()
1617     pre_args += '-DHAVE_LIBSENSORS=1'
1618   endif
1619 else
1620   dep_lmsensors = null_dep
1621 endif
1622
1623 foreach a : pre_args
1624   add_project_arguments(a, language : ['c', 'cpp'])
1625 endforeach
1626 foreach a : c_args
1627   add_project_arguments(a, language : ['c'])
1628 endforeach
1629 foreach a : cpp_args
1630   add_project_arguments(a, language : ['cpp'])
1631 endforeach
1632
1633 gl_priv_reqs = []
1634
1635 if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1636   gl_priv_reqs += ['x11', 'xext', 'xcb']
1637 elif with_glx == 'dri'
1638   gl_priv_reqs += [
1639     'x11', 'xext', 'xdamage >= 1.1', 'xfixes', 'x11-xcb', 'xcb',
1640     'xcb-glx >= 1.8.1']
1641   if with_dri_platform == 'drm'
1642     gl_priv_reqs += 'xcb-dri2 >= 1.8'
1643     gl_priv_reqs += 'xxf86vm'
1644   endif
1645 endif
1646 if dep_libdrm.found()
1647   gl_priv_reqs += 'libdrm >= 2.4.75'
1648 endif
1649
1650 gl_priv_libs = []
1651 if dep_thread.found()
1652   gl_priv_libs += ['-lpthread', '-pthread']
1653 endif
1654 if dep_m.found()
1655   gl_priv_libs += '-lm'
1656 endif
1657 if dep_dl.found()
1658   gl_priv_libs += '-ldl'
1659 endif
1660
1661 pkg = import('pkgconfig')
1662
1663 prog_nm = find_program('nm', required : false)
1664
1665 # This quirk needs to be applied to sources with functions defined in assembly
1666 # as GCC LTO drops them. See: https://bugs.freedesktop.org/show_bug.cgi?id=109391
1667 gcc_lto_quirk = (cc.get_id() == 'gcc') ? ['-fno-lto'] : []
1668
1669 subdir('include')
1670 subdir('bin')
1671 subdir('src')
1672
1673 # Meson 0.49 and earlier seems to have a bug that fails to evaluate the string-
1674 # formatting below unless the first argument is passed as a variable. This has
1675 # been fixed in Meson 0.50 and beyond, but we need to keep it like this for now
1676 # for backwards compatibility.
1677 _with_opengl_string = with_opengl ? 'yes' : 'no'
1678
1679 lines = ['',
1680   'prefix:          ' + get_option('prefix'),
1681   'libdir:          ' + get_option('libdir'),
1682   'includedir:      ' + get_option('includedir'),
1683   '',
1684   'OpenGL:          @0@ (ES1: @1@ ES2: @2@)'.format(_with_opengl_string,
1685                                                     with_gles1 ? 'yes' : 'no',
1686                                                     with_gles2 ? 'yes' : 'no'),
1687 ]
1688
1689 if with_osmesa != 'none'
1690   lines += ''
1691   suffix = ''
1692   if with_osmesa == 'gallium'
1693     suffix = '(Gallium)'
1694   endif
1695   lines += 'OSMesa:          lib' + osmesa_lib_name + suffix
1696 else
1697   lines += 'OSMesa:          no'
1698 endif
1699
1700 if with_dri
1701   lines += ''
1702   lines += 'DRI platform:    ' + with_dri_platform
1703   if dri_drivers.length() != 0 and dri_drivers != ['']
1704     lines += 'DRI drivers:     ' + ' '.join(dri_drivers)
1705   else
1706     lines += 'DRI drivers:     no'
1707   endif
1708   lines += 'DRI driver dir:  ' + dri_drivers_path
1709 endif
1710
1711 if with_glx != 'disabled'
1712   lines += ''
1713   if with_glx == 'dri'
1714     lines += 'GLX:             DRI-based'
1715   elif with_glx == 'xlib'
1716     lines += 'GLX:             Xlib-based'
1717   elif with_glx == 'gallium-xlib'
1718     lines += 'GLX:             Xlib-based (Gallium)'
1719   else
1720     lines += 'GLX:             ' + with_glx
1721   endif
1722 endif
1723
1724 lines += ''
1725 lines += 'EGL:             ' + (with_egl ? 'yes' : 'no')
1726 if with_egl
1727   egl_drivers = []
1728   if with_dri
1729     egl_drivers += 'builtin:egl_dri2'
1730   endif
1731   if with_dri3
1732     egl_drivers += 'builtin:egl_dri3'
1733   endif
1734   lines += 'EGL drivers:     ' + ' '.join(egl_drivers)
1735 endif
1736 lines += 'GBM:             ' + (with_gbm ? 'yes' : 'no')
1737 if with_platforms
1738   lines += 'EGL/Vulkan/VL platforms:   ' + ' '.join(_platforms)
1739 endif
1740
1741 lines += ''
1742 if with_any_vk
1743   lines += 'Vulkan drivers:  ' + ' '.join(_vulkan_drivers)
1744   lines += 'Vulkan ICD dir:  ' + with_vulkan_icd_dir
1745 else
1746   lines += 'Vulkan drivers:  no'
1747 endif
1748
1749 lines += ''
1750 if with_llvm
1751   lines += 'llvm:            yes'
1752   lines += 'llvm-version:    ' + dep_llvm.version()
1753 else
1754   lines += 'llvm:            no'
1755 endif
1756
1757 lines += ''
1758 if with_gallium
1759   lines += 'Gallium drivers: ' + ' '.join(gallium_drivers)
1760   gallium_st = ['mesa']
1761   if with_gallium_xa
1762     gallium_st += 'xa'
1763   endif
1764   if with_gallium_xvmc
1765     gallium_st += 'xvmc'
1766   endif
1767   if with_gallium_xvmc
1768     gallium_st += 'xvmc'
1769   endif
1770   if with_gallium_vdpau
1771     gallium_st += 'vdpau'
1772   endif
1773   if with_gallium_omx != 'disabled'
1774     gallium_st += 'omx' + with_gallium_omx
1775   endif
1776   if with_gallium_va
1777     gallium_st += 'va'
1778   endif
1779   if with_gallium_st_nine
1780     gallium_st += 'nine'
1781   endif
1782   if with_gallium_opencl
1783     gallium_st += 'clover'
1784   endif
1785   lines += 'Gallium st:      ' + ' '.join(gallium_st)
1786 else
1787   lines += 'Gallium:         no'
1788 endif
1789
1790 lines += 'HUD lmsensors:   ' + (dep_lmsensors.found() ? 'yes' : 'no')
1791
1792 lines += ''
1793 lines += 'Shared-glapi:    ' + (with_shared_glapi ? 'yes' : 'no')
1794
1795
1796 indent = '        '
1797 summary = indent + ('\n' + indent).join(lines)
1798 message('Configuration summary:\n@0@\n'.format(summary))