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 with_shader_cache = false
 779 _shader_cache = get_option('shader-cache')
 780 if _shader_cache != 'false'
 781   if host_machine.system() == 'windows'
 782     if _shader_cache == 'true'
 783       error('Shader Cache does not currently work on Windows')
 784     endif
 785   else
 786     pre_args += '-DENABLE_SHADER_CACHE'
 787     with_shader_cache = true
 788   endif
 789 endif
 790 if with_amd_vk and not with_shader_cache
 791   error('Radv requires shader cache support')
 792 endif
 793
 794 # Check for GCC style builtins
 795 foreach b : ['bswap32', 'bswap64', 'clz', 'clzll', 'ctz', 'expect', 'ffs',
 796              'ffsll', 'popcount', 'popcountll', 'unreachable']
 797   if cc.has_function(b)
 798     pre_args += '-DHAVE___BUILTIN_@0@'.format(b.to_upper())
 799   endif
 800 endforeach
 801
 802 # check for GCC __attribute__
 803 foreach a : ['const', 'flatten', 'malloc', 'pure', 'unused',
 804              'warn_unused_result', 'weak',]
 805   if cc.compiles('int foo(void) __attribute__((@0@));'.format(a),
 806                  name : '__attribute__((@0@))'.format(a))
 807     pre_args += '-DHAVE_FUNC_ATTRIBUTE_@0@'.format(a.to_upper())
 808   endif
 809 endforeach
 810 if cc.compiles('int foo(const char *p, ...) __attribute__((format(printf, 1, 2)));',
 811                name : '__attribute__((format(...)))')
 812   pre_args += '-DHAVE_FUNC_ATTRIBUTE_FORMAT'
 813 endif
 814 if cc.compiles('struct __attribute__((packed)) foo { int bar; };',
 815                name : '__attribute__((packed))')
 816   pre_args += '-DHAVE_FUNC_ATTRIBUTE_PACKED'
 817 endif
 818 if cc.compiles('int *foo(void) __attribute__((returns_nonnull));',
 819                name : '__attribute__((returns_nonnull))')
 820   pre_args += '-DHAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL'
 821 endif
 822 if cc.compiles('''int foo_def(void) __attribute__((visibility("default")));
 823                   int foo_hid(void) __attribute__((visibility("hidden")));
 824                   int foo_int(void) __attribute__((visibility("internal")));
 825                   int foo_pro(void) __attribute__((visibility("protected")));''',
 826                name : '__attribute__((visibility(...)))')
 827   pre_args += '-DHAVE_FUNC_ATTRIBUTE_VISIBILITY'
 828 endif
 829 if cc.compiles('int foo(void) { return 0; } int bar(void) __attribute__((alias("foo")));',
 830                name : '__attribute__((alias(...)))')
 831   pre_args += '-DHAVE_FUNC_ATTRIBUTE_ALIAS'
 832 endif
 833 if cc.compiles('int foo(void) __attribute__((__noreturn__));',
 834                name : '__attribute__((__noreturn__))')
 835   pre_args += '-DHAVE_FUNC_ATTRIBUTE_NORETURN'
 836 endif
 837
 838 # TODO: this is very incomplete
 839 if ['linux', 'cygwin', 'gnu'].contains(host_machine.system())
 840   pre_args += '-D_GNU_SOURCE'
 841 endif
 842
 843 # Check for generic C arguments
 844 c_args = []
 845 foreach a : ['-Werror=implicit-function-declaration',
 846              '-Werror=missing-prototypes', '-Werror=return-type',
 847              '-Werror=incompatible-pointer-types',
 848              '-fno-math-errno',
 849              '-fno-trapping-math', '-Qunused-arguments']
 850   if cc.has_argument(a)
 851     c_args += a
 852   endif
 853 endforeach
 854
 855 foreach a : ['missing-field-initializers', 'format-truncation']
 856   if cc.has_argument('-W' + a)
 857     c_args += '-Wno-' + a
 858   endif
 859 endforeach
 860
 861 c_vis_args = []
 862 if cc.has_argument('-fvisibility=hidden')
 863   c_vis_args += '-fvisibility=hidden'
 864 endif
 865
 866 # Check for generic C++ arguments
 867 cpp_args = []
 868 foreach a : ['-Werror=return-type',
 869              '-fno-math-errno', '-fno-trapping-math',
 870              '-Qunused-arguments']
 871   if cpp.has_argument(a)
 872     cpp_args += a
 873   endif
 874 endforeach
 875
 876 # For some reason, the test for -Wno-foo always succeeds with gcc, even if the
 877 # option is not supported. Hence, check for -Wfoo instead.
 878
 879 foreach a : ['non-virtual-dtor', 'missing-field-initializers', 'format-truncation']
 880   if cpp.has_argument('-W' + a)
 881     cpp_args += '-Wno-' + a
 882   endif
 883 endforeach
 884
 885 no_override_init_args = []
 886 foreach a : ['override-init', 'initializer-overrides']
 887   if cc.has_argument('-W' + a)
 888     no_override_init_args += '-Wno-' + a
 889   endif
 890 endforeach
 891
 892 cpp_vis_args = []
 893 if cpp.has_argument('-fvisibility=hidden')
 894   cpp_vis_args += '-fvisibility=hidden'
 895 endif
 896
 897 # Check for C and C++ arguments for MSVC2013 compatibility. These are only used
 898 # in parts of the mesa code base that need to compile with old versions of
 899 # MSVC, mainly common code
 900 c_msvc_compat_args = []
 901 cpp_msvc_compat_args = []
 902 foreach a : ['-Werror=pointer-arith', '-Werror=vla']
 903   if cc.has_argument(a)
 904     c_msvc_compat_args += a
 905   endif
 906   if cpp.has_argument(a)
 907     cpp_msvc_compat_args += a
 908   endif
 909 endforeach
 910
 911 if host_machine.cpu_family().startswith('x86')
 912   pre_args += '-DUSE_SSE41'
 913   with_sse41 = true
 914   sse41_args = ['-msse4.1']
 915
 916   # GCC on x86 (not x86_64) with -msse* assumes a 16 byte aligned stack, but
 917   # that's not guaranteed
 918   if host_machine.cpu_family() == 'x86'
 919     sse41_args += '-mstackrealign'
 920   endif
 921 else
 922   with_sse41 = false
 923   sse41_args = []
 924 endif
 925
 926 # Check for GCC style atomics
 927 dep_atomic = null_dep
 928
 929 if cc.compiles('''#include <stdint.h>
 930                   int main() {
 931                     struct {
 932                       uint64_t *v;
 933                     } x;
 934                     return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
 935                            (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
 936
 937                   }''',
 938                name : 'GCC atomic builtins')
 939   pre_args += '-DUSE_GCC_ATOMIC_BUILTINS'
 940
 941   # Not all atomic calls can be turned into lock-free instructions, in which
 942   # GCC will make calls into the libatomic library. Check whether we need to
 943   # link with -latomic.
 944   #
 945   # This can happen for 64-bit atomic operations on 32-bit architectures such
 946   # as ARM.
 947   if not cc.links('''#include <stdint.h>
 948                      int main() {
 949                        struct {
 950                          uint64_t *v;
 951                        } x;
 952                        return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
 953                               (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
 954                      }''',
 955                   name : 'GCC atomic builtins required -latomic')
 956     dep_atomic = cc.find_library('atomic')
 957   endif
 958 endif
 959 if not cc.links('''#include <stdint.h>
 960                    uint64_t v;
 961                    int main() {
 962                      return __sync_add_and_fetch(&v, (uint64_t)1);
 963                    }''',
 964                 dependencies : dep_atomic,
 965                 name : 'GCC 64bit atomics')
 966   pre_args += '-DMISSING_64BIT_ATOMICS'
 967 endif
 968
 969 # TODO: shared/static? Is this even worth doing?
 970
 971 # When cross compiling we generally need to turn off the use of assembly,
 972 # because mesa's assembly relies on building an executable for the host system,
 973 # and running it to get information about struct sizes. There is at least one
 974 # case of cross compiling where we can use asm, and that's x86_64 -> x86 when
 975 # host OS == build OS, since in that case the build machine can run the host's
 976 # binaries.
 977 if with_asm and meson.is_cross_build()
 978   if build_machine.system() != host_machine.system()
 979     # TODO: It may be possible to do this with an exe_wrapper (like wine).
 980     message('Cross compiling from one OS to another, disabling assembly.')
 981     with_asm = false
 982   elif not (build_machine.cpu_family().startswith('x86') and host_machine.cpu_family() == 'x86')
 983     # FIXME: Gentoo always sets -m32 for x86_64 -> x86 builds, resulting in an
 984     # x86 -> x86 cross compile. We use startswith rather than == to handle this
 985     # case.
 986     # TODO: There may be other cases where the 64 bit version of the
 987     # architecture can run 32 bit binaries (aarch64 and armv7 for example)
 988     message('''
 989       Cross compiling to different architectures, and the host cannot run
 990       the build machine's binaries. Disabling assembly.
 991     ''')
 992     with_asm = false
 993   endif
 994 endif
 995
 996 with_asm_arch = ''
 997 if with_asm
 998   if host_machine.cpu_family() == 'x86'
 999     if system_has_kms_drm or host_machine.system() == 'gnu'
1000       with_asm_arch = 'x86'
1001       pre_args += ['-DUSE_X86_ASM', '-DUSE_MMX_ASM', '-DUSE_3DNOW_ASM',
1002                    '-DUSE_SSE_ASM']
1003
1004       if with_glx_read_only_text
1005          pre_args += ['-DGLX_X86_READONLY_TEXT']
1006       endif
1007     endif
1008   elif host_machine.cpu_family() == 'x86_64'
1009     if system_has_kms_drm
1010       with_asm_arch = 'x86_64'
1011       pre_args += ['-DUSE_X86_64_ASM']
1012     endif
1013   elif host_machine.cpu_family() == 'arm'
1014     if system_has_kms_drm
1015       with_asm_arch = 'arm'
1016       pre_args += ['-DUSE_ARM_ASM']
1017     endif
1018   elif host_machine.cpu_family() == 'aarch64'
1019     if system_has_kms_drm
1020       with_asm_arch = 'aarch64'
1021       pre_args += ['-DUSE_AARCH64_ASM']
1022     endif
1023   elif host_machine.cpu_family() == 'sparc64'
1024     if system_has_kms_drm
1025       with_asm_arch = 'sparc'
1026       pre_args += ['-DUSE_SPARC_ASM']
1027     endif
1028   elif host_machine.cpu_family().startswith('ppc64') and host_machine.endian() == 'little'
1029     if system_has_kms_drm
1030       with_asm_arch = 'ppc64le'
1031       pre_args += ['-DUSE_PPC64LE_ASM']
1032     endif
1033   endif
1034 endif
1035
1036 # Check for standard headers and functions
1037 if cc.has_header_symbol('sys/sysmacros.h', 'major')
1038   pre_args += '-DMAJOR_IN_SYSMACROS'
1039 elif cc.has_header_symbol('sys/mkdev.h', 'major')
1040   pre_args += '-DMAJOR_IN_MKDEV'
1041 endif
1042
1043 foreach h : ['xlocale.h', 'sys/sysctl.h', 'linux/futex.h', 'endian.h', 'dlfcn.h']
1044   if cc.compiles('#include <@0@>'.format(h), name : '@0@'.format(h))
1045     pre_args += '-DHAVE_@0@'.format(h.to_upper().underscorify())
1046   endif
1047 endforeach
1048
1049 foreach f : ['strtof', 'mkostemp', 'posix_memalign', 'timespec_get', 'memfd_create']
1050   if cc.has_function(f)
1051     pre_args += '-DHAVE_@0@'.format(f.to_upper())
1052   endif
1053 endforeach
1054
1055 # strtod locale support
1056 if cc.links('''
1057     #define _GNU_SOURCE
1058     #include <stdlib.h>
1059     #include <locale.h>
1060     #ifdef HAVE_XLOCALE_H
1061     #include <xlocale.h>
1062     #endif
1063     int main() {
1064       locale_t loc = newlocale(LC_CTYPE_MASK, "C", NULL);
1065       const char *s = "1.0";
1066       char *end;
1067       double d = strtod_l(s, end, loc);
1068       float f = strtof_l(s, end, loc);
1069       freelocale(loc);
1070       return 0;
1071     }''',
1072     args : pre_args,
1073     name : 'strtod has locale support')
1074   pre_args += '-DHAVE_STRTOD_L'
1075 endif
1076
1077 # Check for some linker flags
1078 ld_args_bsymbolic = []
1079 if cc.links('int main() { return 0; }', args : '-Wl,-Bsymbolic', name : 'Bsymbolic')
1080   ld_args_bsymbolic += '-Wl,-Bsymbolic'
1081 endif
1082 ld_args_gc_sections = []
1083 if cc.links('static char unused() { return 5; } int main() { return 0; }',
1084             args : '-Wl,--gc-sections', name : 'gc-sections')
1085   ld_args_gc_sections += '-Wl,--gc-sections'
1086 endif
1087 with_ld_version_script = false
1088 if cc.links('int main() { return 0; }',
1089             args : '-Wl,--version-script=@0@'.format(
1090               join_paths(meson.source_root(), 'build-support/conftest.map')),
1091             name : 'version-script')
1092   with_ld_version_script = true
1093 endif
1094 with_ld_dynamic_list = false
1095 if cc.links('int main() { return 0; }',
1096             args : '-Wl,--dynamic-list=@0@'.format(
1097               join_paths(meson.source_root(), 'build-support/conftest.dyn')),
1098             name : 'dynamic-list')
1099   with_ld_dynamic_list = true
1100 endif
1101 ld_args_build_id = []
1102 if build_machine.system() != 'darwin'
1103    ld_args_build_id += '-Wl,--build-id=sha1'
1104 endif
1105
1106 # check for dl support
1107 if cc.has_function('dlopen')
1108   dep_dl = null_dep
1109 else
1110   dep_dl = cc.find_library('dl')
1111 endif
1112 if cc.has_function('dladdr', dependencies : dep_dl)
1113   # This is really only required for megadrivers
1114   pre_args += '-DHAVE_DLADDR'
1115 endif
1116
1117 if cc.has_function('dl_iterate_phdr')
1118   pre_args += '-DHAVE_DL_ITERATE_PHDR'
1119 elif with_intel_vk
1120   error('Intel "Anvil" Vulkan driver requires the dl_iterate_phdr function')
1121 elif with_dri_i965 and with_shader_cache
1122   error('Intel i965 GL driver requires dl_iterate_phdr when built with shader caching.')
1123 endif
1124
1125 # Determine whether or not the rt library is needed for time functions
1126 if cc.has_function('clock_gettime')
1127   dep_clock = null_dep
1128 else
1129   dep_clock = cc.find_library('rt')
1130 endif
1131
1132 # TODO: some of these may be conditional
1133 dep_zlib = dependency('zlib', version : '>= 1.2.3')
1134 pre_args += '-DHAVE_ZLIB'
1135 dep_thread = dependency('threads')
1136 if dep_thread.found() and host_machine.system() != 'windows'
1137   pre_args += '-DHAVE_PTHREAD'
1138   if cc.has_function(
1139       'pthread_setaffinity_np',
1140       dependencies : dep_thread,
1141       prefix : '#include <pthread.h>',
1142       args : '-D_GNU_SOURCE')
1143     pre_args += '-DHAVE_PTHREAD_SETAFFINITY'
1144   endif
1145 endif
1146 dep_expat = dependency('expat')
1147 # this only exists on linux so either this is linux and it will be found, or
1148 # its not linux and and wont
1149 dep_m = cc.find_library('m', required : false)
1150
1151 # Check for libdrm. various drivers have different libdrm version requirements,
1152 # but we always want to use the same version for all libdrm modules. That means
1153 # even if driver foo requires 2.4.0 and driver bar requires 2.4.3, if foo and
1154 # bar are both on use 2.4.3 for both of them
1155 dep_libdrm_amdgpu = null_dep
1156 dep_libdrm_radeon = null_dep
1157 dep_libdrm_nouveau = null_dep
1158 dep_libdrm_etnaviv = null_dep
1159 dep_libdrm_intel = null_dep
1160
1161 _drm_amdgpu_ver = '2.4.97'
1162 _drm_radeon_ver = '2.4.71'
1163 _drm_nouveau_ver = '2.4.66'
1164 _drm_etnaviv_ver = '2.4.89'
1165 _drm_intel_ver = '2.4.75'
1166 _drm_ver = '2.4.75'
1167
1168 _libdrm_checks = [
1169   ['intel', with_dri_i915 or with_gallium_i915],
1170   ['amdgpu', with_amd_vk or with_gallium_radeonsi],
1171   ['radeon', (with_gallium_radeonsi or with_dri_r100 or with_dri_r200 or
1172               with_gallium_r300 or with_gallium_r600)],
1173   ['nouveau', (with_gallium_nouveau or with_dri_nouveau)],
1174   ['etnaviv', with_gallium_etnaviv],
1175 ]
1176
1177 # VC4 only needs core libdrm support of this version, not a libdrm_vc4
1178 # library.
1179 if with_gallium_vc4
1180   _drm_ver = '2.4.89'
1181 endif
1182
1183 # Loop over the enables versions and get the highest libdrm requirement for all
1184 # active drivers.
1185 _drm_blame = ''
1186 foreach d : _libdrm_checks
1187   ver = get_variable('_drm_@0@_ver'.format(d[0]))
1188   if d[1] and ver.version_compare('>' + _drm_ver)
1189     _drm_ver = ver
1190     _drm_blame = d[0]
1191   endif
1192 endforeach
1193 if _drm_blame != ''
1194   message('libdrm @0@ needed because @1@ has the highest requirement'.format(_drm_ver, _drm_blame))
1195 endif
1196
1197 # Then get each libdrm module
1198 foreach d : _libdrm_checks
1199   if d[1]
1200     set_variable(
1201       'dep_libdrm_' + d[0],
1202       dependency('libdrm_' + d[0], version : '>=' + _drm_ver)
1203     )
1204   endif
1205 endforeach
1206
1207 with_gallium_drisw_kms = false
1208 dep_libdrm = dependency(
1209   'libdrm', version : '>=' + _drm_ver,
1210   required : with_dri2 or with_dri3
1211 )
1212 if dep_libdrm.found()
1213   pre_args += '-DHAVE_LIBDRM'
1214   if with_dri_platform == 'drm' and with_dri
1215     with_gallium_drisw_kms = true
1216   endif
1217 endif
1218
1219 llvm_modules = ['bitwriter', 'engine', 'mcdisassembler', 'mcjit']
1220 llvm_optional_modules = []
1221 if with_amd_vk or with_gallium_radeonsi or with_gallium_r600
1222   llvm_modules += ['amdgpu', 'native', 'bitreader', 'ipo']
1223   if with_gallium_r600
1224     llvm_modules += 'asmparser'
1225   endif
1226 endif
1227 if with_gallium_opencl
1228   llvm_modules += [
1229     'all-targets', 'linker', 'coverage', 'instrumentation', 'ipo', 'irreader',
1230     'lto', 'option', 'objcarcopts', 'profiledata',
1231   ]
1232   llvm_optional_modules += ['coroutines']
1233 endif
1234
1235 if with_amd_vk or with_gallium_radeonsi
1236   _llvm_version = '>= 7.0.0'
1237 elif with_gallium_swr
1238   _llvm_version = '>= 6.0.0'
1239 elif with_gallium_opencl or with_gallium_r600
1240   _llvm_version = '>= 3.9.0'
1241 else
1242   _llvm_version = '>= 3.3.0'
1243 endif
1244
1245 _shared_llvm = get_option('shared-llvm')
1246
1247 _llvm = get_option('llvm')
1248 dep_llvm = null_dep
1249 with_llvm = false
1250 if _llvm != 'false'
1251   dep_llvm = dependency(
1252     'llvm',
1253     version : _llvm_version,
1254     modules : llvm_modules,
1255     optional_modules : llvm_optional_modules,
1256     required : (
1257       with_amd_vk or with_gallium_radeonsi or with_gallium_swr or
1258       with_gallium_opencl or _llvm == 'true'
1259     ),
1260     static : not _shared_llvm,
1261   )
1262   with_llvm = dep_llvm.found()
1263 endif
1264 if with_llvm
1265   _llvm_version = dep_llvm.version().split('.')
1266   pre_args += [
1267     '-DHAVE_LLVM=0x0@0@0@1@'.format(_llvm_version[0], _llvm_version[1]),
1268     '-DMESA_LLVM_VERSION_STRING="@0@"'.format(dep_llvm.version()),
1269   ]
1270
1271   # LLVM can be built without rtti, turning off rtti changes the ABI of C++
1272   # programs, so we need to build all C++ code in mesa without rtti as well to
1273   # ensure that linking works.
1274   if dep_llvm.get_configtool_variable('has-rtti') == 'NO'
1275     if with_gallium_nouveau
1276       error('The Nouveau driver requires rtti. You either need to turn off nouveau or use an LLVM built with LLVM_ENABLE_RTTI.')
1277     elif with_gallium_opencl
1278       error('The Clover OpenCL state tracker requires rtti, you need to turn off clover or use an LLVM built with LLVM_ENABLE_RTTI.')
1279     endif
1280     cpp_args += '-fno-rtti'
1281   endif
1282 elif with_amd_vk or with_gallium_radeonsi or with_gallium_swr
1283   error('The following drivers require LLVM: Radv, RadeonSI, SWR. One of these is enabled, but LLVM is disabled.')
1284 elif with_gallium_opencl
1285   error('The OpenCL "Clover" state tracker requires LLVM, but LLVM is disabled.')
1286 endif
1287
1288 if (with_amd_vk or with_gallium_radeonsi or with_gallium_opencl or
1289     (with_gallium_r600 and with_llvm))
1290   dep_elf = dependency('libelf', required : false)
1291   if not dep_elf.found()
1292     dep_elf = cc.find_library('elf')
1293   endif
1294 else
1295   dep_elf = null_dep
1296 endif
1297
1298 dep_glvnd = null_dep
1299 if with_glvnd
1300   dep_glvnd = dependency('libglvnd', version : '>= 0.2.0')
1301   pre_args += '-DUSE_LIBGLVND=1'
1302 endif
1303
1304 if with_valgrind != 'false'
1305   dep_valgrind = dependency('valgrind', required : with_valgrind == 'true')
1306   if dep_valgrind.found()
1307     pre_args += '-DHAVE_VALGRIND'
1308   endif
1309 else
1310   dep_valgrind = null_dep
1311 endif
1312
1313 # pthread stubs. Lets not and say we didn't
1314
1315 prog_bison = find_program('bison', required : with_any_opengl)
1316 prog_flex = find_program('flex', required : with_any_opengl)
1317
1318 dep_selinux = null_dep
1319 if get_option('selinux')
1320   dep_selinux = dependency('libselinux')
1321   pre_args += '-DMESA_SELINUX'
1322 endif
1323
1324 if with_libunwind != 'false'
1325   dep_unwind = dependency('libunwind', required : with_libunwind == 'true')
1326   if dep_unwind.found()
1327     pre_args += '-DHAVE_LIBUNWIND'
1328   endif
1329 else
1330   dep_unwind = null_dep
1331 endif
1332
1333 if with_osmesa != 'none'
1334   if with_osmesa == 'classic' and not with_dri_swrast
1335     error('OSMesa classic requires dri (classic) swrast.')
1336   endif
1337   if with_osmesa == 'gallium' and not with_gallium_softpipe
1338     error('OSMesa gallium requires gallium softpipe or llvmpipe.')
1339   endif
1340   osmesa_lib_name = 'OSMesa'
1341   osmesa_bits = get_option('osmesa-bits')
1342   if osmesa_bits != '8'
1343     if with_dri or with_glx != 'disabled'
1344       error('OSMesa bits must be 8 if building glx or dir based drivers')
1345     endif
1346     osmesa_lib_name = osmesa_lib_name + osmesa_bits
1347     pre_args += [
1348       '-DCHAN_BITS=@0@'.format(osmesa_bits), '-DDEFAULT_SOFTWARE_DEPTH_BITS=31'
1349     ]
1350   endif
1351 endif
1352
1353 # TODO: symbol mangling
1354
1355 if with_platform_wayland
1356   dep_wl_scanner = dependency('wayland-scanner', native: true)
1357   prog_wl_scanner = find_program(dep_wl_scanner.get_pkgconfig_variable('wayland_scanner'))
1358   if dep_wl_scanner.version().version_compare('>= 1.15')
1359     wl_scanner_arg = 'private-code'
1360   else
1361     wl_scanner_arg = 'code'
1362   endif
1363   dep_wl_protocols = dependency('wayland-protocols', version : '>= 1.8')
1364   dep_wayland_client = dependency('wayland-client', version : '>=1.11')
1365   dep_wayland_server = dependency('wayland-server', version : '>=1.11')
1366   if with_egl
1367     dep_wayland_egl = dependency('wayland-egl-backend', version : '>= 3')
1368     dep_wayland_egl_headers = declare_dependency(
1369       compile_args : run_command(prog_pkgconfig, ['wayland-egl-backend', '--cflags']).stdout().split())
1370   endif
1371   wayland_dmabuf_xml = join_paths(
1372     dep_wl_protocols.get_pkgconfig_variable('pkgdatadir'), 'unstable',
1373     'linux-dmabuf', 'linux-dmabuf-unstable-v1.xml'
1374   )
1375   pre_args += ['-DHAVE_WAYLAND_PLATFORM', '-DWL_HIDE_DEPRECATED']
1376 endif
1377
1378 dep_x11 = null_dep
1379 dep_xext = null_dep
1380 dep_xdamage = null_dep
1381 dep_xfixes = null_dep
1382 dep_x11_xcb = null_dep
1383 dep_xcb = null_dep
1384 dep_xcb_glx = null_dep
1385 dep_xcb_dri2 = null_dep
1386 dep_xcb_dri3 = null_dep
1387 dep_dri2proto = null_dep
1388 dep_glproto = null_dep
1389 dep_xxf86vm = null_dep
1390 dep_xcb_dri3 = null_dep
1391 dep_xcb_present = null_dep
1392 dep_xcb_sync = null_dep
1393 dep_xcb_xfixes = null_dep
1394 dep_xshmfence = null_dep
1395 dep_xcb_xrandr = null_dep
1396 dep_xlib_xrandr = null_dep
1397 if with_platform_x11
1398   if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1399     dep_x11 = dependency('x11')
1400     dep_xext = dependency('xext')
1401     dep_xcb = dependency('xcb')
1402   elif with_glx == 'dri'
1403     dep_x11 = dependency('x11')
1404     dep_xext = dependency('xext')
1405     dep_xdamage = dependency('xdamage', version : '>= 1.1')
1406     dep_xfixes = dependency('xfixes')
1407     dep_xcb_glx = dependency('xcb-glx', version : '>= 1.8.1')
1408   endif
1409   if (with_any_vk or with_glx == 'dri' or with_egl or
1410        (with_gallium_vdpau or with_gallium_xvmc or with_gallium_va or
1411         with_gallium_omx != 'disabled'))
1412     dep_xcb = dependency('xcb')
1413     dep_x11_xcb = dependency('x11-xcb')
1414   endif
1415   if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
1416     dep_xcb_dri2 = dependency('xcb-dri2', version : '>= 1.8')
1417
1418     if with_dri3
1419       pre_args += '-DHAVE_DRI3'
1420       dep_xcb_dri3 = dependency('xcb-dri3')
1421       dep_xcb_present = dependency('xcb-present')
1422       # until xcb-dri3 has been around long enough to make a hard-dependency:
1423       if (dep_xcb_dri3.version().version_compare('>= 1.13') and
1424           dep_xcb_present.version().version_compare('>= 1.13'))
1425         pre_args += '-DHAVE_DRI3_MODIFIERS'
1426       endif
1427       dep_xcb_sync = dependency('xcb-sync')
1428       dep_xshmfence = dependency('xshmfence', version : '>= 1.1')
1429     endif
1430   endif
1431   if with_glx == 'dri' or with_glx == 'gallium-xlib'
1432     dep_glproto = dependency('glproto', version : '>= 1.4.14')
1433   endif
1434   if with_glx == 'dri'
1435     if with_dri_platform == 'drm'
1436       dep_dri2proto = dependency('dri2proto', version : '>= 2.8')
1437       dep_xxf86vm = dependency('xxf86vm')
1438     endif
1439   endif
1440   if (with_egl or (
1441       with_gallium_vdpau or with_gallium_xvmc or with_gallium_xa or
1442       with_gallium_omx != 'disabled'))
1443     dep_xcb_xfixes = dependency('xcb-xfixes')
1444   endif
1445   if with_xlib_lease
1446     dep_xcb_xrandr = dependency('xcb-randr')
1447     dep_xlib_xrandr = dependency('xrandr', version : '>= 1.3')
1448   endif
1449 endif
1450
1451 if get_option('gallium-extra-hud')
1452   pre_args += '-DHAVE_GALLIUM_EXTRA_HUD=1'
1453 endif
1454
1455 _sensors = get_option('lmsensors')
1456 if _sensors != 'false'
1457   dep_lmsensors = cc.find_library('sensors', required : _sensors == 'true')
1458   if dep_lmsensors.found()
1459     pre_args += '-DHAVE_LIBSENSORS=1'
1460   endif
1461 else
1462   dep_lmsensors = null_dep
1463 endif
1464
1465 foreach a : pre_args
1466   add_project_arguments(a, language : ['c', 'cpp'])
1467 endforeach
1468 foreach a : c_args
1469   add_project_arguments(a, language : ['c'])
1470 endforeach
1471 foreach a : cpp_args
1472   add_project_arguments(a, language : ['cpp'])
1473 endforeach
1474
1475 gl_priv_reqs = []
1476
1477 if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1478   gl_priv_reqs += ['x11', 'xext', 'xcb']
1479 elif with_glx == 'dri'
1480   gl_priv_reqs += [
1481     'x11', 'xext', 'xdamage >= 1.1', 'xfixes', 'x11-xcb', 'xcb',
1482     'xcb-glx >= 1.8.1']
1483   if with_dri_platform == 'drm'
1484     gl_priv_reqs += 'xcb-dri2 >= 1.8'
1485     gl_priv_reqs += 'xxf86vm'
1486   endif
1487 endif
1488 if dep_libdrm.found()
1489   gl_priv_reqs += 'libdrm >= 2.4.75'
1490 endif
1491
1492 gl_priv_libs = []
1493 if dep_thread.found()
1494   gl_priv_libs += ['-lpthread', '-pthread']
1495 endif
1496 if dep_m.found()
1497   gl_priv_libs += '-lm'
1498 endif
1499 if dep_dl.found()
1500   gl_priv_libs += '-ldl'
1501 endif
1502
1503 pkg = import('pkgconfig')
1504
1505 prog_nm = find_program('nm', required : false)
1506 env_test = environment()
1507 if prog_nm.found()
1508   env_test.set('NM', prog_nm.path())
1509 endif
1510
1511 # This quirk needs to be applied to sources with functions defined in assembly
1512 # as GCC LTO drops them. See: https://bugs.freedesktop.org/show_bug.cgi?id=109391
1513 gcc_lto_quirk = (cc.get_id() == 'gcc') ? ['-fno-lto'] : []
1514
1515 subdir('include')
1516 subdir('bin')
1517 subdir('src')
1518
1519 # Meson 0.49 and earlier seems to have a bug that fails to evaluate the string-
1520 # formatting below unless the first argument is passed as a variable. This has
1521 # been fixed in Meson 0.50 and beyond, but we need to keep it like this for now
1522 # for backwards compatibility.
1523 _with_opengl_string = with_opengl ? 'yes' : 'no'
1524
1525 lines = ['',
1526   'prefix:          ' + get_option('prefix'),
1527   'libdir:          ' + get_option('libdir'),
1528   'includedir:      ' + get_option('includedir'),
1529   '',
1530   'OpenGL:          @0@ (ES1: @1@ ES2: @2@)'.format(_with_opengl_string,
1531                                                     with_gles1 ? 'yes' : 'no',
1532                                                     with_gles2 ? 'yes' : 'no'),
1533 ]
1534
1535 lines += ''
1536 if with_osmesa != 'none'
1537   suffix = ''
1538   if with_osmesa == 'gallium'
1539     suffix = '(Gallium)'
1540   endif
1541   lines += 'OSMesa:          lib' + osmesa_lib_name + suffix
1542 else
1543   lines += 'OSMesa:          no'
1544 endif
1545
1546 lines += ''
1547 if with_dri
1548   lines += 'DRI platform:    ' + with_dri_platform
1549   if dri_drivers.length() != 0 and dri_drivers != ['']
1550     lines += 'DRI drivers:     ' + ' '.join(dri_drivers)
1551   else
1552     lines += 'DRI drivers:     no'
1553   endif
1554   lines += 'DRI driver dir:  ' + dri_drivers_path
1555 endif
1556
1557 lines += ''
1558 if with_glx != 'disabled'
1559   if with_glx == 'dri'
1560     lines += 'GLX:             DRI-based'
1561   elif with_glx == 'xlib'
1562     lines += 'GLX:             Xlib-based'
1563   elif with_glx == 'gallium-xlib'
1564     lines += 'GLX:             Xlib-based (Gallium)'
1565   else
1566     lines += 'GLX:             ' + with_glx
1567   endif
1568 endif
1569
1570 lines += ''
1571 lines += 'EGL:             ' + (with_egl ? 'yes' : 'no')
1572 if with_egl
1573   egl_drivers = []
1574   if with_dri
1575     egl_drivers += 'builtin:egl_dri2'
1576   endif
1577   if with_dri3
1578     egl_drivers += 'builtin:egl_dri3'
1579   endif
1580   lines += 'EGL drivers:     ' + ' '.join(egl_drivers)
1581 endif
1582 lines += 'GBM:             ' + (with_gbm ? 'yes' : 'no')
1583 if with_platforms
1584   lines += 'EGL/Vulkan/VL platforms:   ' + ' '.join(_platforms)
1585 endif
1586
1587 lines += ''
1588 if with_any_vk
1589   lines += 'Vulkan drivers:  ' + ' '.join(_vulkan_drivers)
1590   lines += 'Vulkan ICD dir:  ' + with_vulkan_icd_dir
1591 else
1592   lines += 'Vulkan drivers:  no'
1593 endif
1594
1595 lines += ''
1596 if with_llvm
1597   lines += 'llvm:            yes'
1598   lines += 'llvm-version:    ' + dep_llvm.version()
1599 else
1600   lines += 'llvm:            no'
1601 endif
1602
1603 lines += ''
1604 if with_gallium
1605   lines += 'Gallium drivers: ' + ' '.join(gallium_drivers)
1606   gallium_st = ['mesa']
1607   if with_gallium_xa
1608     gallium_st += 'xa'
1609   endif
1610   if with_gallium_xvmc
1611     gallium_st += 'xvmc'
1612   endif
1613   if with_gallium_xvmc
1614     gallium_st += 'xvmc'
1615   endif
1616   if with_gallium_vdpau
1617     gallium_st += 'vdpau'
1618   endif
1619   if with_gallium_omx != 'disabled'
1620     gallium_st += 'omx' + with_gallium_omx
1621   endif
1622   if with_gallium_va
1623     gallium_st += 'va'
1624   endif
1625   if with_gallium_st_nine
1626     gallium_st += 'nine'
1627   endif
1628   if with_gallium_opencl
1629     gallium_st += 'clover'
1630   endif
1631   lines += 'Gallium st:      ' + ' '.join(gallium_st)
1632 else
1633   lines += 'Gallium:         no'
1634 endif
1635
1636 lines += 'HUD lmsensors:   ' + (dep_lmsensors.found() ? 'yes' : 'no')
1637
1638 lines += ''
1639 lines += 'Shared-glapi:    ' + (with_shared_glapi ? 'yes' : 'no')
1640
1641
1642 indent = '        '
1643 summary = indent + ('\n' + indent).join(lines)
1644 message('Configuration summary:\n@0@\n'.format(summary))