meson.build

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