meson.build

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