meson.build

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