OSDN Git Service

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