php/archived-php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2026-03-24 00:02:20 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
76791e90b9a26f707f4a5f3a0e7e7d5b17e2e820
archived-php-src/win32/build/config.w32
Calvin Buckley 76791e90b9 Use win32 glob implementation on all platforms (#18164) 
* Move glob to main/ from win32/

In preparation to make the Win32 reimplementation the standard
cross-platform one. Currently, it doesn't do that and just passes
through the original glob implementation. We could consider also having
an option to use the standard glob for systems that have a sufficient
one.

* Enable building with win32 glob on non-windows

Kind of broken. We're namespacing the function and struct, but not yet
the GLOB_* defines. There are a lot of places callers check if i.e.
NOMATCH is defined that would likely become redundant.

Currently it also has php_glob and #defines glob php_glob (etc.) - I
suspect doing the opposite and changing the callers would make more
sense, just doing MVP to geet it to build (even if it fails tests).

* Massive first pass at conversion to internal glob

Have not tested yet. the big things are:

- Should be invisible to userland PHP code.
- A lot of :%s/GLOB_/PHP_GLOB_/g; the diff can be noisy as a result,
  especially in comments.
- Prefixes everything with PHP_ to avoid conflicts with system glob in
  case it gets included transitively.
- A lot of weird shared definitions that were sprawled out to other
  headers are now included in php_glob.h.
- A lot of (but not yet all cases) of HAVE_GLOB are removed, since we
  can always fall back to php_glob.
- Using the system glob is not wired up yet; it'll need more shim
  ifdefs for each flag type than just glob_t/glob/globfree defs.

* Fix inclusion of GLOB_ONLYDIR

This is a GNU extension, but we don't need to implement it, as the GNU
implementation is flawed enough that callers have to manually filter it
anyways; just provide a stub definition for the constant.

We could consideer implementing this properly later. For now, fixes the
basic glob constant tests.

* Remove HAVE_GLOBs

We now always have a glob implementation that works. HAVE_GLOB should
only be used to check if we have a system implementation, for if we
decide to wrap the system implementation instead.

* We don't need to care about being POSIXly correct for internal glob

* Check for reallocarray

Ideally temporary until GH-17433.

* Forgot to move this file from win32/ to main/

* Check for issetugid (BSD function)

* Allow using the system glob with --enable-system-glob

* Style fix after removing ifdef

* Remove empty case for system glob
2025-05-20 16:20:59 -03:00

425 lines
16 KiB
JavaScript
Raw Blame History

// vim:ft=javascript
// "Master" config file; think of it as a configure.ac
// equivalent.
ARG_WITH("verbosity", "Output verbosity, 0-2.", "1");
setup_verbosity();
ARG_WITH("toolset", "Toolset to use for the compilation, give: vs, clang, icc. " +
"The only recommended and supported toolset for production use " +
"is Visual Studio. Use others at your own risk.", "vs");
toolset_option_handle();
ARG_WITH('cygwin', 'Path to cygwin utilities on your system', '\\cygwin');
toolset_setup_compiler();
HOST_ARCH = toolset_host_arch();
TARGET_ARCH = toolset_target_arch();
// for compatible only
X64 = TARGET_ARCH != 'x86';
toolset_setup_arch();
toolset_setup_linker();
toolset_setup_project_tools();
// stick objects somewhere outside of the source tree
ARG_ENABLE('object-out-dir', 'Alternate location for binary objects during build', '');
object_out_dir_option_handle();
ARG_ENABLE('debug', 'Compile with debugging symbols', "no");
ARG_ENABLE('debug-pack', 'Release binaries with external debug symbols (--enable-debug must not be specified)', 'no');
if (PHP_DEBUG == "yes" && PHP_DEBUG_PACK == "yes") {
ERROR("Use of both --enable-debug and --enable-debug-pack not allowed.");
}
if (PHP_DEBUG == "yes") {
ADD_FLAG("CFLAGS"," /Wall ");
ADD_FLAG("LDFLAGS", " /verbose ");
}
ARG_ENABLE('pgi', 'Generate PGO instrumented binaries', 'no');
ARG_WITH('pgo', 'Compile optimized binaries using training data from folder', 'no');
if (PHP_PGI == "yes" || PHP_PGO != "no") {
PGOMGR = PATH_PROG('pgomgr', WshShell.Environment("Process").Item("PATH"));
if (!PGOMGR) {
ERROR("--enable-pgi and --with-pgo options can only be used if PGO capable compiler is present.");
}
if (PHP_PGI == "yes" && PHP_PGO != "no") {
ERROR("Use of both --enable-pgi and --with-pgo not allowed.");
}
}
ARG_ENABLE('zts', 'Thread safety', 'yes');
// Configures the hard-coded installation dir
ARG_WITH('prefix', 'where PHP will be installed', '');
if (PHP_PREFIX == '') {
PHP_PREFIX = "C:\\php";
if (PHP_DEBUG == "yes")
PHP_PREFIX += "\\debug";
}
DEFINE('PHP_PREFIX', PHP_PREFIX);
DEFINE("BASE_INCLUDES", "/I . /I main /I Zend /I TSRM /I ext ");
toolset_setup_common_cflags();
if (VS_TOOLSET) {
ARG_WITH('mp', 'Tell Visual Studio use up to [n,auto,disable] processes for compilation', 'auto');
var PHP_MP_DISABLED = true;
if (PHP_MP != 'disable') {
if(PHP_DEBUG == 'yes') {
STDOUT.WriteLine('WARNING: Debug builds cannot be built using multi processing');
} else {
// no from disable-all
if(PHP_MP == 'auto' || PHP_MP == 'no') {
ADD_FLAG('CFLAGS', ' /MP ');
PHP_MP_DISABLED = false;
} else {
if(parseInt(PHP_MP) != 0) {
ADD_FLAG('CFLAGS', ' /MP'+ PHP_MP +' ');
PHP_MP_DISABLED = false;
} else {
STDOUT.WriteLine('WARNING: Invalid argument for MP: ' + PHP_MP);
}
}
}
}
if (!PHP_MP_DISABLED) {
STDOUT.WriteLine('Enabling multi process build');
}
}
// General link flags
toolset_setup_common_ldflags();
// General libs
toolset_setup_common_libs();
// Set some debug/release specific options
toolset_setup_build_mode();
setup_zts_stuff();
// CFLAGS, LDFLAGS and BUILD_DIR are defined
// Add compiler and link flags if PGO options are selected
if (PHP_DEBUG != "yes" && PHP_PGI == "yes") {
ADD_FLAG("STATIC_EXT_CFLAGS", "/GL /O2");
DEFINE("PGOPGD_DIR", "$(BUILD_DIR)");
}
else if (PHP_DEBUG != "yes" && PHP_PGO != "no") {
ADD_FLAG("STATIC_EXT_CFLAGS", "/GL /O2");
DEFINE("PGOPGD_DIR", ((PHP_PGO.length == 0 || PHP_PGO == "yes") ? "$(BUILD_DIR)" : PHP_PGO));
}
// Find the php_build dir - it contains headers and libraries
// that we need
ARG_WITH('php-build', 'Path to where you extracted the development libraries (https://wiki.php.net/internals/windows/libs). Assumes that it is a sibling of this source dir (..\\deps) if not specified', 'no');
php_build_option_handle();
ARG_WITH('extra-includes', 'Extra include path to use when building everything', '');
ARG_WITH('extra-libs', 'Extra library path to use when linking everything', '');
var php_usual_include_suspects = PHP_PHP_BUILD+"\\include";
var php_usual_lib_suspects = PHP_PHP_BUILD+"\\lib";
ADD_FLAG("CFLAGS", '/I "' + php_usual_include_suspects + '" ');
ADD_FLAG("LDFLAGS", '/libpath:"' + php_usual_lib_suspects + '" ');
ADD_FLAG("ARFLAGS", '/nologo /libpath:"' + php_usual_lib_suspects + '" ');
probe_basic_headers();
add_extra_dirs();
//DEFINE("PHP_BUILD", PHP_PHP_BUILD);
ARG_WITH("analyzer", "Enable static analyzer. Pass vs for Visual Studio, clang for clang, cppcheck for Cppcheck, pvs for PVS-Studio", "no");
if (PHP_ANALYZER == "vs") {
ADD_FLAG("CFLAGS", " /analyze ");
ADD_FLAG("CFLAGS", " /wd6308 ");
} else if (PHP_ANALYZER == "clang") {
var clang_cl = false;
if (FSO.FileExists(PROGRAM_FILES + "\\LLVM\\bin\\clang-cl.exe")) {
clang_cl = PROGRAM_FILES + "\\LLVM\\bin\\clang-cl.exe";
} else if (FSO.FileExists(PROGRAM_FILESx86 + "\\LLVM\\bin\\clang-cl.exe")) {
clang_cl = PROGRAM_FILESx86 + "\\LLVM\\bin\\clang-cl.exe";
}
if (!clang_cl) {
if (false == PATH_PROG('clang-cl', null, 'CLANG_CL')) {
WARNING("Couldn't find clang binaries, static analyze was disabled");
PHP_ANALYZER = "no";
}
} else {
DEFINE("CLANG_CL", clang_cl);
}
} else if (PHP_ANALYZER == "cppcheck") {
var cppcheck = false;
if (FSO.FileExists(PROGRAM_FILES + "\\Cppcheck\\cppcheck.exe")) {
cppcheck = PROGRAM_FILES + "\\Cppcheck\\cppcheck.exe";
} else if (FSO.FileExists(PROGRAM_FILESx86 + "\\Cppcheck\\cppcheck.exe")) {
cppcheck = PROGRAM_FILESx86 + "\\Cppcheck\\cppcheck.exe";
}
if (!cppcheck) {
if (false == PATH_PROG('cppcheck', null, 'CPPCHECK')) {
WARNING("Couldn't find Cppcheck binaries, static analyze was disabled");
PHP_ANALYZER = "no";
} else {
cppcheck = get_define("CPPCHECK");
}
} else {
DEFINE("CPPCHECK", cppcheck);
}
if (cppcheck) {
var _tmp = execute(cppcheck + " --version").split(/ /)[1];
var cppcheck_ver = [
parseInt(_tmp.split(".")[0]),
parseInt(_tmp.split(".")[1]),
];
if (cppcheck_ver[0] > 1 || cppcheck_ver[0] == 1 && cppcheck_ver[1] >= 77) {
var build_dir = get_define("BUILD_DIR");
var cppcheck_build_dir = build_dir + "\\cppcheck_build";
if (!FSO.FolderExists(cppcheck_build_dir)) {
FSO.CreateFolder(cppcheck_build_dir);
}
DEFINE("CPPCHECK_BUILD_DIR", cppcheck_build_dir);
}
}
} else if (PHP_ANALYZER == "pvs") {
var pvs_studio = false;
if (FSO.FileExists(PROGRAM_FILES + "\\PVS-Studio\\x64\\PVS-Studio.exe")) {
pvs_studio = PROGRAM_FILES + "\\PVS-Studio\\x86\\PVS-Studio.exe";
} else if (FSO.FileExists(PROGRAM_FILESx86 + "\\PVS-Studio\\x64\\PVS-Studio.exe")) {
pvs_studio = PROGRAM_FILESx86 + "\\PVS-Studio\\x64\\PVS-Studio.exe";
}
if (!pvs_studio) {
WARNING("Couldn't find PVS-Studio binaries, static analyze was disabled");
PHP_ANALYZER = "no";
} else {
var pvscfg = FSO.CreateTextFile("PVS-Studio.conf", true);
DEFINE("PVS_STUDIO", pvs_studio);
pvscfg.WriteLine("exclude-path = " + VCINSTALLDIR);
if (FSO.FolderExists(PROGRAM_FILESx86 + "\\windows kits\\")) {
pvscfg.WriteLine("exclude-path = " + PROGRAM_FILESx86 + "\\windows kits\\");
} else if (FSO.FolderExists(PROGRAM_FILES + "\\windows kits\\")) {
pvscfg.WriteLine("exclude-path = " + PROGRAM_FILES + "\\windows kits\\");
}
pvscfg.WriteLine("vcinstalldir = " + VCINSTALLDIR);
pvscfg.WriteLine("platform = " + (TARGET_ARCH == 'x86' ? 'Win32' : 'x64'));
pvscfg.WriteLine("preprocessor = visualcpp");
pvscfg.WriteLine("language = C");
pvscfg.WriteLine("skip-cl-exe = no");
}
} else {
PHP_ANALYZER = "no"
}
STDOUT.WriteBlankLines(1);
STDOUT.WriteLine("Build dir: " + get_define('BUILD_DIR'));
STDOUT.WriteLine("PHP Core: " + get_define('PHPDLL') + " and " + get_define('PHPLIB'));
ADD_SOURCES("Zend", "zend_language_parser.c zend_language_scanner.c \
zend_ini_parser.c zend_ini_scanner.c zend_alloc.c zend_call_stack.c \
zend_compile.c zend_constants.c zend_exceptions.c \
zend_execute_API.c zend_highlight.c \
zend_llist.c zend_vm_opcodes.c zend_opcode.c zend_operators.c zend_ptr_stack.c \
zend_stack.c zend_variables.c zend.c zend_API.c zend_extensions.c \
zend_hash.c zend_list.c zend_builtin_functions.c zend_attributes.c \
zend_ini.c zend_sort.c zend_multibyte.c \
zend_stream.c zend_iterators.c zend_interfaces.c zend_objects.c \
zend_object_handlers.c zend_objects_API.c \
zend_default_classes.c zend_execute.c zend_strtod.c zend_gc.c zend_closures.c zend_weakrefs.c \
zend_float.c zend_string.c zend_generators.c zend_virtual_cwd.c zend_ast.c \
zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_observer.c zend_system_id.c \
zend_enum.c zend_fibers.c zend_atomic.c zend_hrtime.c zend_frameless_function.c zend_property_hooks.c \
zend_lazy_objects.c");
ADD_SOURCES("Zend\\Optimizer", "zend_optimizer.c pass1.c pass3.c optimize_func_calls.c block_pass.c optimize_temp_vars_5.c nop_removal.c compact_literals.c zend_cfg.c zend_dfg.c dfa_pass.c zend_ssa.c zend_inference.c zend_func_info.c zend_call_graph.c zend_dump.c escape_analysis.c compact_vars.c dce.c sccp.c scdf.c");
var PHP_ASSEMBLER = PATH_PROG({
'x64': 'ML64',
'x86': 'ML',
'arm64': 'armasm64'
}[TARGET_ARCH]);
if (!PHP_ASSEMBLER) {
ERROR("No assembler found, fiber cannot be built");
}
DEFINE('PHP_ASSEMBLER', PHP_ASSEMBLER);
var FIBER_ASM_ABI = {
'x64': 'x86_64_ms_pe_masm',
'x86': 'i386_ms_pe_masm',
'arm64': 'arm64_aapcs_pe_armasm'
}[TARGET_ARCH];
DEFINE('FIBER_ASM_ABI', FIBER_ASM_ABI);
if (TARGET_ARCH == 'arm64') {
DEFINE('FIBER_ASM_FLAGS', '-nologo -machine ARM64 -o');
} else {
DEFINE('FIBER_ASM_FLAGS', '/DBOOST_CONTEXT_EXPORT=EXPORT /nologo /c /Fo');
}
var all_asm_objs = '$(BUILD_DIR)\\Zend\\jump_' + FIBER_ASM_ABI + '.obj $(BUILD_DIR)\\Zend\\make_' + FIBER_ASM_ABI + '.obj';
if (TARGET_ARCH == 'x64') {
all_asm_objs += ' $(BUILD_DIR)\\Zend\\save_xmm_x86_64_ms_masm.obj';
}
ADD_FLAG('ASM_OBJS', all_asm_objs);
MFO.WriteLine('$(BUILD_DIR)\\Zend\\jump_' + FIBER_ASM_ABI + '.obj: Zend\\asm\\jump_' + FIBER_ASM_ABI + '.asm');
MFO.WriteLine('\t$(PHP_ASSEMBLER) $(FIBER_ASM_FLAGS) $(BUILD_DIR)\\Zend\\jump_$(FIBER_ASM_ABI).obj Zend\\asm\\jump_$(FIBER_ASM_ABI).asm');
MFO.WriteLine('$(BUILD_DIR)\\Zend\\make_' + FIBER_ASM_ABI + '.obj: Zend\\asm\\make_' + FIBER_ASM_ABI + '.asm');
MFO.WriteLine('\t$(PHP_ASSEMBLER) $(FIBER_ASM_FLAGS) $(BUILD_DIR)\\Zend\\make_$(FIBER_ASM_ABI).obj Zend\\asm\\make_$(FIBER_ASM_ABI).asm');
if (TARGET_ARCH == 'x64') {
MFO.WriteLine('$(BUILD_DIR)\\Zend\\save_xmm_x86_64_ms_masm.obj: Zend\\asm\\save_xmm_x86_64_ms_masm.asm');
MFO.WriteLine('\t$(PHP_ASSEMBLER) $(FIBER_ASM_FLAGS) $(BUILD_DIR)\\Zend\\save_xmm_x86_64_ms_masm.obj Zend\\asm\\save_xmm_x86_64_ms_masm.asm');
}
ADD_FLAG("CFLAGS_BD_ZEND", "/D ZEND_ENABLE_STATIC_TSRMLS_CACHE=1");
if (VS_TOOLSET && VCVERS >= 1914) {
ADD_FLAG("CFLAGS_BD_ZEND", "/d2FuncCache1");
}
/* XXX inspect this for other toolsets */
//AC_DEFINE('ZEND_DVAL_TO_LVAL_CAST_OK', 1);
ADD_SOURCES("main", "main.c snprintf.c spprintf.c getopt.c fopen_wrappers.c \
php_ini_builder.c php_glob.c \
php_scandir.c php_ini.c SAPI.c rfc1867.c php_content_types.c strlcpy.c \
strlcat.c reentrancy.c php_variables.c php_ticks.c network.c \
php_open_temporary_file.c output.c internal_functions.c \
php_syslog.c php_odbc_utils.c safe_bcmp.c");
ADD_FLAG("CFLAGS_BD_MAIN", "/D ZEND_ENABLE_STATIC_TSRMLS_CACHE=1");
if (VS_TOOLSET && VCVERS >= 1914) {
ADD_FLAG("CFLAGS_BD_MAIN", "/d2FuncCache1");
}
AC_DEFINE('HAVE_STRNLEN', 1);
AC_DEFINE('ZEND_CHECK_STACK_LIMIT', 1)
ADD_SOURCES("main/streams", "streams.c cast.c memory.c filter.c plain_wrapper.c \
userspace.c transports.c xp_socket.c mmap.c glob_wrapper.c");
ADD_FLAG("CFLAGS_BD_MAIN_STREAMS", "/D ZEND_ENABLE_STATIC_TSRMLS_CACHE=1");
if (VS_TOOLSET && VCVERS >= 1914) {
ADD_FLAG("CFLAGS_BD_MAIN_STREAMS", "/d2FuncCache1");
}
ADD_SOURCES("win32", "dllmain.c readdir.c \
registry.c select.c sendmail.c time.c winutil.c wsyslog.c globals.c \
getrusage.c ftok.c ioutil.c codepage.c nice.c \
fnmatch.c sockets.c console.c signal.c");
ADD_FLAG("CFLAGS_BD_WIN32", "/D ZEND_ENABLE_STATIC_TSRMLS_CACHE=1");
if (VS_TOOLSET && VCVERS >= 1914) {
ADD_FLAG("CFLAGS_BD_WIN32", "/d2FuncCache1");
}
PHP_INSTALL_HEADERS("", "Zend/ TSRM/ main/ main/streams/ win32/");
PHP_INSTALL_HEADERS("Zend/Optimizer", "zend_call_graph.h zend_cfg.h zend_dfg.h zend_dump.h zend_func_info.h zend_inference.h zend_optimizer.h zend_ssa.h zend_worklist.h");
STDOUT.WriteBlankLines(1);
/* Can we build with IPv6 support? */
ARG_ENABLE("ipv6", "Disable IPv6 support (default is turn it on if available)", "yes");
AC_DEFINE('HAVE_GAI_STRERROR', 1);
if (PHP_IPV6 == "yes") {
STDOUT.WriteLine("Enabling IPv6 support");
AC_DEFINE('HAVE_IPV6', 1);
}
/* this allows up to 256 sockets to be select()ed in a single
* call to select(), instead of the usual 64 */
ARG_ENABLE('fd-setsize', "Set maximum number of sockets for select(2)", "256");
ADD_FLAG("CFLAGS", "/D FD_SETSIZE=" + parseInt(PHP_FD_SETSIZE));
/* For snapshot builders, where can we find the additional
* files that make up the snapshot template? */
ARG_WITH("snapshot-template", "Path to snapshot builder template dir", "no");
if (PHP_SNAPSHOT_TEMPLATE == "no") {
/* default is as a sibling of the php_build dir */
if (FSO.FolderExists(PHP_PHP_BUILD + "\\template")) {
PHP_SNAPSHOT_TEMPLATE = FSO.GetAbsolutePathName(PHP_PHP_BUILD + "\\template");
} else if (FSO.FolderExists(PHP_PHP_BUILD + "\\..\\template")) {
PHP_SNAPSHOT_TEMPLATE = FSO.GetAbsolutePathName(PHP_PHP_BUILD + "\\..\\template");
}
}
DEFINE('SNAPSHOT_TEMPLATE', PHP_SNAPSHOT_TEMPLATE);
ARG_ENABLE("security-flags", "Disable the compiler security flags", "yes");
if (PHP_SECURITY_FLAGS == "yes") {
ADD_FLAG("LDFLAGS", "/NXCOMPAT /DYNAMICBASE ");
}
ARG_ENABLE("sanitizer", "Enable ASan (and UBSan) extensions", "no");
if (PHP_SANITIZER == "yes" && PHP_DEBUG == "yes") {
ERROR("Use of both --enable-sanitizer and --enable-debug not allowed.");
}
if (PHP_SANITIZER == "yes" && PHP_DEBUG_PACK == "no") {
ERROR("--enable-sanitizer requires --enable-debug-pack");
}
if (VS_TOOLSET) {
if (PHP_SANITIZER == "yes") {
if (COMPILER_NUMERIC_VERSION < 1929) {
ERROR("MSVC at least 16.10 required for sanitation plugins");
}
}
} else if (CLANG_TOOLSET) {
AC_DEFINE("PHP_HAVE_BUILTIN_EXPECT", 1, "Define to 1 if the compiler supports '__builtin_expect'.");
AC_DEFINE("PHP_HAVE_BUILTIN_SADDL_OVERFLOW", 1, "Define to 1 if the compiler supports '__builtin_saddl_overflow'.");
AC_DEFINE("PHP_HAVE_BUILTIN_SADDLL_OVERFLOW", 1, "Define to 1 if the compiler supports '__builtin_saddll_overflow'.");
AC_DEFINE("PHP_HAVE_BUILTIN_SSUBL_OVERFLOW", 1, "Define to 1 if the compiler supports '__builtin_ssubl_overflow'.");
AC_DEFINE("PHP_HAVE_BUILTIN_SSUBLL_OVERFLOW", 1, "Define to 1 if the compiler supports '__builtin_ssubll_overflow'.");
AC_DEFINE("PHP_HAVE_BUILTIN_SMULL_OVERFLOW", 1, "Define to 1 if the compiler supports '__builtin_smull_overflow '.");
AC_DEFINE("PHP_HAVE_BUILTIN_SMULLL_OVERFLOW", 1, "Define to 1 if the compiler supports '__builtin_smulll_overflow'.");
if (PHP_SANITIZER == "yes") {
if (COMPILER_NUMERIC_VERSION < 500) {
ERROR("Clang at least 5.0.0 required for sanitation plugins");
}
add_asan_opts("CFLAGS", "LIBS", "LDFLAGS");
}
}
ARG_WITH("codegen-arch", "Architecture for code generation: ia32. Use --enable-native-intrinsics to enable SIMD optimizations.", "no");
toolset_setup_codegen_arch();
ARG_WITH("all-shared", "Force all the non obligatory extensions to be shared", "no");
// Config profiles (--with-config-profile=<name>) will save a certain config to php-src/config.<name>.bat
// so that it can be executed like: cofig.<name> instead of a long list of parameters
//
// Note, nice as a name is disallowed and will generate a warning and skip saving
ARG_WITH('config-profile', 'Name of the configuration profile to save this to in php-src/config.name.bat', 'no');
ARG_ENABLE("test-ini", "Enable automatic php.ini generation. The test.ini will be put \
into the build dir and used to automatically load the shared extensions.", "yes");
ARG_WITH("test-ini-ext-exclude", "Comma separated list of shared extensions to \
be excluded from the test.ini", "no");
ARG_ENABLE("native-intrinsics", "Comma separated list of intrinsic optimizations to enable. \
Available instruction set names are sse, sse2, sse3, ssse3, sse4.1, sse4.2, avx, avx2, avx512. \
SSE and SSE2 are enabled by default. The best instruction set specified will \
automatically enable all the older instruction sets. Note, that the produced binary \
might not work properly, if the chosen instruction sets are not available on the target \
processor.", "no");
toolset_setup_intrinsic_cflags();
ARG_ENABLE('snapshot-build', 'Build a snapshot: turns on everything it can and ignores build errors', 'no');
ARG_ENABLE('vs-link-compat', 'Allow linking of libraries built with compatible versions of VS toolset', 'yes');
Reference in New Issue View Git Blame Copy Permalink