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