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