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