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