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 if cc.has_function('dlopen')
1117   dep_dl = null_dep
1118 else
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
1126 if cc.has_function('dl_iterate_phdr')
1127   pre_args += '-DHAVE_DL_ITERATE_PHDR'
1128 elif with_intel_vk
1129   error('Intel "Anvil" Vulkan driver requires the dl_iterate_phdr function')
1130 elif with_dri_i965 and with_shader_cache
1131   error('Intel i965 GL driver requires dl_iterate_phdr when built with shader caching.')
1132 endif
1133
1134 # Determine whether or not the rt library is needed for time functions
1135 if cc.has_function('clock_gettime')
1136   dep_clock = null_dep
1137 else
1138   dep_clock = cc.find_library('rt')
1139 endif
1140
1141 # TODO: some of these may be conditional
1142 dep_zlib = dependency('zlib', version : '>= 1.2.3', fallback : ['zlib', 'zlib_dep'])
1143 pre_args += '-DHAVE_ZLIB'
1144 dep_thread = dependency('threads')
1145 if dep_thread.found() and host_machine.system() != 'windows'
1146   pre_args += '-DHAVE_PTHREAD'
1147   if cc.has_function(
1148       'pthread_setaffinity_np',
1149       dependencies : dep_thread,
1150       prefix : '#include <pthread.h>',
1151       args : '-D_GNU_SOURCE')
1152     pre_args += '-DHAVE_PTHREAD_SETAFFINITY'
1153   endif
1154   if cc.has_function(
1155       'pthread_setaffinity_np',
1156       dependencies : dep_thread,
1157       prefix : '#include <pthread_np.h>')
1158     pre_args += '-DPTHREAD_SETAFFINITY_IN_NP_HEADER'
1159   endif
1160 endif
1161 dep_expat = dependency('expat')
1162 # this only exists on linux so either this is linux and it will be found, or
1163 # it's not linux and wont
1164 dep_m = cc.find_library('m', required : false)
1165
1166 # Check for libdrm. Various drivers have different libdrm version requirements,
1167 # but we always want to use the same version for all libdrm modules. That means
1168 # even if driver foo requires 2.4.0 and driver bar requires 2.4.3, if foo and
1169 # bar are both on use 2.4.3 for both of them
1170 dep_libdrm_amdgpu = null_dep
1171 dep_libdrm_radeon = null_dep
1172 dep_libdrm_nouveau = null_dep
1173 dep_libdrm_intel = null_dep
1174
1175 _drm_amdgpu_ver = '2.4.99'
1176 _drm_radeon_ver = '2.4.71'
1177 _drm_nouveau_ver = '2.4.66'
1178 _drm_intel_ver = '2.4.75'
1179 _drm_ver = '2.4.81'
1180
1181 _libdrm_checks = [
1182   ['intel', with_dri_i915 or with_gallium_i915],
1183   ['amdgpu', with_amd_vk or with_gallium_radeonsi],
1184   ['radeon', (with_gallium_radeonsi or with_dri_r100 or with_dri_r200 or
1185               with_gallium_r300 or with_gallium_r600)],
1186   ['nouveau', (with_gallium_nouveau or with_dri_nouveau)],
1187 ]
1188
1189 # VC4 only needs core libdrm support of this version, not a libdrm_vc4
1190 # library.
1191 if with_gallium_vc4
1192   _drm_ver = '2.4.89'
1193 endif
1194
1195 # etnaviv only needs core libdrm
1196 if with_gallium_etnaviv
1197   _drm_ver = '2.4.89'
1198 endif
1199
1200 # Loop over the enables versions and get the highest libdrm requirement for all
1201 # active drivers.
1202 _drm_blame = ''
1203 foreach d : _libdrm_checks
1204   ver = get_variable('_drm_@0@_ver'.format(d[0]))
1205   if d[1] and ver.version_compare('>' + _drm_ver)
1206     _drm_ver = ver
1207     _drm_blame = d[0]
1208   endif
1209 endforeach
1210 if _drm_blame != ''
1211   message('libdrm @0@ needed because @1@ has the highest requirement'.format(_drm_ver, _drm_blame))
1212 endif
1213
1214 # Then get each libdrm module
1215 foreach d : _libdrm_checks
1216   if d[1]
1217     set_variable(
1218       'dep_libdrm_' + d[0],
1219       dependency('libdrm_' + d[0], version : '>=' + _drm_ver)
1220     )
1221   endif
1222 endforeach
1223
1224 with_gallium_drisw_kms = false
1225 dep_libdrm = dependency(
1226   'libdrm', version : '>=' + _drm_ver,
1227   required : with_dri2 or with_dri3
1228 )
1229 if dep_libdrm.found()
1230   pre_args += '-DHAVE_LIBDRM'
1231   if with_dri_platform == 'drm' and with_dri
1232     with_gallium_drisw_kms = true
1233   endif
1234 endif
1235
1236 llvm_modules = ['bitwriter', 'engine', 'mcdisassembler', 'mcjit']
1237 llvm_optional_modules = []
1238 if with_amd_vk or with_gallium_radeonsi or with_gallium_r600
1239   llvm_modules += ['amdgpu', 'native', 'bitreader', 'ipo']
1240   if with_gallium_r600
1241     llvm_modules += 'asmparser'
1242   endif
1243 endif
1244 if with_gallium_opencl
1245   llvm_modules += [
1246     'all-targets', 'linker', 'coverage', 'instrumentation', 'ipo', 'irreader',
1247     'lto', 'option', 'objcarcopts', 'profiledata',
1248   ]
1249   llvm_optional_modules += ['coroutines']
1250 endif
1251
1252 if with_amd_vk or with_gallium_radeonsi
1253   _llvm_version = '>= 8.0.0'
1254 elif with_gallium_swr
1255   _llvm_version = '>= 6.0.0'
1256 elif with_gallium_opencl or with_gallium_r600
1257   _llvm_version = '>= 3.9.0'
1258 else
1259   _llvm_version = '>= 3.3.0'
1260 endif
1261
1262 _shared_llvm = get_option('shared-llvm')
1263
1264 _llvm = get_option('llvm')
1265 dep_llvm = null_dep
1266 with_llvm = false
1267 if _llvm != 'false'
1268   dep_llvm = dependency(
1269     'llvm',
1270     version : _llvm_version,
1271     modules : llvm_modules,
1272     optional_modules : llvm_optional_modules,
1273     required : (
1274       with_amd_vk or with_gallium_radeonsi or with_gallium_swr or
1275       with_gallium_opencl or _llvm == 'true'
1276     ),
1277     static : not _shared_llvm,
1278     method : 'config-tool',
1279   )
1280   with_llvm = dep_llvm.found()
1281 endif
1282 if with_llvm
1283   pre_args += '-DLLVM_AVAILABLE'
1284   pre_args += '-DMESA_LLVM_VERSION_STRING="@0@"'.format(dep_llvm.version())
1285
1286   # LLVM can be built without rtti, turning off rtti changes the ABI of C++
1287   # programs, so we need to build all C++ code in mesa without rtti as well to
1288   # ensure that linking works.
1289   if dep_llvm.get_configtool_variable('has-rtti') == 'NO'
1290     if with_gallium_nouveau
1291       error('The Nouveau driver requires rtti. You either need to turn off nouveau or use an LLVM built with LLVM_ENABLE_RTTI.')
1292     elif with_gallium_opencl
1293       error('The Clover OpenCL state tracker requires rtti, you need to turn off clover or use an LLVM built with LLVM_ENABLE_RTTI.')
1294     endif
1295     cpp_args += '-fno-rtti'
1296   endif
1297 elif with_amd_vk or with_gallium_radeonsi or with_gallium_swr
1298   error('The following drivers require LLVM: Radv, RadeonSI, SWR. One of these is enabled, but LLVM is disabled.')
1299 elif with_gallium_opencl
1300   error('The OpenCL "Clover" state tracker requires LLVM, but LLVM is disabled.')
1301 endif
1302
1303 if (with_amd_vk or with_gallium_radeonsi or with_gallium_opencl or
1304     (with_gallium_r600 and with_llvm))
1305   dep_elf = dependency('libelf', required : false)
1306   if not dep_elf.found()
1307     dep_elf = cc.find_library('elf')
1308   endif
1309 else
1310   dep_elf = null_dep
1311 endif
1312
1313 dep_glvnd = null_dep
1314 if with_glvnd
1315   dep_glvnd = dependency('libglvnd', version : '>= 0.2.0')
1316   pre_args += '-DUSE_LIBGLVND=1'
1317 endif
1318
1319 if with_valgrind != 'false'
1320   dep_valgrind = dependency('valgrind', required : with_valgrind == 'true')
1321   if dep_valgrind.found()
1322     pre_args += '-DHAVE_VALGRIND'
1323   endif
1324 else
1325   dep_valgrind = null_dep
1326 endif
1327
1328 # pthread stubs. Lets not and say we didn't
1329
1330 prog_bison = find_program('bison', required : with_any_opengl)
1331 prog_flex = find_program('flex', required : with_any_opengl)
1332
1333 dep_selinux = null_dep
1334 if get_option('selinux')
1335   dep_selinux = dependency('libselinux')
1336   pre_args += '-DMESA_SELINUX'
1337 endif
1338
1339 if with_libunwind != 'false'
1340   dep_unwind = dependency('libunwind', required : with_libunwind == 'true')
1341   if dep_unwind.found()
1342     pre_args += '-DHAVE_LIBUNWIND'
1343   endif
1344 else
1345   dep_unwind = null_dep
1346 endif
1347
1348 if with_osmesa != 'none'
1349   if with_osmesa == 'gallium' and not with_gallium_softpipe
1350     error('OSMesa gallium requires gallium softpipe or llvmpipe.')
1351   endif
1352   osmesa_lib_name = 'OSMesa'
1353   osmesa_bits = get_option('osmesa-bits')
1354   if osmesa_bits != '8'
1355     if with_dri or with_glx != 'disabled'
1356       error('OSMesa bits must be 8 if building glx or dir based drivers')
1357     endif
1358     osmesa_lib_name = osmesa_lib_name + osmesa_bits
1359     pre_args += [
1360       '-DCHAN_BITS=@0@'.format(osmesa_bits), '-DDEFAULT_SOFTWARE_DEPTH_BITS=31'
1361     ]
1362   endif
1363 endif
1364
1365 # TODO: symbol mangling
1366
1367 if with_platform_wayland
1368   dep_wl_scanner = dependency('wayland-scanner', native: true)
1369   prog_wl_scanner = find_program(dep_wl_scanner.get_pkgconfig_variable('wayland_scanner'))
1370   if dep_wl_scanner.version().version_compare('>= 1.15')
1371     wl_scanner_arg = 'private-code'
1372   else
1373     wl_scanner_arg = 'code'
1374   endif
1375   dep_wl_protocols = dependency('wayland-protocols', version : '>= 1.8')
1376   dep_wayland_client = dependency('wayland-client', version : '>=1.11')
1377   dep_wayland_server = dependency('wayland-server', version : '>=1.11')
1378   if with_egl
1379     dep_wayland_egl = dependency('wayland-egl-backend', version : '>= 3')
1380     dep_wayland_egl_headers = declare_dependency(
1381       compile_args : run_command(prog_pkgconfig, ['wayland-egl-backend', '--cflags']).stdout().split())
1382   endif
1383   wayland_dmabuf_xml = join_paths(
1384     dep_wl_protocols.get_pkgconfig_variable('pkgdatadir'), 'unstable',
1385     'linux-dmabuf', 'linux-dmabuf-unstable-v1.xml'
1386   )
1387   pre_args += ['-DHAVE_WAYLAND_PLATFORM', '-DWL_HIDE_DEPRECATED']
1388 endif
1389
1390 dep_x11 = null_dep
1391 dep_xext = null_dep
1392 dep_xdamage = null_dep
1393 dep_xfixes = null_dep
1394 dep_x11_xcb = null_dep
1395 dep_xcb = null_dep
1396 dep_xcb_glx = null_dep
1397 dep_xcb_dri2 = null_dep
1398 dep_xcb_dri3 = null_dep
1399 dep_dri2proto = null_dep
1400 dep_glproto = null_dep
1401 dep_xxf86vm = null_dep
1402 dep_xcb_dri3 = null_dep
1403 dep_xcb_present = null_dep
1404 dep_xcb_sync = null_dep
1405 dep_xcb_xfixes = null_dep
1406 dep_xshmfence = null_dep
1407 dep_xcb_xrandr = null_dep
1408 dep_xlib_xrandr = null_dep
1409 if with_platform_x11
1410   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1411     dep_x11 = dependency('x11')
1412     dep_xext = dependency('xext')
1413     dep_xcb = dependency('xcb')
1414   elif with_glx == 'dri'
1415     dep_x11 = dependency('x11')
1416     dep_xext = dependency('xext')
1417     dep_xdamage = dependency('xdamage', version : '>= 1.1')
1418     dep_xfixes = dependency('xfixes')
1419     dep_xcb_glx = dependency('xcb-glx', version : '>= 1.8.1')
1420   endif
1421   if (with_any_vk or with_glx == 'dri' or with_egl or
1422        (with_gallium_vdpau or with_gallium_xvmc or with_gallium_va or
1423         with_gallium_omx != 'disabled'))
1424     dep_xcb = dependency('xcb')
1425     dep_x11_xcb = dependency('x11-xcb')
1426   endif
1427   if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
1428     dep_xcb_dri2 = dependency('xcb-dri2', version : '>= 1.8')
1429
1430     if with_dri3
1431       pre_args += '-DHAVE_DRI3'
1432       dep_xcb_dri3 = dependency('xcb-dri3')
1433       dep_xcb_present = dependency('xcb-present')
1434       # until xcb-dri3 has been around long enough to make a hard-dependency:
1435       if (dep_xcb_dri3.version().version_compare('>= 1.13') and
1436           dep_xcb_present.version().version_compare('>= 1.13'))
1437         pre_args += '-DHAVE_DRI3_MODIFIERS'
1438       endif
1439       dep_xcb_sync = dependency('xcb-sync')
1440       dep_xshmfence = dependency('xshmfence', version : '>= 1.1')
1441     endif
1442   endif
1443   if with_glx == 'dri' or with_glx == 'gallium-xlib'
1444     dep_glproto = dependency('glproto', version : '>= 1.4.14')
1445   endif
1446   if with_glx == 'dri'
1447     if with_dri_platform == 'drm'
1448       dep_dri2proto = dependency('dri2proto', version : '>= 2.8')
1449       dep_xxf86vm = dependency('xxf86vm')
1450     endif
1451   endif
1452   if (with_egl or (
1453       with_gallium_vdpau or with_gallium_xvmc or with_gallium_xa or
1454       with_gallium_omx != 'disabled'))
1455     dep_xcb_xfixes = dependency('xcb-xfixes')
1456   endif
1457   if with_xlib_lease
1458     dep_xcb_xrandr = dependency('xcb-randr')
1459     dep_xlib_xrandr = dependency('xrandr', version : '>= 1.3')
1460   endif
1461 endif
1462
1463 if get_option('gallium-extra-hud')
1464   pre_args += '-DHAVE_GALLIUM_EXTRA_HUD=1'
1465 endif
1466
1467 _sensors = get_option('lmsensors')
1468 if _sensors != 'false'
1469   dep_lmsensors = cc.find_library('sensors', required : _sensors == 'true')
1470   if dep_lmsensors.found()
1471     pre_args += '-DHAVE_LIBSENSORS=1'
1472   endif
1473 else
1474   dep_lmsensors = null_dep
1475 endif
1476
1477 foreach a : pre_args
1478   add_project_arguments(a, language : ['c', 'cpp'])
1479 endforeach
1480 foreach a : c_args
1481   add_project_arguments(a, language : ['c'])
1482 endforeach
1483 foreach a : cpp_args
1484   add_project_arguments(a, language : ['cpp'])
1485 endforeach
1486
1487 gl_priv_reqs = []
1488
1489 if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1490   gl_priv_reqs += ['x11', 'xext', 'xcb']
1491 elif with_glx == 'dri'
1492   gl_priv_reqs += [
1493     'x11', 'xext', 'xdamage >= 1.1', 'xfixes', 'x11-xcb', 'xcb',
1494     'xcb-glx >= 1.8.1']
1495   if with_dri_platform == 'drm'
1496     gl_priv_reqs += 'xcb-dri2 >= 1.8'
1497     gl_priv_reqs += 'xxf86vm'
1498   endif
1499 endif
1500 if dep_libdrm.found()
1501   gl_priv_reqs += 'libdrm >= 2.4.75'
1502 endif
1503
1504 gl_priv_libs = []
1505 if dep_thread.found()
1506   gl_priv_libs += ['-lpthread', '-pthread']
1507 endif
1508 if dep_m.found()
1509   gl_priv_libs += '-lm'
1510 endif
1511 if dep_dl.found()
1512   gl_priv_libs += '-ldl'
1513 endif
1514
1515 pkg = import('pkgconfig')
1516
1517 prog_nm = find_program('nm', required : false)
1518
1519 # This quirk needs to be applied to sources with functions defined in assembly
1520 # as GCC LTO drops them. See: https://bugs.freedesktop.org/show_bug.cgi?id=109391
1521 gcc_lto_quirk = (cc.get_id() == 'gcc') ? ['-fno-lto'] : []
1522
1523 subdir('include')
1524 subdir('bin')
1525 subdir('src')
1526
1527 # Meson 0.49 and earlier seems to have a bug that fails to evaluate the string-
1528 # formatting below unless the first argument is passed as a variable. This has
1529 # been fixed in Meson 0.50 and beyond, but we need to keep it like this for now
1530 # for backwards compatibility.
1531 _with_opengl_string = with_opengl ? 'yes' : 'no'
1532
1533 lines = ['',
1534   'prefix:          ' + get_option('prefix'),
1535   'libdir:          ' + get_option('libdir'),
1536   'includedir:      ' + get_option('includedir'),
1537   '',
1538   'OpenGL:          @0@ (ES1: @1@ ES2: @2@)'.format(_with_opengl_string,
1539                                                     with_gles1 ? 'yes' : 'no',
1540                                                     with_gles2 ? 'yes' : 'no'),
1541 ]
1542
1543 if with_osmesa != 'none'
1544   lines += ''
1545   suffix = ''
1546   if with_osmesa == 'gallium'
1547     suffix = '(Gallium)'
1548   endif
1549   lines += 'OSMesa:          lib' + osmesa_lib_name + suffix
1550 else
1551   lines += 'OSMesa:          no'
1552 endif
1553
1554 if with_dri
1555   lines += ''
1556   lines += 'DRI platform:    ' + with_dri_platform
1557   if dri_drivers.length() != 0 and dri_drivers != ['']
1558     lines += 'DRI drivers:     ' + ' '.join(dri_drivers)
1559   else
1560     lines += 'DRI drivers:     no'
1561   endif
1562   lines += 'DRI driver dir:  ' + dri_drivers_path
1563 endif
1564
1565 if with_glx != 'disabled'
1566   lines += ''
1567   if with_glx == 'dri'
1568     lines += 'GLX:             DRI-based'
1569   elif with_glx == 'xlib'
1570     lines += 'GLX:             Xlib-based'
1571   elif with_glx == 'gallium-xlib'
1572     lines += 'GLX:             Xlib-based (Gallium)'
1573   else
1574     lines += 'GLX:             ' + with_glx
1575   endif
1576 endif
1577
1578 lines += ''
1579 lines += 'EGL:             ' + (with_egl ? 'yes' : 'no')
1580 if with_egl
1581   egl_drivers = []
1582   if with_dri
1583     egl_drivers += 'builtin:egl_dri2'
1584   endif
1585   if with_dri3
1586     egl_drivers += 'builtin:egl_dri3'
1587   endif
1588   lines += 'EGL drivers:     ' + ' '.join(egl_drivers)
1589 endif
1590 lines += 'GBM:             ' + (with_gbm ? 'yes' : 'no')
1591 if with_platforms
1592   lines += 'EGL/Vulkan/VL platforms:   ' + ' '.join(_platforms)
1593 endif
1594
1595 lines += ''
1596 if with_any_vk
1597   lines += 'Vulkan drivers:  ' + ' '.join(_vulkan_drivers)
1598   lines += 'Vulkan ICD dir:  ' + with_vulkan_icd_dir
1599 else
1600   lines += 'Vulkan drivers:  no'
1601 endif
1602
1603 lines += ''
1604 if with_llvm
1605   lines += 'llvm:            yes'
1606   lines += 'llvm-version:    ' + dep_llvm.version()
1607 else
1608   lines += 'llvm:            no'
1609 endif
1610
1611 lines += ''
1612 if with_gallium
1613   lines += 'Gallium drivers: ' + ' '.join(gallium_drivers)
1614   gallium_st = ['mesa']
1615   if with_gallium_xa
1616     gallium_st += 'xa'
1617   endif
1618   if with_gallium_xvmc
1619     gallium_st += 'xvmc'
1620   endif
1621   if with_gallium_xvmc
1622     gallium_st += 'xvmc'
1623   endif
1624   if with_gallium_vdpau
1625     gallium_st += 'vdpau'
1626   endif
1627   if with_gallium_omx != 'disabled'
1628     gallium_st += 'omx' + with_gallium_omx
1629   endif
1630   if with_gallium_va
1631     gallium_st += 'va'
1632   endif
1633   if with_gallium_st_nine
1634     gallium_st += 'nine'
1635   endif
1636   if with_gallium_opencl
1637     gallium_st += 'clover'
1638   endif
1639   lines += 'Gallium st:      ' + ' '.join(gallium_st)
1640 else
1641   lines += 'Gallium:         no'
1642 endif
1643
1644 lines += 'HUD lmsensors:   ' + (dep_lmsensors.found() ? 'yes' : 'no')
1645
1646 lines += ''
1647 lines += 'Shared-glapi:    ' + (with_shared_glapi ? 'yes' : 'no')
1648
1649
1650 indent = '        '
1651 summary = indent + ('\n' + indent).join(lines)
1652 message('Configuration summary:\n@0@\n'.format(summary))