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   _llvm_version = dep_llvm.version().split('.')
1277   pre_args += [
1278     '-DHAVE_LLVM=0x0@0@0@1@'.format(_llvm_version[0], _llvm_version[1]),
1279     '-DMESA_LLVM_VERSION_STRING="@0@"'.format(dep_llvm.version()),
1280   ]
1281
1282   # LLVM can be built without rtti, turning off rtti changes the ABI of C++
1283   # programs, so we need to build all C++ code in mesa without rtti as well to
1284   # ensure that linking works.
1285   if dep_llvm.get_configtool_variable('has-rtti') == 'NO'
1286     if with_gallium_nouveau
1287       error('The Nouveau driver requires rtti. You either need to turn off nouveau or use an LLVM built with LLVM_ENABLE_RTTI.')
1288     elif with_gallium_opencl
1289       error('The Clover OpenCL state tracker requires rtti, you need to turn off clover or use an LLVM built with LLVM_ENABLE_RTTI.')
1290     endif
1291     cpp_args += '-fno-rtti'
1292   endif
1293 elif with_amd_vk or with_gallium_radeonsi or with_gallium_swr
1294   error('The following drivers require LLVM: Radv, RadeonSI, SWR. One of these is enabled, but LLVM is disabled.')
1295 elif with_gallium_opencl
1296   error('The OpenCL "Clover" state tracker requires LLVM, but LLVM is disabled.')
1297 endif
1298
1299 if (with_amd_vk or with_gallium_radeonsi or with_gallium_opencl or
1300     (with_gallium_r600 and with_llvm))
1301   dep_elf = dependency('libelf', required : false)
1302   if not dep_elf.found()
1303     dep_elf = cc.find_library('elf')
1304   endif
1305 else
1306   dep_elf = null_dep
1307 endif
1308
1309 dep_glvnd = null_dep
1310 if with_glvnd
1311   dep_glvnd = dependency('libglvnd', version : '>= 0.2.0')
1312   pre_args += '-DUSE_LIBGLVND=1'
1313 endif
1314
1315 if with_valgrind != 'false'
1316   dep_valgrind = dependency('valgrind', required : with_valgrind == 'true')
1317   if dep_valgrind.found()
1318     pre_args += '-DHAVE_VALGRIND'
1319   endif
1320 else
1321   dep_valgrind = null_dep
1322 endif
1323
1324 # pthread stubs. Lets not and say we didn't
1325
1326 prog_bison = find_program('bison', required : with_any_opengl)
1327 prog_flex = find_program('flex', required : with_any_opengl)
1328
1329 dep_selinux = null_dep
1330 if get_option('selinux')
1331   dep_selinux = dependency('libselinux')
1332   pre_args += '-DMESA_SELINUX'
1333 endif
1334
1335 if with_libunwind != 'false'
1336   dep_unwind = dependency('libunwind', required : with_libunwind == 'true')
1337   if dep_unwind.found()
1338     pre_args += '-DHAVE_LIBUNWIND'
1339   endif
1340 else
1341   dep_unwind = null_dep
1342 endif
1343
1344 if with_osmesa != 'none'
1345   if with_osmesa == 'gallium' and not with_gallium_softpipe
1346     error('OSMesa gallium requires gallium softpipe or llvmpipe.')
1347   endif
1348   osmesa_lib_name = 'OSMesa'
1349   osmesa_bits = get_option('osmesa-bits')
1350   if osmesa_bits != '8'
1351     if with_dri or with_glx != 'disabled'
1352       error('OSMesa bits must be 8 if building glx or dir based drivers')
1353     endif
1354     osmesa_lib_name = osmesa_lib_name + osmesa_bits
1355     pre_args += [
1356       '-DCHAN_BITS=@0@'.format(osmesa_bits), '-DDEFAULT_SOFTWARE_DEPTH_BITS=31'
1357     ]
1358   endif
1359 endif
1360
1361 # TODO: symbol mangling
1362
1363 if with_platform_wayland
1364   dep_wl_scanner = dependency('wayland-scanner', native: true)
1365   prog_wl_scanner = find_program(dep_wl_scanner.get_pkgconfig_variable('wayland_scanner'))
1366   if dep_wl_scanner.version().version_compare('>= 1.15')
1367     wl_scanner_arg = 'private-code'
1368   else
1369     wl_scanner_arg = 'code'
1370   endif
1371   dep_wl_protocols = dependency('wayland-protocols', version : '>= 1.8')
1372   dep_wayland_client = dependency('wayland-client', version : '>=1.11')
1373   dep_wayland_server = dependency('wayland-server', version : '>=1.11')
1374   if with_egl
1375     dep_wayland_egl = dependency('wayland-egl-backend', version : '>= 3')
1376     dep_wayland_egl_headers = declare_dependency(
1377       compile_args : run_command(prog_pkgconfig, ['wayland-egl-backend', '--cflags']).stdout().split())
1378   endif
1379   wayland_dmabuf_xml = join_paths(
1380     dep_wl_protocols.get_pkgconfig_variable('pkgdatadir'), 'unstable',
1381     'linux-dmabuf', 'linux-dmabuf-unstable-v1.xml'
1382   )
1383   pre_args += ['-DHAVE_WAYLAND_PLATFORM', '-DWL_HIDE_DEPRECATED']
1384 endif
1385
1386 dep_x11 = null_dep
1387 dep_xext = null_dep
1388 dep_xdamage = null_dep
1389 dep_xfixes = null_dep
1390 dep_x11_xcb = null_dep
1391 dep_xcb = null_dep
1392 dep_xcb_glx = null_dep
1393 dep_xcb_dri2 = null_dep
1394 dep_xcb_dri3 = null_dep
1395 dep_dri2proto = null_dep
1396 dep_glproto = null_dep
1397 dep_xxf86vm = null_dep
1398 dep_xcb_dri3 = null_dep
1399 dep_xcb_present = null_dep
1400 dep_xcb_sync = null_dep
1401 dep_xcb_xfixes = null_dep
1402 dep_xshmfence = null_dep
1403 dep_xcb_xrandr = null_dep
1404 dep_xlib_xrandr = null_dep
1405 if with_platform_x11
1406   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1407     dep_x11 = dependency('x11')
1408     dep_xext = dependency('xext')
1409     dep_xcb = dependency('xcb')
1410   elif with_glx == 'dri'
1411     dep_x11 = dependency('x11')
1412     dep_xext = dependency('xext')
1413     dep_xdamage = dependency('xdamage', version : '>= 1.1')
1414     dep_xfixes = dependency('xfixes')
1415     dep_xcb_glx = dependency('xcb-glx', version : '>= 1.8.1')
1416   endif
1417   if (with_any_vk or with_glx == 'dri' or with_egl or
1418        (with_gallium_vdpau or with_gallium_xvmc or with_gallium_va or
1419         with_gallium_omx != 'disabled'))
1420     dep_xcb = dependency('xcb')
1421     dep_x11_xcb = dependency('x11-xcb')
1422   endif
1423   if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
1424     dep_xcb_dri2 = dependency('xcb-dri2', version : '>= 1.8')
1425
1426     if with_dri3
1427       pre_args += '-DHAVE_DRI3'
1428       dep_xcb_dri3 = dependency('xcb-dri3')
1429       dep_xcb_present = dependency('xcb-present')
1430       # until xcb-dri3 has been around long enough to make a hard-dependency:
1431       if (dep_xcb_dri3.version().version_compare('>= 1.13') and
1432           dep_xcb_present.version().version_compare('>= 1.13'))
1433         pre_args += '-DHAVE_DRI3_MODIFIERS'
1434       endif
1435       dep_xcb_sync = dependency('xcb-sync')
1436       dep_xshmfence = dependency('xshmfence', version : '>= 1.1')
1437     endif
1438   endif
1439   if with_glx == 'dri' or with_glx == 'gallium-xlib'
1440     dep_glproto = dependency('glproto', version : '>= 1.4.14')
1441   endif
1442   if with_glx == 'dri'
1443     if with_dri_platform == 'drm'
1444       dep_dri2proto = dependency('dri2proto', version : '>= 2.8')
1445       dep_xxf86vm = dependency('xxf86vm')
1446     endif
1447   endif
1448   if (with_egl or (
1449       with_gallium_vdpau or with_gallium_xvmc or with_gallium_xa or
1450       with_gallium_omx != 'disabled'))
1451     dep_xcb_xfixes = dependency('xcb-xfixes')
1452   endif
1453   if with_xlib_lease
1454     dep_xcb_xrandr = dependency('xcb-randr')
1455     dep_xlib_xrandr = dependency('xrandr', version : '>= 1.3')
1456   endif
1457 endif
1458
1459 if get_option('gallium-extra-hud')
1460   pre_args += '-DHAVE_GALLIUM_EXTRA_HUD=1'
1461 endif
1462
1463 _sensors = get_option('lmsensors')
1464 if _sensors != 'false'
1465   dep_lmsensors = cc.find_library('sensors', required : _sensors == 'true')
1466   if dep_lmsensors.found()
1467     pre_args += '-DHAVE_LIBSENSORS=1'
1468   endif
1469 else
1470   dep_lmsensors = null_dep
1471 endif
1472
1473 foreach a : pre_args
1474   add_project_arguments(a, language : ['c', 'cpp'])
1475 endforeach
1476 foreach a : c_args
1477   add_project_arguments(a, language : ['c'])
1478 endforeach
1479 foreach a : cpp_args
1480   add_project_arguments(a, language : ['cpp'])
1481 endforeach
1482
1483 gl_priv_reqs = []
1484
1485 if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1486   gl_priv_reqs += ['x11', 'xext', 'xcb']
1487 elif with_glx == 'dri'
1488   gl_priv_reqs += [
1489     'x11', 'xext', 'xdamage >= 1.1', 'xfixes', 'x11-xcb', 'xcb',
1490     'xcb-glx >= 1.8.1']
1491   if with_dri_platform == 'drm'
1492     gl_priv_reqs += 'xcb-dri2 >= 1.8'
1493     gl_priv_reqs += 'xxf86vm'
1494   endif
1495 endif
1496 if dep_libdrm.found()
1497   gl_priv_reqs += 'libdrm >= 2.4.75'
1498 endif
1499
1500 gl_priv_libs = []
1501 if dep_thread.found()
1502   gl_priv_libs += ['-lpthread', '-pthread']
1503 endif
1504 if dep_m.found()
1505   gl_priv_libs += '-lm'
1506 endif
1507 if dep_dl.found()
1508   gl_priv_libs += '-ldl'
1509 endif
1510
1511 pkg = import('pkgconfig')
1512
1513 prog_nm = find_program('nm', required : false)
1514
1515 # This quirk needs to be applied to sources with functions defined in assembly
1516 # as GCC LTO drops them. See: https://bugs.freedesktop.org/show_bug.cgi?id=109391
1517 gcc_lto_quirk = (cc.get_id() == 'gcc') ? ['-fno-lto'] : []
1518
1519 subdir('include')
1520 subdir('bin')
1521 subdir('src')
1522
1523 # Meson 0.49 and earlier seems to have a bug that fails to evaluate the string-
1524 # formatting below unless the first argument is passed as a variable. This has
1525 # been fixed in Meson 0.50 and beyond, but we need to keep it like this for now
1526 # for backwards compatibility.
1527 _with_opengl_string = with_opengl ? 'yes' : 'no'
1528
1529 lines = ['',
1530   'prefix:          ' + get_option('prefix'),
1531   'libdir:          ' + get_option('libdir'),
1532   'includedir:      ' + get_option('includedir'),
1533   '',
1534   'OpenGL:          @0@ (ES1: @1@ ES2: @2@)'.format(_with_opengl_string,
1535                                                     with_gles1 ? 'yes' : 'no',
1536                                                     with_gles2 ? 'yes' : 'no'),
1537 ]
1538
1539 if with_osmesa != 'none'
1540   lines += ''
1541   suffix = ''
1542   if with_osmesa == 'gallium'
1543     suffix = '(Gallium)'
1544   endif
1545   lines += 'OSMesa:          lib' + osmesa_lib_name + suffix
1546 else
1547   lines += 'OSMesa:          no'
1548 endif
1549
1550 if with_dri
1551   lines += ''
1552   lines += 'DRI platform:    ' + with_dri_platform
1553   if dri_drivers.length() != 0 and dri_drivers != ['']
1554     lines += 'DRI drivers:     ' + ' '.join(dri_drivers)
1555   else
1556     lines += 'DRI drivers:     no'
1557   endif
1558   lines += 'DRI driver dir:  ' + dri_drivers_path
1559 endif
1560
1561 if with_glx != 'disabled'
1562   lines += ''
1563   if with_glx == 'dri'
1564     lines += 'GLX:             DRI-based'
1565   elif with_glx == 'xlib'
1566     lines += 'GLX:             Xlib-based'
1567   elif with_glx == 'gallium-xlib'
1568     lines += 'GLX:             Xlib-based (Gallium)'
1569   else
1570     lines += 'GLX:             ' + with_glx
1571   endif
1572 endif
1573
1574 lines += ''
1575 lines += 'EGL:             ' + (with_egl ? 'yes' : 'no')
1576 if with_egl
1577   egl_drivers = []
1578   if with_dri
1579     egl_drivers += 'builtin:egl_dri2'
1580   endif
1581   if with_dri3
1582     egl_drivers += 'builtin:egl_dri3'
1583   endif
1584   lines += 'EGL drivers:     ' + ' '.join(egl_drivers)
1585 endif
1586 lines += 'GBM:             ' + (with_gbm ? 'yes' : 'no')
1587 if with_platforms
1588   lines += 'EGL/Vulkan/VL platforms:   ' + ' '.join(_platforms)
1589 endif
1590
1591 lines += ''
1592 if with_any_vk
1593   lines += 'Vulkan drivers:  ' + ' '.join(_vulkan_drivers)
1594   lines += 'Vulkan ICD dir:  ' + with_vulkan_icd_dir
1595 else
1596   lines += 'Vulkan drivers:  no'
1597 endif
1598
1599 lines += ''
1600 if with_llvm
1601   lines += 'llvm:            yes'
1602   lines += 'llvm-version:    ' + dep_llvm.version()
1603 else
1604   lines += 'llvm:            no'
1605 endif
1606
1607 lines += ''
1608 if with_gallium
1609   lines += 'Gallium drivers: ' + ' '.join(gallium_drivers)
1610   gallium_st = ['mesa']
1611   if with_gallium_xa
1612     gallium_st += 'xa'
1613   endif
1614   if with_gallium_xvmc
1615     gallium_st += 'xvmc'
1616   endif
1617   if with_gallium_xvmc
1618     gallium_st += 'xvmc'
1619   endif
1620   if with_gallium_vdpau
1621     gallium_st += 'vdpau'
1622   endif
1623   if with_gallium_omx != 'disabled'
1624     gallium_st += 'omx' + with_gallium_omx
1625   endif
1626   if with_gallium_va
1627     gallium_st += 'va'
1628   endif
1629   if with_gallium_st_nine
1630     gallium_st += 'nine'
1631   endif
1632   if with_gallium_opencl
1633     gallium_st += 'clover'
1634   endif
1635   lines += 'Gallium st:      ' + ' '.join(gallium_st)
1636 else
1637   lines += 'Gallium:         no'
1638 endif
1639
1640 lines += 'HUD lmsensors:   ' + (dep_lmsensors.found() ? 'yes' : 'no')
1641
1642 lines += ''
1643 lines += 'Shared-glapi:    ' + (with_shared_glapi ? 'yes' : 'no')
1644
1645
1646 indent = '        '
1647 summary = indent + ('\n' + indent).join(lines)
1648 message('Configuration summary:\n@0@\n'.format(summary))