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