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