meson.build

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