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