X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=scons%2Fgallium.py;h=46dbf0ebd0e58e71f131c72ba04ca522d7c3cc54;hb=641c25dd5505333ae4d260c6e821249c1be6da65;hp=9118257ac05211a42298dd6197fa9d5def60cbeb;hpb=b922a0ce12916a91cfc3e56714913fcf63279ff2;p=mesa.git diff --git a/scons/gallium.py b/scons/gallium.py index 9118257ac05..46dbf0ebd0e 100755 --- a/scons/gallium.py +++ b/scons/gallium.py @@ -5,7 +5,7 @@ Frontend-tool for Gallium3D architecture. """ # -# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. +# Copyright 2008 VMware, Inc. # All Rights Reserved. # # Permission is hereby granted, free of charge, to any person obtaining a @@ -23,7 +23,7 @@ Frontend-tool for Gallium3D architecture. # 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 +# IN NO EVENT SHALL VMWARE 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. @@ -35,7 +35,9 @@ import os import os.path import re import subprocess -import platform as _platform +import platform as host_platform +import sys +import tempfile import SCons.Action import SCons.Builder @@ -74,7 +76,7 @@ def install_shared_library(env, sources, version = ()): while len(version): version = version[:-1] target_name = '.'.join((str(source),) + version) - action = SCons.Action.Action(symlink, "$TARGET -> $SOURCE") + action = SCons.Action.Action(symlink, " Symlinking $TARGET ...") last = env.Command(os.path.join(target_dir, target_name), last, action) targets += last return targets @@ -85,6 +87,25 @@ def createInstallMethods(env): env.AddMethod(install_shared_library, 'InstallSharedLibrary') +def msvc2013_compat(env): + if env['gcc']: + env.Append(CCFLAGS = [ + '-Werror=vla', + '-Werror=pointer-arith', + ]) + +def msvc2008_compat(env): + msvc2013_compat(env) + if env['gcc']: + env.Append(CFLAGS = [ + '-Werror=declaration-after-statement', + ]) + +def createMSVCCompatMethods(env): + env.AddMethod(msvc2013_compat, 'MSVC2013Compat') + env.AddMethod(msvc2008_compat, 'MSVC2008Compat') + + def num_jobs(): try: return int(os.environ['NUMBER_OF_PROCESSORS']) @@ -104,39 +125,37 @@ def num_jobs(): return 1 -def pkg_config_modules(env, name, modules): - '''Simple wrapper for pkg-config.''' +def check_cc(env, cc, expr, cpp_opt = '-E'): + # Invoke C-preprocessor to determine whether the specified expression is + # true or not. - env[name] = False + sys.stdout.write('Checking for %s ... ' % cc) - if env['platform'] == 'windows': - return + source = tempfile.NamedTemporaryFile(suffix='.c', delete=False) + source.write('#if !(%s)\n#error\n#endif\n' % expr) + source.close() - if not env.Detect('pkg-config'): - return + pipe = SCons.Action._subproc(env, [env['CC'], cpp_opt, source.name], + stdin = 'devnull', + stderr = 'devnull', + stdout = 'devnull') + result = pipe.wait() == 0 - if subprocess.call(["pkg-config", "--exists", ' '.join(modules)]) != 0: - return + os.unlink(source.name) - # 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 + sys.stdout.write(' %s\n' % ['no', 'yes'][int(bool(result))]) + return result - # 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 +def check_prog(env, prog): + """Check whether this program exists.""" + + sys.stdout.write('Checking for %s ... ' % prog) + result = env.Detect(prog) + + sys.stdout.write(' %s\n' % ['no', 'yes'][int(bool(result))]) + return result def generate(env): @@ -148,11 +167,6 @@ def generate(env): # Toolchain platform = env['platform'] - if env['toolchain'] == 'default': - if platform == 'winddk': - env['toolchain'] = 'winddk' - elif platform == 'wince': - env['toolchain'] = 'wcesdk' env.Tool(env['toolchain']) # Allow override compiler and specify additional flags from environment @@ -177,8 +191,19 @@ def generate(env): if os.environ.has_key('LDFLAGS'): env['LINKFLAGS'] += SCons.Util.CLVar(os.environ['LDFLAGS']) - env['gcc'] = 'gcc' in os.path.basename(env['CC']).split('-') - env['msvc'] = env['CC'] == 'cl' + # Detect gcc/clang not by executable name, but through pre-defined macros + # as autoconf does, to avoid drawing wrong conclusions when using tools + # that overrice CC/CXX like scan-build. + env['gcc'] = 0 + env['clang'] = 0 + env['msvc'] = 0 + if host_platform.system() == 'Windows': + env['msvc'] = check_cc(env, 'MSVC', 'defined(_MSC_VER)', '/E') + if not env['msvc']: + env['gcc'] = check_cc(env, 'GCC', 'defined(__GNUC__) && !defined(__clang__)') + env['clang'] = check_cc(env, 'Clang', '__clang__') + env['suncc'] = env['platform'] == 'sunos' and os.path.basename(env['CC']) == 'cc' + env['icc'] = 'icc' == os.path.basename(env['CC']) if env['msvc'] and env['toolchain'] == 'default' and env['machine'] == 'x86_64': # MSVC x64 support is broken in earlier versions of scons @@ -189,13 +214,17 @@ def generate(env): platform = env['platform'] x86 = env['machine'] == 'x86' ppc = env['machine'] == 'ppc' - gcc = env['gcc'] + gcc_compat = env['gcc'] or env['clang'] msvc = env['msvc'] + suncc = env['suncc'] + icc = env['icc'] # 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_ARCHITEW6432', os.environ.get('PROCESSOR_ARCHITECTURE', _platform.machine())) + hosthost_platform = host_platform.system().lower() + if hosthost_platform.startswith('cygwin'): + hosthost_platform = 'cygwin' + host_machine = os.environ.get('PROCESSOR_ARCHITEW6432', os.environ.get('PROCESSOR_ARCHITECTURE', host_platform.machine())) host_machine = { 'x86': 'x86', 'i386': 'x86', @@ -206,7 +235,7 @@ def generate(env): 'AMD64': 'x86_64', 'x86_64': 'x86_64', }.get(host_machine, 'generic') - env['crosscompile'] = platform != host_platform + env['crosscompile'] = platform != hosthost_platform if machine == 'x86_64' and host_machine != 'x86_64': env['crosscompile'] = True env['hostonly'] = False @@ -245,6 +274,8 @@ def generate(env): # configuration. See also http://www.scons.org/wiki/AdvancedBuildExample build_topdir = 'build' build_subdir = env['platform'] + if env['embedded']: + build_subdir = 'embedded-' + build_subdir if env['machine'] != 'generic': build_subdir += '-' + env['machine'] if env['build'] != 'release': @@ -269,12 +300,48 @@ def generate(env): # C preprocessor options cppdefines = [] + cppdefines += ['__STDC_LIMIT_MACROS'] if env['build'] in ('debug', 'checked'): cppdefines += ['DEBUG'] else: cppdefines += ['NDEBUG'] if env['build'] == 'profile': cppdefines += ['PROFILE'] + if env['platform'] in ('posix', 'linux', 'freebsd', 'darwin'): + cppdefines += [ + '_POSIX_SOURCE', + ('_POSIX_C_SOURCE', '199309L'), + '_SVID_SOURCE', + '_BSD_SOURCE', + '_GNU_SOURCE', + '_DEFAULT_SOURCE', + 'HAVE_PTHREAD', + 'HAVE_POSIX_MEMALIGN', + ] + if env['platform'] == 'darwin': + cppdefines += [ + '_DARWIN_C_SOURCE', + 'GLX_USE_APPLEGL', + 'GLX_DIRECT_RENDERING', + ] + else: + cppdefines += [ + 'GLX_DIRECT_RENDERING', + 'GLX_INDIRECT_RENDERING', + ] + if env['platform'] in ('linux', 'freebsd'): + cppdefines += ['HAVE_ALIAS'] + else: + cppdefines += ['GLX_ALIAS_UNSUPPORTED'] + + if env['platform'] in ('linux', 'darwin'): + cppdefines += ['HAVE_XLOCALE_H'] + + if env['platform'] == 'haiku': + cppdefines += [ + 'HAVE_PTHREAD', + 'HAVE_POSIX_MEMALIGN' + ] if platform == 'windows': cppdefines += [ 'WIN32', @@ -285,7 +352,9 @@ def generate(env): ('_WIN32_WINNT', '0x0601'), ('WINVER', '0x0601'), ] - if msvc and env['toolchain'] != 'winddk': + if gcc_compat: + cppdefines += [('__MSVCRT_VERSION__', '0x0700')] + if msvc: cppdefines += [ 'VC_EXTRALEAN', '_USE_MATH_DEFINES', @@ -293,148 +362,137 @@ def generate(env): '_CRT_SECURE_NO_DEPRECATE', '_SCL_SECURE_NO_WARNINGS', '_SCL_SECURE_NO_DEPRECATE', + '_ALLOW_KEYWORD_MACROS', + '_HAS_EXCEPTIONS=0', # Tell C++ STL to not use exceptions ] if env['build'] in ('debug', 'checked'): cppdefines += ['_DEBUG'] - if env['toolchain'] == 'winddk': - # 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/ - if machine == 'x86': - cppdefines += ['_X86_', 'i386'] - if machine == 'x86_64': - cppdefines += ['_AMD64_', 'AMD64'] - if platform == 'winddk': - 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'), - ] - if env['build'] in ('debug', 'checked'): - 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'] - cppdefines += ['PIPE_SUBSYSTEM_WINDOWS_CE_OGL'] - if platform == 'embedded': - cppdefines += ['PIPE_OS_EMBEDDED'] + if env['embedded']: + cppdefines += ['PIPE_SUBSYSTEM_EMBEDDED'] + if env['texture_float']: + print 'warning: Floating-point textures enabled.' + print 'warning: Please consult docs/patents.txt with your lawyer before building Mesa.' + cppdefines += ['TEXTURE_FLOAT_ENABLED'] + if gcc_compat: + ccversion = env['CCVERSION'] + cppdefines += [ + 'HAVE___BUILTIN_EXPECT', + 'HAVE___BUILTIN_FFS', + 'HAVE___BUILTIN_FFSLL', + 'HAVE_FUNC_ATTRIBUTE_FLATTEN', + 'HAVE_FUNC_ATTRIBUTE_UNUSED', + # GCC 3.0 + 'HAVE_FUNC_ATTRIBUTE_FORMAT', + 'HAVE_FUNC_ATTRIBUTE_PACKED', + # GCC 3.4 + 'HAVE___BUILTIN_CTZ', + 'HAVE___BUILTIN_POPCOUNT', + 'HAVE___BUILTIN_POPCOUNTLL', + 'HAVE___BUILTIN_CLZ', + 'HAVE___BUILTIN_CLZLL', + ] + if distutils.version.LooseVersion(ccversion) >= distutils.version.LooseVersion('4.5'): + cppdefines += ['HAVE___BUILTIN_UNREACHABLE'] env.Append(CPPDEFINES = cppdefines) # C compiler options cflags = [] # C cxxflags = [] # C++ ccflags = [] # C & C++ - if gcc: + if gcc_compat: ccversion = env['CCVERSION'] if env['build'] == 'debug': ccflags += ['-O0'] - elif ccversion.startswith('4.2.'): + elif env['gcc'] and ccversion.startswith('4.2.'): # gcc 4.2.x optimizer is broken print "warning: gcc 4.2.x optimizer is broken -- disabling optimizations" ccflags += ['-O0'] else: ccflags += ['-O3'] - ccflags += ['-g3'] + if env['gcc']: + # gcc's builtin memcmp is slower than glibc's + # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43052 + ccflags += ['-fno-builtin-memcmp'] + # Work around aliasing bugs - developers should comment this out + ccflags += ['-fno-strict-aliasing'] + ccflags += ['-g'] if env['build'] in ('checked', 'profile'): # 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', ] + if env['gcc']: + ccflags += ['-fno-optimize-sibling-calls'] if env['machine'] == 'x86': ccflags += [ '-m32', #'-march=pentium4', ] - if distutils.version.LooseVersion(ccversion) >= distutils.version.LooseVersion('4.2') \ - and (platform != 'windows' or env['build'] == 'debug' or True): + if platform != 'haiku': # 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. # - # XXX: -O and -mstackrealign causes stack corruption on MinGW - # # XXX: We could have SSE without -mstackrealign if we always used # __attribute__((force_align_arg_pointer)), but that's not # always the case. ccflags += [ '-mstackrealign', # ensure stack is aligned - '-mmmx', '-msse', '-msse2', # enable SIMD intrinsics - #'-mfpmath=sse', + '-msse', '-msse2', # enable SIMD intrinsics + '-mfpmath=sse', # generate SSE floating-point arithmetic ] if platform in ['windows', 'darwin']: # Workaround http://gcc.gnu.org/bugzilla/show_bug.cgi?id=37216 ccflags += ['-fno-common'] + if platform in ['haiku']: + # Make optimizations compatible with Pentium or higher on Haiku + ccflags += [ + '-mstackrealign', # ensure stack is aligned + '-march=i586', # Haiku target is Pentium + '-mtune=i686' # use i686 where we can + ] if env['machine'] == 'x86_64': ccflags += ['-m64'] if platform == 'darwin': ccflags += ['-fno-common'] + if env['platform'] not in ('cygwin', 'haiku', 'windows'): + ccflags += ['-fvisibility=hidden'] # See also: # - http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html ccflags += [ '-Wall', '-Wno-long-long', - '-ffast-math', '-fmessage-length=0', # be nice to Eclipse ] cflags += [ '-Wmissing-prototypes', '-std=gnu99', ] - if distutils.version.LooseVersion(ccversion) >= distutils.version.LooseVersion('4.0'): - ccflags += [ - '-Wmissing-field-initializers', - ] - if distutils.version.LooseVersion(ccversion) >= distutils.version.LooseVersion('4.2'): - ccflags += [ - '-Werror=pointer-arith', - ] - cflags += [ - '-Werror=declaration-after-statement', - ] + if icc: + cflags += [ + '-std=gnu99', + ] if msvc: # See also: # - http://msdn.microsoft.com/en-us/library/19z1t1wy.aspx # - cl /? + if 'MSVC_VERSION' not in env or distutils.version.LooseVersion(env['MSVC_VERSION']) < distutils.version.LooseVersion('12.0'): + # Use bundled stdbool.h and stdint.h headers for older MSVC + # versions. stdint.h was introduced in MSVC 2010, but stdbool.h + # was only introduced in MSVC 2013. + top_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) + env.Append(CPPPATH = [os.path.join(top_dir, 'include/c99')]) if env['build'] == 'debug': ccflags += [ '/Od', # disable optimizations '/Oi', # enable intrinsic functions - '/Oy-', # disable frame pointer omission ] else: + if 'MSVC_VERSION' in env and distutils.version.LooseVersion(env['MSVC_VERSION']) < distutils.version.LooseVersion('11.0'): + print 'scons: warning: Visual Studio versions prior to 2012 are known to produce incorrect code when optimizations are enabled ( https://bugs.freedesktop.org/show_bug.cgi?id=58718 )' ccflags += [ '/O2', # optimize for speed ] @@ -444,54 +502,29 @@ def generate(env): ] else: ccflags += [ + '/Oy-', # disable frame pointer omission '/GL-', # disable whole program optimization ] ccflags += [ - '/fp:fast', # fast floating point '/W3', # warning level - #'/Wp64', # enable 64 bit porting warnings + '/wd4018', # signed/unsigned mismatch + '/wd4056', # overflow in floating-point constant arithmetic + '/wd4244', # conversion from 'type1' to 'type2', possible loss of data + '/wd4267', # 'var' : conversion from 'size_t' to 'type', possible loss of data + '/wd4305', # truncation from 'type1' to 'type2' + '/wd4351', # new behavior: elements of array 'array' will be default initialized + '/wd4756', # overflow in constant arithmetic + '/wd4800', # forcing value to bool 'true' or 'false' (performance warning) + '/wd4996', # disable deprecated POSIX name warnings ] if env['machine'] == 'x86': ccflags += [ - #'/arch:SSE2', # use the SSE2 instructions + '/arch:SSE2', # use the SSE2 instructions (default since MSVC 2012) ] if platform == 'windows': ccflags += [ # TODO ] - if platform == 'winddk': - ccflags += [ - '/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 - ccflags += [ - '/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) @@ -510,8 +543,21 @@ def generate(env): env.Append(CCFLAGS = ['/MT']) env.Append(SHCCFLAGS = ['/LD']) + # Static code analysis + if env['analyze']: + if env['msvc']: + # http://msdn.microsoft.com/en-us/library/ms173498.aspx + env.Append(CCFLAGS = [ + '/analyze', + #'/analyze:log', '${TARGET.base}.xml', + '/wd28251', # Inconsistent annotation for function + ]) + if env['clang']: + # scan-build will produce more comprehensive output + env.Append(CCFLAGS = ['--analyze']) + # Assembler options - if gcc: + if gcc_compat: if env['machine'] == 'x86': env.Append(ASFLAGS = ['-m32']) if env['machine'] == 'x86_64': @@ -520,7 +566,7 @@ def generate(env): # Linker options linkflags = [] shlinkflags = [] - if gcc: + if gcc_compat: if env['machine'] == 'x86': linkflags += ['-m32'] if env['machine'] == 'x86_64': @@ -534,6 +580,18 @@ def generate(env): pass else: env['_LIBFLAGS'] = '-Wl,--start-group ' + env['_LIBFLAGS'] + ' -Wl,--end-group' + if env['platform'] == 'windows': + linkflags += [ + '-Wl,--nxcompat', # DEP + '-Wl,--dynamicbase', # ASLR + ] + # Avoid depending on gcc runtime DLLs + linkflags += ['-static-libgcc'] + if 'w64' in env['CC'].split('-'): + linkflags += ['-static-libstdc++'] + # Handle the @xx symbol munging of DLL exports + shlinkflags += ['-Wl,--enable-stdcall-fixup'] + #shlinkflags += ['-Wl,--kill-at'] if msvc: if env['build'] == 'release': # enable Link-time Code Generation @@ -545,73 +603,89 @@ def generate(env): linkflags += [ '/fixed:no', '/incremental:no', - ] - if platform == 'winddk': - 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', - ] - if env['build'] != 'release': - linkflags += [ - '/MAP', # http://msdn.microsoft.com/en-us/library/k7xkk3e2.aspx - ] - if platform == 'wince': - linkflags += [ - '/nodefaultlib', - #'/incremental:no', - #'/fullbuild', - '/entry:_DllMainCRTStartup', + '/dynamicbase', # ASLR + '/nxcompat', # DEP ] env.Append(LINKFLAGS = linkflags) env.Append(SHLINKFLAGS = shlinkflags) # We have C++ in several libraries, so always link with the C++ compiler - if env['gcc']: + if gcc_compat: env['LINK'] = env['CXX'] # Default libs - env.Append(LIBS = []) + libs = [] + if env['platform'] in ('darwin', 'freebsd', 'linux', 'posix', 'sunos'): + libs += ['m', 'pthread', 'dl'] + if env['platform'] in ('linux',): + libs += ['rt'] + if env['platform'] in ('haiku'): + libs += ['root', 'be', 'network', 'translation'] + env.Append(LIBS = libs) + + # OpenMP + if env['openmp']: + if env['msvc']: + env.Append(CCFLAGS = ['/openmp']) + # When building openmp release VS2008 link.exe crashes with LNK1103 error. + # Workaround: overwrite PDB flags with empty value as it isn't required anyways + if env['build'] == 'release': + env['PDB'] = '' + if env['gcc']: + env.Append(CCFLAGS = ['-fopenmp']) + env.Append(LIBS = ['gomp']) # Load tools + env.Tool('lex') + if env['msvc']: + env.Append(LEXFLAGS = [ + # Force flex to use const keyword in prototypes, as relies on + # __cplusplus or __STDC__ macro to determine whether it's safe to + # use const keyword, but MSVC never defines __STDC__ unless we + # disable all MSVC extensions. + '-DYY_USE_CONST=', + ]) + # Flex relies on __STDC_VERSION__>=199901L to decide when to include + # C99 inttypes.h. We always have inttypes.h available with MSVC + # (either the one bundled with MSVC 2013, or the one we bundle + # ourselves), but we can't just define __STDC_VERSION__ without + # breaking stuff, as MSVC doesn't fully support C99. There's also no + # way to premptively include stdint. + env.Append(CCFLAGS = ['-FIinttypes.h']) + if host_platform.system() == 'Windows': + # Prefer winflexbison binaries, as not only they are easier to install + # (no additional dependencies), but also better Windows support. + if check_prog(env, 'win_flex'): + env["LEX"] = 'win_flex' + env.Append(LEXFLAGS = [ + # windows compatibility (uses instead of and + # _isatty, _fileno functions) + '--wincompat' + ]) + + env.Tool('yacc') + if host_platform.system() == 'Windows': + if check_prog(env, 'win_bison'): + env["YACC"] = 'win_bison' + if env['llvm']: env.Tool('llvm') - env.Tool('udis86') - pkg_config_modules(env, 'x11', ['x11', 'xext']) - pkg_config_modules(env, 'drm', ['libdrm']) - pkg_config_modules(env, 'drm_intel', ['libdrm_intel']) - pkg_config_modules(env, 'drm_radeon', ['libdrm_radeon']) - pkg_config_modules(env, 'xorg', ['xorg-server']) - pkg_config_modules(env, 'kms', ['libkms']) - - env['dri'] = env['x11'] and env['drm'] - # Custom builders and methods env.Tool('custom') createInstallMethods(env) + createMSVCCompatMethods(env) + + env.PkgCheckModules('X11', ['x11', 'xext', 'xdamage', 'xfixes', 'glproto >= 1.4.13']) + env.PkgCheckModules('XCB', ['x11-xcb', 'xcb-glx >= 1.8.1', 'xcb-dri2 >= 1.8']) + env.PkgCheckModules('XF86VIDMODE', ['xxf86vm']) + env.PkgCheckModules('DRM', ['libdrm >= 2.4.38']) + env.PkgCheckModules('UDEV', ['libudev >= 151']) + + if env['x11']: + env.Append(CPPPATH = env['X11_CPPPATH']) + + env['dri'] = env['x11'] and env['drm'] # for debugging #print env.Dump()