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