meson.build 46.3 KB
Newer Older
1
# Copyright © 2017-2019 Intel Corporation
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:

# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

21 22 23
project(
  'mesa',
  ['c', 'cpp'],
24 25 26
  version : run_command(
    [find_program('python', 'python2', 'python3'), 'bin/meson_get_version.py']
  ).stdout(),
27
  license : 'MIT',
28 29
  meson_version : '>= 0.45',
  default_options : ['buildtype=debugoptimized', 'b_ndebug=if-release', 'c_std=c99', 'cpp_std=c++11']
30
)
31

32 33 34
cc = meson.get_compiler('c')
cpp = meson.get_compiler('cpp')

35 36
null_dep = dependency('', required : false)

37 38 39 40 41 42 43
# Arguments for the preprocessor, put these in a separate array from the C and
# C++ (cpp in meson terminology) arguments since they need to be added to the
# default arguments for both C and C++.
pre_args = [
  '-D__STDC_CONSTANT_MACROS',
  '-D__STDC_FORMAT_MACROS',
  '-D__STDC_LIMIT_MACROS',
44
  '-DPACKAGE_VERSION="@0@"'.format(meson.project_version()),
45 46 47
  '-DPACKAGE_BUGREPORT="https://bugs.freedesktop.org/enter_bug.cgi?product=Mesa"',
]

48
with_vulkan_icd_dir = get_option('vulkan-icd-dir')
49 50
with_tests = get_option('build-tests')
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 57
with_swr_arches = get_option('swr-arches')
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 63
dri_drivers_path = get_option('dri-drivers-path')
if dri_drivers_path == ''
64
  dri_drivers_path = join_paths(get_option('prefix'), get_option('libdir'), 'dri')
65
endif
66 67
dri_search_path = get_option('dri-search-path')
if dri_search_path == ''
68
  dri_search_path = dri_drivers_path
69
endif
70

71 72 73 74
with_gles1 = get_option('gles1')
with_gles2 = get_option('gles2')
with_opengl = get_option('opengl')
with_any_opengl = with_opengl or with_gles1 or with_gles2
Dylan Baker's avatar
Dylan Baker committed
75 76
# Only build shared_glapi if at least one OpenGL API is enabled
with_shared_glapi = get_option('shared-glapi') and with_any_opengl
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91


# shared-glapi is required if at least two OpenGL APIs are being built
if not with_shared_glapi
  if ((with_gles1 and with_gles2) or (with_gles1 and with_opengl)
      or (with_gles2 and with_opengl))
    error('shared-glapi required for building two or more of OpenGL, OpenGL ES 1.x, OpenGL ES 2.x')
  endif
endif

# We require OpenGL for OpenGL ES
if (with_gles1 or with_gles2) and not with_opengl
  error('building OpenGL ES without OpenGL is not supported.')
endif

92 93
system_has_kms_drm = ['openbsd', 'netbsd', 'freebsd', 'dragonfly', 'linux'].contains(host_machine.system())

94
_drivers = get_option('dri-drivers')
95
if _drivers.contains('auto')
96
  if system_has_kms_drm
97
    # TODO: PPC, Sparc
98
    if ['x86', 'x86_64'].contains(host_machine.cpu_family())
99
      _drivers = ['i915', 'i965', 'r100', 'r200', 'nouveau']
100
    elif ['arm', 'aarch64'].contains(host_machine.cpu_family())
101
      _drivers = []
102
    else
103 104
      error('Unknown architecture @0@. Please pass -Ddri-drivers to set driver options. Patches gladly accepted to fix this.'.format(
            host_machine.cpu_family()))
105
    endif
106
  elif ['darwin', 'windows', 'cygwin', 'haiku'].contains(host_machine.system())
107
    # only swrast would make sense here, but gallium swrast is a much better default
108
    _drivers = []
109
  else
110 111
    error('Unknown OS @0@. Please pass -Ddri-drivers to set driver options. Patches gladly accepted to fix this.'.format(
          host_machine.system()))
112 113
  endif
endif
114 115 116 117 118 119 120 121 122

with_dri_i915 = _drivers.contains('i915')
with_dri_i965 = _drivers.contains('i965')
with_dri_r100 = _drivers.contains('r100')
with_dri_r200 = _drivers.contains('r200')
with_dri_nouveau = _drivers.contains('nouveau')
with_dri_swrast = _drivers.contains('swrast')

with_dri = _drivers.length() != 0 and _drivers != ['']
123

124
_drivers = get_option('gallium-drivers')
125
if _drivers.contains('auto')
126
  if system_has_kms_drm
127 128
    # TODO: PPC, Sparc
    if ['x86', 'x86_64'].contains(host_machine.cpu_family())
129 130 131
      _drivers = [
        'r300', 'r600', 'radeonsi', 'nouveau', 'virgl', 'svga', 'swrast'
      ]
132
    elif ['arm', 'aarch64'].contains(host_machine.cpu_family())
133
      _drivers = [
134
        'kmsro', 'v3d', 'vc4', 'freedreno', 'etnaviv', 'nouveau',
135 136
        'tegra', 'virgl', 'swrast',
      ]
137
    else
138 139
      error('Unknown architecture @0@. Please pass -Dgallium-drivers to set driver options. Patches gladly accepted to fix this.'.format(
            host_machine.cpu_family()))
140
    endif
141
  elif ['darwin', 'windows', 'cygwin', 'haiku'].contains(host_machine.system())
142
    _drivers = ['swrast']
143
  else
144 145
    error('Unknown OS @0@. Please pass -Dgallium-drivers to set driver options. Patches gladly accepted to fix this.'.format(
          host_machine.system()))
146 147
  endif
endif
148
with_gallium_kmsro = _drivers.contains('kmsro')
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
with_gallium_radeonsi = _drivers.contains('radeonsi')
with_gallium_r300 = _drivers.contains('r300')
with_gallium_r600 = _drivers.contains('r600')
with_gallium_nouveau = _drivers.contains('nouveau')
with_gallium_freedreno = _drivers.contains('freedreno')
with_gallium_softpipe = _drivers.contains('swrast')
with_gallium_vc4 = _drivers.contains('vc4')
with_gallium_v3d = _drivers.contains('v3d')
with_gallium_etnaviv = _drivers.contains('etnaviv')
with_gallium_tegra = _drivers.contains('tegra')
with_gallium_i915 = _drivers.contains('i915')
with_gallium_svga = _drivers.contains('svga')
with_gallium_virgl = _drivers.contains('virgl')
with_gallium_swr = _drivers.contains('swr')

164
if cc.get_id() == 'intel'
Vinson Lee's avatar
Vinson Lee committed
165
  if meson.version().version_compare('< 0.49.0')
166
    error('Meson does not have sufficient support of ICC before 0.49.0 to compile mesa')
Vinson Lee's avatar
Vinson Lee committed
167
  elif with_gallium_swr and meson.version().version_compare('== 0.49.0')
168 169 170 171
    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')
  endif
endif

172 173 174 175 176 177 178
with_gallium = _drivers.length() != 0 and _drivers != ['']

if with_gallium and system_has_kms_drm
  _glx = get_option('glx')
  _egl = get_option('egl')
  if _glx == 'dri' or _egl == 'true' or (_glx == 'disabled' and _egl != 'false')
    with_dri = true
179
  endif
Ville Syrjälä's avatar
Ville Syrjälä committed
180 181
endif

182
_vulkan_drivers = get_option('vulkan-drivers')
183
if _vulkan_drivers.contains('auto')
184
  if system_has_kms_drm
185
    if host_machine.cpu_family().startswith('x86')
186
      _vulkan_drivers = ['amd', 'intel']
187 188
    elif ['arm', 'aarch64'].contains(host_machine.cpu_family())
      _vulkan_drivers = []
189
    else
190 191
      error('Unknown architecture @0@. Please pass -Dvulkan-drivers to set driver options. Patches gladly accepted to fix this.'.format(
            host_machine.cpu_family()))
192
    endif
193
  elif ['darwin', 'windows', 'cygwin', 'haiku'].contains(host_machine.system())
194
    # No vulkan driver supports windows or macOS currently
195
    _vulkan_drivers = []
196
  else
197 198
    error('Unknown OS @0@. Please pass -Dvulkan-drivers to set driver options. Patches gladly accepted to fix this.'.format(
          host_machine.system()))
199 200
  endif
endif
201 202 203 204

with_intel_vk = _vulkan_drivers.contains('intel')
with_amd_vk = _vulkan_drivers.contains('amd')
with_any_vk = _vulkan_drivers.length() != 0 and _vulkan_drivers != ['']
205

Dylan Baker's avatar
Dylan Baker committed
206
if with_dri_swrast and (with_gallium_softpipe or with_gallium_swr)
Dylan Baker's avatar
Dylan Baker committed
207 208
  error('Only one swrast provider can be built')
endif
Dylan Baker's avatar
Dylan Baker committed
209 210 211
if with_dri_i915 and with_gallium_i915
  error('Only one i915 provider can be built')
endif
212 213
if with_gallium_kmsro and not (with_gallium_vc4 or with_gallium_etnaviv or with_gallium_freedreno)
  error('kmsro driver requires one or more renderonly drivers (vc4, etnaviv, freedreno)')
214
endif
Thierry Reding's avatar
Thierry Reding committed
215 216 217
if with_gallium_tegra and not with_gallium_nouveau
  error('tegra driver requires nouveau driver')
endif
Dylan Baker's avatar
Dylan Baker committed
218

219 220 221 222
if host_machine.system() == 'darwin'
  with_dri_platform = 'apple'
elif ['windows', 'cygwin'].contains(host_machine.system())
  with_dri_platform = 'windows'
myfreeweb's avatar
myfreeweb committed
223
elif system_has_kms_drm
224 225 226 227
  with_dri_platform = 'drm'
else
  # FIXME: haiku doesn't use dri, and xlib doesn't use dri, probably should
  # assert here that one of those cases has been met.
myfreeweb's avatar
myfreeweb committed
228
  # FIXME: illumos ends up here as well
229 230
  with_dri_platform = 'none'
endif
Dylan Baker's avatar
Dylan Baker committed
231

232
_platforms = get_option('platforms')
233
if _platforms.contains('auto')
myfreeweb's avatar
myfreeweb committed
234
  if system_has_kms_drm
235
    _platforms = ['x11', 'wayland', 'drm', 'surfaceless']
236
  elif ['darwin', 'windows', 'cygwin'].contains(host_machine.system())
237
    _platforms = ['x11', 'surfaceless']
238
  elif ['haiku'].contains(host_machine.system())
239
    _platforms = ['haiku']
240
  else
241 242
    error('Unknown OS @0@. Please pass -Dplatforms to set platforms. Patches gladly accepted to fix this.'.format(
          host_machine.system()))
243 244
  endif
endif
Eric Engestrom's avatar
Eric Engestrom committed
245 246 247 248 249 250 251 252 253 254 255

with_platform_android = _platforms.contains('android')
with_platform_x11 = _platforms.contains('x11')
with_platform_wayland = _platforms.contains('wayland')
with_platform_drm = _platforms.contains('drm')
with_platform_haiku = _platforms.contains('haiku')
with_platform_surfaceless = _platforms.contains('surfaceless')

with_platforms = false
if _platforms.length() != 0 and _platforms != ['']
  with_platforms = true
256
  egl_native_platform = _platforms[0]
257 258
endif

259 260 261 262 263 264 265
_xlib_lease = get_option('xlib-lease')
if _xlib_lease == 'auto'
  with_xlib_lease = with_platform_x11 and with_platform_drm
else
  with_xlib_lease = _xlib_lease == 'true'
endif

266 267 268 269
with_glx = get_option('glx')
if with_glx == 'auto'
  if with_dri
    with_glx = 'dri'
270 271
  elif with_platform_haiku
    with_glx = 'disabled'
272
  elif with_gallium
273 274
    # Even when building just gallium drivers the user probably wants dri
    with_glx = 'dri'
275 276 277 278 279 280 281 282
  elif with_platform_x11 and with_any_opengl and not with_any_vk
    # The automatic behavior should not be to turn on xlib based glx when
    # building only vulkan drivers
    with_glx = 'xlib'
  else
    with_glx = 'disabled'
  endif
endif
283 284 285 286 287
if with_glx == 'dri'
   if with_gallium
      with_dri = true
   endif
endif
288

289
if not (with_dri or with_gallium or with_glx == 'xlib' or with_glx == 'gallium-xlib')
290 291 292 293 294 295 296
  with_gles1 = false
  with_gles2 = false
  with_opengl = false
  with_any_opengl = false
  with_shared_glapi = false
endif

297 298 299
_gbm = get_option('gbm')
if _gbm == 'auto'
  with_gbm = system_has_kms_drm and with_dri
Dylan Baker's avatar
Dylan Baker committed
300
else
301 302 303 304
  with_gbm = _gbm == 'true'
endif
if with_gbm and not system_has_kms_drm
  error('GBM only supports DRM/KMS platforms')
Dylan Baker's avatar
Dylan Baker committed
305 306
endif

Dylan Baker's avatar
Dylan Baker committed
307 308
_egl = get_option('egl')
if _egl == 'auto'
309 310 311 312
  with_egl = (
    not ['darwin', 'windows'].contains(host_machine.system()) and
    with_dri and with_shared_glapi and with_platforms
  )
313
elif _egl == 'true'
Dylan Baker's avatar
Dylan Baker committed
314 315 316 317
  if not with_dri
    error('EGL requires dri')
  elif not with_shared_glapi
    error('EGL requires shared-glapi')
318
  elif not with_platforms
319
    error('No platforms specified, consider -Dplatforms=drm,x11,surfaceless at least')
320 321
  elif not ['disabled', 'dri'].contains(with_glx)
    error('EGL requires dri, but a GLX is being built without dri')
322 323
  elif ['darwin', 'windows'].contains(host_machine.system())
    error('EGL is not available on Windows or MacOS')
Dylan Baker's avatar
Dylan Baker committed
324 325 326 327 328 329
  endif
  with_egl = true
else
  with_egl = false
endif

Dylan Baker's avatar
Dylan Baker committed
330 331 332 333 334 335 336
if with_egl and not (with_platform_drm or with_platform_surfaceless)
  if with_gallium_radeonsi
    error('RadeonSI requires drm or surfaceless platform when using EGL')
  endif
  if with_gallium_virgl
    error('Virgl requires drm or surfaceless platform when using EGL')
  endif
Dylan Baker's avatar
Dylan Baker committed
337 338
endif

339
pre_args += '-DGLX_USE_TLS'
Dylan Baker's avatar
Dylan Baker committed
340
if with_glx != 'disabled'
341
  if not (with_platform_x11 and with_any_opengl)
342
    error('Cannot build GLX support without X11 platform support and at least one OpenGL API')
Dylan Baker's avatar
Dylan Baker committed
343 344 345
  elif with_glx == 'gallium-xlib' 
    if not with_gallium
      error('Gallium-xlib based GLX requires at least one gallium driver')
346 347
    elif not with_gallium_softpipe
      error('Gallium-xlib based GLX requires softpipe or llvmpipe.')
Dylan Baker's avatar
Dylan Baker committed
348 349 350
    elif with_dri
      error('gallium-xlib conflicts with any dri driver')
    endif
351
  elif with_glx == 'xlib' 
Dylan Baker's avatar
Dylan Baker committed
352
    if with_dri
353
      error('xlib conflicts with any dri driver')
Dylan Baker's avatar
Dylan Baker committed
354
    endif
355 356 357 358 359 360
  elif with_glx == 'dri'
    if not with_dri
      error('dri based GLX requires at least one DRI driver')
    elif not with_shared_glapi
      error('dri based GLX requires shared-glapi')
    endif
Dylan Baker's avatar
Dylan Baker committed
361 362 363 364
  endif
endif

with_glvnd = get_option('glvnd')
365 366 367 368 369 370
if with_glvnd
  if with_glx == 'xlib' or with_glx == 'gallium-xlib'
    error('Cannot build glvnd support for GLX that is not DRI based.')
  elif with_glx == 'disabled' and not with_egl
    error('glvnd requires DRI based GLX and/or EGL')
  endif
Dylan Baker's avatar
Dylan Baker committed
371 372
endif

373 374 375 376
if with_vulkan_icd_dir == ''
  with_vulkan_icd_dir = join_paths(get_option('datadir'), 'vulkan/icd.d')
endif

377
with_dri2 = (with_dri or with_any_vk) and with_dri_platform == 'drm'
378 379
_dri3 = get_option('dri3')
if _dri3 == 'auto'
380
  with_dri3 = system_has_kms_drm and with_dri2
381
else
382
  with_dri3 = _dri3 == 'true'
383 384 385 386 387
endif

if with_any_vk and (with_platform_x11 and not with_dri3)
  error('Vulkan drivers require dri3 for X11 support')
endif
388
if with_dri
389 390
  if with_glx == 'disabled' and not with_egl and not with_gbm and with_osmesa != 'classic'
    error('building dri drivers require at least one windowing system or classic osmesa')
Dylan Baker's avatar
Dylan Baker committed
391
  endif
392 393
endif

394 395
prog_pkgconfig = find_program('pkg-config')

396
_vdpau = get_option('gallium-vdpau')
397 398 399
if not system_has_kms_drm
  if _vdpau == 'true'
    error('VDPAU state tracker can only be build on unix-like OSes.')
400
  else
401
    _vdpau = 'false'
402
  endif
403 404
elif not with_platform_x11
  if _vdpau == 'true'
405
    error('VDPAU state tracker requires X11 support.')
406 407 408 409 410 411
  else
    _vdpau = 'false'
  endif
elif not (with_gallium_r300 or with_gallium_r600 or with_gallium_radeonsi or
          with_gallium_nouveau)
  if _vdpau == 'true'
412
    error('VDPAU state tracker requires at least one of the following gallium drivers: r300, r600, radeonsi, nouveau.')
413 414
  else
    _vdpau = 'false'
415 416
  endif
endif
417
dep_vdpau = null_dep
418 419 420 421 422 423 424 425 426
with_gallium_vdpau = false
if _vdpau != 'false'
  dep_vdpau = dependency('vdpau', version : '>= 1.1', required : _vdpau == 'true')
  if dep_vdpau.found()
    dep_vdpau = declare_dependency(
      compile_args : run_command(prog_pkgconfig, ['vdpau', '--cflags']).stdout().split()
    )
    with_gallium_vdpau = true
  endif
427 428 429 430 431 432 433 434 435 436
endif

if with_gallium_vdpau
  pre_args += '-DHAVE_ST_VDPAU'
endif
vdpau_drivers_path = get_option('vdpau-libs-path')
if vdpau_drivers_path == ''
  vdpau_drivers_path = join_paths(get_option('libdir'), 'vdpau')
endif

437
_xvmc = get_option('gallium-xvmc')
438 439 440
if not system_has_kms_drm
  if _xvmc == 'true'
    error('XVMC state tracker can only be build on unix-like OSes.')
441
  else
442
    _xvmc = 'false'
443
  endif
444 445
elif not with_platform_x11
  if _xvmc == 'true'
446
    error('XVMC state tracker requires X11 support.')
447 448 449 450 451
  else
    _xvmc = 'false'
  endif
elif not (with_gallium_r600 or with_gallium_nouveau)
  if _xvmc == 'true'
452
    error('XVMC state tracker requires at least one of the following gallium drivers: r600, nouveau.')
453 454
  else
    _xvmc = 'false'
455 456
  endif
endif
457
dep_xvmc = null_dep
458
with_gallium_xvmc = false
459
if _xvmc != 'false'
460 461
  dep_xvmc = dependency('xvmc', version : '>= 1.0.6', required : _xvmc == 'true')
  with_gallium_xvmc = dep_xvmc.found()
462 463 464 465 466 467 468
endif

xvmc_drivers_path = get_option('xvmc-libs-path')
if xvmc_drivers_path == ''
  xvmc_drivers_path = get_option('libdir')
endif

469
_omx = get_option('gallium-omx')
470
if not system_has_kms_drm
471
  if ['auto', 'disabled'].contains(_omx)
472
    _omx = 'disabled'
473 474
  else
    error('OMX state tracker can only be built on unix-like OSes.')
475
  endif
476
elif not (with_platform_x11 or with_platform_drm)
477
  if ['auto', 'disabled'].contains(_omx)
478
    _omx = 'disabled'
479 480
  else
    error('OMX state tracker requires X11 or drm platform support.')
481 482
  endif
elif not (with_gallium_r600 or with_gallium_radeonsi or with_gallium_nouveau)
483
  if ['auto', 'disabled'].contains(_omx)
484
    _omx = 'disabled'
485 486
  else
    error('OMX state tracker requires at least one of the following gallium drivers: r600, radeonsi, nouveau.')
487
  endif
488
endif
489 490
with_gallium_omx = _omx
dep_omx = null_dep
491
dep_omx_other = []
492
if ['auto', 'bellagio'].contains(_omx)
493
  dep_omx = dependency(
494
    'libomxil-bellagio', required : _omx == 'bellagio'
495 496 497 498 499
  )
  if dep_omx.found()
    with_gallium_omx = 'bellagio'
  endif
endif
500 501
if ['auto', 'tizonia'].contains(_omx)
  if with_dri and with_egl
502 503
    dep_omx = dependency(
      'libtizonia', version : '>= 0.10.0',
504
      required : _omx == 'tizonia',
505 506
    )
    dep_omx_other = [
507 508
      dependency('libtizplatform', required : _omx == 'tizonia'),
      dependency('tizilheaders', required : _omx == 'tizonia'),
509 510 511 512
    ]
    if dep_omx.found() and dep_omx_other[0].found() and dep_omx_other[1].found()
      with_gallium_omx = 'tizonia'
    endif
513 514
  elif _omx == 'tizonia'
    error('OMX-Tizonia state tracker requires dri and egl')
515
  endif
516
endif
517 518 519 520 521
if _omx == 'auto'
  with_gallium_omx = 'disabled'
else
  with_gallium_omx = _omx
endif
522

523 524 525 526 527 528
pre_args += [
  '-DENABLE_ST_OMX_BELLAGIO=' + (with_gallium_omx == 'bellagio' ? '1' : '0'),
  '-DENABLE_ST_OMX_TIZONIA=' + (with_gallium_omx == 'tizonia' ? '1' : '0'),
]


529
omx_drivers_path = get_option('omx-libs-path')
530

531
if with_gallium_omx != 'disabled'
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
  # Figure out where to put the omx driver.
  # FIXME: this could all be vastly simplified by adding a 'defined_variable'
  # argument to meson's get_pkgconfig_variable method.
  if omx_drivers_path == ''
    _omx_libdir = dep_omx.get_pkgconfig_variable('libdir')
    _omx_drivers_dir = dep_omx.get_pkgconfig_variable('pluginsdir')
    if _omx_libdir == get_option('libdir')
      omx_drivers_path = _omx_drivers_dir
    else
      _omx_base_dir = []
      # This will fail on windows. Does OMX run on windows?
      _omx_libdir = _omx_libdir.split('/')
      _omx_drivers_dir = _omx_drivers_dir.split('/')
      foreach o : _omx_drivers_dir
        if not _omx_libdir.contains(o)
          _omx_base_dir += o
        endif
      endforeach
      omx_drivers_path = join_paths(get_option('libdir'), _omx_base_dir)
    endif
  endif
endif

555
_va = get_option('gallium-va')
556 557 558
if not system_has_kms_drm
  if _va == 'true'
    error('VA state tracker can only be built on unix-like OSes.')
559
  else
560
    _va = 'false'
561
  endif
562 563
elif not (with_platform_x11 or with_platform_drm)
  if _va == 'true'
564
    error('VA state tracker requires X11 or drm or wayland platform support.')
565 566 567 568 569
  else
    _va = 'false'
  endif
elif not (with_gallium_r600 or with_gallium_radeonsi or with_gallium_nouveau)
  if _va == 'true'
570
    error('VA state tracker requires at least one of the following gallium drivers: r600, radeonsi, nouveau.')
571 572
  else
    _va = 'false'
573 574
  endif
endif
575
with_gallium_va = false
576
dep_va = null_dep
577 578 579 580 581 582 583 584
if _va != 'false'
  dep_va = dependency('libva', version : '>= 0.38.0', required : _va == 'true')
  if dep_va.found()
    dep_va_headers = declare_dependency(
      compile_args : run_command(prog_pkgconfig, ['libva', '--cflags']).stdout().split()
    )
    with_gallium_va = true
  endif
585 586 587 588 589 590 591
endif

va_drivers_path = get_option('va-libs-path')
if va_drivers_path == ''
  va_drivers_path = join_paths(get_option('libdir'), 'dri')
endif

592
_xa = get_option('gallium-xa')
593 594 595
if not system_has_kms_drm
  if _xa == 'true'
    error('XA state tracker can only be built on unix-like OSes.')
596
  else
597
    _xa = 'false'
598
  endif
599 600 601
elif not (with_gallium_nouveau or with_gallium_freedreno or with_gallium_i915
          or with_gallium_svga)
  if _xa == 'true'
602
    error('XA state tracker requires at least one of the following gallium drivers: nouveau, freedreno, i915, svga.')
603 604
  else
    _xa = 'false'
605 606
  endif
endif
607
with_gallium_xa = _xa != 'false'
608

609 610 611 612 613 614 615 616 617 618 619
d3d_drivers_path = get_option('d3d-drivers-path')
if d3d_drivers_path == ''
  d3d_drivers_path = join_paths(get_option('libdir'), 'd3d')
endif

with_gallium_st_nine =  get_option('gallium-nine')
if with_gallium_st_nine
  if not with_gallium_softpipe
    error('The nine state tracker requires gallium softpipe/llvmpipe.')
  elif not (with_gallium_radeonsi or with_gallium_nouveau or with_gallium_r600
            or with_gallium_r300 or with_gallium_svga or with_gallium_i915)
Vinson Lee's avatar
Vinson Lee committed
620
    error('The nine state tracker requires at least one non-swrast gallium driver.')
621 622 623 624 625 626
  endif
  if not with_dri3
    error('Using nine with wine requires dri3')
  endif
endif

627
if get_option('power8') != 'false'
628 629 630 631 632 633
  # on old versions of meson the cpu family would return as ppc64le on little
  # endian power8, this was changed in 0.48 such that the family would always
  # be ppc64 regardless of endianness, and the the machine.endian() value
  # should be checked. Since we support versions < 0.48 we need to use
  # startswith.
  if host_machine.cpu_family().startswith('ppc64') and host_machine.endian() == 'little'
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
    if cc.get_id() == 'gcc' and cc.version().version_compare('< 4.8')
      error('Altivec is not supported with gcc version < 4.8.')
    endif
    if cc.compiles('''
        #include <altivec.h>
        int main() {
          vector unsigned char r;
          vector unsigned int v = vec_splat_u32 (1);
          r = __builtin_vec_vgbbd ((vector unsigned char) v);
          return 0;
        }''',
        args : '-mpower8-vector',
        name : 'POWER8 intrinsics')
      pre_args += ['-D_ARCH_PWR8', '-mpower8-vector']
    elif get_option('power8') == 'true'
      error('POWER8 intrinsic support required but not found.')
    endif
  endif
endif

Dylan Baker's avatar
Dylan Baker committed
654
_opencl = get_option('gallium-opencl')
655
clover_cpp_std = []
656
if _opencl != 'disabled'
Dylan Baker's avatar
Dylan Baker committed
657 658 659 660 661 662 663
  if not with_gallium
    error('OpenCL Clover implementation requires at least one gallium driver.')
  endif

  dep_clc = dependency('libclc')
  with_gallium_opencl = true
  with_opencl_icd = _opencl == 'icd'
664 665 666 667 668 669 670 671

  if host_machine.cpu_family().startswith('ppc') and cpp.compiles('''
      #if !defined(__VEC__) || !defined(__ALTIVEC__)
      #error "AltiVec not enabled"
      #endif''',
      name : 'Altivec')
    clover_cpp_std += ['cpp_std=gnu++11']
  endif
Dylan Baker's avatar
Dylan Baker committed
672
else
673
  dep_clc = null_dep
Dylan Baker's avatar
Dylan Baker committed
674
  with_gallium_opencl = false
675
  with_opencl_icd = false
Dylan Baker's avatar
Dylan Baker committed
676 677
endif

Dylan Baker's avatar
Dylan Baker committed
678
gl_pkgconfig_c_flags = []
679
if with_platform_x11
680
  if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
681 682
    pre_args += '-DHAVE_X11_PLATFORM'
  endif
683
  if with_glx == 'xlib' or with_glx == 'gallium-xlib'
684
    pre_args += '-DUSE_XSHM'
685 686 687 688 689 690 691
  else
    pre_args += '-DGLX_INDIRECT_RENDERING'
    if with_glx_direct
      pre_args += '-DGLX_DIRECT_RENDERING'
    endif
    if with_dri_platform == 'drm'
      pre_args += '-DGLX_USE_DRM'
692 693
    elif with_dri_platform == 'apple'
      pre_args += '-DGLX_USE_APPLEGL'
694 695
    elif with_dri_platform == 'windows'
      pre_args += '-DGLX_USE_WINDOWSGL'
696 697
    endif
  endif
Dylan Baker's avatar
Dylan Baker committed
698 699 700 701 702 703 704 705 706 707 708 709
else
  pre_args += '-DMESA_EGL_NO_X11_HEADERS'
  gl_pkgconfig_c_flags += '-DMESA_EGL_NO_X11_HEADERS'
endif
if with_platform_drm
  if with_egl and not with_gbm
    error('EGL drm platform requires gbm')
  endif
  pre_args += '-DHAVE_DRM_PLATFORM'
endif
if with_platform_surfaceless
  pre_args += '-DHAVE_SURFACELESS_PLATFORM'
710
endif
711 712 713 714 715 716 717 718
if with_platform_android
  dep_android = [
    dependency('cutils'),
    dependency('hardware'),
    dependency('sync'),
  ]
  pre_args += '-DHAVE_ANDROID_PLATFORM'
endif
719 720 721
if with_platform_haiku
  pre_args += '-DHAVE_HAIKU_PLATFORM'
endif
722

723
prog_python = import('python3').find_python()
724 725 726 727 728 729 730
has_mako = run_command(
  prog_python, '-c',
  '''
from distutils.version import StrictVersion
import mako
assert StrictVersion(mako.__version__) > StrictVersion("0.8.0")
  ''')
731
if has_mako.returncode() != 0
732
  error('Python (3.x) mako module >= 0.8.0 required to build mesa.')
733
endif
734 735

if cc.get_id() == 'gcc' and cc.version().version_compare('< 4.4.6')
736
  error('When using GCC, version 4.4.6 or later is required.')
737 738
endif

739 740
# Define DEBUG for debug builds only (debugoptimized is not included on this one)
if get_option('buildtype') == 'debug'
741 742 743
  pre_args += '-DDEBUG'
endif

744 745 746 747 748 749
if get_option('shader-cache')
  pre_args += '-DENABLE_SHADER_CACHE'
elif with_amd_vk
  error('Radv requires shader cache support')
endif

750 751 752 753 754 755 756 757
# Check for GCC style builtins
foreach b : ['bswap32', 'bswap64', 'clz', 'clzll', 'ctz', 'expect', 'ffs',
             'ffsll', 'popcount', 'popcountll', 'unreachable']
  if cc.has_function(b)
    pre_args += '-DHAVE___BUILTIN_@0@'.format(b.to_upper())
  endif
endforeach

758
# check for GCC __attribute__
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
foreach a : ['const', 'flatten', 'malloc', 'pure', 'unused',
             'warn_unused_result', 'weak',]
  if cc.compiles('int foo(void) __attribute__((@0@));'.format(a),
                 name : '__attribute__((@0@))'.format(a))
    pre_args += '-DHAVE_FUNC_ATTRIBUTE_@0@'.format(a.to_upper())
  endif
endforeach
if cc.compiles('int foo(const char *p, ...) __attribute__((format(printf, 1, 2)));',
               name : '__attribute__((format(...)))')
  pre_args += '-DHAVE_FUNC_ATTRIBUTE_FORMAT'
endif
if cc.compiles('struct __attribute__((packed)) foo { int bar; };',
               name : '__attribute__((packed))')
  pre_args += '-DHAVE_FUNC_ATTRIBUTE_PACKED'
endif
if cc.compiles('int *foo(void) __attribute__((returns_nonnull));',
               name : '__attribute__((returns_nonnull))')
776
  pre_args += '-DHAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL'
777 778 779 780 781 782
endif
if cc.compiles('''int foo_def(void) __attribute__((visibility("default")));
                  int foo_hid(void) __attribute__((visibility("hidden")));
                  int foo_int(void) __attribute__((visibility("internal")));
                  int foo_pro(void) __attribute__((visibility("protected")));''',
               name : '__attribute__((visibility(...)))')
783
  pre_args += '-DHAVE_FUNC_ATTRIBUTE_VISIBILITY'
784 785 786 787 788
endif
if cc.compiles('int foo(void) { return 0; } int bar(void) __attribute__((alias("foo")));',
               name : '__attribute__((alias(...)))')
  pre_args += '-DHAVE_FUNC_ATTRIBUTE_ALIAS'
endif
789 790 791 792
if cc.compiles('int foo(void) __attribute__((__noreturn__));',
               name : '__attribute__((__noreturn__))')
  pre_args += '-DHAVE_FUNC_ATTRIBUTE_NORETURN'
endif
793 794

# TODO: this is very incomplete
795
if ['linux', 'cygwin', 'gnu'].contains(host_machine.system())
796 797 798
  pre_args += '-D_GNU_SOURCE'
endif

799
# Check for generic C arguments
800
c_args = []
Dylan Baker's avatar
Dylan Baker committed
801
foreach a : ['-Werror=implicit-function-declaration',
802 803
             '-Werror=missing-prototypes', '-Werror=return-type',
             '-fno-math-errno',
804 805 806 807 808
             '-fno-trapping-math', '-Qunused-arguments']
  if cc.has_argument(a)
    c_args += a
  endif
endforeach
809

810
foreach a : ['missing-field-initializers', 'format-truncation']
811 812 813 814
  if cc.has_argument('-W' + a)
    c_args += '-Wno-' + a
  endif
endforeach
815

816 817 818 819 820
c_vis_args = []
if cc.has_argument('-fvisibility=hidden')
  c_vis_args += '-fvisibility=hidden'
endif

821 822
# Check for generic C++ arguments
cpp_args = []
Dylan Baker's avatar
Dylan Baker committed
823
foreach a : ['-Werror=return-type',
824
             '-fno-math-errno', '-fno-trapping-math',
825 826 827 828 829 830
             '-Qunused-arguments']
  if cpp.has_argument(a)
    cpp_args += a
  endif
endforeach

831 832
# For some reason, the test for -Wno-foo always succeeds with gcc, even if the
# option is not supported. Hence, check for -Wfoo instead.
833

834
foreach a : ['non-virtual-dtor', 'missing-field-initializers', 'format-truncation']
835 836 837 838
  if cpp.has_argument('-W' + a)
    cpp_args += '-Wno-' + a
  endif
endforeach
839 840 841 842 843 844 845 846

no_override_init_args = []
foreach a : ['override-init', 'initializer-overrides']
  if cc.has_argument('-W' + a)
    no_override_init_args += '-Wno-' + a
  endif
endforeach

847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
cpp_vis_args = []
if cpp.has_argument('-fvisibility=hidden')
  cpp_vis_args += '-fvisibility=hidden'
endif

# Check for C and C++ arguments for MSVC2013 compatibility. These are only used
# in parts of the mesa code base that need to compile with old versions of
# MSVC, mainly common code
c_msvc_compat_args = []
cpp_msvc_compat_args = []
foreach a : ['-Werror=pointer-arith', '-Werror=vla']
  if cc.has_argument(a)
    c_msvc_compat_args += a
  endif
  if cpp.has_argument(a)
    cpp_msvc_compat_args += a
  endif
endforeach

866
if host_machine.cpu_family().startswith('x86')
867
  pre_args += '-DUSE_SSE41'
868 869 870 871 872 873 874 875 876 877 878 879
  with_sse41 = true
  sse41_args = ['-msse4.1']

  # GCC on x86 (not x86_64) with -msse* assumes a 16 byte aligned stack, but
  # that's not guaranteed
  if host_machine.cpu_family() == 'x86'
    sse41_args += '-mstackrealign'
  endif
else
  with_sse41 = false
  sse41_args = []
endif
880 881

# Check for GCC style atomics
882
dep_atomic = null_dep
883

Matt Turner's avatar
Matt Turner committed
884 885 886 887 888
if cc.compiles('''#include <stdint.h>
                  int main() {
                    struct {
                      uint64_t *v;
                    } x;
889 890 891
                    return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
                           (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);

Matt Turner's avatar
Matt Turner committed
892
                  }''',
893 894
               name : 'GCC atomic builtins')
  pre_args += '-DUSE_GCC_ATOMIC_BUILTINS'
895 896 897 898 899 900 901 902 903

  # Not all atomic calls can be turned into lock-free instructions, in which
  # GCC will make calls into the libatomic library. Check whether we need to
  # link with -latomic.
  #
  # This can happen for 64-bit atomic operations on 32-bit architectures such
  # as ARM.
  if not cc.links('''#include <stdint.h>
                     int main() {
904 905 906
                       struct {
                         uint64_t *v;
                       } x;
907 908
                       return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
                              (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
909 910 911 912
                     }''',
                  name : 'GCC atomic builtins required -latomic')
    dep_atomic = cc.find_library('atomic')
  endif
913 914 915 916 917 918
endif
if not cc.links('''#include <stdint.h>
                   uint64_t v;
                   int main() {
                     return __sync_add_and_fetch(&v, (uint64_t)1);
                   }''',
Dylan Baker's avatar
Dylan Baker committed
919
                dependencies : dep_atomic,
920
                name : 'GCC 64bit atomics')
Dylan Baker's avatar
Dylan Baker committed
921
  pre_args += '-DMISSING_64BIT_ATOMICS'
922 923 924 925
endif

# TODO: shared/static? Is this even worth doing?

926 927 928 929 930 931
# When cross compiling we generally need to turn off the use of assembly,
# because mesa's assembly relies on building an executable for the host system,
# and running it to get information about struct sizes. There is at least one
# case of cross compiling where we can use asm, and that's x86_64 -> x86 when
# host OS == build OS, since in that case the build machine can run the host's
# binaries.
932
if with_asm and meson.is_cross_build()
933 934 935 936
  if build_machine.system() != host_machine.system()
    # TODO: It may be possible to do this with an exe_wrapper (like wine).
    message('Cross compiling from one OS to another, disabling assembly.')
    with_asm = false
937 938 939 940
  elif not (build_machine.cpu_family().startswith('x86') and host_machine.cpu_family() == 'x86')
    # FIXME: Gentoo always sets -m32 for x86_64 -> x86 builds, resulting in an
    # x86 -> x86 cross compile. We use startswith rather than == to handle this
    # case.
941 942 943 944 945 946
    # TODO: There may be other cases where the 64 bit version of the
    # architecture can run 32 bit binaries (aarch64 and armv7 for example)
    message('''
      Cross compiling to different architectures, and the host cannot run
      the build machine's binaries. Disabling assembly.
    ''')
947 948
    with_asm = false
  endif
949 950 951 952 953
endif

with_asm_arch = ''
if with_asm
  if host_machine.cpu_family() == 'x86'
954
    if system_has_kms_drm or host_machine.system() == 'gnu'
955 956 957
      with_asm_arch = 'x86'
      pre_args += ['-DUSE_X86_ASM', '-DUSE_MMX_ASM', '-DUSE_3DNOW_ASM',
                   '-DUSE_SSE_ASM']
958 959 960 961

      if with_glx_read_only_text
         pre_args += ['-DGLX_X86_READONLY_TEXT']
      endif
962 963
    endif
  elif host_machine.cpu_family() == 'x86_64'
myfreeweb's avatar
myfreeweb committed
964
    if system_has_kms_drm
965 966 967 968
      with_asm_arch = 'x86_64'
      pre_args += ['-DUSE_X86_64_ASM']
    endif
  elif host_machine.cpu_family() == 'arm'
myfreeweb's avatar
myfreeweb committed
969
    if system_has_kms_drm
970 971 972 973
      with_asm_arch = 'arm'
      pre_args += ['-DUSE_ARM_ASM']
    endif
  elif host_machine.cpu_family() == 'aarch64'
myfreeweb's avatar
myfreeweb committed
974
    if system_has_kms_drm
975 976 977
      with_asm_arch = 'aarch64'
      pre_args += ['-DUSE_AARCH64_ASM']
    endif
978 979 980 981 982
  elif host_machine.cpu_family() == 'sparc64'
    if system_has_kms_drm
      with_asm_arch = 'sparc'
      pre_args += ['-DUSE_SPARC_ASM']
    endif
983
  elif host_machine.cpu_family().startswith('ppc64') and host_machine.endian() == 'little'
984 985 986 987
    if system_has_kms_drm
      with_asm_arch = 'ppc64le'
      pre_args += ['-DUSE_PPC64LE_ASM']
    endif
988 989
  endif
endif
990 991 992 993 994 995 996 997

# Check for standard headers and functions
if cc.has_header_symbol('sys/sysmacros.h', 'major')
  pre_args += '-DMAJOR_IN_SYSMACROS'
elif cc.has_header_symbol('sys/mkdev.h', 'major')
  pre_args += '-DMAJOR_IN_MKDEV'
endif

998
foreach h : ['xlocale.h', 'sys/sysctl.h', 'linux/futex.h', 'endian.h', 'dlfcn.h']
999
  if cc.compiles('#include <@0@>'.format(h), name : '@0@'.format(h))
1000 1001 1002 1003
    pre_args += '-DHAVE_@0@'.format(h.to_upper().underscorify())
  endif
endforeach

1004
foreach f : ['strtof', 'mkostemp', 'posix_memalign', 'timespec_get', 'memfd_create']
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
  if cc.has_function(f)
    pre_args += '-DHAVE_@0@'.format(f.to_upper())
  endif
endforeach

# strtod locale support
if cc.links('''
    #define _GNU_SOURCE
    #include <stdlib.h>
    #include <locale.h>
    #ifdef HAVE_XLOCALE_H
    #include <xlocale.h>
    #endif
    int main() {
      locale_t loc = newlocale(LC_CTYPE_MASK, "C", NULL);
      const char *s = "1.0";
      char *end;
      double d = strtod_l(s, end, loc);
1023
      float f = strtof_l(s, end, loc);
1024 1025 1026
      freelocale(loc);
      return 0;
    }''',
1027
    args : pre_args,
1028 1029 1030 1031 1032 1033
    name : 'strtod has locale support')
  pre_args += '-DHAVE_STRTOD_L'
endif

# Check for some linker flags
ld_args_bsymbolic = []
1034
if cc.links('int main() { return 0; }', args : '-Wl,-Bsymbolic', name : 'Bsymbolic')
1035 1036 1037 1038
  ld_args_bsymbolic += '-Wl,-Bsymbolic'
endif
ld_args_gc_sections = []
if cc.links('static char unused() { return 5; } int main() { return 0; }',
1039
            args : '-Wl,--gc-sections', name : 'gc-sections')
1040 1041
  ld_args_gc_sections += '-Wl,--gc-sections'
endif
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
with_ld_version_script = false
if cc.links('int main() { return 0; }',
            args : '-Wl,--version-script=@0@'.format(
              join_paths(meson.source_root(), 'build-support/conftest.map')),
            name : 'version-script')
  with_ld_version_script = true
endif
with_ld_dynamic_list = false
if cc.links('int main() { return 0; }',
            args : '-Wl,--dynamic-list=@0@'.format(
              join_paths(meson.source_root(), 'build-support/conftest.dyn')),
            name : 'dynamic-list')
  with_ld_dynamic_list = true
endif
1056 1057 1058 1059
ld_args_build_id = []
if build_machine.system() != 'darwin'
   ld_args_build_id += '-Wl,--build-id=sha1'
endif
1060 1061 1062

# check for dl support
if cc.has_function('dlopen')
1063
  dep_dl = null_dep
1064 1065 1066
else
  dep_dl = cc.find_library('dl')
endif
1067 1068 1069
if cc.has_function('dladdr', dependencies : dep_dl)
  # This is really only required for megadrivers
  pre_args += '-DHAVE_DLADDR'
1070 1071 1072 1073
endif

if cc.has_function('dl_iterate_phdr')
  pre_args += '-DHAVE_DL_ITERATE_PHDR'
1074 1075 1076 1077
elif with_intel_vk
  error('Intel "Anvil" Vulkan driver requires the dl_iterate_phdr function')
elif with_dri_i965 and get_option('shader-cache')
  error('Intel i965 GL driver requires dl_iterate_phdr when built with shader caching.')
1078 1079 1080 1081
endif

# Determine whether or not the rt library is needed for time functions
if cc.has_function('clock_gettime')
1082
  dep_clock = null_dep
1083 1084 1085 1086 1087 1088
else
  dep_clock = cc.find_library('rt')
endif

# TODO: some of these may be conditional
dep_zlib = dependency('zlib', version : '>= 1.2.3')
1089
pre_args += '-DHAVE_ZLIB'
1090
dep_thread = dependency('threads')
1091
if dep_thread.found() and host_machine.system() != 'windows'
1092
  pre_args += '-DHAVE_PTHREAD'
1093 1094 1095 1096 1097 1098 1099
  if cc.has_function(
      'pthread_setaffinity_np',
      dependencies : dep_thread,
      prefix : '#include <pthread.h>',
      args : '-D_GNU_SOURCE')
    pre_args += '-DHAVE_PTHREAD_SETAFFINITY'
  endif
1100
endif
1101 1102 1103 1104
dep_expat = dependency('expat')
# this only exists on linux so either this is linux and it will be found, or
# its not linux and and wont
dep_m = cc.find_library('m', required : false)
Dylan Baker's avatar
Dylan Baker committed
1105

1106 1107 1108 1109
# Check for libdrm. various drivers have different libdrm version requirements,
# but we always want to use the same version for all libdrm modules. That means
# even if driver foo requires 2.4.0 and driver bar requires 2.4.3, if foo and
# bar are both on use 2.4.3 for both of them
1110 1111 1112 1113 1114
dep_libdrm_amdgpu = null_dep
dep_libdrm_radeon = null_dep
dep_libdrm_nouveau = null_dep
dep_libdrm_etnaviv = null_dep
dep_libdrm_intel = null_dep
1115

1116
_drm_amdgpu_ver = '2.4.97'
1117 1118
_drm_radeon_ver = '2.4.71'
_drm_nouveau_ver = '2.4.66'
1119
_drm_etnaviv_ver = '2.4.89'
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
_drm_intel_ver = '2.4.75'
_drm_ver = '2.4.75'

_libdrm_checks = [
  ['intel', with_dri_i915 or with_gallium_i915],
  ['amdgpu', with_amd_vk or with_gallium_radeonsi],
  ['radeon', (with_gallium_radeonsi or with_dri_r100 or with_dri_r200 or
              with_gallium_r300 or with_gallium_r600)],
  ['nouveau', (with_gallium_nouveau or with_dri_nouveau)],
  ['etnaviv', with_gallium_etnaviv],
]

1132 1133 1134 1135 1136 1137
# VC4 only needs core libdrm support of this version, not a libdrm_vc4
# library.
if with_gallium_vc4
  _drm_ver = '2.4.89'
endif

1138 1139
# Loop over the enables versions and get the highest libdrm requirement for all
# active drivers.
1140
_drm_blame = ''
1141 1142 1143 1144
foreach d : _libdrm_checks
  ver = get_variable('_drm_@0@_ver'.format(d[0]))
  if d[1] and ver.version_compare('>' + _drm_ver)
    _drm_ver = ver
1145
    _drm_blame = d[0]
1146 1147
  endif
endforeach
1148 1149 1150
if _drm_blame != ''
  message('libdrm @0@ needed because @1@ has the highest requirement'.format(_drm_ver, _drm_blame))
endif
1151 1152 1153 1154 1155 1156

# Then get each libdrm module
foreach d : _libdrm_checks
  if d[1]
    set_variable(
      'dep_libdrm_' + d[0],
1157
      dependency('libdrm_' + d[0], version : '>=' + _drm_ver)
1158 1159 1160
    )
  endif
endforeach
1161

1162
with_gallium_drisw_kms = false
1163 1164
dep_libdrm = dependency(
  'libdrm', version : '>=' + _drm_ver,
1165
  required : with_dri2 or with_dri3
1166
)
1167 1168 1169 1170 1171 1172 1173
if dep_libdrm.found()
  pre_args += '-DHAVE_LIBDRM'
  if with_dri_platform == 'drm' and with_dri
    with_gallium_drisw_kms = true
  endif
endif

1174
llvm_modules = ['bitwriter', 'engine', 'mcdisassembler', 'mcjit']
1175
llvm_optional_modules = []
Dylan Baker's avatar
Dylan Baker committed
1176
if with_amd_vk or with_gallium_radeonsi or with_gallium_r600
1177
  llvm_modules += ['amdgpu', 'native', 'bitreader', 'ipo']
Dylan Baker's avatar
Dylan Baker committed
1178 1179 1180
  if with_gallium_r600
    llvm_modules += 'asmparser'
  endif
1181
endif
Dylan Baker's avatar
Dylan Baker committed
1182 1183 1184 1185 1186
if with_gallium_opencl
  llvm_modules += [
    'all-targets', 'linker', 'coverage', 'instrumentation', 'ipo', 'irreader',
    'lto', 'option', 'objcarcopts', 'profiledata',
  ]
1187
  llvm_optional_modules += ['coroutines']
Dylan Baker's avatar
Dylan Baker committed
1188
endif
1189

1190
if with_amd_vk or with_gallium_radeonsi
1191
  _llvm_version = '>= 7.0.0'
1192
elif with_gallium_swr
1193
  _llvm_version = '>= 6.0.0'
1194
elif with_gallium_opencl or with_gallium_r600
1195 1196 1197 1198 1199
  _llvm_version = '>= 3.9.0'
else
  _llvm_version = '>= 3.3.0'
endif

1200 1201
_shared_llvm = get_option('shared-llvm')

1202
_llvm = get_option('llvm')
1203 1204 1205
dep_llvm = null_dep
with_llvm = false
if _llvm != 'false'
1206 1207 1208 1209 1210
  dep_llvm = dependency(
    'llvm',
    version : _llvm_version,
    modules : llvm_modules,
    optional_modules : llvm_optional_modules,
1211 1212 1213 1214
    required : (
      with_amd_vk or with_gallium_radeonsi or with_gallium_swr or
      with_gallium_opencl or _llvm == 'true'
    ),
1215
    static : not _shared_llvm,
1216
  )
1217
  with_llvm = dep_llvm.found()
1218 1219 1220
endif
if with_llvm
  _llvm_version = dep_llvm.version().split('.')
1221 1222 1223 1224 1225 1226 1227 1228

  # 3 digits versions in LLVM only started from 3.4.1 on
  if dep_llvm.version().version_compare('>= 3.4.1')
    _llvm_patch = _llvm_version[2]
  else
    _llvm_patch = '0'
  endif

1229
  pre_args += [
1230
    '-DHAVE_LLVM=0x0@0@0@1@'.format(_llvm_version[0], _llvm_version[1]),
1231 1232
    '-DMESA_LLVM_VERSION_PATCH=@0@'.format(_llvm_patch),
  ]
1233 1234 1235 1236 1237

  # LLVM can be built without rtti, turning off rtti changes the ABI of C++
  # programs, so we need to build all C++ code in mesa without rtti as well to
  # ensure that linking works.
  if dep_llvm.get_configtool_variable('has-rtti') == 'NO'
1238 1239 1240
    if with_gallium_nouveau
      error('The Nouveau driver requires rtti. You either need to turn off nouveau or use an LLVM built with LLVM_ENABLE_RTTI.')
    endif
1241
    cpp_args += '-fno-rtti'
1242
  endif
Dylan Baker's avatar
Dylan Baker committed
1243
elif with_amd_vk or with_gallium_radeonsi or with_gallium_swr
1244
  error('The following drivers require LLVM: Radv, RadeonSI, SWR. One of these is enabled, but LLVM is disabled.')
1245
endif
1246

1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
if (with_amd_vk or with_gallium_radeonsi or with_gallium_opencl or
    (with_gallium_r600 and with_llvm))
  dep_elf = dependency('libelf', required : false)
  if not dep_elf.found()
    dep_elf = cc.find_library('elf')
  endif
else
  dep_elf = null_dep
endif

1257
dep_glvnd = null_dep
Dylan Baker's avatar
Dylan Baker committed
1258 1259 1260 1261 1262
if with_glvnd
  dep_glvnd = dependency('libglvnd', version : '>= 0.2.0')
  pre_args += '-DUSE_LIBGLVND=1'
endif

1263 1264 1265 1266 1267 1268
if with_valgrind != 'false'
  dep_valgrind = dependency('valgrind', required : with_valgrind == 'true')
  if dep_valgrind.found()
    pre_args += '-DHAVE_VALGRIND'
  endif
else
1269
  dep_valgrind = null_dep
1270 1271 1272 1273
endif

# pthread stubs. Lets not and say we didn't

1274 1275 1276
prog_bison = find_program('bison', required : with_any_opengl)
prog_flex = find_program('flex', required : with_any_opengl)

1277
dep_selinux = null_dep
Eric Engestrom's avatar
Eric Engestrom committed
1278 1279 1280 1281
if get_option('selinux')
  dep_selinux = dependency('libselinux')
  pre_args += '-DMESA_SELINUX'
endif
1282

1283 1284 1285 1286 1287 1288
if with_libunwind != 'false'
  dep_unwind = dependency('libunwind', required : with_libunwind == 'true')
  if dep_unwind.found()
    pre_args += '-DHAVE_LIBUNWIND'
  endif
else
1289
  dep_unwind = null_dep
1290
endif
1291

1292 1293 1294 1295
if with_osmesa != 'none'
  if with_osmesa == 'classic' and not with_dri_swrast
    error('OSMesa classic requires dri (classic) swrast.')
  endif
1296 1297 1298
  if with_osmesa == 'gallium' and not with_gallium_softpipe
    error('OSMesa gallium requires gallium softpipe or llvmpipe.')
  endif
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
  osmesa_lib_name = 'OSMesa'
  osmesa_bits = get_option('osmesa-bits')
  if osmesa_bits != '8'
    if with_dri or with_glx != 'disabled'
      error('OSMesa bits must be 8 if building glx or dir based drivers')
    endif
    osmesa_lib_name = osmesa_lib_name + osmesa_bits
    pre_args += [
      '-DCHAN_BITS=@0@'.format(osmesa_bits), '-DDEFAULT_SOFTWARE_DEPTH_BITS=31'
    ]
  endif
endif
1311 1312 1313 1314

# TODO: symbol mangling

if with_platform_wayland
1315 1316
  dep_wl_scanner = dependency('wayland-scanner', native: true)
  prog_wl_scanner = find_program(dep_wl_scanner.get_pkgconfig_variable('wayland_scanner'))
1317 1318 1319 1320 1321
  if dep_wl_scanner.version().version_compare('>= 1.15')
    wl_scanner_arg = 'private-code'
  else
    wl_scanner_arg = 'code'
  endif
1322 1323 1324
  dep_wl_protocols = dependency('wayland-protocols', version : '>= 1.8')
  dep_wayland_client = dependency('wayland-client', version : '>=1.11')
  dep_wayland_server = dependency('wayland-server', version : '>=1.11')
1325
  if with_egl
1326 1327 1328
    dep_wayland_egl = dependency('wayland-egl-backend', version : '>= 3')
    dep_wayland_egl_headers = declare_dependency(
      compile_args : run_command(prog_pkgconfig, ['wayland-egl-backend', '--cflags']).stdout().split())
1329
  endif
Dylan Baker's avatar
Dylan Baker committed
1330 1331 1332 1333 1334
  wayland_dmabuf_xml = join_paths(
    dep_wl_protocols.get_pkgconfig_variable('pkgdatadir'), 'unstable',
    'linux-dmabuf', 'linux-dmabuf-unstable-v1.xml'
  )
  pre_args += ['-DHAVE_WAYLAND_PLATFORM', '-DWL_HIDE_DEPRECATED']
1335 1336
endif

1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
dep_x11 = null_dep
dep_xext = null_dep
dep_xdamage = null_dep
dep_xfixes = null_dep
dep_x11_xcb = null_dep
dep_xcb = null_dep
dep_xcb_glx = null_dep
dep_xcb_dri2 = null_dep
dep_xcb_dri3 = null_dep
dep_dri2proto = null_dep
dep_glproto = null_dep
dep_xxf86vm = null_dep
dep_xcb_dri3 = null_dep
dep_xcb_present = null_dep
dep_xcb_sync = null_dep
dep_xcb_xfixes = null_dep
dep_xshmfence = null_dep
1354
dep_xcb_xrandr = null_dep
1355
dep_xlib_xrandr = null_dep
1356
if with_platform_x11
1357
  if with_glx == 'xlib' or with_glx == 'gallium-xlib'
1358 1359 1360
    dep_x11 = dependency('x11')
    dep_xext = dependency('xext')
    dep_xcb = dependency('xcb')
1361
  elif with_glx == 'dri'
1362 1363 1364 1365 1366
    dep_x11 = dependency('x11')
    dep_xext = dependency('xext')
    dep_xdamage = dependency('xdamage', version : '>= 1.1')
    dep_xfixes = dependency('xfixes')
    dep_xcb_glx = dependency('xcb-glx', version : '>= 1.8.1')
Dylan Baker's avatar
Dylan Baker committed
1367
  endif
1368
  if (with_any_vk or with_glx == 'dri' or with_egl or
1369 1370
       (with_gallium_vdpau or with_gallium_xvmc or with_gallium_va or
        with_gallium_omx != 'disabled'))
1371 1372
    dep_xcb = dependency('xcb')
    dep_x11_xcb = dependency('x11-xcb')
1373
  endif
1374
  if with_any_vk or with_egl or (with_glx == 'dri' and with_dri_platform == 'drm')
1375 1376
    dep_xcb_dri2 = dependency('xcb-dri2', version : '>= 1.8')

Dylan Baker's avatar
Dylan Baker committed
1377
    if with_dri3
1378 1379 1380 1381 1382 1383 1384 1385
      pre_args += '-DHAVE_DRI3'
      dep_xcb_dri3 = dependency('xcb-dri3')
      dep_xcb_present = dependency('xcb-present')
      # until xcb-dri3 has been around long enough to make a hard-dependency:
      if (dep_xcb_dri3.version().version_compare('>= 1.13') and
          dep_xcb_present.version().version_compare('>= 1.13'))
        pre_args += '-DHAVE_DRI3_MODIFIERS'
      endif
1386 1387
      dep_xcb_sync = dependency('xcb-sync')
      dep_xshmfence = dependency('xshmfence', version : '>= 1.1')
Dylan Baker's avatar
Dylan Baker committed
1388
    endif
1389
  endif
1390
  if with_glx == 'dri'
1391 1392
    if with_dri_platform == 'drm'
      dep_dri2proto = dependency('dri2proto', version : '>= 2.8')
1393
      dep_xxf86vm = dependency('xxf86vm')
1394
    endif
1395 1396
    dep_glproto = dependency('glproto', version : '>= 1.4.14')
  endif
1397 1398 1399
  if (with_egl or (
      with_gallium_vdpau or with_gallium_xvmc or with_gallium_xa or
      with_gallium_omx != 'disabled'))
Dylan Baker's avatar
Dylan Baker committed
1400 1401
    dep_xcb_xfixes = dependency('xcb-xfixes')
  endif
1402
  if with_xlib_lease
1403
    dep_xcb_xrandr = dependency('xcb-randr')
1404
    dep_xlib_xrandr = dependency('xrandr', version : '>= 1.3')
1405
  endif
1406 1407
endif

1408 1409 1410 1411
if get_option('gallium-extra-hud')
  pre_args += '-DHAVE_GALLIUM_EXTRA_HUD=1'
endif

1412 1413
_sensors = get_option('lmsensors')
if _sensors != 'false'
1414
  dep_lmsensors = cc.find_library('sensors', required : _sensors == 'true')
1415 1416 1417 1418
  if dep_lmsensors.found()
    pre_args += '-DHAVE_LIBSENSORS=1'
  endif
else
1419
  dep_lmsensors = null_dep
1420 1421
endif

1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
foreach a : pre_args
  add_project_arguments(a, language : ['c', 'cpp'])
endforeach
foreach a : c_args
  add_project_arguments(a, language : ['c'])
endforeach
foreach a : cpp_args
  add_project_arguments(a, language : ['cpp'])
endforeach

inc_include = include_directories('include')

1434 1435 1436 1437 1438 1439 1440 1441 1442 1443
gl_priv_reqs = []

if with_glx == 'xlib' or with_glx == 'gallium-xlib'
  gl_priv_reqs += ['x11', 'xext', 'xcb']
elif with_glx == 'dri'
  gl_priv_reqs += [
    'x11', 'xext', 'xdamage >= 1.1', 'xfixes', 'x11-xcb', 'xcb',
    'xcb-glx >= 1.8.1']
  if with_dri_platform == 'drm'
    gl_priv_reqs += 'xcb-dri2 >= 1.8'
1444
    gl_priv_reqs += 'xxf86vm'
1445 1446
  endif
endif
1447 1448 1449
if dep_libdrm.found()
  gl_priv_reqs += 'libdrm >= 2.4.75'
endif
Dylan Baker's avatar
Dylan Baker committed
1450 1451 1452 1453 1454 1455 1456 1457

gl_priv_libs = []
if dep_thread.found()
  gl_priv_libs += ['-lpthread', '-pthread']
endif
if dep_m.found()
  gl_priv_libs += '-lm'
endif
1458
if dep_dl.found()
Dylan Baker's avatar
Dylan Baker committed
1459 1460 1461
  gl_priv_libs += '-ldl'
endif

1462 1463
pkg = import('pkgconfig')

1464 1465 1466
env_test = environment()
env_test.set('NM', find_program('nm').path())

1467
subdir('include')
1468
subdir('bin')
1469
subdir('src')