meson.build

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