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