meson.build

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