def CHECK_SAMBA3_CHARSET(conf, crossbuild=False):
'''Check for default charsets for Samba3
'''
if conf.CHECK_ICONV(define='HAVE_NATIVE_ICONV'):
default_dos_charset = False
default_unix_charset = False
# check for default dos charset name
for charset in ['CP850', 'IBM850']:
if conf.CHECK_CHARSET_EXISTS(charset, headers='iconv.h'):
default_dos_charset = charset
break
# check for default unix charset name
for charset in ['UTF-8', 'UTF8']:
if conf.CHECK_CHARSET_EXISTS(charset, headers='iconv.h'):
default_unix_charset = charset
break
# At this point, we have a libiconv candidate. We know that
# we have the right headers and libraries, but we don't know
# whether it does the conversions we want. We can't test this
# because we are cross-compiling. This is not necessarily a big
# deal, since we can't guarantee that the results we get now will
# match the results we get at runtime anyway.
if crossbuild:
default_dos_charset = "CP850"
default_unix_charset = "UTF-8"
# TODO: this used to warn about the set charset on cross builds
if default_dos_charset is False or default_unix_charset is False:
# we found iconv, but it failed to convert anything (e.g. on AIX)
conf.undefine('HAVE_NATIVE_ICONV')
default_dos_charset = "ASCII"
default_unix_charset = "UTF-8"
conf.DEFINE('DEFAULT_DOS_CHARSET', default_dos_charset, quote=True)
conf.DEFINE('DEFAULT_UNIX_CHARSET', default_unix_charset, quote=True)
else:
conf.DEFINE('DEFAULT_DOS_CHARSET', "ASCII", quote=True)
conf.DEFINE('DEFAULT_UNIX_CHARSET', "UTF8", quote=True)
def SAMBA_CONFIG_H(conf, path=None):
'''write out config.h in the right directory'''
# we don't want to produce a config.h in places like lib/replace
# when we are building projects that depend on lib/replace
if not IN_LAUNCH_DIR(conf):
return
# we need to build real code that can't be optimized away to test
stack_protect_list = ['-fstack-protector-strong', '-fstack-protector']
for stack_protect_flag in stack_protect_list:
flag_supported = conf.check(
fragment='''
#include <stdio.h>
int main(void)
{
char t[100000];
while (fgets(t, sizeof(t), stdin));
return 0;
}
''',
execute=0,
cflags=['-Werror', '-Wp,-D_FORTIFY_SOURCE=2', stack_protect_flag],
mandatory=False,
msg='Checking if compiler accepts %s' % (stack_protect_flag))
if flag_supported:
conf.ADD_CFLAGS('%s' % (stack_protect_flag))
break
flag_supported = conf.check(
fragment='''
#include <stdio.h>
int main(void)
{
char t[100000];
while (fgets(t, sizeof(t), stdin));
return 0;
}
''',
execute=0,
cflags=['-Werror', '-fstack-clash-protection'],
mandatory=False,
msg='Checking if compiler accepts -fstack-clash-protection')
if flag_supported:
conf.ADD_CFLAGS('-fstack-clash-protection')
if Options.options.debug:
conf.ADD_CFLAGS('-g', testflags=True)
if Options.options.pidl_developer:
conf.env.PIDL_DEVELOPER_MODE = True
if Options.options.developer:
conf.env.DEVELOPER_MODE = True
conf.ADD_CFLAGS('-g', testflags=True)
conf.ADD_CFLAGS('-Wall', testflags=True)
conf.ADD_CFLAGS('-Wshadow', testflags=True)
conf.ADD_CFLAGS('-Wmissing-prototypes', testflags=True)
if CHECK_CODE(
conf,
'struct a { int b; }; struct c { struct a d; } e = { };',
'CHECK_C99_INIT',
link=False,
cflags=
'-Wmissing-field-initializers -Werror=missing-field-initializers',
msg="Checking C99 init of nested structs."):
conf.ADD_CFLAGS('-Wmissing-field-initializers', testflags=True)
conf.ADD_CFLAGS('-Wformat-overflow=2', testflags=True)
conf.ADD_CFLAGS('-Wformat-zero-length', testflags=True)
conf.ADD_CFLAGS('-Wcast-align -Wcast-qual', testflags=True)
conf.ADD_CFLAGS('-fno-common', testflags=True)
conf.ADD_CFLAGS('-Werror=address', testflags=True)
# we add these here to ensure that -Wstrict-prototypes is not set during configure
conf.ADD_CFLAGS('-Werror=strict-prototypes -Wstrict-prototypes',
testflags=True)
conf.ADD_CFLAGS('-Werror=write-strings -Wwrite-strings',
testflags=True)
conf.ADD_CFLAGS('-Werror-implicit-function-declaration',
testflags=True)
conf.ADD_CFLAGS('-Werror=pointer-arith -Wpointer-arith',
testflags=True)
conf.ADD_CFLAGS(
'-Werror=declaration-after-statement -Wdeclaration-after-statement',
testflags=True)
conf.ADD_CFLAGS('-Werror=return-type -Wreturn-type', testflags=True)
conf.ADD_CFLAGS('-Werror=uninitialized -Wuninitialized',
testflags=True)
conf.ADD_CFLAGS('-Wimplicit-fallthrough', testflags=True)
conf.ADD_CFLAGS('-Werror=strict-overflow -Wstrict-overflow=2',
testflags=True)
conf.ADD_CFLAGS('-Wformat=2 -Wno-format-y2k', testflags=True)
conf.ADD_CFLAGS('-Wno-format-zero-length', testflags=True)
conf.ADD_CFLAGS('-Werror=format-security -Wformat-security',
testflags=True,
prereq_flags='-Wformat')
# This check is because for ldb_search(), a NULL format string
# is not an error, but some compilers complain about that.
if CHECK_CFLAGS(
conf, ["-Werror=format", "-Wformat=2"], '''
int testformat(char *format, ...) __attribute__ ((format (__printf__, 1, 2)));
int main(void) {
testformat(0);
return 0;
}
'''):
if not 'EXTRA_CFLAGS' in conf.env:
conf.env['EXTRA_CFLAGS'] = []
conf.env['EXTRA_CFLAGS'].extend(TO_LIST("-Werror=format"))
if not Options.options.disable_warnings_as_errors:
conf.ADD_NAMED_CFLAGS('PICKY_CFLAGS',
'-Werror -Wno-error=deprecated-declarations',
testflags=True)
conf.ADD_NAMED_CFLAGS('PICKY_CFLAGS',
'-Wno-error=tautological-compare',
testflags=True)
conf.ADD_NAMED_CFLAGS('PICKY_CFLAGS',
'-Wno-error=cast-align',
testflags=True)
if Options.options.fatal_errors:
conf.ADD_CFLAGS('-Wfatal-errors', testflags=True)
if Options.options.pedantic:
conf.ADD_CFLAGS('-W', testflags=True)
if (Options.options.address_sanitizer
or Options.options.undefined_sanitizer):
conf.ADD_CFLAGS('-g -O1', testflags=True)
if Options.options.address_sanitizer:
conf.ADD_CFLAGS('-fno-omit-frame-pointer', testflags=True)
conf.ADD_CFLAGS('-fsanitize=address', testflags=True)
conf.ADD_LDFLAGS('-fsanitize=address', testflags=True)
conf.env['ADDRESS_SANITIZER'] = True
if Options.options.undefined_sanitizer:
conf.ADD_CFLAGS('-fsanitize=undefined', testflags=True)
conf.ADD_CFLAGS('-fsanitize=null', testflags=True)
conf.ADD_CFLAGS('-fsanitize=alignment', testflags=True)
conf.ADD_LDFLAGS('-fsanitize=undefined', testflags=True)
conf.env['UNDEFINED_SANITIZER'] = True
# Let people pass an additional ADDITIONAL_{CFLAGS,LDFLAGS}
# environment variables which are only used the for final build.
#
# The CFLAGS and LDFLAGS environment variables are also
# used for the configure checks which might impact their results.
#
# If these variables don't pass a smoke test, fail the configure
conf.add_os_flags('ADDITIONAL_CFLAGS')
if conf.env.ADDITIONAL_CFLAGS:
conf.CHECK_CFLAGS(conf.env['ADDITIONAL_CFLAGS'], mandatory=True)
conf.env['EXTRA_CFLAGS'].extend(conf.env['ADDITIONAL_CFLAGS'])
conf.add_os_flags('ADDITIONAL_LDFLAGS')
if conf.env.ADDITIONAL_LDFLAGS:
conf.CHECK_LDFLAGS(conf.env['ADDITIONAL_LDFLAGS'], mandatory=True)
conf.env['EXTRA_LDFLAGS'].extend(conf.env['ADDITIONAL_LDFLAGS'])
if path is None:
conf.write_config_header('default/config.h', top=True, remove=False)
else:
conf.write_config_header(os.path.join(conf.variant, path),
remove=False)
for key in conf.env.define_key:
conf.undefine(key, from_env=False)
conf.env.define_key = []
conf.SAMBA_CROSS_CHECK_COMPLETE()
def CHECK_CODE(conf,
code,
define,
always=False,
execute=False,
addmain=True,
add_headers=True,
mandatory=False,
headers=None,
msg=None,
cflags='',
includes='# .',
local_include=True,
lib=None,
link=True,
define_ret=False,
quote=False,
on_target=True,
strict=False):
'''check if some code compiles and/or runs'''
if CONFIG_SET(conf, define):
return True
if headers is not None:
CHECK_HEADERS(conf, headers=headers, lib=lib)
if add_headers:
hdrs = header_list(conf, headers=headers, lib=lib)
else:
hdrs = ''
if execute:
execute = 1
else:
execute = 0
if addmain:
fragment = '%s\n int main(void) { %s; return 0; }\n' % (hdrs, code)
else:
fragment = '%s\n%s\n' % (hdrs, code)
if msg is None:
msg = "Checking for %s" % define
cflags = TO_LIST(cflags)
# Be strict when relying on a compiler check
# Some compilers (e.g. xlc) ignore non-supported features as warnings
if strict:
if 'WERROR_CFLAGS' in conf.env:
cflags.extend(conf.env['WERROR_CFLAGS'])
if local_include:
cflags.append('-I%s' % conf.path.abspath())
if not link:
type = 'nolink'
else:
type = 'cprogram'
uselib = TO_LIST(lib)
(ccflags, ldflags, cpppath) = library_flags(conf, uselib)
includes = TO_LIST(includes)
includes.extend(cpppath)
uselib = [l.upper() for l in uselib]
cflags.extend(ccflags)
if on_target:
test_args = conf.SAMBA_CROSS_ARGS(msg=msg)
else:
test_args = []
conf.COMPOUND_START(msg)
try:
ret = conf.check(fragment=fragment,
execute=execute,
define_name=define,
cflags=cflags,
ldflags=ldflags,
includes=includes,
uselib=uselib,
type=type,
msg=msg,
quote=quote,
test_args=test_args,
define_ret=define_ret)
except Exception:
if always:
conf.DEFINE(define, 0)
else:
conf.undefine(define)
conf.COMPOUND_END(False)
if mandatory:
raise
return False
else:
# Success is indicated by ret but we should unset
# defines set by WAF's c_config.check() because it
# defines it to int(ret) and we want to undefine it
if not ret:
conf.undefine(define)
conf.COMPOUND_END(False)
return False
if not define_ret:
conf.DEFINE(define, 1)
conf.COMPOUND_END(True)
else:
conf.DEFINE(define, ret, quote=quote)
conf.COMPOUND_END(ret)
return True
def load_win_x64_win_x64_clang_common_settings(conf):
"""
Setup all compiler and linker settings shared over all win_x64_win_x64 configurations
"""
v = conf.env
global PLATFORM
# Load MSVC settings for non-build stuff (AzCG, CrcFix, etc)
load_win_x64_win_x64_vs2015_common_settings(conf)
windows_kit = conf.options.win_vs2015_winkit
try:
_, _, _, system_includes, _, _ = conf.detect_msvc(windows_kit, True)
except:
Logs.warn(
'Unable to find Windows Kit {}, removing build target'.format(
windows_kit))
conf.mark_supported_platform_for_removal(PLATFORM)
return
restricted_tool_list_macro_header = 'AZ_TOOLS_EXPAND_FOR_RESTRICTED_PLATFORMS='
restricted_tool_list_macro = restricted_tool_list_macro_header
# Start with a blank platform slate
conf.undefine('AZ_TOOLS_EXPAND_FOR_RESTRICTED_PLATFORMS')
if len(restricted_tool_list_macro) > len(
restricted_tool_list_macro_header):
v['DEFINES'] += [restricted_tool_list_macro]
# Remove MSVC/clang specific settings
v['CFLAGS'] = []
v['CXXFLAGS'] = []
v['LINKFLAGS'] = []
# Linker
v['CCLNK_SRC_F'] = v['CXXLNK_SRC_F'] = []
v['CCLNK_TGT_F'] = v['CXXLNK_TGT_F'] = '/OUT:'
v['LIB_ST'] = '%s.lib'
v['LIBPATH_ST'] = '/LIBPATH:%s'
v['STLIB_ST'] = '%s.lib'
v['STLIBPATH_ST'] = '/LIBPATH:%s'
v['cprogram_PATTERN'] = '%s.exe'
v['cxxprogram_PATTERN'] = '%s.exe'
v['cstlib_PATTERN'] = '%s.lib'
v['cxxstlib_PATTERN'] = '%s.lib'
v['cshlib_PATTERN'] = '%s.dll'
v['cxxshlib_PATTERN'] = '%s.dll'
v['LINKFLAGS_cshlib'] = ['/DLL']
v['LINKFLAGS_cxxshlib'] = ['/DLL']
# AR Tools
v['ARFLAGS'] = ['/NOLOGO']
v['AR_TGT_F'] = '/OUT:'
# Delete the env variables so that they can be replaced with the clang versions
del v['AR']
del v['CC']
del v['CXX']
del v['LINK']
conf.find_program('clang', var='CC', mandatory=False, silent_output=True)
if not v['CC']:
conf.mark_supported_platform_for_removal(PLATFORM)
Logs.warn('clang executable not found, removing platform {}'.format(
PLATFORM))
return
conf.find_program('clang++', var='CXX', silent_output=True)
conf.find_program('llvm-lib', var='AR', silent_output=True)
conf.find_program('lld-link', var='LINK', silent_output=True)
v['LINK_CC'] = v['LINK_CXX'] = v['LINK']
clang_FLAGS = [
'-mcx16',
'-msse3',
'-Wno-macro-redefined',
'-Wno-nonportable-include-path',
'-Wno-microsoft-cast',
'-Wno-ignored-pragma-intrinsic', # Clang doens't need #pragma intrinsic anyway, so don't whine when one isn't recognized
]
# Path to clang.exe is [clang]/bin/clang.exe, but the include path is [clang]/lib/clang/6.0.0/include
clang_include_path = os.path.join(
os.path.dirname(os.path.dirname(v['CXX'])), 'lib', 'clang', '6.0.0',
'include')
system_includes = [clang_include_path] + system_includes
# Treat all MSVC include paths as system headers
for include in system_includes:
clang_FLAGS += ['-isystem', include]
v['CFLAGS'] += clang_FLAGS
v['CXXFLAGS'] += clang_FLAGS
v['DEFINES'] += [
'_CRT_SECURE_NO_WARNINGS',
'_CRT_NONSTDC_NO_WARNINGS',
]
v['LINKFLAGS'] += [
'/MACHINE:x64',
'/MANIFEST', # Create a manifest file
'/OPT:REF',
'/OPT:ICF', # Always optimize for size, there's no reason not to
'/LARGEADDRESSAWARE', # tell the linker that the application can handle addresses larger than 2 gigabytes.
]
