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