meson.build

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