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