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