meson.build

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