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