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://bugs.freedesktop.org/enter_bug.cgi?product=Mesa"',
  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'].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', 'windows', 'cygwin'].contains(host_machine.system())
 281     _platforms = ['x11', 'surfaceless']
 282   elif ['haiku'].contains(host_machine.system())
 283     _platforms = ['haiku']
 284   else
 285     error('Unknown OS @0@. Please pass -Dplatforms to set platforms. Patches gladly accepted to fix this.'.format(
 286           host_machine.system()))
 287   endif
 288 endif
 289
 290 with_platform_android = _platforms.contains('android')
 291 with_platform_x11 = _platforms.contains('x11')
 292 with_platform_wayland = _platforms.contains('wayland')
 293 with_platform_drm = _platforms.contains('drm')
 294 with_platform_haiku = _platforms.contains('haiku')
 295 with_platform_surfaceless = _platforms.contains('surfaceless')
 296
 297 with_platforms = false
 298 if _platforms.length() != 0 and _platforms != ['']
 299   # sanity check that list contains no empty strings
 300   if _platforms.contains('')
 301     error('Invalid argument list given to -Dplatforms, please fix.')
 302   endif
 303   with_platforms = true
 304   egl_native_platform = _platforms[0]
 305 endif
 306
 307 _xlib_lease = get_option('xlib-lease')
 308 if _xlib_lease == 'auto'
 309   with_xlib_lease = with_platform_x11 and with_platform_drm
 310 else
 311   with_xlib_lease = _xlib_lease == 'true'
 312 endif
 313
 314 with_glx = get_option('glx')
 315 if with_glx == 'auto'
 316   if with_dri
 317     with_glx = 'dri'
 318   elif with_platform_haiku
 319     with_glx = 'disabled'
 320   elif with_gallium
 321     # Even when building just gallium drivers the user probably wants dri
 322     with_glx = 'dri'
 323   elif with_platform_x11 and with_any_opengl and not with_any_vk
 324     # The automatic behavior should not be to turn on xlib based glx when
 325     # building only vulkan drivers
 326     with_glx = 'xlib'
 327   else
 328     with_glx = 'disabled'
 329   endif
 330 endif
 331 if with_glx == 'dri'
 332    if with_gallium
 333       with_dri = true
 334    endif
 335 endif
 336
 337 if not (with_dri or with_gallium or with_glx != 'disabled')
 338   with_gles1 = false
 339   with_gles2 = false
 340   with_opengl = false
 341   with_any_opengl = false
 342   with_shared_glapi = false
 343 endif
 344
 345 _gbm = get_option('gbm')
 346 if _gbm == 'auto'
 347   with_gbm = system_has_kms_drm and with_dri
 348 else
 349   with_gbm = _gbm == 'true'
 350 endif
 351 if with_gbm and not system_has_kms_drm
 352   error('GBM only supports DRM/KMS platforms')
 353 endif
 354
 355 _egl = get_option('egl')
 356 if _egl == 'auto'
 357   with_egl = (
 358     not ['darwin', 'windows'].contains(host_machine.system()) and
 359     with_dri and with_shared_glapi and with_platforms
 360   )
 361 elif _egl == 'true'
 362   if not with_dri
 363     error('EGL requires dri')
 364   elif not with_shared_glapi
 365     error('EGL requires shared-glapi')
 366   elif not with_platforms
 367     error('No platforms specified, consider -Dplatforms=drm,x11,surfaceless at least')
 368   elif not ['disabled', 'dri'].contains(with_glx)
 369     error('EGL requires dri, but a GLX is being built without dri')
 370   elif ['darwin', 'windows'].contains(host_machine.system())
 371     error('EGL is not available on Windows or MacOS')
 372   endif
 373   with_egl = true
 374 else
 375   with_egl = false
 376 endif
 377
 378 if with_egl and not (with_platform_drm or with_platform_surfaceless or with_platform_android)
 379   if with_gallium_radeonsi
 380     error('RadeonSI requires the drm, surfaceless or android platform when using EGL')
 381   endif
 382   if with_gallium_virgl
 383     error('Virgl requires the drm, surfaceless or android platform when using EGL')
 384   endif
 385 endif
 386
 387 # Android uses emutls for versions <= P/28. For USE_ELF_TLS we need ELF TLS.
 388 if not with_platform_android or get_option('platform-sdk-version') >= 29
 389   pre_args += '-DUSE_ELF_TLS'
 390 endif
 391
 392 if with_glx != 'disabled'
 393   if not (with_platform_x11 and with_any_opengl)
 394     error('Cannot build GLX support without X11 platform support and at least one OpenGL API')
 395   elif with_glx == 'gallium-xlib'
 396     if not with_gallium
 397       error('Gallium-xlib based GLX requires at least one gallium driver')
 398     elif not with_gallium_softpipe
 399       error('Gallium-xlib based GLX requires softpipe or llvmpipe.')
 400     elif with_dri
 401       error('gallium-xlib conflicts with any dri driver')
 402     endif
 403   elif with_glx == 'xlib'
 404     if with_dri
 405       error('xlib conflicts with any dri driver')
 406     endif
 407   elif with_glx == 'dri'
 408     if not with_shared_glapi
 409       error('dri based GLX requires shared-glapi')
 410     endif
 411   endif
 412 endif
 413
 414 with_glvnd = get_option('glvnd')
 415 if with_glvnd
 416   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
 417     error('Cannot build glvnd support for GLX that is not DRI based.')
 418   elif with_glx == 'disabled' and not with_egl
 419     error('glvnd requires DRI based GLX and/or EGL')
 420   endif
 421   if get_option('egl-lib-suffix') != ''
 422     error('''EGL lib suffix can't be used with libglvnd''')
 423   endif
 424 endif
 425
 426 if with_vulkan_icd_dir == ''
 427   with_vulkan_icd_dir = join_paths(get_option('datadir'), 'vulkan/icd.d')
 428 endif
 429
 430 with_dri2 = (with_dri or with_any_vk) and (with_dri_platform == 'drm' or
 431   host_machine.system() == 'gnu')
 432 _dri3 = get_option('dri3')
 433 if _dri3 == 'auto'
 434   with_dri3 = system_has_kms_drm and with_dri2
 435 else
 436   with_dri3 = _dri3 == 'true'
 437 endif
 438
 439 if with_any_vk and (with_platform_x11 and not with_dri3)
 440   error('Vulkan drivers require dri3 for X11 support')
 441 endif
 442 if with_dri
 443   if with_glx == 'disabled' and not with_egl and not with_gbm and with_osmesa != 'classic'
 444     error('building dri drivers require at least one windowing system or classic osmesa')
 445   endif
 446 endif
 447
 448 prog_pkgconfig = find_program('pkg-config')
 449
 450 _vdpau = get_option('gallium-vdpau')
 451 if not system_has_kms_drm
 452   if _vdpau == 'true'
 453     error('VDPAU state tracker can only be build on unix-like OSes.')
 454   else
 455     _vdpau = 'false'
 456   endif
 457 elif not with_platform_x11
 458   if _vdpau == 'true'
 459     error('VDPAU state tracker requires X11 support.')
 460   else
 461     _vdpau = 'false'
 462   endif
 463 elif not (with_gallium_r300 or with_gallium_r600 or with_gallium_radeonsi or
 464           with_gallium_nouveau)
 465   if _vdpau == 'true'
 466     error('VDPAU state tracker requires at least one of the following gallium drivers: r300, r600, radeonsi, nouveau.')
 467   else
 468     _vdpau = 'false'
 469   endif
 470 endif
 471 dep_vdpau = null_dep
 472 with_gallium_vdpau = false
 473 if _vdpau != 'false'
 474   dep_vdpau = dependency('vdpau', version : '>= 1.1', required : _vdpau == 'true')
 475   if dep_vdpau.found()
 476     dep_vdpau = declare_dependency(
 477       compile_args : run_command(prog_pkgconfig, ['vdpau', '--cflags']).stdout().split()
 478     )
 479     with_gallium_vdpau = true
 480   endif
 481 endif
 482
 483 if with_gallium_vdpau
 484   pre_args += '-DHAVE_ST_VDPAU'
 485 endif
 486 vdpau_drivers_path = get_option('vdpau-libs-path')
 487 if vdpau_drivers_path == ''
 488   vdpau_drivers_path = join_paths(get_option('libdir'), 'vdpau')
 489 endif
 490
 491 _xvmc = get_option('gallium-xvmc')
 492 if not system_has_kms_drm
 493   if _xvmc == 'true'
 494     error('XVMC state tracker can only be build on unix-like OSes.')
 495   else
 496     _xvmc = 'false'
 497   endif
 498 elif not with_platform_x11
 499   if _xvmc == 'true'
 500     error('XVMC state tracker requires X11 support.')
 501   else
 502     _xvmc = 'false'
 503   endif
 504 elif not (with_gallium_r600 or with_gallium_nouveau)
 505   if _xvmc == 'true'
 506     error('XVMC state tracker requires at least one of the following gallium drivers: r600, nouveau.')
 507   else
 508     _xvmc = 'false'
 509   endif
 510 endif
 511 dep_xvmc = null_dep
 512 with_gallium_xvmc = false
 513 if _xvmc != 'false'
 514   dep_xvmc = dependency('xvmc', version : '>= 1.0.6', required : _xvmc == 'true')
 515   with_gallium_xvmc = dep_xvmc.found()
 516 endif
 517
 518 xvmc_drivers_path = get_option('xvmc-libs-path')
 519 if xvmc_drivers_path == ''
 520   xvmc_drivers_path = get_option('libdir')
 521 endif
 522
 523 _omx = get_option('gallium-omx')
 524 if not system_has_kms_drm
 525   if ['auto', 'disabled'].contains(_omx)
 526     _omx = 'disabled'
 527   else
 528     error('OMX state tracker can only be built on unix-like OSes.')
 529   endif
 530 elif not (with_gallium_r600 or with_gallium_radeonsi or with_gallium_nouveau)
 531   if ['auto', 'disabled'].contains(_omx)
 532     _omx = 'disabled'
 533   else
 534     error('OMX state tracker requires at least one of the following gallium drivers: r600, radeonsi, nouveau.')
 535   endif
 536 endif
 537 with_gallium_omx = _omx
 538 dep_omx = null_dep
 539 dep_omx_other = []
 540 if ['auto', 'bellagio'].contains(_omx)
 541   dep_omx = dependency(
 542     'libomxil-bellagio', required : _omx == 'bellagio'
 543   )
 544   if dep_omx.found()
 545     with_gallium_omx = 'bellagio'
 546   endif
 547 endif
 548 if ['auto', 'tizonia'].contains(_omx)
 549   if with_dri and with_egl
 550     dep_omx = dependency(
 551       'libtizonia', version : '>= 0.10.0',
 552       required : _omx == 'tizonia',
 553     )
 554     dep_omx_other = [
 555       dependency('libtizplatform', required : _omx == 'tizonia'),
 556       dependency('tizilheaders', required : _omx == 'tizonia'),
 557     ]
 558     if dep_omx.found() and dep_omx_other[0].found() and dep_omx_other[1].found()
 559       with_gallium_omx = 'tizonia'
 560     endif
 561   elif _omx == 'tizonia'
 562     error('OMX-Tizonia state tracker requires dri and egl')
 563   endif
 564 endif
 565 if _omx == 'auto'
 566   with_gallium_omx = 'disabled'
 567 else
 568   with_gallium_omx = _omx
 569 endif
 570
 571 pre_args += [
 572   '-DENABLE_ST_OMX_BELLAGIO=' + (with_gallium_omx == 'bellagio' ? '1' : '0'),
 573   '-DENABLE_ST_OMX_TIZONIA=' + (with_gallium_omx == 'tizonia' ? '1' : '0'),
 574 ]
 575
 576
 577 omx_drivers_path = get_option('omx-libs-path')
 578
 579 if with_gallium_omx != 'disabled'
 580   # Figure out where to put the omx driver.
 581   # FIXME: this could all be vastly simplified by adding a 'defined_variable'
 582   # argument to meson's get_pkgconfig_variable method.
 583   if omx_drivers_path == ''
 584     _omx_libdir = dep_omx.get_pkgconfig_variable('libdir')
 585     _omx_drivers_dir = dep_omx.get_pkgconfig_variable('pluginsdir')
 586     if _omx_libdir == get_option('libdir')
 587       omx_drivers_path = _omx_drivers_dir
 588     else
 589       _omx_base_dir = []
 590       # This will fail on windows. Does OMX run on windows?
 591       _omx_libdir = _omx_libdir.split('/')
 592       _omx_drivers_dir = _omx_drivers_dir.split('/')
 593       foreach o : _omx_drivers_dir
 594         if not _omx_libdir.contains(o)
 595           _omx_base_dir += o
 596         endif
 597       endforeach
 598       omx_drivers_path = join_paths(get_option('libdir'), _omx_base_dir)
 599     endif
 600   endif
 601 endif
 602
 603 _va = get_option('gallium-va')
 604 if not system_has_kms_drm
 605   if _va == 'true'
 606     error('VA state tracker can only be built on unix-like OSes.')
 607   else
 608     _va = 'false'
 609   endif
 610 elif not (with_gallium_r600 or with_gallium_radeonsi or with_gallium_nouveau)
 611   if _va == 'true'
 612     error('VA state tracker requires at least one of the following gallium drivers: r600, radeonsi, nouveau.')
 613   else
 614     _va = 'false'
 615   endif
 616 endif
 617 with_gallium_va = false
 618 dep_va = null_dep
 619 if _va != 'false'
 620   dep_va = dependency('libva', version : '>= 0.38.0', required : _va == 'true')
 621   if dep_va.found()
 622     dep_va_headers = declare_dependency(
 623       compile_args : run_command(prog_pkgconfig, ['libva', '--cflags']).stdout().split()
 624     )
 625     with_gallium_va = true
 626   endif
 627 endif
 628
 629 va_drivers_path = get_option('va-libs-path')
 630 if va_drivers_path == ''
 631   va_drivers_path = join_paths(get_option('libdir'), 'dri')
 632 endif
 633
 634 _xa = get_option('gallium-xa')
 635 if not system_has_kms_drm
 636   if _xa == 'true'
 637     error('XA state tracker can only be built on unix-like OSes.')
 638   else
 639     _xa = 'false'
 640   endif
 641 elif not (with_gallium_nouveau or with_gallium_freedreno or with_gallium_i915
 642           or with_gallium_svga)
 643   if _xa == 'true'
 644     error('XA state tracker requires at least one of the following gallium drivers: nouveau, freedreno, i915, svga.')
 645   else
 646     _xa = 'false'
 647   endif
 648 endif
 649 with_gallium_xa = _xa != 'false'
 650
 651 d3d_drivers_path = get_option('d3d-drivers-path')
 652 if d3d_drivers_path == ''
 653   d3d_drivers_path = join_paths(get_option('prefix'), get_option('libdir'), 'd3d')
 654 endif
 655
 656 with_gallium_st_nine =  get_option('gallium-nine')
 657 if with_gallium_st_nine
 658   if not with_gallium_softpipe
 659     error('The nine state tracker requires gallium softpipe/llvmpipe.')
 660   elif not (with_gallium_radeonsi or with_gallium_nouveau or with_gallium_r600
 661             or with_gallium_r300 or with_gallium_svga or with_gallium_i915
 662             or with_gallium_iris)
 663     error('The nine state tracker requires at least one non-swrast gallium driver.')
 664   endif
 665   if not with_dri3
 666     error('Using nine with wine requires dri3')
 667   endif
 668 endif
 669
 670 if get_option('power8') != 'false'
 671   # on old versions of meson the cpu family would return as ppc64le on little
 672   # endian power8, this was changed in 0.48 such that the family would always
 673   # be ppc64 regardless of endianness, and then the machine.endian() value
 674   # should be checked. Since we support versions < 0.48 we need to use
 675   # startswith.
 676   if host_machine.cpu_family().startswith('ppc64') and host_machine.endian() == 'little'
 677     if cc.get_id() == 'gcc' and cc.version().version_compare('< 4.8')
 678       error('Altivec is not supported with gcc version < 4.8.')
 679     endif
 680     if cc.compiles('''
 681         #include <altivec.h>
 682         int main() {
 683           vector unsigned char r;
 684           vector unsigned int v = vec_splat_u32 (1);
 685           r = __builtin_vec_vgbbd ((vector unsigned char) v);
 686           return 0;
 687         }''',
 688         args : '-mpower8-vector',
 689         name : 'POWER8 intrinsics')
 690       pre_args += ['-D_ARCH_PWR8', '-mpower8-vector']
 691     elif get_option('power8') == 'true'
 692       error('POWER8 intrinsic support required but not found.')
 693     endif
 694   endif
 695 endif
 696
 697 _opencl = get_option('gallium-opencl')
 698 clover_cpp_std = []
 699 if _opencl != 'disabled'
 700   if not with_gallium
 701     error('OpenCL Clover implementation requires at least one gallium driver.')
 702   endif
 703
 704   dep_clc = dependency('libclc')
 705   with_gallium_opencl = true
 706   with_opencl_icd = _opencl == 'icd'
 707
 708   if host_machine.cpu_family().startswith('ppc') and cpp.compiles('''
 709       #if !defined(__VEC__) || !defined(__ALTIVEC__)
 710       #error "AltiVec not enabled"
 711       #endif''',
 712       name : 'Altivec')
 713     clover_cpp_std += ['cpp_std=gnu++11']
 714   endif
 715 else
 716   dep_clc = null_dep
 717   with_gallium_opencl = false
 718   with_opencl_icd = false
 719 endif
 720
 721 gl_pkgconfig_c_flags = []
 722 if with_platform_x11
 723   if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
 724     pre_args += '-DHAVE_X11_PLATFORM'
 725   endif
 726   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
 727     pre_args += '-DUSE_XSHM'
 728   else
 729     pre_args += '-DGLX_INDIRECT_RENDERING'
 730     if with_glx_direct
 731       pre_args += '-DGLX_DIRECT_RENDERING'
 732     endif
 733     if with_dri_platform == 'drm'
 734       pre_args += '-DGLX_USE_DRM'
 735     elif with_dri_platform == 'apple'
 736       pre_args += '-DGLX_USE_APPLEGL'
 737     elif with_dri_platform == 'windows'
 738       pre_args += '-DGLX_USE_WINDOWSGL'
 739     endif
 740   endif
 741 else
 742   pre_args += '-DMESA_EGL_NO_X11_HEADERS'
 743   gl_pkgconfig_c_flags += '-DMESA_EGL_NO_X11_HEADERS'
 744 endif
 745 if with_platform_drm
 746   if with_egl and not with_gbm
 747     error('EGL drm platform requires gbm')
 748   endif
 749   pre_args += '-DHAVE_DRM_PLATFORM'
 750 endif
 751 if with_platform_surfaceless
 752   pre_args += '-DHAVE_SURFACELESS_PLATFORM'
 753 endif
 754 if with_platform_android
 755   dep_android = [
 756     dependency('cutils'),
 757     dependency('hardware'),
 758     dependency('sync'),
 759   ]
 760   if get_option('platform-sdk-version') >= 26
 761     dep_android += dependency('nativewindow')
 762   endif
 763   pre_args += '-DHAVE_ANDROID_PLATFORM'
 764 endif
 765 if with_platform_haiku
 766   pre_args += '-DHAVE_HAIKU_PLATFORM'
 767 endif
 768
 769 if meson.version().version_compare('>=0.50')
 770   prog_python = import('python').find_installation('python3')
 771 else
 772   prog_python = import('python3').find_python()
 773 endif
 774 has_mako = run_command(
 775   prog_python, '-c',
 776   '''
 777 from distutils.version import StrictVersion
 778 import mako
 779 assert StrictVersion(mako.__version__) > StrictVersion("0.8.0")
 780   ''')
 781 if has_mako.returncode() != 0
 782   error('Python (3.x) mako module >= 0.8.0 required to build mesa.')
 783 endif
 784
 785 if cc.get_id() == 'gcc' and cc.version().version_compare('< 4.4.6')
 786   error('When using GCC, version 4.4.6 or later is required.')
 787 endif
 788
 789 # Support systems without ETIME (e.g. FreeBSD)
 790 if cc.get_define('ETIME', prefix : '#include <errno.h>') == ''
 791   pre_args += '-DETIME=ETIMEDOUT'
 792 endif
 793
 794 # Define DEBUG for debug builds only (debugoptimized is not included on this one)
 795 if get_option('buildtype') == 'debug'
 796   pre_args += '-DDEBUG'
 797 endif
 798
 799 with_shader_cache = false
 800 _shader_cache = get_option('shader-cache')
 801 if _shader_cache != 'false'
 802   if host_machine.system() == 'windows'
 803     if _shader_cache == 'true'
 804       error('Shader Cache does not currently work on Windows')
 805     endif
 806   else
 807     pre_args += '-DENABLE_SHADER_CACHE'
 808     with_shader_cache = true
 809   endif
 810 endif
 811 if with_amd_vk and not with_shader_cache
 812   error('Radv requires shader cache support')
 813 endif
 814
 815 # Check for GCC style builtins
 816 foreach b : ['bswap32', 'bswap64', 'clz', 'clzll', 'ctz', 'expect', 'ffs',
 817              'ffsll', 'popcount', 'popcountll', 'unreachable']
 818   if cc.has_function(b)
 819     pre_args += '-DHAVE___BUILTIN_@0@'.format(b.to_upper())
 820   endif
 821 endforeach
 822
 823 # check for GCC __attribute__
 824 foreach a : ['const', 'flatten', 'malloc', 'pure', 'unused',
 825              'warn_unused_result', 'weak',]
 826   if cc.compiles('int foo(void) __attribute__((@0@));'.format(a),
 827                  name : '__attribute__((@0@))'.format(a))
 828     pre_args += '-DHAVE_FUNC_ATTRIBUTE_@0@'.format(a.to_upper())
 829   endif
 830 endforeach
 831 if cc.compiles('int foo(const char *p, ...) __attribute__((format(printf, 1, 2)));',
 832                name : '__attribute__((format(...)))')
 833   pre_args += '-DHAVE_FUNC_ATTRIBUTE_FORMAT'
 834 endif
 835 if cc.compiles('struct __attribute__((packed)) foo { int bar; };',
 836                name : '__attribute__((packed))')
 837   pre_args += '-DHAVE_FUNC_ATTRIBUTE_PACKED'
 838 endif
 839 if cc.compiles('int *foo(void) __attribute__((returns_nonnull));',
 840                name : '__attribute__((returns_nonnull))')
 841   pre_args += '-DHAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL'
 842 endif
 843 if cc.compiles('''int foo_def(void) __attribute__((visibility("default")));
 844                   int foo_hid(void) __attribute__((visibility("hidden")));
 845                   int foo_int(void) __attribute__((visibility("internal")));
 846                   int foo_pro(void) __attribute__((visibility("protected")));''',
 847                name : '__attribute__((visibility(...)))')
 848   pre_args += '-DHAVE_FUNC_ATTRIBUTE_VISIBILITY'
 849 endif
 850 if cc.compiles('int foo(void) { return 0; } int bar(void) __attribute__((alias("foo")));',
 851                name : '__attribute__((alias(...)))')
 852   pre_args += '-DHAVE_FUNC_ATTRIBUTE_ALIAS'
 853 endif
 854 if cc.compiles('int foo(void) __attribute__((__noreturn__));',
 855                name : '__attribute__((__noreturn__))')
 856   pre_args += '-DHAVE_FUNC_ATTRIBUTE_NORETURN'
 857 endif
 858 if cc.compiles('__uint128_t foo(void) { return 0; }',
 859                name : '__uint128_t')
 860   pre_args += '-DHAVE_UINT128'
 861 endif
 862
 863 # TODO: this is very incomplete
 864 if ['linux', 'cygwin', 'gnu', 'gnu/kfreebsd'].contains(host_machine.system())
 865   pre_args += '-D_GNU_SOURCE'
 866 endif
 867
 868 # Check for generic C arguments
 869 c_args = []
 870 foreach a : ['-Werror=implicit-function-declaration',
 871              '-Werror=missing-prototypes', '-Werror=return-type',
 872              '-Werror=incompatible-pointer-types',
 873              '-Werror=format',
 874              '-Wformat-security',
 875              '-fno-math-errno',
 876              '-fno-trapping-math', '-Qunused-arguments']
 877   if cc.has_argument(a)
 878     c_args += a
 879   endif
 880 endforeach
 881
 882 foreach a : ['missing-field-initializers', 'format-truncation']
 883   if cc.has_argument('-W' + a)
 884     c_args += '-Wno-' + a
 885   endif
 886 endforeach
 887
 888 c_vis_args = []
 889 if cc.has_argument('-fvisibility=hidden')
 890   c_vis_args += '-fvisibility=hidden'
 891 endif
 892
 893 # Check for generic C++ arguments
 894 cpp_args = []
 895 foreach a : ['-Werror=return-type',
 896              '-Werror=format',
 897              '-Wformat-security',
 898              '-fno-math-errno', '-fno-trapping-math',
 899              '-Qunused-arguments']
 900   if cpp.has_argument(a)
 901     cpp_args += a
 902   endif
 903 endforeach
 904
 905 # For some reason, the test for -Wno-foo always succeeds with gcc, even if the
 906 # option is not supported. Hence, check for -Wfoo instead.
 907
 908 foreach a : ['non-virtual-dtor', 'missing-field-initializers', 'format-truncation']
 909   if cpp.has_argument('-W' + a)
 910     cpp_args += '-Wno-' + a
 911   endif
 912 endforeach
 913
 914 no_override_init_args = []
 915 foreach a : ['override-init', 'initializer-overrides']
 916   if cc.has_argument('-W' + a)
 917     no_override_init_args += '-Wno-' + a
 918   endif
 919 endforeach
 920
 921 cpp_vis_args = []
 922 if cpp.has_argument('-fvisibility=hidden')
 923   cpp_vis_args += '-fvisibility=hidden'
 924 endif
 925
 926 # Check for C and C++ arguments for MSVC2013 compatibility. These are only used
 927 # in parts of the mesa code base that need to compile with old versions of
 928 # MSVC, mainly common code
 929 c_msvc_compat_args = []
 930 cpp_msvc_compat_args = []
 931 foreach a : ['-Werror=pointer-arith', '-Werror=vla']
 932   if cc.has_argument(a)
 933     c_msvc_compat_args += a
 934   endif
 935   if cpp.has_argument(a)
 936     cpp_msvc_compat_args += a
 937   endif
 938 endforeach
 939
 940 if host_machine.cpu_family().startswith('x86')
 941   pre_args += '-DUSE_SSE41'
 942   with_sse41 = true
 943   sse41_args = ['-msse4.1']
 944
 945   # GCC on x86 (not x86_64) with -msse* assumes a 16 byte aligned stack, but
 946   # that's not guaranteed
 947   if host_machine.cpu_family() == 'x86'
 948     sse41_args += '-mstackrealign'
 949   endif
 950 else
 951   with_sse41 = false
 952   sse41_args = []
 953 endif
 954
 955 # Check for GCC style atomics
 956 dep_atomic = null_dep
 957
 958 if cc.compiles('''#include <stdint.h>
 959                   int main() {
 960                     struct {
 961                       uint64_t *v;
 962                     } x;
 963                     return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
 964                            (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
 965
 966                   }''',
 967                name : 'GCC atomic builtins')
 968   pre_args += '-DUSE_GCC_ATOMIC_BUILTINS'
 969
 970   # Not all atomic calls can be turned into lock-free instructions, in which
 971   # GCC will make calls into the libatomic library. Check whether we need to
 972   # link with -latomic.
 973   #
 974   # This can happen for 64-bit atomic operations on 32-bit architectures such
 975   # as ARM.
 976   if not cc.links('''#include <stdint.h>
 977                      int main() {
 978                        struct {
 979                          uint64_t *v;
 980                        } x;
 981                        return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
 982                               (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
 983                      }''',
 984                   name : 'GCC atomic builtins required -latomic')
 985     dep_atomic = cc.find_library('atomic')
 986   endif
 987 endif
 988 if not cc.links('''#include <stdint.h>
 989                    uint64_t v;
 990                    int main() {
 991                      return __sync_add_and_fetch(&v, (uint64_t)1);
 992                    }''',
 993                 dependencies : dep_atomic,
 994                 name : 'GCC 64bit atomics')
 995   pre_args += '-DMISSING_64BIT_ATOMICS'
 996 endif
 997
 998 # TODO: shared/static? Is this even worth doing?
 999
1000 with_asm_arch = ''
1001 if host_machine.cpu_family() == 'x86'
1002   if system_has_kms_drm or host_machine.system() == 'gnu'
1003     with_asm_arch = 'x86'
1004     pre_args += ['-DUSE_X86_ASM', '-DUSE_MMX_ASM', '-DUSE_3DNOW_ASM',
1005                  '-DUSE_SSE_ASM']
1006
1007     if with_glx_read_only_text
1008       pre_args += ['-DGLX_X86_READONLY_TEXT']
1009     endif
1010   endif
1011 elif host_machine.cpu_family() == 'x86_64'
1012   if system_has_kms_drm
1013     with_asm_arch = 'x86_64'
1014     pre_args += ['-DUSE_X86_64_ASM']
1015   endif
1016 elif host_machine.cpu_family() == 'arm'
1017   if system_has_kms_drm
1018     with_asm_arch = 'arm'
1019     pre_args += ['-DUSE_ARM_ASM']
1020   endif
1021 elif host_machine.cpu_family() == 'aarch64'
1022   if system_has_kms_drm
1023     with_asm_arch = 'aarch64'
1024     pre_args += ['-DUSE_AARCH64_ASM']
1025   endif
1026 elif host_machine.cpu_family() == 'sparc64'
1027   if system_has_kms_drm
1028     with_asm_arch = 'sparc'
1029     pre_args += ['-DUSE_SPARC_ASM']
1030   endif
1031 elif host_machine.cpu_family().startswith('ppc64') and host_machine.endian() == 'little'
1032   if system_has_kms_drm
1033     with_asm_arch = 'ppc64le'
1034     pre_args += ['-DUSE_PPC64LE_ASM']
1035   endif
1036 endif
1037
1038 # Check for standard headers and functions
1039 if cc.has_header_symbol('sys/sysmacros.h', 'major')
1040   pre_args += '-DMAJOR_IN_SYSMACROS'
1041 elif cc.has_header_symbol('sys/mkdev.h', 'major')
1042   pre_args += '-DMAJOR_IN_MKDEV'
1043 endif
1044
1045 foreach h : ['xlocale.h', 'sys/sysctl.h', 'linux/futex.h', 'endian.h', 'dlfcn.h', 'execinfo.h', 'sys/shm.h', 'cet.h']
1046   if cc.compiles('#include <@0@>'.format(h), name : '@0@'.format(h))
1047     pre_args += '-DHAVE_@0@'.format(h.to_upper().underscorify())
1048   endif
1049 endforeach
1050
1051 foreach f : ['strtof', 'mkostemp', 'posix_memalign', 'timespec_get', 'memfd_create', 'random_r']
1052   if cc.has_function(f)
1053     pre_args += '-DHAVE_@0@'.format(f.to_upper())
1054   endif
1055 endforeach
1056
1057 if cc.has_header_symbol('errno.h', 'program_invocation_name',
1058                         args : '-D_GNU_SOURCE')
1059    pre_args += '-DHAVE_PROGRAM_INVOCATION_NAME'
1060 elif with_tools.contains('intel')
1061   error('Intel tools require the program_invocation_name variable')
1062 endif
1063
1064 # strtod locale support
1065 if cc.links('''
1066     #define _GNU_SOURCE
1067     #include <stdlib.h>
1068     #include <locale.h>
1069     #ifdef HAVE_XLOCALE_H
1070     #include <xlocale.h>
1071     #endif
1072     int main() {
1073       locale_t loc = newlocale(LC_CTYPE_MASK, "C", NULL);
1074       const char *s = "1.0";
1075       char *end;
1076       double d = strtod_l(s, end, loc);
1077       float f = strtof_l(s, end, loc);
1078       freelocale(loc);
1079       return 0;
1080     }''',
1081     args : pre_args,
1082     name : 'strtod has locale support')
1083   pre_args += '-DHAVE_STRTOD_L'
1084 endif
1085
1086 # Check for some linker flags
1087 ld_args_bsymbolic = []
1088 if cc.links('int main() { return 0; }', args : '-Wl,-Bsymbolic', name : 'Bsymbolic')
1089   ld_args_bsymbolic += '-Wl,-Bsymbolic'
1090 endif
1091 ld_args_gc_sections = []
1092 if cc.links('static char unused() { return 5; } int main() { return 0; }',
1093             args : '-Wl,--gc-sections', name : 'gc-sections')
1094   ld_args_gc_sections += '-Wl,--gc-sections'
1095 endif
1096 with_ld_version_script = false
1097 if cc.links('int main() { return 0; }',
1098             args : '-Wl,--version-script=@0@'.format(
1099               join_paths(meson.source_root(), 'build-support/conftest.map')),
1100             name : 'version-script')
1101   with_ld_version_script = true
1102 endif
1103 with_ld_dynamic_list = false
1104 if cc.links('int main() { return 0; }',
1105             args : '-Wl,--dynamic-list=@0@'.format(
1106               join_paths(meson.source_root(), 'build-support/conftest.dyn')),
1107             name : 'dynamic-list')
1108   with_ld_dynamic_list = true
1109 endif
1110 ld_args_build_id = []
1111 if build_machine.system() != 'darwin'
1112    ld_args_build_id += '-Wl,--build-id=sha1'
1113 endif
1114
1115 # check for dl support
1116 dep_dl = null_dep
1117 if host_machine.system() != 'windows'
1118   if not cc.has_function('dlopen')
1119     dep_dl = cc.find_library('dl')
1120   endif
1121   if cc.has_function('dladdr', dependencies : dep_dl)
1122     # This is really only required for megadrivers
1123     pre_args += '-DHAVE_DLADDR'
1124   endif
1125 endif
1126
1127 if cc.has_function('dl_iterate_phdr')
1128   pre_args += '-DHAVE_DL_ITERATE_PHDR'
1129 elif with_intel_vk
1130   error('Intel "Anvil" Vulkan driver requires the dl_iterate_phdr function')
1131 elif with_dri_i965 and with_shader_cache
1132   error('Intel i965 GL driver requires dl_iterate_phdr when built with shader caching.')
1133 endif
1134
1135 # Determine whether or not the rt library is needed for time functions
1136 if cc.has_function('clock_gettime')
1137   dep_clock = null_dep
1138 else
1139   dep_clock = cc.find_library('rt')
1140 endif
1141
1142 # TODO: some of these may be conditional
1143 dep_zlib = dependency('zlib', version : '>= 1.2.3', fallback : ['zlib', 'zlib_dep'])
1144 pre_args += '-DHAVE_ZLIB'
1145 dep_thread = dependency('threads')
1146 if dep_thread.found() and host_machine.system() != 'windows'
1147   pre_args += '-DHAVE_PTHREAD'
1148   if cc.has_function(
1149       'pthread_setaffinity_np',
1150       dependencies : dep_thread,
1151       prefix : '#include <pthread.h>',
1152       args : '-D_GNU_SOURCE')
1153     pre_args += '-DHAVE_PTHREAD_SETAFFINITY'
1154   endif
1155   if cc.has_function(
1156       'pthread_setaffinity_np',
1157       dependencies : dep_thread,
1158       prefix : '#include <pthread_np.h>')
1159     pre_args += '-DPTHREAD_SETAFFINITY_IN_NP_HEADER'
1160   endif
1161 endif
1162 dep_expat = dependency('expat', fallback : ['expat', 'expat_dep'])
1163 # this only exists on linux so either this is linux and it will be found, or
1164 # it's not linux and wont
1165 dep_m = cc.find_library('m', required : false)
1166
1167 # Check for libdrm. Various drivers have different libdrm version requirements,
1168 # but we always want to use the same version for all libdrm modules. That means
1169 # even if driver foo requires 2.4.0 and driver bar requires 2.4.3, if foo and
1170 # bar are both on use 2.4.3 for both of them
1171 dep_libdrm_amdgpu = null_dep
1172 dep_libdrm_radeon = null_dep
1173 dep_libdrm_nouveau = null_dep
1174 dep_libdrm_intel = null_dep
1175
1176 _drm_amdgpu_ver = '2.4.99'
1177 _drm_radeon_ver = '2.4.71'
1178 _drm_nouveau_ver = '2.4.66'
1179 _drm_intel_ver = '2.4.75'
1180 _drm_ver = '2.4.81'
1181
1182 _libdrm_checks = [
1183   ['intel', with_dri_i915 or with_gallium_i915],
1184   ['amdgpu', with_amd_vk or with_gallium_radeonsi],
1185   ['radeon', (with_gallium_radeonsi or with_dri_r100 or with_dri_r200 or
1186               with_gallium_r300 or with_gallium_r600)],
1187   ['nouveau', (with_gallium_nouveau or with_dri_nouveau)],
1188 ]
1189
1190 # VC4 only needs core libdrm support of this version, not a libdrm_vc4
1191 # library.
1192 if with_gallium_vc4
1193   _drm_ver = '2.4.89'
1194 endif
1195
1196 # etnaviv only needs core libdrm
1197 if with_gallium_etnaviv
1198   _drm_ver = '2.4.89'
1199 endif
1200
1201 # Loop over the enables versions and get the highest libdrm requirement for all
1202 # active drivers.
1203 _drm_blame = ''
1204 foreach d : _libdrm_checks
1205   ver = get_variable('_drm_@0@_ver'.format(d[0]))
1206   if d[1] and ver.version_compare('>' + _drm_ver)
1207     _drm_ver = ver
1208     _drm_blame = d[0]
1209   endif
1210 endforeach
1211 if _drm_blame != ''
1212   message('libdrm @0@ needed because @1@ has the highest requirement'.format(_drm_ver, _drm_blame))
1213 endif
1214
1215 # Then get each libdrm module
1216 foreach d : _libdrm_checks
1217   if d[1]
1218     set_variable(
1219       'dep_libdrm_' + d[0],
1220       dependency('libdrm_' + d[0], version : '>=' + _drm_ver)
1221     )
1222   endif
1223 endforeach
1224
1225 with_gallium_drisw_kms = false
1226 dep_libdrm = dependency(
1227   'libdrm', version : '>=' + _drm_ver,
1228   required : with_dri2 or with_dri3
1229 )
1230 if dep_libdrm.found()
1231   pre_args += '-DHAVE_LIBDRM'
1232   if with_dri_platform == 'drm' and with_dri
1233     with_gallium_drisw_kms = true
1234   endif
1235 endif
1236
1237 llvm_modules = ['bitwriter', 'engine', 'mcdisassembler', 'mcjit']
1238 llvm_optional_modules = []
1239 if with_amd_vk or with_gallium_radeonsi or with_gallium_r600
1240   llvm_modules += ['amdgpu', 'native', 'bitreader', 'ipo']
1241   if with_gallium_r600
1242     llvm_modules += 'asmparser'
1243   endif
1244 endif
1245 if with_gallium_opencl
1246   llvm_modules += [
1247     'all-targets', 'linker', 'coverage', 'instrumentation', 'ipo', 'irreader',
1248     'lto', 'option', 'objcarcopts', 'profiledata',
1249   ]
1250   llvm_optional_modules += ['coroutines']
1251 endif
1252
1253 if with_amd_vk or with_gallium_radeonsi
1254   _llvm_version = '>= 8.0.0'
1255 elif with_gallium_swr
1256   _llvm_version = '>= 6.0.0'
1257 elif with_gallium_opencl or with_gallium_r600
1258   _llvm_version = '>= 3.9.0'
1259 else
1260   _llvm_version = '>= 3.3.0'
1261 endif
1262
1263 _shared_llvm = get_option('shared-llvm')
1264
1265 _llvm = get_option('llvm')
1266 dep_llvm = null_dep
1267 with_llvm = false
1268 if _llvm != 'false'
1269   dep_llvm = dependency(
1270     'llvm',
1271     version : _llvm_version,
1272     modules : llvm_modules,
1273     optional_modules : llvm_optional_modules,
1274     required : (
1275       with_amd_vk or with_gallium_radeonsi or with_gallium_swr or
1276       with_gallium_opencl or _llvm == 'true'
1277     ),
1278     static : not _shared_llvm,
1279     method : 'config-tool',
1280   )
1281   with_llvm = dep_llvm.found()
1282 endif
1283 if with_llvm
1284   pre_args += '-DLLVM_AVAILABLE'
1285   pre_args += '-DMESA_LLVM_VERSION_STRING="@0@"'.format(dep_llvm.version())
1286
1287   # LLVM can be built without rtti, turning off rtti changes the ABI of C++
1288   # programs, so we need to build all C++ code in mesa without rtti as well to
1289   # ensure that linking works.
1290   if dep_llvm.get_configtool_variable('has-rtti') == 'NO'
1291     if with_gallium_nouveau
1292       error('The Nouveau driver requires rtti. You either need to turn off nouveau or use an LLVM built with LLVM_ENABLE_RTTI.')
1293     elif with_gallium_opencl
1294       error('The Clover OpenCL state tracker requires rtti, you need to turn off clover or use an LLVM built with LLVM_ENABLE_RTTI.')
1295     endif
1296     cpp_args += '-fno-rtti'
1297   endif
1298 elif with_amd_vk or with_gallium_radeonsi or with_gallium_swr
1299   error('The following drivers require LLVM: Radv, RadeonSI, SWR. One of these is enabled, but LLVM is disabled.')
1300 elif with_gallium_opencl
1301   error('The OpenCL "Clover" state tracker requires LLVM, but LLVM is disabled.')
1302 endif
1303
1304 if (with_amd_vk or with_gallium_radeonsi or with_gallium_opencl or
1305     (with_gallium_r600 and with_llvm))
1306   dep_elf = dependency('libelf', required : false)
1307   if not dep_elf.found()
1308     dep_elf = cc.find_library('elf')
1309   endif
1310 else
1311   dep_elf = null_dep
1312 endif
1313
1314 dep_glvnd = null_dep
1315 if with_glvnd
1316   dep_glvnd = dependency('libglvnd', version : '>= 0.2.0')
1317   pre_args += '-DUSE_LIBGLVND=1'
1318 endif
1319
1320 if with_valgrind != 'false'
1321   dep_valgrind = dependency('valgrind', required : with_valgrind == 'true')
1322   if dep_valgrind.found()
1323     pre_args += '-DHAVE_VALGRIND'
1324   endif
1325 else
1326   dep_valgrind = null_dep
1327 endif
1328
1329 # pthread stubs. Lets not and say we didn't
1330
1331 prog_bison = find_program('bison', required : with_any_opengl)
1332 prog_flex = find_program('flex', required : with_any_opengl)
1333
1334 dep_selinux = null_dep
1335 if get_option('selinux')
1336   dep_selinux = dependency('libselinux')
1337   pre_args += '-DMESA_SELINUX'
1338 endif
1339
1340 if with_libunwind != 'false'
1341   dep_unwind = dependency('libunwind', required : with_libunwind == 'true')
1342   if dep_unwind.found()
1343     pre_args += '-DHAVE_LIBUNWIND'
1344   endif
1345 else
1346   dep_unwind = null_dep
1347 endif
1348
1349 if with_osmesa != 'none'
1350   if with_osmesa == 'gallium' and not with_gallium_softpipe
1351     error('OSMesa gallium requires gallium softpipe or llvmpipe.')
1352   endif
1353   osmesa_lib_name = 'OSMesa'
1354   osmesa_bits = get_option('osmesa-bits')
1355   if osmesa_bits != '8'
1356     if with_dri or with_glx != 'disabled'
1357       error('OSMesa bits must be 8 if building glx or dir based drivers')
1358     endif
1359     osmesa_lib_name = osmesa_lib_name + osmesa_bits
1360     pre_args += [
1361       '-DCHAN_BITS=@0@'.format(osmesa_bits), '-DDEFAULT_SOFTWARE_DEPTH_BITS=31'
1362     ]
1363   endif
1364 endif
1365
1366 # TODO: symbol mangling
1367
1368 if with_platform_wayland
1369   dep_wl_scanner = dependency('wayland-scanner', native: true)
1370   prog_wl_scanner = find_program(dep_wl_scanner.get_pkgconfig_variable('wayland_scanner'))
1371   if dep_wl_scanner.version().version_compare('>= 1.15')
1372     wl_scanner_arg = 'private-code'
1373   else
1374     wl_scanner_arg = 'code'
1375   endif
1376   dep_wl_protocols = dependency('wayland-protocols', version : '>= 1.8')
1377   dep_wayland_client = dependency('wayland-client', version : '>=1.11')
1378   dep_wayland_server = dependency('wayland-server', version : '>=1.11')
1379   if with_egl
1380     dep_wayland_egl = dependency('wayland-egl-backend', version : '>= 3')
1381     dep_wayland_egl_headers = declare_dependency(
1382       compile_args : run_command(prog_pkgconfig, ['wayland-egl-backend', '--cflags']).stdout().split())
1383   endif
1384   wayland_dmabuf_xml = join_paths(
1385     dep_wl_protocols.get_pkgconfig_variable('pkgdatadir'), 'unstable',
1386     'linux-dmabuf', 'linux-dmabuf-unstable-v1.xml'
1387   )
1388   pre_args += ['-DHAVE_WAYLAND_PLATFORM', '-DWL_HIDE_DEPRECATED']
1389 endif
1390
1391 dep_x11 = null_dep
1392 dep_xext = null_dep
1393 dep_xdamage = null_dep
1394 dep_xfixes = null_dep
1395 dep_x11_xcb = null_dep
1396 dep_xcb = null_dep
1397 dep_xcb_glx = null_dep
1398 dep_xcb_dri2 = null_dep
1399 dep_xcb_dri3 = null_dep
1400 dep_dri2proto = null_dep
1401 dep_glproto = null_dep
1402 dep_xxf86vm = null_dep
1403 dep_xcb_dri3 = null_dep
1404 dep_xcb_present = null_dep
1405 dep_xcb_sync = null_dep
1406 dep_xcb_xfixes = null_dep
1407 dep_xshmfence = null_dep
1408 dep_xcb_xrandr = null_dep
1409 dep_xlib_xrandr = null_dep
1410 if with_platform_x11
1411   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1412     dep_x11 = dependency('x11')
1413     dep_xext = dependency('xext')
1414     dep_xcb = dependency('xcb')
1415   elif with_glx == 'dri'
1416     dep_x11 = dependency('x11')
1417     dep_xext = dependency('xext')
1418     dep_xdamage = dependency('xdamage', version : '>= 1.1')
1419     dep_xfixes = dependency('xfixes')
1420     dep_xcb_glx = dependency('xcb-glx', version : '>= 1.8.1')
1421   endif
1422   if (with_any_vk or with_glx == 'dri' or with_egl or
1423        (with_gallium_vdpau or with_gallium_xvmc or with_gallium_va or
1424         with_gallium_omx != 'disabled'))
1425     dep_xcb = dependency('xcb')
1426     dep_x11_xcb = dependency('x11-xcb')
1427   endif
1428   if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
1429     dep_xcb_dri2 = dependency('xcb-dri2', version : '>= 1.8')
1430
1431     if with_dri3
1432       pre_args += '-DHAVE_DRI3'
1433       dep_xcb_dri3 = dependency('xcb-dri3')
1434       dep_xcb_present = dependency('xcb-present')
1435       # until xcb-dri3 has been around long enough to make a hard-dependency:
1436       if (dep_xcb_dri3.version().version_compare('>= 1.13') and
1437           dep_xcb_present.version().version_compare('>= 1.13'))
1438         pre_args += '-DHAVE_DRI3_MODIFIERS'
1439       endif
1440       dep_xcb_sync = dependency('xcb-sync')
1441       dep_xshmfence = dependency('xshmfence', version : '>= 1.1')
1442     endif
1443   endif
1444   if with_glx == 'dri' or with_glx == 'gallium-xlib'
1445     dep_glproto = dependency('glproto', version : '>= 1.4.14')
1446   endif
1447   if with_glx == 'dri'
1448     if with_dri_platform == 'drm'
1449       dep_dri2proto = dependency('dri2proto', version : '>= 2.8')
1450       dep_xxf86vm = dependency('xxf86vm')
1451     endif
1452   endif
1453   if (with_egl or (
1454       with_gallium_vdpau or with_gallium_xvmc or with_gallium_xa or
1455       with_gallium_omx != 'disabled'))
1456     dep_xcb_xfixes = dependency('xcb-xfixes')
1457   endif
1458   if with_xlib_lease
1459     dep_xcb_xrandr = dependency('xcb-randr')
1460     dep_xlib_xrandr = dependency('xrandr', version : '>= 1.3')
1461   endif
1462 endif
1463
1464 if get_option('gallium-extra-hud')
1465   pre_args += '-DHAVE_GALLIUM_EXTRA_HUD=1'
1466 endif
1467
1468 _sensors = get_option('lmsensors')
1469 if _sensors != 'false'
1470   dep_lmsensors = cc.find_library('sensors', required : _sensors == 'true')
1471   if dep_lmsensors.found()
1472     pre_args += '-DHAVE_LIBSENSORS=1'
1473   endif
1474 else
1475   dep_lmsensors = null_dep
1476 endif
1477
1478 foreach a : pre_args
1479   add_project_arguments(a, language : ['c', 'cpp'])
1480 endforeach
1481 foreach a : c_args
1482   add_project_arguments(a, language : ['c'])
1483 endforeach
1484 foreach a : cpp_args
1485   add_project_arguments(a, language : ['cpp'])
1486 endforeach
1487
1488 gl_priv_reqs = []
1489
1490 if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1491   gl_priv_reqs += ['x11', 'xext', 'xcb']
1492 elif with_glx == 'dri'
1493   gl_priv_reqs += [
1494     'x11', 'xext', 'xdamage >= 1.1', 'xfixes', 'x11-xcb', 'xcb',
1495     'xcb-glx >= 1.8.1']
1496   if with_dri_platform == 'drm'
1497     gl_priv_reqs += 'xcb-dri2 >= 1.8'
1498     gl_priv_reqs += 'xxf86vm'
1499   endif
1500 endif
1501 if dep_libdrm.found()
1502   gl_priv_reqs += 'libdrm >= 2.4.75'
1503 endif
1504
1505 gl_priv_libs = []
1506 if dep_thread.found()
1507   gl_priv_libs += ['-lpthread', '-pthread']
1508 endif
1509 if dep_m.found()
1510   gl_priv_libs += '-lm'
1511 endif
1512 if dep_dl.found()
1513   gl_priv_libs += '-ldl'
1514 endif
1515
1516 pkg = import('pkgconfig')
1517
1518 prog_nm = find_program('nm', required : false)
1519
1520 # This quirk needs to be applied to sources with functions defined in assembly
1521 # as GCC LTO drops them. See: https://bugs.freedesktop.org/show_bug.cgi?id=109391
1522 gcc_lto_quirk = (cc.get_id() == 'gcc') ? ['-fno-lto'] : []
1523
1524 subdir('include')
1525 subdir('bin')
1526 subdir('src')
1527
1528 # Meson 0.49 and earlier seems to have a bug that fails to evaluate the string-
1529 # formatting below unless the first argument is passed as a variable. This has
1530 # been fixed in Meson 0.50 and beyond, but we need to keep it like this for now
1531 # for backwards compatibility.
1532 _with_opengl_string = with_opengl ? 'yes' : 'no'
1533
1534 lines = ['',
1535   'prefix:          ' + get_option('prefix'),
1536   'libdir:          ' + get_option('libdir'),
1537   'includedir:      ' + get_option('includedir'),
1538   '',
1539   'OpenGL:          @0@ (ES1: @1@ ES2: @2@)'.format(_with_opengl_string,
1540                                                     with_gles1 ? 'yes' : 'no',
1541                                                     with_gles2 ? 'yes' : 'no'),
1542 ]
1543
1544 if with_osmesa != 'none'
1545   lines += ''
1546   suffix = ''
1547   if with_osmesa == 'gallium'
1548     suffix = '(Gallium)'
1549   endif
1550   lines += 'OSMesa:          lib' + osmesa_lib_name + suffix
1551 else
1552   lines += 'OSMesa:          no'
1553 endif
1554
1555 if with_dri
1556   lines += ''
1557   lines += 'DRI platform:    ' + with_dri_platform
1558   if dri_drivers.length() != 0 and dri_drivers != ['']
1559     lines += 'DRI drivers:     ' + ' '.join(dri_drivers)
1560   else
1561     lines += 'DRI drivers:     no'
1562   endif
1563   lines += 'DRI driver dir:  ' + dri_drivers_path
1564 endif
1565
1566 if with_glx != 'disabled'
1567   lines += ''
1568   if with_glx == 'dri'
1569     lines += 'GLX:             DRI-based'
1570   elif with_glx == 'xlib'
1571     lines += 'GLX:             Xlib-based'
1572   elif with_glx == 'gallium-xlib'
1573     lines += 'GLX:             Xlib-based (Gallium)'
1574   else
1575     lines += 'GLX:             ' + with_glx
1576   endif
1577 endif
1578
1579 lines += ''
1580 lines += 'EGL:             ' + (with_egl ? 'yes' : 'no')
1581 if with_egl
1582   egl_drivers = []
1583   if with_dri
1584     egl_drivers += 'builtin:egl_dri2'
1585   endif
1586   if with_dri3
1587     egl_drivers += 'builtin:egl_dri3'
1588   endif
1589   lines += 'EGL drivers:     ' + ' '.join(egl_drivers)
1590 endif
1591 lines += 'GBM:             ' + (with_gbm ? 'yes' : 'no')
1592 if with_platforms
1593   lines += 'EGL/Vulkan/VL platforms:   ' + ' '.join(_platforms)
1594 endif
1595
1596 lines += ''
1597 if with_any_vk
1598   lines += 'Vulkan drivers:  ' + ' '.join(_vulkan_drivers)
1599   lines += 'Vulkan ICD dir:  ' + with_vulkan_icd_dir
1600 else
1601   lines += 'Vulkan drivers:  no'
1602 endif
1603
1604 lines += ''
1605 if with_llvm
1606   lines += 'llvm:            yes'
1607   lines += 'llvm-version:    ' + dep_llvm.version()
1608 else
1609   lines += 'llvm:            no'
1610 endif
1611
1612 lines += ''
1613 if with_gallium
1614   lines += 'Gallium drivers: ' + ' '.join(gallium_drivers)
1615   gallium_st = ['mesa']
1616   if with_gallium_xa
1617     gallium_st += 'xa'
1618   endif
1619   if with_gallium_xvmc
1620     gallium_st += 'xvmc'
1621   endif
1622   if with_gallium_xvmc
1623     gallium_st += 'xvmc'
1624   endif
1625   if with_gallium_vdpau
1626     gallium_st += 'vdpau'
1627   endif
1628   if with_gallium_omx != 'disabled'
1629     gallium_st += 'omx' + with_gallium_omx
1630   endif
1631   if with_gallium_va
1632     gallium_st += 'va'
1633   endif
1634   if with_gallium_st_nine
1635     gallium_st += 'nine'
1636   endif
1637   if with_gallium_opencl
1638     gallium_st += 'clover'
1639   endif
1640   lines += 'Gallium st:      ' + ' '.join(gallium_st)
1641 else
1642   lines += 'Gallium:         no'
1643 endif
1644
1645 lines += 'HUD lmsensors:   ' + (dep_lmsensors.found() ? 'yes' : 'no')
1646
1647 lines += ''
1648 lines += 'Shared-glapi:    ' + (with_shared_glapi ? 'yes' : 'no')
1649
1650
1651 indent = '        '
1652 summary = indent + ('\n' + indent).join(lines)
1653 message('Configuration summary:\n@0@\n'.format(summary))