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