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 clover_cpp_std = []
 652 if _opencl != 'disabled'
 653   if not with_gallium
 654     error('OpenCL Clover implementation requires at least one gallium driver.')
 655   endif
 656
 657   dep_clc = dependency('libclc')
 658   with_gallium_opencl = true
 659   with_opencl_icd = _opencl == 'icd'
 660
 661   if host_machine.cpu_family().startswith('ppc') and cpp.compiles('''
 662       #if !defined(__VEC__) || !defined(__ALTIVEC__)
 663       #error "AltiVec not enabled"
 664       #endif''',
 665       name : 'Altivec')
 666     clover_cpp_std += ['cpp_std=gnu++11']
 667   endif
 668 else
 669   dep_clc = null_dep
 670   with_gallium_opencl = false
 671   with_gallium_icd = false
 672 endif
 673
 674 gl_pkgconfig_c_flags = []
 675 if with_platform_x11
 676   if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
 677     pre_args += '-DHAVE_X11_PLATFORM'
 678   endif
 679   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
 680     pre_args += '-DUSE_XSHM'
 681   else
 682     pre_args += '-DGLX_INDIRECT_RENDERING'
 683     if with_glx_direct
 684       pre_args += '-DGLX_DIRECT_RENDERING'
 685     endif
 686     if with_dri_platform == 'drm'
 687       pre_args += '-DGLX_USE_DRM'
 688     elif with_dri_platform == 'apple'
 689       pre_args += '-DGLX_USE_APPLEGL'
 690     elif with_dri_platform == 'windows'
 691       pre_args += '-DGLX_USE_WINDOWSGL'
 692     endif
 693   endif
 694 else
 695   pre_args += '-DMESA_EGL_NO_X11_HEADERS'
 696   gl_pkgconfig_c_flags += '-DMESA_EGL_NO_X11_HEADERS'
 697 endif
 698 if with_platform_drm
 699   if with_egl and not with_gbm
 700     error('EGL drm platform requires gbm')
 701   endif
 702   pre_args += '-DHAVE_DRM_PLATFORM'
 703 endif
 704 if with_platform_surfaceless
 705   pre_args += '-DHAVE_SURFACELESS_PLATFORM'
 706 endif
 707 if with_platform_android
 708   dep_android = [
 709     dependency('cutils'),
 710     dependency('hardware'),
 711     dependency('sync'),
 712   ]
 713   pre_args += '-DHAVE_ANDROID_PLATFORM'
 714 endif
 715 if with_platform_haiku
 716   pre_args += '-DHAVE_HAIKU_PLATFORM'
 717 endif
 718
 719 prog_python = import('python3').find_python()
 720 has_mako = run_command(
 721   prog_python, '-c',
 722   '''
 723 from distutils.version import StrictVersion
 724 import mako
 725 assert StrictVersion(mako.__version__) > StrictVersion("0.8.0")
 726   ''')
 727 if has_mako.returncode() != 0
 728   error('Python (3.x) mako module >= 0.8.0 required to build mesa.')
 729 endif
 730
 731 if cc.get_id() == 'gcc' and cc.version().version_compare('< 4.4.6')
 732   error('When using GCC, version 4.4.6 or later is required.')
 733 endif
 734
 735 # Define DEBUG for debug builds only (debugoptimized is not included on this one)
 736 if get_option('buildtype') == 'debug'
 737   pre_args += '-DDEBUG'
 738 endif
 739
 740 if get_option('shader-cache')
 741   pre_args += '-DENABLE_SHADER_CACHE'
 742 elif with_amd_vk
 743   error('Radv requires shader cache support')
 744 endif
 745
 746 # Check for GCC style builtins
 747 foreach b : ['bswap32', 'bswap64', 'clz', 'clzll', 'ctz', 'expect', 'ffs',
 748              'ffsll', 'popcount', 'popcountll', 'unreachable']
 749   if cc.has_function(b)
 750     pre_args += '-DHAVE___BUILTIN_@0@'.format(b.to_upper())
 751   endif
 752 endforeach
 753
 754 # check for GCC __attribute__
 755 foreach a : ['const', 'flatten', 'malloc', 'pure', 'unused',
 756              'warn_unused_result', 'weak',]
 757   if cc.compiles('int foo(void) __attribute__((@0@));'.format(a),
 758                  name : '__attribute__((@0@))'.format(a))
 759     pre_args += '-DHAVE_FUNC_ATTRIBUTE_@0@'.format(a.to_upper())
 760   endif
 761 endforeach
 762 if cc.compiles('int foo(const char *p, ...) __attribute__((format(printf, 1, 2)));',
 763                name : '__attribute__((format(...)))')
 764   pre_args += '-DHAVE_FUNC_ATTRIBUTE_FORMAT'
 765 endif
 766 if cc.compiles('struct __attribute__((packed)) foo { int bar; };',
 767                name : '__attribute__((packed))')
 768   pre_args += '-DHAVE_FUNC_ATTRIBUTE_PACKED'
 769 endif
 770 if cc.compiles('int *foo(void) __attribute__((returns_nonnull));',
 771                name : '__attribute__((returns_nonnull))')
 772   pre_args += '-DHAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL'
 773 endif
 774 if cc.compiles('''int foo_def(void) __attribute__((visibility("default")));
 775                   int foo_hid(void) __attribute__((visibility("hidden")));
 776                   int foo_int(void) __attribute__((visibility("internal")));
 777                   int foo_pro(void) __attribute__((visibility("protected")));''',
 778                name : '__attribute__((visibility(...)))')
 779   pre_args += '-DHAVE_FUNC_ATTRIBUTE_VISIBILITY'
 780 endif
 781 if cc.compiles('int foo(void) { return 0; } int bar(void) __attribute__((alias("foo")));',
 782                name : '__attribute__((alias(...)))')
 783   pre_args += '-DHAVE_FUNC_ATTRIBUTE_ALIAS'
 784 endif
 785 if cc.compiles('int foo(void) __attribute__((__noreturn__));',
 786                name : '__attribute__((__noreturn__))')
 787   pre_args += '-DHAVE_FUNC_ATTRIBUTE_NORETURN'
 788 endif
 789
 790 # TODO: this is very incomplete
 791 if ['linux', 'cygwin', 'gnu'].contains(host_machine.system())
 792   pre_args += '-D_GNU_SOURCE'
 793 endif
 794
 795 # Check for generic C arguments
 796 c_args = []
 797 foreach a : ['-Werror=implicit-function-declaration',
 798              '-Werror=missing-prototypes', '-Werror=return-type',
 799              '-fno-math-errno',
 800              '-fno-trapping-math', '-Qunused-arguments']
 801   if cc.has_argument(a)
 802     c_args += a
 803   endif
 804 endforeach
 805
 806 foreach a : ['missing-field-initializers', 'format-truncation']
 807   if cc.has_argument('-W' + a)
 808     c_args += '-Wno-' + a
 809   endif
 810 endforeach
 811
 812 c_vis_args = []
 813 if cc.has_argument('-fvisibility=hidden')
 814   c_vis_args += '-fvisibility=hidden'
 815 endif
 816
 817 # Check for generic C++ arguments
 818 cpp_args = []
 819 foreach a : ['-Werror=return-type',
 820              '-fno-math-errno', '-fno-trapping-math',
 821              '-Qunused-arguments']
 822   if cpp.has_argument(a)
 823     cpp_args += a
 824   endif
 825 endforeach
 826
 827 # For some reason, the test for -Wno-foo always succeeds with gcc, even if the
 828 # option is not supported. Hence, check for -Wfoo instead.
 829
 830 foreach a : ['non-virtual-dtor', 'missing-field-initializers', 'format-truncation']
 831   if cpp.has_argument('-W' + a)
 832     cpp_args += '-Wno-' + a
 833   endif
 834 endforeach
 835
 836 no_override_init_args = []
 837 foreach a : ['override-init', 'initializer-overrides']
 838   if cc.has_argument('-W' + a)
 839     no_override_init_args += '-Wno-' + a
 840   endif
 841 endforeach
 842
 843 cpp_vis_args = []
 844 if cpp.has_argument('-fvisibility=hidden')
 845   cpp_vis_args += '-fvisibility=hidden'
 846 endif
 847
 848 # Check for C and C++ arguments for MSVC2013 compatibility. These are only used
 849 # in parts of the mesa code base that need to compile with old versions of
 850 # MSVC, mainly common code
 851 c_msvc_compat_args = []
 852 cpp_msvc_compat_args = []
 853 foreach a : ['-Werror=pointer-arith', '-Werror=vla']
 854   if cc.has_argument(a)
 855     c_msvc_compat_args += a
 856   endif
 857   if cpp.has_argument(a)
 858     cpp_msvc_compat_args += a
 859   endif
 860 endforeach
 861
 862 if host_machine.cpu_family().startswith('x86')
 863   pre_args += '-DUSE_SSE41'
 864   with_sse41 = true
 865   sse41_args = ['-msse4.1']
 866
 867   # GCC on x86 (not x86_64) with -msse* assumes a 16 byte aligned stack, but
 868   # that's not guaranteed
 869   if host_machine.cpu_family() == 'x86'
 870     sse41_args += '-mstackrealign'
 871   endif
 872 else
 873   with_sse41 = false
 874   sse41_args = []
 875 endif
 876
 877 # Check for GCC style atomics
 878 dep_atomic = null_dep
 879
 880 if cc.compiles('''#include <stdint.h>
 881                   int main() {
 882                     struct {
 883                       uint64_t *v;
 884                     } x;
 885                     return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
 886                            (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
 887
 888                   }''',
 889                name : 'GCC atomic builtins')
 890   pre_args += '-DUSE_GCC_ATOMIC_BUILTINS'
 891
 892   # Not all atomic calls can be turned into lock-free instructions, in which
 893   # GCC will make calls into the libatomic library. Check whether we need to
 894   # link with -latomic.
 895   #
 896   # This can happen for 64-bit atomic operations on 32-bit architectures such
 897   # as ARM.
 898   if not cc.links('''#include <stdint.h>
 899                      int main() {
 900                        struct {
 901                          uint64_t *v;
 902                        } x;
 903                        return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
 904                               (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
 905                      }''',
 906                   name : 'GCC atomic builtins required -latomic')
 907     dep_atomic = cc.find_library('atomic')
 908   endif
 909 endif
 910 if not cc.links('''#include <stdint.h>
 911                    uint64_t v;
 912                    int main() {
 913                      return __sync_add_and_fetch(&v, (uint64_t)1);
 914                    }''',
 915                 dependencies : dep_atomic,
 916                 name : 'GCC 64bit atomics')
 917   pre_args += '-DMISSING_64BIT_ATOMICS'
 918 endif
 919
 920 # TODO: shared/static? Is this even worth doing?
 921
 922 # When cross compiling we generally need to turn off the use of assembly,
 923 # because mesa's assembly relies on building an executable for the host system,
 924 # and running it to get information about struct sizes. There is at least one
 925 # case of cross compiling where we can use asm, and that's x86_64 -> x86 when
 926 # host OS == build OS, since in that case the build machine can run the host's
 927 # binaries.
 928 if with_asm and meson.is_cross_build()
 929   if build_machine.system() != host_machine.system()
 930     # TODO: It may be possible to do this with an exe_wrapper (like wine).
 931     message('Cross compiling from one OS to another, disabling assembly.')
 932     with_asm = false
 933   elif not (build_machine.cpu_family().startswith('x86') and host_machine.cpu_family() == 'x86')
 934     # FIXME: Gentoo always sets -m32 for x86_64 -> x86 builds, resulting in an
 935     # x86 -> x86 cross compile. We use startswith rather than == to handle this
 936     # case.
 937     # TODO: There may be other cases where the 64 bit version of the
 938     # architecture can run 32 bit binaries (aarch64 and armv7 for example)
 939     message('''
 940       Cross compiling to different architectures, and the host cannot run
 941       the build machine's binaries. Disabling assembly.
 942     ''')
 943     with_asm = false
 944   endif
 945 endif
 946
 947 with_asm_arch = ''
 948 if with_asm
 949   if host_machine.cpu_family() == 'x86'
 950     if system_has_kms_drm or host_machine.system() == 'gnu'
 951       with_asm_arch = 'x86'
 952       pre_args += ['-DUSE_X86_ASM', '-DUSE_MMX_ASM', '-DUSE_3DNOW_ASM',
 953                    '-DUSE_SSE_ASM']
 954
 955       if with_glx_read_only_text
 956          pre_args += ['-DGLX_X86_READONLY_TEXT']
 957       endif
 958     endif
 959   elif host_machine.cpu_family() == 'x86_64'
 960     if system_has_kms_drm
 961       with_asm_arch = 'x86_64'
 962       pre_args += ['-DUSE_X86_64_ASM']
 963     endif
 964   elif host_machine.cpu_family() == 'arm'
 965     if system_has_kms_drm
 966       with_asm_arch = 'arm'
 967       pre_args += ['-DUSE_ARM_ASM']
 968     endif
 969   elif host_machine.cpu_family() == 'aarch64'
 970     if system_has_kms_drm
 971       with_asm_arch = 'aarch64'
 972       pre_args += ['-DUSE_AARCH64_ASM']
 973     endif
 974   elif host_machine.cpu_family() == 'sparc64'
 975     if system_has_kms_drm
 976       with_asm_arch = 'sparc'
 977       pre_args += ['-DUSE_SPARC_ASM']
 978     endif
 979   elif host_machine.cpu_family().startswith('ppc64') and host_machine.endian() == 'little'
 980     if system_has_kms_drm
 981       with_asm_arch = 'ppc64le'
 982       pre_args += ['-DUSE_PPC64LE_ASM']
 983     endif
 984   endif
 985 endif
 986
 987 # Check for standard headers and functions
 988 if cc.has_header_symbol('sys/sysmacros.h', 'major')
 989   pre_args += '-DMAJOR_IN_SYSMACROS'
 990 elif cc.has_header_symbol('sys/mkdev.h', 'major')
 991   pre_args += '-DMAJOR_IN_MKDEV'
 992 endif
 993
 994 foreach h : ['xlocale.h', 'sys/sysctl.h', 'linux/futex.h', 'endian.h', 'dlfcn.h']
 995   if cc.compiles('#include <@0@>'.format(h), name : '@0@'.format(h))
 996     pre_args += '-DHAVE_@0@'.format(h.to_upper().underscorify())
 997   endif
 998 endforeach
 999
1000 foreach f : ['strtof', 'mkostemp', 'posix_memalign', 'timespec_get', 'memfd_create']
1001   if cc.has_function(f)
1002     pre_args += '-DHAVE_@0@'.format(f.to_upper())
1003   endif
1004 endforeach
1005
1006 # strtod locale support
1007 if cc.links('''
1008     #define _GNU_SOURCE
1009     #include <stdlib.h>
1010     #include <locale.h>
1011     #ifdef HAVE_XLOCALE_H
1012     #include <xlocale.h>
1013     #endif
1014     int main() {
1015       locale_t loc = newlocale(LC_CTYPE_MASK, "C", NULL);
1016       const char *s = "1.0";
1017       char *end;
1018       double d = strtod_l(s, end, loc);
1019       float f = strtof_l(s, end, loc);
1020       freelocale(loc);
1021       return 0;
1022     }''',
1023     args : pre_args,
1024     name : 'strtod has locale support')
1025   pre_args += '-DHAVE_STRTOD_L'
1026 endif
1027
1028 # Check for some linker flags
1029 ld_args_bsymbolic = []
1030 if cc.links('int main() { return 0; }', args : '-Wl,-Bsymbolic', name : 'Bsymbolic')
1031   ld_args_bsymbolic += '-Wl,-Bsymbolic'
1032 endif
1033 ld_args_gc_sections = []
1034 if cc.links('static char unused() { return 5; } int main() { return 0; }',
1035             args : '-Wl,--gc-sections', name : 'gc-sections')
1036   ld_args_gc_sections += '-Wl,--gc-sections'
1037 endif
1038 with_ld_version_script = false
1039 if cc.links('int main() { return 0; }',
1040             args : '-Wl,--version-script=@0@'.format(
1041               join_paths(meson.source_root(), 'build-support/conftest.map')),
1042             name : 'version-script')
1043   with_ld_version_script = true
1044 endif
1045 with_ld_dynamic_list = false
1046 if cc.links('int main() { return 0; }',
1047             args : '-Wl,--dynamic-list=@0@'.format(
1048               join_paths(meson.source_root(), 'build-support/conftest.dyn')),
1049             name : 'dynamic-list')
1050   with_ld_dynamic_list = true
1051 endif
1052 ld_args_build_id = []
1053 if build_machine.system() != 'darwin'
1054    ld_args_build_id += '-Wl,--build-id=sha1'
1055 endif
1056
1057 # check for dl support
1058 if cc.has_function('dlopen')
1059   dep_dl = null_dep
1060 else
1061   dep_dl = cc.find_library('dl')
1062 endif
1063 if cc.has_function('dladdr', dependencies : dep_dl)
1064   # This is really only required for megadrivers
1065   pre_args += '-DHAVE_DLADDR'
1066 endif
1067
1068 if cc.has_function('dl_iterate_phdr')
1069   pre_args += '-DHAVE_DL_ITERATE_PHDR'
1070 elif with_intel_vk
1071   error('Intel "Anvil" Vulkan driver requires the dl_iterate_phdr function')
1072 elif with_dri_i965 and get_option('shader-cache')
1073   error('Intel i965 GL driver requires dl_iterate_phdr when built with shader caching.')
1074 endif
1075
1076 # Determine whether or not the rt library is needed for time functions
1077 if cc.has_function('clock_gettime')
1078   dep_clock = null_dep
1079 else
1080   dep_clock = cc.find_library('rt')
1081 endif
1082
1083 # TODO: some of these may be conditional
1084 dep_zlib = dependency('zlib', version : '>= 1.2.3')
1085 pre_args += '-DHAVE_ZLIB'
1086 dep_thread = dependency('threads')
1087 if dep_thread.found() and host_machine.system() != 'windows'
1088   pre_args += '-DHAVE_PTHREAD'
1089   if cc.has_function(
1090       'pthread_setaffinity_np',
1091       dependencies : dep_thread,
1092       prefix : '#include <pthread.h>',
1093       args : '-D_GNU_SOURCE')
1094     pre_args += '-DHAVE_PTHREAD_SETAFFINITY'
1095   endif
1096 endif
1097 dep_expat = dependency('expat')
1098 # this only exists on linux so either this is linux and it will be found, or
1099 # its not linux and and wont
1100 dep_m = cc.find_library('m', required : false)
1101
1102 # Check for libdrm. various drivers have different libdrm version requirements,
1103 # but we always want to use the same version for all libdrm modules. That means
1104 # even if driver foo requires 2.4.0 and driver bar requires 2.4.3, if foo and
1105 # bar are both on use 2.4.3 for both of them
1106 dep_libdrm_amdgpu = null_dep
1107 dep_libdrm_radeon = null_dep
1108 dep_libdrm_nouveau = null_dep
1109 dep_libdrm_etnaviv = null_dep
1110 dep_libdrm_intel = null_dep
1111
1112 _drm_amdgpu_ver = '2.4.95'
1113 _drm_radeon_ver = '2.4.71'
1114 _drm_nouveau_ver = '2.4.66'
1115 _drm_etnaviv_ver = '2.4.89'
1116 _drm_intel_ver = '2.4.75'
1117 _drm_ver = '2.4.75'
1118
1119 _libdrm_checks = [
1120   ['intel', with_dri_i915 or with_gallium_i915],
1121   ['amdgpu', with_amd_vk or with_gallium_radeonsi],
1122   ['radeon', (with_gallium_radeonsi or with_dri_r100 or with_dri_r200 or
1123               with_gallium_r300 or with_gallium_r600)],
1124   ['nouveau', (with_gallium_nouveau or with_dri_nouveau)],
1125   ['etnaviv', with_gallium_etnaviv],
1126 ]
1127
1128 # VC4 only needs core libdrm support of this version, not a libdrm_vc4
1129 # library.
1130 if with_gallium_vc4
1131   _drm_ver = '2.4.89'
1132 endif
1133
1134 # Loop over the enables versions and get the highest libdrm requirement for all
1135 # active drivers.
1136 _drm_blame = ''
1137 foreach d : _libdrm_checks
1138   ver = get_variable('_drm_@0@_ver'.format(d[0]))
1139   if d[1] and ver.version_compare('>' + _drm_ver)
1140     _drm_ver = ver
1141     _drm_blame = d[0]
1142   endif
1143 endforeach
1144 if _drm_blame != ''
1145   message('libdrm @0@ needed because @1@ has the highest requirement'.format(_drm_ver, _drm_blame))
1146 endif
1147
1148 # Then get each libdrm module
1149 foreach d : _libdrm_checks
1150   if d[1]
1151     set_variable(
1152       'dep_libdrm_' + d[0],
1153       dependency('libdrm_' + d[0], version : '>=' + _drm_ver)
1154     )
1155   endif
1156 endforeach
1157
1158 with_gallium_drisw_kms = false
1159 dep_libdrm = dependency(
1160   'libdrm', version : '>=' + _drm_ver,
1161   required : with_dri2 or with_dri3
1162 )
1163 if dep_libdrm.found()
1164   pre_args += '-DHAVE_LIBDRM'
1165   if with_dri_platform == 'drm' and with_dri
1166     with_gallium_drisw_kms = true
1167   endif
1168 endif
1169
1170 llvm_modules = ['bitwriter', 'engine', 'mcdisassembler', 'mcjit']
1171 llvm_optional_modules = []
1172 if with_amd_vk or with_gallium_radeonsi or with_gallium_r600
1173   llvm_modules += ['amdgpu', 'native', 'bitreader', 'ipo']
1174   if with_gallium_r600
1175     llvm_modules += 'asmparser'
1176   endif
1177 endif
1178 if with_gallium_opencl
1179   llvm_modules += [
1180     'all-targets', 'linker', 'coverage', 'instrumentation', 'ipo', 'irreader',
1181     'lto', 'option', 'objcarcopts', 'profiledata',
1182   ]
1183   llvm_optional_modules += ['coroutines']
1184 endif
1185
1186 if with_amd_vk or with_gallium_radeonsi
1187   _llvm_version = '>= 7.0.0'
1188 elif with_gallium_swr
1189   _llvm_version = '>= 6.0.0'
1190 elif with_gallium_opencl or with_gallium_r600
1191   _llvm_version = '>= 3.9.0'
1192 else
1193   _llvm_version = '>= 3.3.0'
1194 endif
1195
1196 _shared_llvm = get_option('shared-llvm')
1197
1198 _llvm = get_option('llvm')
1199 dep_llvm = null_dep
1200 with_llvm = false
1201 if _llvm != 'false'
1202   dep_llvm = dependency(
1203     'llvm',
1204     version : _llvm_version,
1205     modules : llvm_modules,
1206     optional_modules : llvm_optional_modules,
1207     required : (
1208       with_amd_vk or with_gallium_radeonsi or with_gallium_swr or
1209       with_gallium_opencl or _llvm == 'true'
1210     ),
1211     static : not _shared_llvm,
1212   )
1213   with_llvm = dep_llvm.found()
1214 endif
1215 if with_llvm
1216   _llvm_version = dep_llvm.version().split('.')
1217
1218   # 3 digits versions in LLVM only started from 3.4.1 on
1219   if dep_llvm.version().version_compare('>= 3.4.1')
1220     _llvm_patch = _llvm_version[2]
1221   else
1222     _llvm_patch = '0'
1223   endif
1224
1225   pre_args += [
1226     '-DHAVE_LLVM=0x0@0@0@1@'.format(_llvm_version[0], _llvm_version[1]),
1227     '-DMESA_LLVM_VERSION_PATCH=@0@'.format(_llvm_patch),
1228   ]
1229
1230   # LLVM can be built without rtti, turning off rtti changes the ABI of C++
1231   # programs, so we need to build all C++ code in mesa without rtti as well to
1232   # ensure that linking works.
1233   if dep_llvm.get_configtool_variable('has-rtti') == 'NO'
1234     if with_gallium_nouveau
1235       error('The Nouveau driver requires rtti. You either need to turn off nouveau or use an LLVM built with LLVM_ENABLE_RTTI.')
1236     endif
1237     cpp_args += '-fno-rtti'
1238   endif
1239 elif with_amd_vk or with_gallium_radeonsi or with_gallium_swr
1240   error('The following drivers require LLVM: Radv, RadeonSI, SWR. One of these is enabled, but LLVM is disabled.')
1241 endif
1242
1243 if (with_amd_vk or with_gallium_radeonsi or with_gallium_opencl or
1244     (with_gallium_r600 and with_llvm))
1245   dep_elf = dependency('libelf', required : false)
1246   if not dep_elf.found()
1247     dep_elf = cc.find_library('elf')
1248   endif
1249 else
1250   dep_elf = null_dep
1251 endif
1252
1253 dep_glvnd = null_dep
1254 if with_glvnd
1255   dep_glvnd = dependency('libglvnd', version : '>= 0.2.0')
1256   pre_args += '-DUSE_LIBGLVND=1'
1257 endif
1258
1259 if with_valgrind != 'false'
1260   dep_valgrind = dependency('valgrind', required : with_valgrind == 'true')
1261   if dep_valgrind.found()
1262     pre_args += '-DHAVE_VALGRIND'
1263   endif
1264 else
1265   dep_valgrind = null_dep
1266 endif
1267
1268 # pthread stubs. Lets not and say we didn't
1269
1270 prog_bison = find_program('bison', required : with_any_opengl)
1271 prog_flex = find_program('flex', required : with_any_opengl)
1272
1273 dep_selinux = null_dep
1274 if get_option('selinux')
1275   dep_selinux = dependency('libselinux')
1276   pre_args += '-DMESA_SELINUX'
1277 endif
1278
1279 if with_libunwind != 'false'
1280   dep_unwind = dependency('libunwind', required : with_libunwind == 'true')
1281   if dep_unwind.found()
1282     pre_args += '-DHAVE_LIBUNWIND'
1283   endif
1284 else
1285   dep_unwind = null_dep
1286 endif
1287
1288 if with_osmesa != 'none'
1289   if with_osmesa == 'classic' and not with_dri_swrast
1290     error('OSMesa classic requires dri (classic) swrast.')
1291   endif
1292   if with_osmesa == 'gallium' and not with_gallium_softpipe
1293     error('OSMesa gallium requires gallium softpipe or llvmpipe.')
1294   endif
1295   osmesa_lib_name = 'OSMesa'
1296   osmesa_bits = get_option('osmesa-bits')
1297   if osmesa_bits != '8'
1298     if with_dri or with_glx != 'disabled'
1299       error('OSMesa bits must be 8 if building glx or dir based drivers')
1300     endif
1301     osmesa_lib_name = osmesa_lib_name + osmesa_bits
1302     pre_args += [
1303       '-DCHAN_BITS=@0@'.format(osmesa_bits), '-DDEFAULT_SOFTWARE_DEPTH_BITS=31'
1304     ]
1305   endif
1306 endif
1307
1308 # TODO: symbol mangling
1309
1310 if with_platform_wayland
1311   dep_wl_scanner = dependency('wayland-scanner', native: true)
1312   prog_wl_scanner = find_program(dep_wl_scanner.get_pkgconfig_variable('wayland_scanner'))
1313   if dep_wl_scanner.version().version_compare('>= 1.15')
1314     wl_scanner_arg = 'private-code'
1315   else
1316     wl_scanner_arg = 'code'
1317   endif
1318   dep_wl_protocols = dependency('wayland-protocols', version : '>= 1.8')
1319   dep_wayland_client = dependency('wayland-client', version : '>=1.11')
1320   dep_wayland_server = dependency('wayland-server', version : '>=1.11')
1321   if with_egl
1322     dep_wayland_egl = dependency('wayland-egl-backend', version : '>= 3')
1323     dep_wayland_egl_headers = declare_dependency(
1324       compile_args : run_command(prog_pkgconfig, ['wayland-egl-backend', '--cflags']).stdout().split())
1325   endif
1326   wayland_dmabuf_xml = join_paths(
1327     dep_wl_protocols.get_pkgconfig_variable('pkgdatadir'), 'unstable',
1328     'linux-dmabuf', 'linux-dmabuf-unstable-v1.xml'
1329   )
1330   pre_args += ['-DHAVE_WAYLAND_PLATFORM', '-DWL_HIDE_DEPRECATED']
1331 endif
1332
1333 dep_x11 = null_dep
1334 dep_xext = null_dep
1335 dep_xdamage = null_dep
1336 dep_xfixes = null_dep
1337 dep_x11_xcb = null_dep
1338 dep_xcb = null_dep
1339 dep_xcb_glx = null_dep
1340 dep_xcb_dri2 = null_dep
1341 dep_xcb_dri3 = null_dep
1342 dep_dri2proto = null_dep
1343 dep_glproto = null_dep
1344 dep_xxf86vm = null_dep
1345 dep_xcb_dri3 = null_dep
1346 dep_xcb_present = null_dep
1347 dep_xcb_sync = null_dep
1348 dep_xcb_xfixes = null_dep
1349 dep_xshmfence = null_dep
1350 dep_xcb_xrandr = null_dep
1351 dep_xlib_xrandr = null_dep
1352 if with_platform_x11
1353   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1354     dep_x11 = dependency('x11')
1355     dep_xext = dependency('xext')
1356     dep_xcb = dependency('xcb')
1357   elif with_glx == 'dri'
1358     dep_x11 = dependency('x11')
1359     dep_xext = dependency('xext')
1360     dep_xdamage = dependency('xdamage', version : '>= 1.1')
1361     dep_xfixes = dependency('xfixes')
1362     dep_xcb_glx = dependency('xcb-glx', version : '>= 1.8.1')
1363   endif
1364   if (with_any_vk or with_glx == 'dri' or with_egl or
1365        (with_gallium_vdpau or with_gallium_xvmc or with_gallium_va or
1366         with_gallium_omx != 'disabled'))
1367     dep_xcb = dependency('xcb')
1368     dep_x11_xcb = dependency('x11-xcb')
1369   endif
1370   if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
1371     dep_xcb_dri2 = dependency('xcb-dri2', version : '>= 1.8')
1372
1373     if with_dri3
1374       pre_args += '-DHAVE_DRI3'
1375       dep_xcb_dri3 = dependency('xcb-dri3')
1376       dep_xcb_present = dependency('xcb-present')
1377       # until xcb-dri3 has been around long enough to make a hard-dependency:
1378       if (dep_xcb_dri3.version().version_compare('>= 1.13') and
1379           dep_xcb_present.version().version_compare('>= 1.13'))
1380         pre_args += '-DHAVE_DRI3_MODIFIERS'
1381       endif
1382       dep_xcb_sync = dependency('xcb-sync')
1383       dep_xshmfence = dependency('xshmfence', version : '>= 1.1')
1384     endif
1385   endif
1386   if with_glx == 'dri'
1387     if with_dri_platform == 'drm'
1388       dep_dri2proto = dependency('dri2proto', version : '>= 2.8')
1389       dep_xxf86vm = dependency('xxf86vm')
1390     endif
1391     dep_glproto = dependency('glproto', version : '>= 1.4.14')
1392   endif
1393   if (with_egl or (
1394       with_gallium_vdpau or with_gallium_xvmc or with_gallium_xa or
1395       with_gallium_omx != 'disabled'))
1396     dep_xcb_xfixes = dependency('xcb-xfixes')
1397   endif
1398   if with_xlib_lease
1399     dep_xcb_xrandr = dependency('xcb-randr', version : '>= 1.12')
1400     dep_xlib_xrandr = dependency('xrandr', version : '>= 1.3')
1401   endif
1402 endif
1403
1404 if get_option('gallium-extra-hud')
1405   pre_args += '-DHAVE_GALLIUM_EXTRA_HUD=1'
1406 endif
1407
1408 _sensors = get_option('lmsensors')
1409 if _sensors != 'false'
1410   dep_lmsensors = cc.find_library('sensors', required : _sensors == 'true')
1411   if dep_lmsensors.found()
1412     pre_args += '-DHAVE_LIBSENSORS=1'
1413   endif
1414 else
1415   dep_lmsensors = null_dep
1416 endif
1417
1418 foreach a : pre_args
1419   add_project_arguments(a, language : ['c', 'cpp'])
1420 endforeach
1421 foreach a : c_args
1422   add_project_arguments(a, language : ['c'])
1423 endforeach
1424 foreach a : cpp_args
1425   add_project_arguments(a, language : ['cpp'])
1426 endforeach
1427
1428 inc_include = include_directories('include')
1429
1430 gl_priv_reqs = []
1431
1432 if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1433   gl_priv_reqs += ['x11', 'xext', 'xcb']
1434 elif with_glx == 'dri'
1435   gl_priv_reqs += [
1436     'x11', 'xext', 'xdamage >= 1.1', 'xfixes', 'x11-xcb', 'xcb',
1437     'xcb-glx >= 1.8.1']
1438   if with_dri_platform == 'drm'
1439     gl_priv_reqs += 'xcb-dri2 >= 1.8'
1440     gl_priv_reqs += 'xxf86vm'
1441   endif
1442 endif
1443 if dep_libdrm.found()
1444   gl_priv_reqs += 'libdrm >= 2.4.75'
1445 endif
1446
1447 gl_priv_libs = []
1448 if dep_thread.found()
1449   gl_priv_libs += ['-lpthread', '-pthread']
1450 endif
1451 if dep_m.found()
1452   gl_priv_libs += '-lm'
1453 endif
1454 if dep_dl.found()
1455   gl_priv_libs += '-ldl'
1456 endif
1457
1458 pkg = import('pkgconfig')
1459
1460 env_test = environment()
1461 env_test.set('NM', find_program('nm').path())
1462
1463 subdir('include')
1464 subdir('bin')
1465 subdir('src')