############################################################################
|
# Copyright 2016-2017 Intel Corporation
|
#
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
# you may not use this file except in compliance with the License.
|
# You may obtain a copy of the License at
|
#
|
# http://www.apache.org/licenses/LICENSE-2.0
|
#
|
# Unless required by applicable law or agreed to in writing, software
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
# See the License for the specific language governing permissions and
|
# limitations under the License.
|
############################################################################
|
|
"""use scons -k to invoke all builds regardless of unit test failures
|
"""
|
import string
|
import sys
|
import SCons.Script
|
import os.path
|
import subprocess
|
from subprocess import Popen, PIPE
|
from parts import *
|
import re
|
import tempfile
|
import shutil
|
from collections import OrderedDict
|
|
def get_parts_versions(env):
|
"""Get Parts related versions given SCons environment env"""
|
return OrderedDict({'python': string.split(sys.version, " ", 1)[0],
|
'scons': str(SCons.__version__),
|
'parts': str(PartsExtensionVersion())})
|
|
def get_toolchain_versions(env):
|
"""Get version of compilation toolchain given SCons environment env"""
|
versions = OrderedDict()
|
if 'MSVC_VERSION' in env:
|
versions['compiler'] = 'MSVC ' + env['MSVC_VERSION']
|
cmd = env.subst('echo int main(){return 0;} > a.cpp'
|
' | $CXX $CCFLAGS a.cpp /link /verbose')
|
defaultlib_regexp = r'.*Searching (.*\.lib).*'
|
elif 'GCC_VERSION' in env:
|
versions['compiler'] = 'GCC ' + env['GCC_VERSION']
|
if 'GXX_VERSION' in env:
|
versions['compiler'] += ' and GXX ' + env['GXX_VERSION']
|
if os.name == 'nt':
|
cmd = env.subst('echo int main(){return 0;}'
|
' | $CXX $CCFLAGS -xc++ -Wl,--verbose -')
|
else:
|
cmd = env.subst('echo "int main(){return 0;}"'
|
' | $CXX $CCFLAGS -xc++ -Wl,--verbose -')
|
else:
|
if os.name == 'nt':
|
cmd = env.subst('echo int main(){return 0;}'
|
' | $CXX $CCFLAGS -xc++ -Wl,--verbose -')
|
else:
|
cmd = env.subst('echo "int main(){return 0;}"'
|
' | $CC $CCFLAGS -xc -Wl,--verbose -')
|
if os.name == 'nt':
|
defaultlib_regexp = r'\n.* open (.*) succeeded'
|
else:
|
defaultlib_regexp = r'[\n(](/.*\.so[-.\da-fA-F]*).*'
|
|
# Intel C compiler always depends from base toolchain
|
if 'INTELC_VERSION' in env:
|
versions['compiler'] = 'INTELC {0} with {1}'.format(
|
env['INTELC_VERSION'],
|
versions['compiler'])
|
|
env['ENV']['PATH'] = str(env['ENV']['PATH'])
|
temp_dir = tempfile.mkdtemp()
|
try:
|
proc = subprocess.Popen(cmd,
|
cwd=temp_dir,
|
env=env['ENV'],
|
shell=True,
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
stdout, _ = proc.communicate()
|
if proc.returncode != 0:
|
versions['default_libs'] = 'failure executing: "{0}"'.format(cmd)
|
else:
|
default_libs = list(
|
set(re.findall(defaultlib_regexp, stdout, re.M)))
|
if 'MSVC_VERSION' in env:
|
# for windows additionally report versions of Windows Kit used
|
runtime_version_set = set()
|
for lib_path in default_libs:
|
path_components = os.path.realpath(lib_path).split(os.sep)
|
if 'Windows Kits' in path_components:
|
i = path_components.index('Windows Kits')
|
runtime_version_set.add(
|
'Windows Kits {0} {1}'.format(path_components[i + 1],
|
path_components[i + 3]))
|
versions['sdk_or_libc'] = '; '.join(list(runtime_version_set))
|
else:
|
# for posix additionally report versions of libc used
|
versions['sdk_or_libc'] = os.path.split(os.path.realpath(
|
next((lib for lib in default_libs if
|
'libc' in lib.lower() and 'libcilk' not in lib.lower()), None)))[1]
|
versions['default_libs'] = default_libs
|
finally:
|
shutil.rmtree(temp_dir)
|
|
return versions
|
|
|
def log_versions(env, include_toolchain=True):
|
"""Log tools and libraries versions given SCons environment env
|
|
Args:
|
env: Scons environment.
|
include_toolchain: Log version of compilation toolchain if True.
|
"""
|
|
versions = get_parts_versions(env)
|
if include_toolchain:
|
versions.update(get_toolchain_versions(env))
|
|
print "**************** VERSIONS *************"
|
long_names = {
|
'python': 'Python Version',
|
'scons': 'SCons Version',
|
'parts': 'Parts Version',
|
'compiler': 'Compiler Version',
|
'sdk_or_libc': 'Libc/SDK',
|
'default_libs': 'Default Libs'
|
}
|
for name, value in versions.iteritems():
|
if not isinstance(value, list):
|
print '* {0}: {1}'.format(long_names.get(name, name), value)
|
else:
|
print '* {0}:\n* \t{1}'.format(long_names.get(name, name),
|
'\n* \t'.join(sorted(value)))
|
print "***************************************"
|
|
|
def include_parts(part_list, **kwargs):
|
for parts_file in part_list:
|
if os.path.isfile(DefaultEnvironment().subst(parts_file)):
|
Part(parts_file=parts_file, **kwargs)
|
|
|
######## Part groups ####################################################
|
ipp_parts = ['ext/ipp/ippcp.parts']
|
utest_parts = ['ext/gtest/gtest.parts',
|
'epid/common-testhelper/common-testhelper.parts']
|
common_parts = ['epid/common/common.parts']
|
member_parts = ['epid/member/member.parts']
|
verifier_parts = ['epid/verifier/verifier.parts']
|
util_parts = ['example/util/util.parts']
|
example_parts = ['ext/argtable3/argtable3.parts',
|
'example/verifysig/verifysig.parts',
|
'example/signmsg/signmsg.parts',
|
'example/data/data.parts',
|
'example/compressed_data/compressed_data.parts']
|
sizing_parts = ['example/util/util_static.parts',
|
'example/signmsg/signmsg_shared.parts',
|
'example/verifysig/verifysig_shared.parts',
|
'example/verifysig/verifysig11_shared.parts']
|
example_static_parts = ['example/util/util_static.parts',
|
'example/signmsg/signmsg_static.parts',
|
'example/verifysig/verifysig_static.parts']
|
tools_parts = ['tools/revokegrp/revokegrp.parts',
|
'tools/revokekey/revokekey.parts',
|
'tools/revokesig/revokesig.parts',
|
'tools/extractkeys/extractkeys.parts',
|
'tools/extractgrps/extractgrps.parts']
|
testbot_test_parts = ['test/testbot/testbot.parts',
|
'test/testbot/signmsg/signmsg_testbot.parts',
|
'test/testbot/verifysig/verifysig_testbot.parts',
|
'test/testbot/integration/integration_testbot.parts',
|
'test/testbot/ssh_remote/ssh_remote_testbot.parts',
|
'test/testbot/revokegrp/revokegrp_testbot.parts',
|
'test/testbot/revokekey/revokekey_testbot.parts',
|
'test/testbot/revokesig/revokesig_testbot.parts',
|
'test/testbot/extractkeys/extractkeys_testbot.parts',
|
'test/testbot/extractgrps/extractgrps_testbot.parts',
|
'tools/reports/reports.parts']
|
tss_test_parts = ['test/tss/tss.parts']
|
package_parts = ['ext/gtest/gtest.parts',
|
'ext/ipp/ippcp.parts',
|
'package.parts']
|
memory_profiler_parts = ['tools/memory_profiler/memory_profiler.parts']
|
internal_tools_parts = ['ext/argtable3/argtable3.parts',
|
'tools/ikgfwrapper/ikgfwrapper.parts']
|
epid_data = ['test/epid_data/epid_data.parts']
|
perf_benchmark_parts = ['ext/google_benchmark/google_benchmark.parts',
|
'test/performance/performance.parts']
|
memory_benchmark_parts = ['test/dynamic_memory/dynamic_memory.parts']
|
######## End Part groups ###############################################
|
######## Commandline option setup #######################################
|
product_variants = [
|
'production',
|
'internal-test',
|
'package-epid-sdk',
|
'internal-tools',
|
'benchmark',
|
'tiny',
|
'internal-test-tiny'
|
]
|
|
default_variant = 'production'
|
|
|
def is_production():
|
return GetOption("product-variant") == 'production'
|
|
|
def is_internal_test():
|
return GetOption("product-variant") == 'internal-test'
|
|
|
def is_internal_tools():
|
return GetOption("product-variant") == 'internal-tools'
|
|
|
def is_package():
|
return GetOption("product-variant") == 'package-epid-sdk'
|
|
|
def is_benchmark():
|
return GetOption("product-variant") == 'benchmark'
|
|
def is_tiny():
|
return GetOption("product-variant") == 'tiny'
|
|
def is_internal_test_tiny():
|
return GetOption("product-variant") == 'internal-test-tiny'
|
|
|
def use_commercial_ipp():
|
return GetOption("use-commercial-ipp")
|
|
|
def use_tss():
|
return GetOption("use-tss")
|
|
|
def config_has_instrumentation():
|
return any(DefaultEnvironment().isConfigBasedOn(config_name)
|
for config_name in ['instr_release'])
|
|
|
def variant_dirname():
|
s = GetOption("product-variant")
|
if s == 'production':
|
return 'epid-sdk'
|
elif s == 'package-epid-sdk':
|
return 'epid-sdk'
|
elif s == 'tiny':
|
return 'epid-sdk'
|
else:
|
return s
|
|
|
AddOption("--product-variant", "--prod-var", nargs=1,
|
help=("Select product variant to build. Possible "
|
"options are: {0}. The default is {1} if no option "
|
"is specified").format(", ".join(product_variants),
|
default_variant),
|
action='store', dest='product-variant', type='choice',
|
choices=product_variants, default=default_variant)
|
|
AddOption("--use-commercial-ipp",
|
help=("Link with commercial IPP. The IPPCRYPTOROOT environment "
|
"variable must be set."),
|
action='store_true', dest='use-commercial-ipp',
|
default=False)
|
|
AddOption("--use-tss",
|
help=("Link with TPM TSS. The TSSROOT environment variable "
|
"must be set."),
|
action='store_true', dest='use-tss',
|
default=False)
|
|
AddOption("--ipp-shared",
|
help=("Build /ext/ipp as shared library."),
|
action='store_true', dest='ipp-shared',
|
default=False)
|
|
AddOption("--enable-sanitizers",
|
help=("Build with sanitizers (https://github.com/google/sanitizers)."),
|
action='store_true', dest='sanitizers',
|
default=False)
|
|
AddOption("--sanitizers-recover",
|
help=("Configure sanititzers to recover and continue execution "
|
"on error found. Only applicable when sanitizers are enabled."
|
"See --enable-sanitizers option."),
|
action='store_true', dest='sanitizers-recover',
|
default=False)
|
|
|
SetOptionDefault("PRODUCT_VARIANT", variant_dirname())
|
|
######## End Commandline option setup ###################################
|
|
|
# fix for parts 0.10.8 until we get better logic to extract ${CC}
|
SetOptionDefault('PARTS_USE_SHORT_TOOL_NAMES', 1)
|
|
|
def enable_sanitizers(recover):
|
"""
|
Configures compiler to enable sanitizers.
|
Adds sanitizer options to default scons environment such
|
that it affects all parts.
|
Args:
|
recover: Enable sanitizers recovery from errors found when True.
|
"""
|
env = DefaultEnvironment()
|
error_msg = None
|
try:
|
major = int(env.subst('$GCC_VERSION').partition('.')[0])
|
except ValueError:
|
major = 0
|
|
if major >= 6 and env['TARGET_OS'] == 'posix':
|
if 'INTELC_VERSION' not in env:
|
ccflags = ['-fsanitize=address,undefined', '-fno-sanitize=alignment',
|
'-fno-sanitize=shift', '-fno-omit-frame-pointer']
|
if recover:
|
ccflags = ccflags + ['-fsanitize-recover=all', '-fsanitize-recover=address']
|
else:
|
ccflags = ccflags + ['-fno-sanitize-recover']
|
# Extends default flags with sanitizer options
|
SetOptionDefault('CCFLAGS', ccflags)
|
SetOptionDefault('LIBS', ['asan', 'ubsan'])
|
else:
|
error_msg = """
|
Build with sanitizers is not supported for Intel(R) C++ Compiler.
|
Try scons --toolchain=gcc_6 --target=posix
|
"""
|
else:
|
# User experience with sanitizers in GCC 4.8 is not great. Use at least GCC 6.x.
|
error_msg = """
|
Build with sanitizers is only supported for GCC version greater than
|
6.x targeting posix OS. Current GCC version is "{0}" and OS target is "{1}".
|
Try scons --toolchain=gcc_6 --target=posix
|
""".format(env.get('GCC_VERSION', 'unknown'), env.get('TARGET_OS', 'unknown'))
|
if error_msg is not None:
|
env.PrintError(error_msg)
|
|
|
def set_default_production_options():
|
SetOptionDefault('CONFIG', 'release')
|
|
SetOptionDefault('TARGET_VARIANT', '${TARGET_OS}-${TARGET_ARCH}')
|
|
SetOptionDefault('INSTALL_ROOT',
|
'#_install/${PRODUCT_VARIANT}')
|
|
SetOptionDefault('INSTALL_TOOLS_BIN',
|
'$INSTALL_ROOT/tools')
|
|
SetOptionDefault('INSTALL_SAMPLE_BIN',
|
'$INSTALL_ROOT/example')
|
|
SetOptionDefault('INSTALL_EPID_INCLUDE',
|
'$INSTALL_ROOT/include/epid')
|
|
SetOptionDefault('INSTALL_IPP_INCLUDE',
|
'$INSTALL_ROOT/include/ext/ipp/include')
|
|
SetOptionDefault('INSTALL_TEST_BIN',
|
'$INSTALL_ROOT/test')
|
|
SetOptionDefault('INSTALL_LIB',
|
'$INSTALL_ROOT/lib/${TARGET_VARIANT}')
|
|
SetOptionDefault('INSTALL_SAMPLE_DATA',
|
'$INSTALL_ROOT/example')
|
|
SetOptionDefault('INSTALL_TOOLS_DATA',
|
'$INSTALL_ROOT/tools')
|
|
SetOptionDefault('PACKAGE_DIR',
|
'#_package')
|
|
SetOptionDefault('PACKAGE_ROOT',
|
'#_package/${PRODUCT_VARIANT}')
|
|
SetOptionDefault('ROOT',
|
'#')
|
|
SetOptionDefault('PACKAGE_NAME',
|
'{PRODUCT_VARIANT}')
|
|
|
if GetOption("sanitizers"):
|
enable_sanitizers(GetOption("sanitizers-recover"))
|
|
if is_production():
|
set_default_production_options()
|
ipp_mode = ['install_lib']
|
if use_commercial_ipp():
|
ipp_mode.append('use_commercial_ipp')
|
sdk_mode = ['install_lib']
|
if use_tss():
|
sdk_mode.append('use_tss')
|
if GetOption('ipp-shared'):
|
ipp_mode.append('build_ipp_shared')
|
include_parts(ipp_parts, mode=ipp_mode,
|
INSTALL_INCLUDE='${INSTALL_IPP_INCLUDE}')
|
include_parts(utest_parts + common_parts +
|
member_parts + verifier_parts,
|
mode=sdk_mode,
|
INSTALL_INCLUDE='${INSTALL_EPID_INCLUDE}')
|
include_parts(util_parts + example_parts,
|
INSTALL_INCLUDE='${INSTALL_EPID_INCLUDE}',
|
INSTALL_BIN='${INSTALL_SAMPLE_BIN}',
|
INSTALL_DATA='${INSTALL_SAMPLE_DATA}')
|
include_parts(tools_parts,
|
INSTALL_BIN='${INSTALL_TOOLS_BIN}',
|
INSTALL_DATA='${INSTALL_TOOLS_DATA}')
|
Default('all')
|
Default('utest::')
|
if not use_tss():
|
Default('run_utest::')
|
|
if is_internal_test():
|
set_default_production_options()
|
sdk_mode = []
|
if use_tss():
|
sdk_mode.append('use_tss')
|
include_parts(tss_test_parts)
|
include_parts(ipp_parts)
|
include_parts(utest_parts + common_parts +
|
member_parts + verifier_parts,
|
mode=sdk_mode)
|
include_parts(util_parts + example_parts,
|
INSTALL_BIN='${INSTALL_SAMPLE_BIN}',
|
INSTALL_DATA='${INSTALL_SAMPLE_DATA}')
|
include_parts(sizing_parts,
|
INSTALL_BIN='${INSTALL_SAMPLE_BIN}')
|
include_parts(tools_parts, INSTALL_BIN='${INSTALL_TOOLS_BIN}')
|
include_parts(testbot_test_parts)
|
Default('all')
|
|
if is_internal_tools():
|
set_default_production_options()
|
include_parts(ipp_parts + utest_parts + common_parts + verifier_parts + member_parts + util_parts)
|
include_parts(internal_tools_parts + memory_profiler_parts,
|
INSTALL_BIN='${INSTALL_TOOLS_BIN}')
|
Default('ikgfwrapper', 'memory_profiler')
|
Default('run_utest::memory_profiler::')
|
|
if is_benchmark():
|
set_default_production_options()
|
MODE = []
|
if config_has_instrumentation():
|
MODE.append('use_memory_profiler')
|
ipp_mode = []
|
if use_commercial_ipp():
|
ipp_mode.append('use_commercial_ipp')
|
|
# install ipp static and ipp shared builds into separate locations
|
if GetOption('ipp-shared'):
|
ipp_mode.append('build_ipp_shared')
|
SetOptionDefault('INSTALL_TEST_BIN',
|
'$INSTALL_ROOT/test_ipp_shared')
|
SetOptionDefault('INSTALL_LIB',
|
'$INSTALL_ROOT/lib_ipp_shared')
|
else:
|
SetOptionDefault('INSTALL_LIB',
|
'$INSTALL_ROOT/lib')
|
|
# do not allow file links to keep previous builds intact
|
SetOptionDefault('CCOPY_LOGIC', 'copy')
|
|
include_parts(ipp_parts, config_independent=True, mode=MODE + ipp_mode,
|
INSTALL_BIN='${INSTALL_TEST_BIN}')
|
include_parts(example_static_parts + utest_parts + perf_benchmark_parts +
|
common_parts + verifier_parts +
|
sizing_parts + epid_data,
|
config_independent=True,
|
mode=MODE,
|
INSTALL_BIN='${INSTALL_TEST_BIN}')
|
|
member_mode = ['install_lib']
|
member_cfg = ('embedded' if not DefaultEnvironment().isConfigBasedOn(
|
'debug') and not config_has_instrumentation() else DefaultEnvironment().subst('$CONFIG'))
|
Part(parts_file='epid/common/tinycommon.parts', CONFIG=member_cfg)
|
Part(parts_file='epid/member/tinymember.parts', CONFIG=member_cfg,
|
config_independent=True, mode=MODE + member_mode, INSTALL_BIN='${INSTALL_TEST_BIN}')
|
|
if config_has_instrumentation():
|
include_parts(memory_benchmark_parts + memory_profiler_parts,
|
config_independent=True,
|
mode=MODE,
|
INSTALL_BIN='${INSTALL_TEST_BIN}')
|
|
Default('build::')
|
|
if is_package():
|
set_default_production_options()
|
include_parts(package_parts,
|
mode=['install_package'],
|
INSTALL_TOP_LEVEL='${PACKAGE_ROOT}')
|
Default('package')
|
|
if is_tiny():
|
set_default_production_options()
|
### Member
|
Part(parts_file='ext/gtest/gtest.parts')
|
member_mode = ['install_lib']
|
member_cfg = ('embedded'
|
if not DefaultEnvironment().isConfigBasedOn('debug')
|
else DefaultEnvironment().subst('$CONFIG'))
|
Part(parts_file='epid/common/tinycommon.parts', CONFIG=member_cfg)
|
Part(parts_file='epid/member/tinymember.parts', CONFIG=member_cfg,
|
config_independent=True, mode=member_mode)
|
Default('member::')
|
Default('run_utest::member::')
|
### Verifier, samples and tools
|
verifier_mode = ['install_lib']
|
ipp_mode = ['install_lib']
|
if use_commercial_ipp():
|
ipp_mode.append('use_commercial_ipp')
|
if GetOption('ipp-shared'):
|
ipp_mode.append('build_ipp_shared')
|
include_parts(ipp_parts, mode=ipp_mode,
|
INSTALL_INCLUDE='${INSTALL_IPP_INCLUDE}')
|
Part(parts_file='epid/common-testhelper/common-testhelper.parts',
|
config_independent=True)
|
include_parts(common_parts + verifier_parts,
|
mode=verifier_mode,
|
INSTALL_INCLUDE='${INSTALL_EPID_INCLUDE}')
|
include_parts(util_parts + example_parts,
|
INSTALL_INCLUDE='${INSTALL_EPID_INCLUDE}',
|
INSTALL_BIN='${INSTALL_SAMPLE_BIN}',
|
INSTALL_DATA='${INSTALL_SAMPLE_DATA}')
|
include_parts(tools_parts,
|
INSTALL_BIN='${INSTALL_TOOLS_BIN}',
|
INSTALL_DATA='${INSTALL_TOOLS_DATA}')
|
Default('all')
|
Default('utest::')
|
|
if is_internal_test_tiny():
|
set_default_production_options()
|
sdk_mode = []
|
### Member
|
Part(parts_file='ext/gtest/gtest.parts')
|
member_cfg = ('embedded'
|
if not DefaultEnvironment().isConfigBasedOn('debug')
|
else DefaultEnvironment().subst('$CONFIG'))
|
Part(parts_file='epid/common/tinycommon.parts', CONFIG=member_cfg)
|
Part(parts_file='epid/member/tinymember.parts', CONFIG=member_cfg,
|
config_independent=True, mode=sdk_mode)
|
### Verifier, samples and tools
|
include_parts(ipp_parts)
|
Part(parts_file='epid/common-testhelper/common-testhelper.parts',
|
config_independent=True)
|
include_parts(common_parts + verifier_parts,
|
mode=sdk_mode)
|
include_parts(util_parts + example_parts,
|
INSTALL_BIN='${INSTALL_SAMPLE_BIN}',
|
INSTALL_DATA='${INSTALL_SAMPLE_DATA}')
|
include_parts(tools_parts, INSTALL_BIN='${INSTALL_TOOLS_BIN}')
|
include_parts(testbot_test_parts)
|
Default('build::')
|
|
log_versions(DefaultEnvironment(), not is_package())
|
