generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
442c5e47cd
webrtc/talk/main.scons
henrike@webrtc.org 28e2075280 Adds trunk/talk folder of revision 359 from libjingles google code to 
trunk/talk


git-svn-id: http://webrtc.googlecode.com/svn/trunk@4318 4adac7df-926f-26a2-2b94-8c16560cd09d
2013-07-10 00:45:36 +00:00

890 lines
27 KiB
Python
Raw Blame History

# -*- Python -*-
#
#
# All the helper functions are defined in:
# - site_scons/talk.py
# Use 'import talk' in any .scons file to get access to it.
# Add any new helper functions to it; unittest are available
# in talk_unittest.py.
#
# Each 'component' that is built is defined in a .scons file.
# See talk.Components(...) for further info on file naming convention.
#
# To add a new platform clone and modify the root_env object. Remember to add
# the new environment object to the envs list otherwise it will not be included
# in the build.
#
#
#
import talk
import os
import platform
#-------------------------------------------------------------------------------
# The build files/directories to 'build'.
# If the name is the name of a directory then that directory shall contain a
# .scons file with the same name as the directory itself:
# Ex: The directory session/phone contains a file called phone.scons
# This list must be in order of library dependencies. e.g., if
# session/phone/phone.scons defines a target that links to a library target
# defined in sound/sound.scons, then 'sound' must come first.
# When no particular order is imposed by library dependencies, try to keep in
# mostly alphabetical order.
#
components = talk.Components("libjingle.scons")
#-------------------------------------------------------------------------------
# Build environments
#
# The list of build environments.
envs = []
# The root of all builds.
root_env = Environment(
tools = [
'component_bits',
'component_setup',
'replace_strings',
'talk_noops',
#'talk_utils',
],
BUILD_SCONSCRIPTS = components,
DESTINATION_ROOT = '$MAIN_DIR/build',
CPPPATH = [
'$OBJ_ROOT', # generated headers are relative to here
'$MAIN_DIR/..', # TODO(dape): how can we use GOOGLECLIENT instead?
],
CPPDEFINES = [
'LOGGING=1',
# Feature selection
'FEATURE_ENABLE_SSL',
'FEATURE_ENABLE_VOICEMAIL',
'FEATURE_ENABLE_PSTN',
'HAVE_SRTP',
],
# Ensure the os environment is captured for any scripts we call out to
ENV = os.environ,
)
# This is where we set common environments
#
# Detect if building on 64-bit or 32-bit platform.
DeclareBit('build_platform_64bit', 'Platform of the build machine is 64-bit')
if platform.architecture()[0] == "64bit":
root_env.SetBits('build_platform_64bit')
# This bit denotes that an env is for 64-bit builds. When set, all build
# artifacts will be 64-bit. When unset, all build artifacts will be 32-bit.
DeclareBit('host_platform_64bit',
'Platform of the host machine (where artifacts will execute) is '
'64-bit')
# This bit denotes that we are cross-compiling using a sysroot.
DeclareBit('cross_compile',
'Cross compiling using the SYSROOT environment variable')
def CrossArch(env):
"""Return whether or not the host platform architecture differs from the build
environment architecture."""
if env.Bit('cross_compile'):
# The architecture of the Python process may not match the architecture of
# the sysroot, so we just assume it's not a cross-arch build or that it
# doesn't matter. Currently it only matters if you try to build a cross-arch
# Debian package, so just don't do that.
return False
else:
return env.Bit('host_platform_64bit') != env.Bit('build_platform_64bit')
root_env.AddMethod(CrossArch)
DeclareBit('use_static_openssl', 'Build OpenSSL as a static library')
DeclareBit('have_dbus_glib',
'Whether the build system has the dbus-glib-1 package')
DeclareBit('have_libpulse',
'Whether the build system has the libpulse package')
# List all the locales we localize to.
root_env.AppendUnique(locales = [
'af', 'am', 'ar', 'bg', 'bn', 'ca', 'cs', 'da', 'de', 'el', 'en', 'en-GB',
'es', 'es-419', 'et', 'eu', 'fa', 'fi', 'fil', 'fr', 'fr-CA', 'gl', 'gu',
'hi', 'hr', 'hu', 'id', 'is', 'it', 'iw', 'ja', 'kn', 'ko', 'lt', 'lv',
'ml', 'mr', 'ms', 'nl', 'no', 'or', 'pl', 'pt-BR', 'pt-PT', 'ro', 'ru',
'sk', 'sl', 'sr', 'sv', 'sw', 'ta', 'te', 'th', 'tl', 'tr', 'uk', 'ur',
'vi', 'zh-CN', 'zh-HK', 'zh-TW', 'zu'])
AddTargetGroup('all_breakpads', 'breakpad files can be built')
AddTargetGroup('all_dsym', 'dsym debug packages can be built')
#-------------------------------------------------------------------------------
# W I N D O W S
#
win_env = root_env.Clone(
tools = [
'atlmfc_vc80',
#'code_signing',
'component_targets_msvs',
'directx_9_0_c',
#'grid_builder',
'midl',
'target_platform_windows'
],
# Don't use default vc80 midl.exe. It doesn't understand vista_sdk idl files.
MIDL = '$PLATFORM_SDK_VISTA_6_0_DIR/Bin/midl.exe ',
WIX_DIR = '$GOOGLECLIENT/third_party/wix/v3_0_2925/files',
# Flags for debug and optimization are added to CCFLAGS instead
CCPDBFLAGS = '',
CCFLAGS_DEBUG = '',
CCFLAGS_OPTIMIZED = '',
# We force a x86 target even when building on x64 Windows platforms.
TARGET_ARCH = 'x86',
)
win_env.Decider('MD5-timestamp')
win_env.Append(
COMPONENT_LIBRARY_PUBLISH = True, # Put dlls in output dir too
CCFLAGS = [
'/Fd${TARGET}.pdb', # pdb per object allows --jobs=
'/WX', # warnings are errors
'/Zc:forScope', # handle 'for (int i = 0 ...)' right
'/EHs-c-', # disable C++ EH
'/GR-', # disable RTTI
'/Gy', # enable function level linking
'/wd4996', # ignore POSIX deprecated warnings
# promote certain level 4 warnings
'/w14701', # potentially uninitialized var
'/w14702', # unreachable code
'/w14706', # assignment within a conditional
'/w14709', # comma operator within array index
'/w14063', # case 'identifier' is not a valid value for switch of enum
'/w14064', # switch of incomplete enum 'enumeration'
'/w14057', # 'identifier1' indirection to slightly different base
# types from 'identifier2'
'/w14263', # member function does not override any base class virtual
# member function
'/w14266', # no override available for virtual memberfunction from base
# 'type'; function is hidden
'/w14296', # expression is always false
'/w14355', # 'this' : used in base member initializer list
],
CPPDEFINES = [
'_ATL_CSTRING_EXPLICIT_CONSTRUCTORS',
# TODO(dape): encapsulate all string operations that are not based
# on std::string/std::wstring and make sure we use the safest versions
# available on all platforms.
'_CRT_SECURE_NO_WARNINGS',
'_USE_32BIT_TIME_T',
'_UNICODE',
'UNICODE',
'_HAS_EXCEPTIONS=0',
'WIN32',
# TODO(dape): remove this from logging.cc and enable here instead.
#'WIN32_LEAN_AND_MEAN',
'WINVER=0x0500',
'_WIN32_WINNT=0x0501',
'_WIN32_IE=0x0501',
# The Vista platform SDK 6.0 needs at least
# this NTDDI version or else the headers
# that LMI includes from it won't compile.
'NTDDI_VERSION=NTDDI_WINXP',
# npapi.h requires the following:
'_WINDOWS',
],
CPPPATH = [
'$THIRD_PARTY/wtl_71/include',
'$PLATFORM_SDK_VISTA_6_0_DIR/Include',
],
LIBPATH = [
'$PLATFORM_SDK_VISTA_6_0_DIR/Lib'
],
LINKFLAGS = [
'-manifest', # TODO(thaloun): Why do we need this?
# Some of the third-party libraries we link in don't have public symbols, so
# ignore that linker warning.
'/ignore:4221',
'/nxcompat', # Binary was tested to be be compatible with Windows DEP.
'/dynamicbase', # Use ASLR to dynamically rebase at load-time.
'/fixed:no', # Binary can be loaded at any base-address.
],
MIDLFLAGS = [
'/win32',
'/I$PLATFORM_SDK_VISTA_6_0_DIR/include'
]
)
# TODO(dape): Figure out what this does; found it in
# omaha/main.scons. This fixes the problem with redefinition
# of OS_WINDOWS symbol.
win_env.FilterOut(CPPDEFINES = ['OS_WINDOWS=OS_WINDOWS'])
# Set up digital signing
DeclareBit('test_signing', 'Sign binaries with the test certificate')
win_env.SetBitFromOption('test_signing', False)
if win_env.Bit('test_signing'):
win_env.Replace(
CERTIFICATE_PATH = win_env.File(
'$GOOGLECLIENT/tools/test_key/testkey.pfx').abspath,
CERTIFICATE_PASSWORD = 'test',
)
AddTargetGroup('signed_binaries', 'digitally signed binaries can be built')
win_dbg_env = win_env.Clone(
BUILD_TYPE = 'dbg',
BUILD_TYPE_DESCRIPTION = 'Windows debug build',
BUILD_GROUPS = ['default', 'all'],
tools = ['target_debug'],
)
win_dbg_env.Prepend(
CCFLAGS = [
'/ZI', # enable debugging
'/Od', # disable optimizations
'/MTd', # link with LIBCMTD.LIB debug lib
'/RTC1', # enable runtime checks
],
)
envs.append(win_dbg_env)
win_dbg64_env = win_dbg_env.Clone(
BUILD_TYPE = 'dbg64',
BUILD_TYPE_DESCRIPTION = 'Windows debug 64bit build',
BUILD_GROUPS = ['all'],
)
win_dbg64_env.FilterOut(CCFLAGS = ['/ZI'])
win_dbg64_env.Append(
CCFLAGS = [
'/Zi', # enable debugging that is 64 bit compatible.
# TODO(fbarchard): fix warnings and remove these disables.
'/wd4244', # disable cast warning
'/wd4267', # disable cast warning
],
ARFLAGS = [
'/MACHINE:x64',
],
CPPDEFINES = [
'WIN64',
'ARCH_CPU_64_BITS',
],
LIBFLAGS = [
'/MACHINE:x64',
],
LINKFLAGS = [
'/MACHINE:x64',
],
)
win_dbg64_env.FilterOut(CPPDEFINES = ['_USE_32BIT_TIME_T'])
win_dbg64_env.Prepend(
LIBPATH = [
'$VC80_DIR/vc/lib/amd64',
'$ATLMFC_VC80_DIR/lib/amd64',
'$PLATFORM_SDK_VISTA_6_0_DIR/Lib/x64',
],
)
win_dbg64_env.PrependENVPath(
'PATH',
win_dbg64_env.Dir('$VC80_DIR/vc/bin/x86_amd64'))
win_dbg64_env.SetBits('host_platform_64bit')
envs.append(win_dbg64_env)
win_coverage_env = win_dbg_env.Clone(
tools = ['code_coverage'],
BUILD_TYPE = 'coverage',
BUILD_TYPE_DESCRIPTION = 'Windows code coverage build',
BUILD_GROUPS = ['all'],
)
win_coverage_env.Append(
CPPDEFINES = [
'COVERAGE_ENABLED',
],
)
envs.append(win_coverage_env)
win_opt_env = win_env.Clone(
BUILD_TYPE = 'opt',
BUILD_TYPE_DESCRIPTION = 'Windows opt build',
BUILD_GROUPS = ['all'],
tools = ['target_optimized'],
)
win_opt_env.Prepend(
CCFLAGS=[
'/Zi', # enable debugging
'/O1', # optimize for size
'/fp:fast', # float faster but less precise
'/MT', # link with LIBCMT.LIB (multi-threaded, static linked crt)
'/GS', # enable security checks
],
LINKFLAGS = [
'/safeseh', # protect against attacks against exception handlers
'/opt:ref', # Remove unused references (functions/data).
],
)
envs.append(win_opt_env)
#-------------------------------------------------------------------------------
# P O S I X
#
posix_env = root_env.Clone()
posix_env.Append(
CPPDEFINES = [
'HASHNAMESPACE=__gnu_cxx',
'HASH_NAMESPACE=__gnu_cxx',
'POSIX',
'DISABLE_DYNAMIC_CAST',
# The POSIX standard says we have to define this.
'_REENTRANT',
],
CCFLAGS = [
'-Wall',
'-Werror',
'-Wno-switch',
'-fno-exceptions',
# Needed for a clean ABI and for link-time dead-code removal to work
# properly.
'-fvisibility=hidden',
# Generate debugging info in the DWARF2 format.
'-gdwarf-2',
# Generate maximal debugging information. (It is stripped from what we ship
# to users, so we want it for both dbg and opt.)
# Note that hammer automatically supplies "-g" for mac/linux dbg, so that
# flag must be filtered out of linux_dbg and mac_dbg envs below.
'-g3',
],
CXXFLAGS = [
'-Wno-non-virtual-dtor',
'-Wno-ctor-dtor-privacy',
'-fno-rtti',
],
)
# Switch-hit between NSS and OpenSSL
if 'NSS_BUILD_PLATFORM' in root_env['ENV']:
posix_env.AppendUnique(CPPDEFINES=['HAVE_NSS_SSL_H=1',
'NSS_SSL_RELATIVE_PATH'])
else:
posix_env.AppendUnique(CPPDEFINES=['HAVE_OPENSSL_SSL_H=1'])
#-------------------------------------------------------------------------------
# M A C OSX
#
mac_env = posix_env.Clone(
tools = [
'target_platform_mac',
#'talk_mac',
#'fill_plist',
],
)
# Use static OpenSSL on mac so that we can use the latest APIs on all
# supported mac platforms (10.5+).
mac_env.SetBits('use_static_openssl')
# For libjingle we don't specify a sysroot or minimum OS version.
mac_osx_version_min_32 = ""
mac_osx_version_min_64 = ""
# Generic mac environment common to all targets
mac_env.Append(
CPPDEFINES = [
'OSX',
],
CCFLAGS = [
'-arch', 'i386',
'-fasm-blocks',
],
LINKFLAGS = [
'-Wl,-search_paths_first',
# This flag makes all members of a static library be included in the
# final exe - that increases the size of the exe, but without it
# Obj-C categories aren't properly included in the exe.
# TODO(thaloun): consider only defining for libs that actually have objc.
'-ObjC',
'-arch', 'i386',
'-dead_strip',
],
FRAMEWORKS = [
'CoreServices',
'Security',
'SystemConfiguration',
'OpenGL',
'CoreAudio',
'Quartz',
'Cocoa',
'QTKit',
]
)
if 'NSS_BUILD_PLATFORM' in root_env['ENV']:
mac_env.AppendUnique(LINKFLAGS = ['-Lthird_party/mozilla/dist/' + root_env['ENV']['NSS_BUILD_PLATFORM'] + '/lib'])
else:
mac_env.AppendUnique(LINKFLAGS = ['-Lthird_party/openssl'])
# add debug flags to environment
def mac_debug_include(env):
env.Append(
CCFLAGS = [
'-O0',
],
CPPDEFINES = [
'DEBUG=1',
],
)
# Remove -g set by hammer, which is not what we want (we have set -g3 above).
env.FilterOut(CCFLAGS = ['-g'])
# add 32/64 bit specific options to specified environment
def mac_common_include_x86_32(env):
env.Append(
CCFLAGS = [
'-m32',
],
LINKFLAGS = [
'-m32',
],
FRAMEWORKS = [
'Carbon',
'QuickTime',
],
)
envs.append(env)
def mac_common_include_x86_64(env):
env.Append(
CCFLAGS = [
'-m64',
'-fPIC',
],
CPPDEFINES = [
'ARCH_CPU_64_BITS',
'CARBON_DEPRECATED',
],
LINKFLAGS = [
'-m64',
],
FRAMEWORKS = [
'AppKit',
],
)
env.SetBits('host_platform_64bit')
envs.append(env)
def mac_osx_version_min(env, ver):
if ver != "":
sdk_path = '/Developer/SDKs/MacOSX%s.sdk' % ver
env.Append(
CCFLAGS = [
'-mmacosx-version-min=' + ver,
'-isysroot', sdk_path,
],
LINKFLAGS = [
'-mmacosx-version-min=' + ver,
'-isysroot', sdk_path,
],
osx_sdk_path = sdk_path,
osx_version_min = ver,
)
# Create all environments
mac_dbg_env = mac_env.Clone(
BUILD_TYPE = 'dbg',
BUILD_TYPE_DESCRIPTION = 'Mac debug build',
BUILD_GROUPS = ['default', 'all'],
tools = ['target_debug'],
)
mac_opt_env = mac_env.Clone(
BUILD_TYPE = 'opt',
BUILD_TYPE_DESCRIPTION = 'Mac opt build',
BUILD_GROUPS = ['all'],
tools = ['target_optimized'],
)
mac_dbg64_env = mac_dbg_env.Clone(
BUILD_TYPE = 'dbg64',
BUILD_TYPE_DESCRIPTION = 'Mac debug 64bit build',
BUILD_GROUPS = ['all'],
)
mac_opt64_env = mac_opt_env.Clone(
BUILD_TYPE = 'opt64',
BUILD_TYPE_DESCRIPTION = 'Mac opt 64bit build',
BUILD_GROUPS = ['all'],
)
mac_debug_include(mac_dbg_env)
mac_debug_include(mac_dbg64_env)
mac_common_include_x86_32(mac_dbg_env)
mac_common_include_x86_32(mac_opt_env)
mac_common_include_x86_64(mac_dbg64_env)
mac_common_include_x86_64(mac_opt64_env)
mac_osx_version_min(mac_dbg_env, mac_osx_version_min_32)
mac_osx_version_min(mac_opt_env, mac_osx_version_min_32)
mac_osx_version_min(mac_dbg64_env, mac_osx_version_min_64)
mac_osx_version_min(mac_opt64_env, mac_osx_version_min_64)
#-------------------------------------------------------------------------------
# L I N U X
#
linux_common_env = posix_env.Clone(
tools = [
'target_platform_linux',
'talk_linux',
],
)
linux_common_env.Append(
CPPDEFINES = [
'LINUX',
],
CCFLAGS = [
# Needed for link-time dead-code removal to work properly.
'-ffunction-sections',
'-fdata-sections',
],
LINKFLAGS = [
# Enable dead-code removal.
'-Wl,--gc-sections',
# Elide dependencies on shared libraries that we're not actually using.
'-Wl,--as-needed',
'-Wl,--start-group',
],
_LIBFLAGS = ['-Wl,--end-group'],
)
# Remove default rpath set by Hammer. Hammer sets it to LIB_DIR, which is wrong.
# The rpath is the _run-time_ library search path for the resulting binary, i.e.
# the one used by ld.so at load time. Setting it equal to the path to build
# output on the build machine is nonsense.
linux_common_env.Replace(
RPATH = [],
)
# Enable the optional DBus-GLib code if the build machine has the required
# dependency.
linux_common_env.EnableFeatureWherePackagePresent('have_dbus_glib',
'HAVE_DBUS_GLIB',
'dbus-glib-1')
def linux_common_include_x86_32(env):
"""Include x86-32 settings into an env based on linux_common."""
env.Append(
CCFLAGS = [
'-m32',
],
LINKFLAGS = [
'-m32',
],
)
def linux_common_include_x86_64(env):
"""Include x86-64 settings into an env based on linux_common."""
env.Append(
CCFLAGS = [
'-m64',
'-fPIC',
],
LINKFLAGS = [
'-m64',
],
)
env.SetBits('host_platform_64bit')
#-------------------------------------------------------------------------------
# L I N U X -- C R O S S -- B U I L D
# Cross build requires the following tool names be provided by the environment:
linux_cross_common_env = linux_common_env.Clone(
AR = os.environ.get("AR"),
AS = os.environ.get("AS"),
LD = os.environ.get("LD"),
NM = os.environ.get("NM"),
RANLIB = os.environ.get("RANLIB"),
CC = str(os.environ.get("CC")) +
' --sysroot=' + str(os.environ.get("SYSROOT")),
CXX = str(os.environ.get("CXX")) +
' --sysroot=' + str(os.environ.get("SYSROOT")),
)
linux_cross_common_env.SetBits('cross_compile')
# The rest of these paths and flags are optional:
if os.environ.get("CPPPATH"):
linux_cross_common_env.Append(
CPPPATH = os.environ.get("CPPPATH").split(':'),
)
if os.environ.get("LIBPATH"):
linux_cross_common_env.Append(
LIBPATH = os.environ.get("LIBPATH").split(':'),
)
if os.environ.get("CFLAGS"):
linux_cross_common_env.Append(
CFLAGS = os.environ.get("CFLAGS").split(' '),
)
if os.environ.get("CCFLAGS"):
linux_cross_common_env.Append(
CCFLAGS = os.environ.get("CCFLAGS").split(' '),
)
if os.environ.get("CXXFLAGS"):
linux_cross_common_env.Append(
CXXFLAGS = os.environ.get("CXXFLAGS").split(' '),
)
if os.environ.get("LIBFLAGS"):
linux_cross_common_env.Append(
_LIBFLAGS = os.environ.get("LIBFLAGS").split(' '),
)
if os.environ.get("LINKFLAGS"):
linux_cross_common_env.Prepend(
LINKFLAGS = os.environ.get("LINKFLAGS").split(' '),
)
#-------------------------------------------------------------------------------
# L I N U X -- T R A D I T I O N A L -- X 8 6
#
# Settings that are specific to our desktop Linux x86 targets.
def linux_common_include_traditional(env):
"""Include traditional Linux settings into an env based on linux_common."""
# OpenSSL has infamously poor ABI stability, so that building against one
# version and running against a different one often will not work. Since our
# non-ChromeOS Linux builds are used on many different distros and distro
# versions, this means we can't safely dynamically link to OpenSSL because the
# product would end up being broken on any computer with a different version
# installed. So instead we build it ourself and statically link to it.
env.SetBits('use_static_openssl')
# Enable the optional PulseAudio code if the build machine has the required
# dependency.
# TODO(?): This belongs in linux_common_env, but we can't safely move it there
# yet because pkg-config is not being used properly with ChromeOS builds (see
# TODO below).
env.EnableFeatureWherePackagePresent('have_libpulse',
'HAVE_LIBPULSE',
'libpulse')
def linux_traditional_include_dbg(env):
"""Include traditional Linux dbg settings into an env based on the above."""
# Remove -g set by hammer, which is not what we want (we have set -g3 above).
env.FilterOut(CCFLAGS = ['-g'])
def linux_traditional_include_opt(env):
"""Include traditional Linux opt settings into an env based on the above."""
# Remove -O2 set by hammer, which is not what we want.
env.FilterOut(CCFLAGS = ['-O2'])
env.Append(CCFLAGS = ['-Os'])
def gen_linux_nonhermetic(linux_env, type_suffix, desc_suffix):
groups = ['nonhermetic']
if not linux_env.CrossArch():
groups = groups + ['nonhermetic-native']
# The non-hermetic, native-arch dbg build is the default.
dbg_groups = groups + ['default']
native_desc = ', native '
# No suffix for native modes.
type_suffix = ''
else:
groups = groups + ['nonhermetic-cross']
dbg_groups = groups
native_desc = ', cross-built for '
linux_dbg_env = linux_env.Clone(
BUILD_TYPE = 'dbg' + type_suffix,
BUILD_TYPE_DESCRIPTION = 'Linux debug build%s%s' % (native_desc,
desc_suffix),
BUILD_GROUPS = dbg_groups,
tools = ['target_debug'],
)
linux_traditional_include_dbg(linux_dbg_env)
envs.append(linux_dbg_env)
linux_opt_env = linux_env.Clone(
BUILD_TYPE = 'opt' + type_suffix,
BUILD_TYPE_DESCRIPTION = 'Linux optimized build%s%s' % (native_desc,
desc_suffix),
BUILD_GROUPS = groups,
tools = ['target_optimized'],
)
linux_traditional_include_opt(linux_opt_env)
envs.append(linux_opt_env)
linux_nonhermetic_common_env = linux_common_env.Clone()
linux_common_include_traditional(linux_nonhermetic_common_env)
linux_nonhermetic_x86_32_env = linux_nonhermetic_common_env.Clone()
linux_common_include_x86_32(linux_nonhermetic_x86_32_env)
gen_linux_nonhermetic(linux_nonhermetic_x86_32_env, '32', '32-bit')
linux_nonhermetic_x86_64_env = linux_nonhermetic_common_env.Clone()
linux_common_include_x86_64(linux_nonhermetic_x86_64_env)
gen_linux_nonhermetic(linux_nonhermetic_x86_64_env, '64', '64-bit')
def gen_linux_hermetic(linux_env, type_suffix, desc):
groups = ['hermetic']
linux_dbg_env = linux_env.Clone(
BUILD_TYPE = 'hermetic-dbg' + type_suffix,
BUILD_TYPE_DESCRIPTION = 'Hermetic %s Linux debug build' % desc,
BUILD_GROUPS = groups,
tools = ['target_debug'],
)
linux_traditional_include_dbg(linux_dbg_env)
envs.append(linux_dbg_env)
linux_opt_env = linux_env.Clone(
BUILD_TYPE = 'hermetic-opt' + type_suffix,
BUILD_TYPE_DESCRIPTION = 'Hermetic %s Linux optimized build' % desc,
BUILD_GROUPS = groups,
tools = ['target_optimized'],
)
linux_traditional_include_opt(linux_opt_env)
envs.append(linux_opt_env)
linux_hermetic_common_env = linux_cross_common_env.Clone()
linux_common_include_traditional(linux_hermetic_common_env)
linux_hermetic_x86_32_env = linux_hermetic_common_env.Clone()
linux_common_include_x86_32(linux_hermetic_x86_32_env)
gen_linux_hermetic(linux_hermetic_x86_32_env, '32', '32-bit')
linux_hermetic_x86_64_env = linux_hermetic_common_env.Clone()
linux_common_include_x86_64(linux_hermetic_x86_64_env)
gen_linux_hermetic(linux_hermetic_x86_64_env, '64', '64-bit')
#-------------------------------------------------------------------------------
# L I N U X -- C R O S S -- B U I L D -- A R M
# TODO(noahric): All the following Linux builds are running against a sysroot
# but improperly using the host machine's pkg-config environment. The ChromeOS
# ones should probably be using
# https://cs.corp.google.com/#chrome/src/build/linux/pkg-config-wrapper.
linux_cross_arm_env = linux_cross_common_env.Clone()
linux_cross_arm_env.Append(
CPPDEFINES = [
'NACL_BUILD_ARCH=arm',
'DISABLE_EFFECTS=1',
],
CCFLAGS = [
'-fPIC',
],
)
DeclareBit('arm', 'ARM build')
linux_cross_arm_env.SetBits('arm')
# Detect NEON support from the -mfpu build flag.
DeclareBit('arm_neon', 'ARM supporting neon')
if '-mfpu=neon' in linux_cross_arm_env['CFLAGS'] or \
'-mfpu=neon' in linux_cross_arm_env['CCFLAGS'] or \
'-mfpu=neon' in linux_cross_arm_env['CXXFLAGS']:
print "Building with ARM NEON support."
linux_cross_arm_env.SetBits('arm_neon')
# Detect hardfp from the -mfloat-abi build flag
DeclareBit('arm_hardfp', 'ARM supporting hardfp')
if '-mfloat-abi=hard' in linux_cross_arm_env['CFLAGS'] or \
'-mfloat-abi=hard' in linux_cross_arm_env['CCFLAGS'] or \
'-mfloat-abi=hard' in linux_cross_arm_env['CXXFLAGS']:
print "Building with hard floating point support."
linux_cross_arm_env.SetBits('arm_hardfp')
linux_cross_arm_dbg_env = linux_cross_arm_env.Clone(
BUILD_TYPE = 'arm-dbg',
BUILD_TYPE_DESCRIPTION = 'Cross-compiled ARM debug build',
BUILD_GROUPS = ['arm'],
tools = ['target_debug'],
)
envs.append(linux_cross_arm_dbg_env)
linux_cross_arm_opt_env = linux_cross_arm_env.Clone(
BUILD_TYPE = 'arm-opt',
BUILD_TYPE_DESCRIPTION = 'Cross-compiled ARM optimized build',
BUILD_GROUPS = ['arm'],
tools = ['target_optimized'],
)
envs.append(linux_cross_arm_opt_env)
# Create a group for installers
AddTargetGroup('all_installers', 'installers that can be built')
# Parse child .scons files
BuildEnvironments(envs)
# Explicitly set which targets to build when not stated on commandline
Default(None)
# Build the following, which excludes unit test output (ie running them)
# To run unittests, specify the test to run, or run_all_tests. See -h option.
Default(['all_libraries', 'all_programs', 'all_test_programs'])
# .sln creation code lifted from googleclient/bar/main.scons. Must be after
# the call to BuildEnvironments for all_foo aliases to be defined.
# Run 'hammer --mode=all --vsproj' to generate
DeclareBit('vsproj', 'Generate Visual Studio projects and solution files.')
win_env.SetBitFromOption('vsproj', False)
if win_env.Bit('vsproj'):
vs_env = win_env.Clone()
vs_env.Append(
COMPONENT_VS_SOURCE_SUFFIXES = [
'.def',
'.grd',
'.html',
'.idl',
'.mk',
'.txt',
'.py',
'.scons',
'.wxs.template',
]
)
# Source project
p = vs_env.ComponentVSDirProject(
'flute_source',
['$MAIN_DIR',
],
COMPONENT_VS_SOURCE_FOLDERS = [
# Files are assigned to first matching folder. Folder names of None
# are filters.
(None, '$DESTINATION_ROOT'),
('flute', '$MAIN_DIR'),
('google3', '$GOOGLE3'),
('third_party', '$THIRD_PARTY'),
],
# Force source project to main dir, so that Visual Studio can find the
# source files corresponding to build errors.
COMPONENT_VS_PROJECT_DIR = '$MAIN_DIR',
)
vs_env.AlwaysBuild(p)
# Solution and target projects
s = vs_env.ComponentVSSolution(
# 'libjingle', # Please uncomment this line if you build VS proj files.
['all_libraries', 'all_programs', 'all_test_programs'],
projects = [p],
)
print '***Unfortunately the vsproj creator isn\'t smart enough to '
print '***automatically get the correct output locations. It is very easy'
print '***though to change it in the properties pane to the following'
print '***$(SolutionDir)/build/<foo>/staging/<bar>.exe'
Default(None)
Default([s])
Reference in New Issue View Git Blame Copy Permalink