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