gallium.py 21.3 KB
Newer Older
1 2 3 4 5 6
"""gallium

Frontend-tool for Gallium3D architecture.

"""

7
#
8 9
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
# All Rights Reserved.
10
#
11 12 13 14 15 16 17
# 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, sub license, 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:
18
#
19 20 21
# The above copyright notice and this permission notice (including the
# next paragraph) shall be included in all copies or substantial portions
# of the Software.
22
#
23 24 25 26 27 28 29
# 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 NON-INFRINGEMENT.
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
30
#
31 32


33
import distutils.version
34
import os
35
import os.path
36
import re
37
import subprocess
38
import platform as _platform
39 40 41

import SCons.Action
import SCons.Builder
42
import SCons.Scanner
43

44

45 46 47 48 49 50 51
def symlink(target, source, env):
    target = str(target[0])
    source = str(source[0])
    if os.path.islink(target) or os.path.exists(target):
        os.remove(target)
    os.symlink(os.path.basename(source), target)

52
def install(env, source, subdir):
53
    target_dir = os.path.join(env.Dir('#.').srcnode().abspath, env['build_dir'], subdir)
54
    return env.Install(target_dir, source)
55

56
def install_program(env, source):
57
    return install(env, source, 'bin')
58

59
def install_shared_library(env, sources, version = ()):
60
    targets = []
61
    install_dir = os.path.join(env.Dir('#.').srcnode().abspath, env['build_dir'])
62
    version = tuple(map(str, version))
63 64
    if env['SHLIBSUFFIX'] == '.dll':
        dlls = env.FindIxes(sources, 'SHLIBPREFIX', 'SHLIBSUFFIX')
65
        targets += install(env, dlls, 'bin')
66
        libs = env.FindIxes(sources, 'LIBPREFIX', 'LIBSUFFIX')
67
        targets += install(env, libs, 'lib')
68
    else:
69 70 71 72
        for source in sources:
            target_dir =  os.path.join(install_dir, 'lib')
            target_name = '.'.join((str(source),) + version)
            last = env.InstallAs(os.path.join(target_dir, target_name), source)
73
            targets += last
74 75 76 77 78
            while len(version):
                version = version[:-1]
                target_name = '.'.join((str(source),) + version)
                action = SCons.Action.Action(symlink, "$TARGET -> $SOURCE")
                last = env.Command(os.path.join(target_dir, target_name), last, action) 
79 80 81
                targets += last
    return targets

82 83

def createInstallMethods(env):
84
    env.AddMethod(install_program, 'InstallProgram')
85 86 87
    env.AddMethod(install_shared_library, 'InstallSharedLibrary')


88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
def num_jobs():
    try:
        return int(os.environ['NUMBER_OF_PROCESSORS'])
    except (ValueError, KeyError):
        pass

    try:
        return os.sysconf('SC_NPROCESSORS_ONLN')
    except (ValueError, OSError, AttributeError):
        pass

    try:
        return int(os.popen2("sysctl -n hw.ncpu")[1].read())
    except ValueError:
        pass

    return 1


107 108 109 110 111 112 113 114 115 116 117
def pkg_config_modules(env, name, modules):
    '''Simple wrapper for pkg-config.'''

    env[name] = False

    if env['platform'] == 'windows':
        return

    if not env.Detect('pkg-config'):
        return

118 119 120
    if subprocess.call(["pkg-config", "--exists", ' '.join(modules)]) != 0:
        return

121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
    # Put -I and -L flags directly into the environment, as these don't affect
    # the compilation of targets that do not use them
    try:
        env.ParseConfig('pkg-config --cflags-only-I --libs-only-L ' + ' '.join(modules))
    except OSError:
        return

    # Other flags may affect the compilation of unrelated targets, so store
    # them with a prefix, (e.g., XXX_CFLAGS, XXX_LIBS, etc)
    try:
        flags = env.ParseFlags('!pkg-config --cflags-only-other --libs-only-l --libs-only-other ' + ' '.join(modules))
    except OSError:
        return
    prefix = name.upper() + '_'
    for flag_name, flag_value in flags.iteritems():
        env[prefix + flag_name] = flag_value

    env[name] = True



142
def generate(env):
143 144
    """Common environment generation code"""

Jose Fonseca's avatar
Jose Fonseca committed
145 146 147 148
    # Tell tools which machine to compile for
    env['TARGET_ARCH'] = env['machine']
    env['MSVS_ARCH'] = env['machine']

149 150 151 152
    # Toolchain
    platform = env['platform']
    if env['toolchain'] == 'default':
        if platform == 'winddk':
153
            env['toolchain'] = 'winddk'
154
        elif platform == 'wince':
155
            env['toolchain'] = 'wcesdk'
156 157
    env.Tool(env['toolchain'])

158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
    # Allow override compiler and specify additional flags from environment
    if os.environ.has_key('CC'):
        env['CC'] = os.environ['CC']
        # Update CCVERSION to match
        pipe = SCons.Action._subproc(env, [env['CC'], '--version'],
                                     stdin = 'devnull',
                                     stderr = 'devnull',
                                     stdout = subprocess.PIPE)
        if pipe.wait() == 0:
            line = pipe.stdout.readline()
            match = re.search(r'[0-9]+(\.[0-9]+)+', line)
            if match:
                env['CCVERSION'] = match.group(0)
    if os.environ.has_key('CFLAGS'):
        env['CCFLAGS'] += SCons.Util.CLVar(os.environ['CFLAGS'])
    if os.environ.has_key('CXX'):
        env['CXX'] = os.environ['CXX']
    if os.environ.has_key('CXXFLAGS'):
        env['CXXFLAGS'] += SCons.Util.CLVar(os.environ['CXXFLAGS'])
    if os.environ.has_key('LDFLAGS'):
        env['LINKFLAGS'] += SCons.Util.CLVar(os.environ['LDFLAGS'])
179

180 181 182
    env['gcc'] = 'gcc' in os.path.basename(env['CC']).split('-')
    env['msvc'] = env['CC'] == 'cl'

Jose Fonseca's avatar
Jose Fonseca committed
183 184 185 186
    if env['msvc'] and env['toolchain'] == 'default' and env['machine'] == 'x86_64':
        # MSVC x64 support is broken in earlier versions of scons
        env.EnsurePythonVersion(2, 0)

187 188 189 190
    # shortcuts
    machine = env['machine']
    platform = env['platform']
    x86 = env['machine'] == 'x86'
Michel Dänzer's avatar
Michel Dänzer committed
191
    ppc = env['machine'] == 'ppc'
192 193
    gcc = env['gcc']
    msvc = env['msvc']
194

195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
    # Determine whether we are cross compiling; in particular, whether we need
    # to compile code generators with a different compiler as the target code.
    host_platform = _platform.system().lower()
    host_machine = os.environ.get('PROCESSOR_ARCHITECTURE', _platform.machine())
    host_machine = {
        'x86': 'x86',
        'i386': 'x86',
        'i486': 'x86',
        'i586': 'x86',
        'i686': 'x86',
        'ppc' : 'ppc',
        'x86_64': 'x86_64',
    }.get(host_machine, 'generic')
    env['crosscompile'] = platform != host_platform
    if machine == 'x86_64' and host_machine != 'x86_64':
        env['crosscompile'] = True
211
    env['hostonly'] = False
212

213 214 215
    # Backwards compatability with the debug= profile= options
    if env['build'] == 'debug':
        if not env['debug']:
216 217 218 219
            print 'scons: warning: debug option is deprecated and will be removed eventually; use instead'
            print
            print ' scons build=release'
            print
220 221
            env['build'] = 'release'
        if env['profile']:
222 223 224 225
            print 'scons: warning: profile option is deprecated and will be removed eventually; use instead'
            print
            print ' scons build=profile'
            print
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
            env['build'] = 'profile'
    if False:
        # Enforce SConscripts to use the new build variable
        env.popitem('debug')
        env.popitem('profile')
    else:
        # Backwards portability with older sconscripts
        if env['build'] in ('debug', 'checked'):
            env['debug'] = True
            env['profile'] = False
        if env['build'] == 'profile':
            env['debug'] = False
            env['profile'] = True
        if env['build'] == 'release':
            env['debug'] = False
            env['profile'] = False

243 244 245 246 247 248
    # Put build output in a separate dir, which depends on the current
    # configuration. See also http://www.scons.org/wiki/AdvancedBuildExample
    build_topdir = 'build'
    build_subdir = env['platform']
    if env['machine'] != 'generic':
        build_subdir += '-' + env['machine']
249 250
    if env['build'] != 'release':
        build_subdir += '-' +  env['build']
251 252 253
    build_dir = os.path.join(build_topdir, build_subdir)
    # Place the .sconsign file in the build dir too, to avoid issues with
    # different scons versions building the same source file
254
    env['build_dir'] = build_dir
255
    env.SConsignFile(os.path.join(build_dir, '.sconsign'))
256 257 258
    if 'SCONS_CACHE_DIR' in os.environ:
        print 'scons: Using build cache in %s.' % (os.environ['SCONS_CACHE_DIR'],)
        env.CacheDir(os.environ['SCONS_CACHE_DIR'])
259 260
    env['CONFIGUREDIR'] = os.path.join(build_dir, 'conf')
    env['CONFIGURELOG'] = os.path.join(os.path.abspath(build_dir), 'config.log')
261

262 263 264 265
    # Parallel build
    if env.GetOption('num_jobs') <= 1:
        env.SetOption('num_jobs', num_jobs())

266 267 268
    env.Decider('MD5-timestamp')
    env.SetOption('max_drift', 60)

269 270
    # C preprocessor options
    cppdefines = []
271
    if env['build'] in ('debug', 'checked'):
272 273 274
        cppdefines += ['DEBUG']
    else:
        cppdefines += ['NDEBUG']
275
    if env['build'] == 'profile':
276 277 278 279 280
        cppdefines += ['PROFILE']
    if platform == 'windows':
        cppdefines += [
            'WIN32',
            '_WINDOWS',
281 282
            #'_UNICODE',
            #'UNICODE',
Jose Fonseca's avatar
Jose Fonseca committed
283 284 285
            # http://msdn.microsoft.com/en-us/library/aa383745.aspx
            ('_WIN32_WINNT', '0x0601'),
            ('WINVER', '0x0601'),
286
        ]
287
        if msvc and env['toolchain'] != 'winddk':
288 289
            cppdefines += [
                'VC_EXTRALEAN',
290
                '_USE_MATH_DEFINES',
291
                '_CRT_SECURE_NO_WARNINGS',
292
                '_CRT_SECURE_NO_DEPRECATE',
293 294
                '_SCL_SECURE_NO_WARNINGS',
                '_SCL_SECURE_NO_DEPRECATE',
295
            ]
296
        if env['build'] in ('debug', 'checked'):
297
            cppdefines += ['_DEBUG']
298
    if env['toolchain'] == 'winddk':
299 300 301 302
        # Mimic WINDDK's builtin flags. See also:
        # - WINDDK's bin/makefile.new i386mk.inc for more info.
        # - buildchk_wxp_x86.log files, generated by the WINDDK's build
        # - http://alter.org.ua/docs/nt_kernel/vc8_proj/
303 304 305 306 307
        if machine == 'x86':
            cppdefines += ['_X86_', 'i386']
        if machine == 'x86_64':
            cppdefines += ['_AMD64_', 'AMD64']
    if platform == 'winddk':
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
        cppdefines += [
            'STD_CALL',
            ('CONDITION_HANDLING', '1'),
            ('NT_INST', '0'),
            ('WIN32', '100'),
            ('_NT1X_', '100'),
            ('WINNT', '1'),
            ('_WIN32_WINNT', '0x0501'), # minimum required OS version
            ('WINVER', '0x0501'),
            ('_WIN32_IE', '0x0603'),
            ('WIN32_LEAN_AND_MEAN', '1'),
            ('DEVL', '1'),
            ('__BUILDMACHINE__', 'WinDDK'),
            ('FPO', '0'),
        ]
323
        if env['build'] in ('debug', 'checked'):
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
            cppdefines += [('DBG', 1)]
    if platform == 'wince':
        cppdefines += [
            '_CRT_SECURE_NO_DEPRECATE',
            '_USE_32BIT_TIME_T',
            'UNICODE',
            '_UNICODE',
            ('UNDER_CE', '600'),
            ('_WIN32_WCE', '0x600'),
            'WINCEOEM',
            'WINCEINTERNAL',
            'WIN32',
            'STRICT',
            'x86',
            '_X86_',
            'INTERNATIONAL',
            ('INTLMSG_CODEPAGE', '1252'),
        ]
    if platform == 'windows':
        cppdefines += ['PIPE_SUBSYSTEM_WINDOWS_USER']
    if platform == 'winddk':
        cppdefines += ['PIPE_SUBSYSTEM_WINDOWS_DISPLAY']
    if platform == 'wince':
        cppdefines += ['PIPE_SUBSYSTEM_WINDOWS_CE']
348
        cppdefines += ['PIPE_SUBSYSTEM_WINDOWS_CE_OGL']
349
    if platform == 'embedded':
350
        cppdefines += ['PIPE_OS_EMBEDDED']
351 352 353
    env.Append(CPPDEFINES = cppdefines)

    # C compiler options
354 355 356
    cflags = [] # C
    cxxflags = [] # C++
    ccflags = [] # C & C++
357
    if gcc:
358
        ccversion = env['CCVERSION']
359 360
        if env['build'] == 'debug':
            ccflags += ['-O0']
361
        elif ccversion.startswith('4.2.'):
362 363
            # gcc 4.2.x optimizer is broken
            print "warning: gcc 4.2.x optimizer is broken -- disabling optimizations"
364
            ccflags += ['-O0']
365
        else:
366 367 368
            ccflags += ['-O3']
        ccflags += ['-g3']
        if env['build'] in ('checked', 'profile'):
369 370 371 372 373
            # See http://code.google.com/p/jrfonseca/wiki/Gprof2Dot#Which_options_should_I_pass_to_gcc_when_compiling_for_profiling?
            ccflags += [
                '-fno-omit-frame-pointer',
                '-fno-optimize-sibling-calls',
            ]
374
        if env['machine'] == 'x86':
375
            ccflags += [
376 377 378
                '-m32',
                #'-march=pentium4',
            ]
379 380
            if distutils.version.LooseVersion(ccversion) >= distutils.version.LooseVersion('4.2') \
               and (platform != 'windows' or env['build'] == 'debug' or True):
381 382 383 384 385
                # NOTE: We need to ensure stack is realigned given that we
                # produce shared objects, and have no control over the stack
                # alignment policy of the application. Therefore we need
                # -mstackrealign ore -mincoming-stack-boundary=2.
                #
386 387
                # XXX: -O and -mstackrealign causes stack corruption on MinGW
                #
388 389 390
                # XXX: We could have SSE without -mstackrealign if we always used
                # __attribute__((force_align_arg_pointer)), but that's not
                # always the case.
391
                ccflags += [
392
                    '-mstackrealign', # ensure stack is aligned
393
                    '-mmmx', '-msse', '-msse2', # enable SIMD intrinsics
394
                    #'-mfpmath=sse',
395
                ]
396
            if platform in ['windows', 'darwin']:
397 398
                # Workaround http://gcc.gnu.org/bugzilla/show_bug.cgi?id=37216
                ccflags += ['-fno-common']
399
        if env['machine'] == 'x86_64':
400
            ccflags += ['-m64']
401 402
            if platform == 'darwin':
                ccflags += ['-fno-common']
403 404
        # See also:
        # - http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
405
        ccflags += [
406 407 408 409 410
            '-Wall',
            '-Wno-long-long',
            '-ffast-math',
            '-fmessage-length=0', # be nice to Eclipse
        ]
411 412 413 414
        cflags += [
            '-Wmissing-prototypes',
            '-std=gnu99',
        ]
415 416 417 418
        if distutils.version.LooseVersion(ccversion) >= distutils.version.LooseVersion('4.0'):
            ccflags += [
                '-Wmissing-field-initializers',
            ]
419
        if distutils.version.LooseVersion(ccversion) >= distutils.version.LooseVersion('4.2'):
420 421 422 423 424 425
            ccflags += [
                '-Werror=pointer-arith',
            ]
            cflags += [
                '-Werror=declaration-after-statement',
            ]
426 427
    if msvc:
        # See also:
428
        # - http://msdn.microsoft.com/en-us/library/19z1t1wy.aspx
429
        # - cl /?
430
        if env['build'] == 'debug':
431
            ccflags += [
432 433 434 435 436
              '/Od', # disable optimizations
              '/Oi', # enable intrinsic functions
              '/Oy-', # disable frame pointer omission
            ]
        else:
437
            ccflags += [
438
                '/O2', # optimize for speed
439 440 441
            ]
        if env['build'] == 'release':
            ccflags += [
442
                '/GL', # enable whole program optimization
443
            ]
444 445 446 447
        else:
            ccflags += [
                '/GL-', # disable whole program optimization
            ]
448
        ccflags += [
449
            '/fp:fast', # fast floating point 
450 451 452
            '/W3', # warning level
            #'/Wp64', # enable 64 bit porting warnings
        ]
453
        if env['machine'] == 'x86':
454
            ccflags += [
455 456
                #'/arch:SSE2', # use the SSE2 instructions
            ]
457
        if platform == 'windows':
458
            ccflags += [
459 460 461
                # TODO
            ]
        if platform == 'winddk':
462
            ccflags += [
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
                '/Zl', # omit default library name in .OBJ
                '/Zp8', # 8bytes struct member alignment
                '/Gy', # separate functions for linker
                '/Gm-', # disable minimal rebuild
                '/WX', # treat warnings as errors
                '/Gz', # __stdcall Calling convention
                '/GX-', # disable C++ EH
                '/GR-', # disable C++ RTTI
                '/GF', # enable read-only string pooling
                '/G6', # optimize for PPro, P-II, P-III
                '/Ze', # enable extensions
                '/Gi-', # disable incremental compilation
                '/QIfdiv-', # disable Pentium FDIV fix
                '/hotpatch', # prepares an image for hotpatching.
                #'/Z7', #enable old-style debug info
            ]
        if platform == 'wince':
            # See also C:\WINCE600\public\common\oak\misc\makefile.def
481
            ccflags += [
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
                '/Zl', # omit default library name in .OBJ
                '/GF', # enable read-only string pooling
                '/GR-', # disable C++ RTTI
                '/GS', # enable security checks
                # Allow disabling language conformance to maintain backward compat
                #'/Zc:wchar_t-', # don't force wchar_t as native type, instead of typedef
                #'/Zc:forScope-', # don't enforce Standard C++ for scoping rules
                #'/wd4867',
                #'/wd4430',
                #'/MT',
                #'/U_MT',
            ]
        # Automatic pdb generation
        # See http://scons.tigris.org/issues/show_bug.cgi?id=1656
        env.EnsureSConsVersion(0, 98, 0)
        env['PDB'] = '${TARGET.base}.pdb'
498
    env.Append(CCFLAGS = ccflags)
499
    env.Append(CFLAGS = cflags)
500
    env.Append(CXXFLAGS = cxxflags)
501

502 503 504
    if env['platform'] == 'windows' and msvc:
        # Choose the appropriate MSVC CRT
        # http://msdn.microsoft.com/en-us/library/2kzt1wy3.aspx
505
        if env['build'] in ('debug', 'checked'):
506 507 508 509 510 511
            env.Append(CCFLAGS = ['/MTd'])
            env.Append(SHCCFLAGS = ['/LDd'])
        else:
            env.Append(CCFLAGS = ['/MT'])
            env.Append(SHCCFLAGS = ['/LD'])
    
512 513 514 515 516 517 518 519 520
    # Assembler options
    if gcc:
        if env['machine'] == 'x86':
            env.Append(ASFLAGS = ['-m32'])
        if env['machine'] == 'x86_64':
            env.Append(ASFLAGS = ['-m64'])

    # Linker options
    linkflags = []
521
    shlinkflags = []
522 523 524 525 526
    if gcc:
        if env['machine'] == 'x86':
            linkflags += ['-m32']
        if env['machine'] == 'x86_64':
            linkflags += ['-m64']
527 528 529 530
        if env['platform'] not in ('darwin'):
            shlinkflags += [
                '-Wl,-Bsymbolic',
            ]
531
        # Handle circular dependencies in the libraries
532 533 534 535
        if env['platform'] in ('darwin'):
            pass
        else:
            env['_LIBFLAGS'] = '-Wl,--start-group ' + env['_LIBFLAGS'] + ' -Wl,--end-group'
536
    if msvc:
537
        if env['build'] == 'release':
538 539 540
            # enable Link-time Code Generation
            linkflags += ['/LTCG']
            env.Append(ARFLAGS = ['/LTCG'])
Jose Fonseca's avatar
Jose Fonseca committed
541
    if platform == 'windows' and msvc:
542 543
        # See also:
        # - http://msdn2.microsoft.com/en-us/library/y0zzbyt4.aspx
544 545 546 547 548
        linkflags += [
            '/fixed:no',
            '/incremental:no',
        ]
    if platform == 'winddk':
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
        linkflags += [
            '/merge:_PAGE=PAGE',
            '/merge:_TEXT=.text',
            '/section:INIT,d',
            '/opt:ref',
            '/opt:icf',
            '/ignore:4198,4010,4037,4039,4065,4070,4078,4087,4089,4221',
            '/incremental:no',
            '/fullbuild',
            '/release',
            '/nodefaultlib',
            '/wx',
            '/debug',
            '/debugtype:cv',
            '/version:5.1',
            '/osversion:5.1',
            '/functionpadmin:5',
            '/safeseh',
            '/pdbcompress',
            '/stack:0x40000,0x1000',
            '/driver',
            '/align:0x80',
            '/subsystem:native,5.01',
            '/base:0x10000',

            '/entry:DrvEnableDriver',
        ]
576
        if env['build'] != 'release':
577 578 579 580 581 582 583 584 585 586 587
            linkflags += [
                '/MAP', # http://msdn.microsoft.com/en-us/library/k7xkk3e2.aspx
            ]
    if platform == 'wince':
        linkflags += [
            '/nodefaultlib',
            #'/incremental:no',
            #'/fullbuild',
            '/entry:_DllMainCRTStartup',
        ]
    env.Append(LINKFLAGS = linkflags)
588
    env.Append(SHLINKFLAGS = shlinkflags)
589

590 591 592 593
    # We have C++ in several libraries, so always link with the C++ compiler
    if env['gcc']:
        env['LINK'] = env['CXX']

594 595 596
    # Default libs
    env.Append(LIBS = [])

597
    # Load tools
598 599
    if env['llvm']:
        env.Tool('llvm')
600 601 602
        env.Tool('udis86')
    
    pkg_config_modules(env, 'x11', ['x11', 'xext'])
603 604 605
    pkg_config_modules(env, 'drm', ['libdrm'])
    pkg_config_modules(env, 'drm_intel', ['libdrm_intel'])
    pkg_config_modules(env, 'drm_radeon', ['libdrm_radeon'])
606
    pkg_config_modules(env, 'xorg', ['xorg-server'])
607
    pkg_config_modules(env, 'kms', ['libkms'])
608

609 610
    env['dri'] = env['x11'] and env['drm']

611
    # Custom builders and methods
612
    env.Tool('custom')
613
    createInstallMethods(env)
614 615 616

    # for debugging
    #print env.Dump()
617 618 619


def exists(env):
620
    return 1