meson.build

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