]> git.ipfire.org Git - thirdparty/openssl.git/blame - Configure
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Move cpuid_asm_src file information to build.info files
[thirdparty/openssl.git] / Configure
CommitLineData
de17db91 1#! /usr/bin/env perl
f4d8f037 2# -*- mode: perl; -*-
48e5119a 3# Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
ac3d0e13 4#
402dd558 5# Licensed under the Apache License 2.0 (the "License"). You may not use
ac3d0e13
RS		 6# this file except in compliance with the License. You can obtain a copy
7# in the file LICENSE in the source distribution or at
8# https://www.openssl.org/source/license.html
de17db91 9
a4ed5532 10## Configure -- OpenSSL source tree configuration script
1641cb60 11
d83112b7 12use 5.10.0;
1641cb60 13use strict;
141d7325 14use Config;
cb6afcd6
RL		 15use FindBin;
16use lib "$FindBin::Bin/util/perl";
f09e7ca9 17use File::Basename;
7f73eafe 18use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs splitdir/;
dca99383 19use File::Path qw/mkpath/;
8d2214c0 20use OpenSSL::Glob;
1641cb60 21
22a4f969 22# see INSTALL for instructions.
462ba4f6 23
8937a4ed
RL		 24my $orig_death_handler = $SIG{__DIE__};
25$SIG{__DIE__} = \&death_handler;
26
31b6ed76 27my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
462ba4f6 28
434c5dd3 29# Options:
e5f3045f 30#
f09e7ca9
RS		 31# --config add the given configuration file, which will be read after
32# any "Configurations*" files that are found in the same
33# directory as this script.
d74dfafd
RL		 34# --prefix prefix for the OpenSSL installation, which includes the
35# directories bin, lib, include, share/man, share/doc/openssl
36# This becomes the value of INSTALLTOP in Makefile
37# (Default: /usr/local)
38# --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
39# If it's a relative directory, it will be added on the directory
40# given with --prefix.
41# This becomes the value of OPENSSLDIR in Makefile and in C.
42# (Default: PREFIX/ssl)
e5f3045f 43#
cbfb39d1
AP		 44# --cross-compile-prefix Add specified prefix to binutils components.
45#
fcd2d5a6
RL		 46# --api One of 0.9.8, 1.0.0, 1.0.1, 1.0.2, 1.1.0, 1.1.1, or 3.0.0 / 3.
47# Do not compile support for interfaces deprecated as of the
48# specified OpenSSL version.
98186eb4 49#
5270e702
RL		 50# no-hw-xxx do not compile support for specific crypto hardware.
51# Generic OpenSSL-style methods relating to this support
52# are always compiled but return NULL if the hardware
53# support isn't compiled.
54# no-hw do not compile support for any crypto hardware.
5f8d5c96
BM		 55# [no-]threads [don't] try to create a library that is suitable for
56# multithreaded applications (default is "threads" if we
57# know how to do it)
84f32c84 58# [no-]shared [don't] try to create shared libraries when supported.
ae48242c 59# [no-]pic [don't] try to build position independent code when supported.
45b71abe 60# If disabled, it also disables shared and dynamic-engine.
a723979d 61# no-asm do not use assembler
0423f812 62# no-egd do not compile support for the entropy-gathering daemon APIs
e452de9d 63# [no-]zlib [don't] compile support for zlib compression.
84f32c84
DMSP		 64# zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
65# library and will be loaded in run-time by the OpenSSL library.
7e159e01 66# sctp include SCTP support
5ded1ca6 67# no-uplink Don't build support for UPLINK interface.
8b1a5af3 68# enable-weak-ssl-ciphers
edcdf38b 69# Enable weak ciphers that are disabled by default.
5ae5dc96
AP		 70# 386 generate 80386 code in assembly modules
71# no-sse2 disables IA-32 SSE2 code in assembly modules, the above
72# mentioned '386' option implies this one
79df9d62 73# no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
fce0ba5f 74# -<xxx> +<xxx> compiler options are passed through
047d97af
AP		 75# -static while -static is also a pass-through compiler option (and
76# as such is limited to environments where it's actually
77# meaningful), it triggers a number configuration options,
31b6ed76 78# namely no-pic, no-shared and no-threads. It is
047d97af
AP		 79# argued that the only reason to produce statically linked
80# binaries (and in context it means executables linked with
81# -static flag, and not just executables linked with static
82# libcrypto.a) is to eliminate dependency on specific run-time,
83# a.k.a. libc version. The mentioned config options are meant
84# to achieve just that. Unfortunately on Linux it's impossible
85# to eliminate the dependency completely for openssl executable
86# because of getaddrinfo and gethostbyname calls, which can
87# invoke dynamically loadable library facility anyway to meet
88# the lookup requests. For this reason on Linux statically
89# linked openssl executable has rather debugging value than
90# production quality.
e41c8d6a 91#
84f32c84
DMSP		 92# BN_LLONG use the type 'long long' in crypto/bn/bn.h
93# RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
d0590fe6
AP		 94# Following are set automatically by this script
95#
84f32c84
DMSP		 96# MD5_ASM use some extra md5 assembler,
97# SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
98# RMD160_ASM use some extra ripemd160 assembler,
99# SHA256_ASM sha256_block is implemented in assembler
100# SHA512_ASM sha512_block is implemented in assembler
101# AES_ASM AES_[en|de]crypt is implemented in assembler
d02b48c6 102
3b437400
RL		 103# Minimum warning options... any contributions to OpenSSL should at least
104# get past these. Note that we only use these with C compilers, not with
105# C++ compilers.
363bd0b4 106
463a7b8c 107# DEBUG_UNUSED enables __owur (warn unused result) checks.
77305338
RS		 108# -DPEDANTIC complements -pedantic and is meant to mask code that
109# is not strictly standard-compliant and/or implementation-specific,
110# e.g. inline assembly, disregards to alignment requirements, such
111# that -pedantic would complain about. Incidentally -DPEDANTIC has
112# to be used even in sanitized builds, because sanitizer too is
113# supposed to and does take notice of non-standard behaviour. Then
114# -pedantic with pre-C9x compiler would also complain about 'long
115# long' not being supported. As 64-bit algorithms are common now,
116# it grew impossible to resolve this without sizeable additional
117# code, so we just tell compiler to be pedantic about everything
118# but 'long long' type.
119
3b437400
RL		 120my @gcc_devteam_warn = qw(
121 -DDEBUG_UNUSED
122 -DPEDANTIC -pedantic -Wno-long-long
123 -Wall
124 -Wextra
125 -Wno-unused-parameter
126 -Wno-missing-field-initializers
127 -Wswitch
128 -Wsign-compare
129 -Wshadow
130 -Wformat
131 -Wtype-limits
132 -Wundef
133 -Werror
134 -Wmissing-prototypes
135 -Wstrict-prototypes
136);
363bd0b4 137
190c8c60
BL		 138# These are used in addition to $gcc_devteam_warn when the compiler is clang.
139# TODO(openssl-team): fix problems and investigate if (at least) the
480405e4 140# following warnings can also be enabled:
8bccbce5 141# -Wcast-align
77305338 142# -Wunreachable-code -- no, too ugly/compiler-specific
a773b52a
RS		 143# -Wlanguage-extension-token -- no, we use asm()
144# -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
145# -Wextended-offsetof -- no, needed in CMS ASN1 code
3b437400
RL		 146my @clang_devteam_warn = qw(
147 -Wswitch-default
148 -Wno-parentheses-equality
149 -Wno-language-extension-token
150 -Wno-extended-offsetof
151 -Wconditional-uninitialized
152 -Wincompatible-pointer-types-discards-qualifiers
153 -Wno-unknown-warning-option
154 -Wmissing-variable-declarations
155);
cb2bc054 156
ef8ca6bd
RL		 157# This adds backtrace information to the memory leak info. Is only used
158# when crypto-mdebug-backtrace is enabled.
159my $memleak_devteam_backtrace = "-rdynamic";
a1d3f3d1 160
0c28f277
DSH		 161my $strict_warnings = 0;
162
b7efa56a 163# As for $BSDthreads. Idea is to maintain "collective" set of flags,
fce0ba5f 164# which would cover all BSD flavors. -pthread applies to them all,
b7efa56a
AP		 165# but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
166# -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
167# which has to be accompanied by explicit -D_THREAD_SAFE and
168# sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
169# seems to be sufficient?
9c62a279 170our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
d02b48c6 171
98186eb4 172#
f430ba31 173# API compatibility name to version number mapping.
98186eb4 174#
db2f2d49 175my $maxapi = "3.0.0"; # API for "no-deprecated" builds
98186eb4 176my $apitable = {
fcd2d5a6
RL		 177 "3.0.0" => 3,
178 "1.1.1" => 2,
179 "1.1.0" => 2,
180 "1.0.2" => 1,
181 "1.0.1" => 1,
182 "1.0.0" => 1,
183 "0.9.8" => 0,
98186eb4
VD		 184};
185
9e0724a1 186our %table = ();
291e94df 187our %config = ();
98fdbce0 188our %withargs = ();
f770d75b
AP		 189our $now_printing; # set to current entry's name in print_table_entry
190 # (todo: right thing would be to encapsulate name
191 # into %target [class] and make print_table_entry
192 # a method)
3e83e686 193
bd5192b1 194# Forward declarations ###############################################
7ead0c89 195
bd5192b1
RL		 196# read_config(filename)
197#
198# Reads a configuration file and populates %table with the contents
199# (which the configuration file places in %targets).
200sub read_config;
7d46b942 201
bd5192b1
RL		 202# resolve_config(target)
203#
8483a003 204# Resolves all the late evaluations, inheritances and so on for the
bd5192b1
RL		 205# chosen target and any target it inherits from.
206sub resolve_config;
7d46b942 207
15c7adb0 208
107b5792
RL		 209# Information collection #############################################
210
9fe2bb77 211# Unified build supports separate build dir
ec182ef0
RL		 212my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
213my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
9fe2bb77
RL		 214my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
215
b5293d4c
RL		 216my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
217
9fe2bb77
RL		 218$config{sourcedir} = abs2rel($srcdir);
219$config{builddir} = abs2rel($blddir);
220
ee4cdb7f
RL		 221# Collect reconfiguration information if needed
222my @argvcopy=@ARGV;
223
224if (grep /^reconf(igure)?$/, @argvcopy) {
99aeeecb
RL		 225 die "reconfiguring with other arguments present isn't supported"
226 if scalar @argvcopy > 1;
ee4cdb7f 227 if (-f "./configdata.pm") {
84f32c84
DMSP		 228 my $file = "./configdata.pm";
229 unless (my $return = do $file) {
230 die "couldn't parse $file: $@" if $@;
ee4cdb7f
RL		 231 die "couldn't do $file: $!" unless defined $return;
232 die "couldn't run $file" unless $return;
84f32c84 233 }
ee4cdb7f 234
84f32c84
DMSP		 235 @argvcopy = defined($configdata::config{perlargv}) ?
236 @{$configdata::config{perlargv}} : ();
237 die "Incorrect data to reconfigure, please do a normal configuration\n"
238 if (grep(/^reconf/,@argvcopy));
239 $config{perlenv} = $configdata::config{perlenv} // {};
ee4cdb7f 240 } else {
84f32c84 241 die "Insufficient data to reconfigure, please do a normal configuration\n";
ee4cdb7f
RL		 242 }
243}
244
245$config{perlargv} = [ @argvcopy ];
246
107b5792 247# Collect version numbers
3a63dbef
RL		 248$config{major} = "unknown";
249$config{minor} = "unknown";
250$config{patch} = "unknown";
251$config{prerelease} = "";
252$config{build_metadata} = "";
253$config{shlib_version} = "unknown";
107b5792
RL		 254
255collect_information(
9fe2bb77 256 collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
3a63dbef
RL		 257 qr/#\s+define\s+OPENSSL_VERSION_MAJOR\s+(\d+)/ =>
258 sub { $config{major} = $1; },
259 qr/#\s+define\s+OPENSSL_VERSION_MINOR\s+(\d+)/ =>
260 sub { $config{minor} = $1; },
261 qr/#\s+define\s+OPENSSL_VERSION_PATCH\s+(\d+)/ =>
262 sub { $config{patch} = $1; },
263 qr/#\s+define\s+OPENSSL_VERSION_PRE_RELEASE\s+"((?:\\.|[^"])*)"/ =>
264 sub { $config{prerelease} = $1; },
265 qr/#\s+define\s+OPENSSL_VERSION_BUILD_METADATA\s+"((?:\\.|[^"])*)"/ =>
266 sub { $config{build_metadata} = $1; },
267 qr/#\s+define\s+OPENSSL_SHLIB_VERSION\s+([\d\.]+)/ =>
268 sub { $config{shlib_version} = $1; },
107b5792 269 );
107b5792 270die "erroneous version information in opensslv.h: ",
3a63dbef
RL		 271 "$config{major}.$config{minor}.$config{patch}, $config{shlib_version}\n"
272 if ($config{major} eq "unknown"
273 || $config{minor} eq "unknown"
274 || $config{patch} eq "unknown"
275 || $config{shlib_version} eq "unknown");
107b5792 276
16942e08
DMSP		 277$config{version} = "$config{major}.$config{minor}.$config{patch}";
278$config{full_version} = "$config{version}$config{prerelease}$config{build_metadata}";
279
107b5792
RL		 280# Collect target configurations
281
85152ca4 282my $pattern = catfile(dirname($0), "Configurations", "*.conf");
97855556 283foreach (sort glob($pattern)) {
f09e7ca9
RS		 284 &read_config($_);
285}
d02b48c6 286
7ecdf18d 287if (defined env($local_config_envname)) {
b5293d4c
RL		 288 if ($^O eq 'VMS') {
289 # VMS environment variables are logical names,
290 # which can be used as is
291 $pattern = $local_config_envname . ':' . '*.conf';
292 } else {
7ecdf18d 293 $pattern = catfile(env($local_config_envname), '*.conf');
b5293d4c
RL		 294 }
295
97855556 296 foreach (sort glob($pattern)) {
b5293d4c
RL		 297 &read_config($_);
298 }
299}
300
d5fa7035
RL		 301# Save away perl command information
302$config{perl_cmd} = $^X;
303$config{perl_version} = $Config{version};
304$config{perl_archname} = $Config{archname};
305
291e94df
RL		 306$config{prefix}="";
307$config{openssldir}="";
7d130f68 308$config{processor}="";
107b5792 309$config{libdir}="";
9c62a279 310my $auto_threads=1; # enable threads automatically? true by default
0396479d 311my $default_ranlib;
107b5792 312
6b01bed2 313# Known TLS and DTLS protocols
84a68336 314my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
6b01bed2
VD		 315my @dtls = qw(dtls1 dtls1_2);
316
8483a003 317# Explicitly known options that are possible to disable. They can
8b527be2
RL		 318# be regexps, and will be used like this: /^no-${option}$/
319# For developers: keep it sorted alphabetically
320
321my @disablables = (
69495e3d 322 "ktls",
c91a0a83 323 "afalgeng",
d42d0a4d 324 "aria",
c38bb727 325 "asan",
8b527be2 326 "asm",
52739e40 327 "async",
b184e3ef 328 "autoalginit",
498abff0 329 "autoerrinit",
dbabc862 330 "autoload-config",
8b527be2 331 "bf",
2d0b4412 332 "blake2",
ac4033d6 333 "buildtest-c++",
8b527be2
RL		 334 "camellia",
335 "capieng",
336 "cast",
48f14845 337 "chacha",
8b527be2 338 "cmac",
538f38db 339 "cmp",
8b527be2
RL		 340 "cms",
341 "comp",
3e45d393 342 "crypto-mdebug",
ef8ca6bd 343 "crypto-mdebug-backtrace",
8b527be2
RL		 344 "ct",
345 "deprecated",
346 "des",
619eb33a 347 "devcryptoeng",
8b527be2
RL		 348 "dgram",
349 "dh",
350 "dsa",
a5ecdc6a 351 "dtls",
343ec2b0 352 "dynamic-engine",
8b527be2
RL		 353 "ec",
354 "ec2m",
6b01bed2
VD		 355 "ecdh",
356 "ecdsa",
8b527be2 357 "ec_nistp_64_gcc_128",
b31feae6 358 "egd",
8b527be2 359 "engine",
1288f26f 360 "err",
ce2596d4 361 "external-tests",
02f7114a 362 "filenames",
e7545517 363 "fips",
f59d0131
KR		 364 "fuzz-libfuzzer",
365 "fuzz-afl",
168c3b73 366 "gost",
8b527be2 367 "idea",
d0308923 368 "legacy",
09aa263a 369 "makedepend",
8b527be2
RL		 370 "md2",
371 "md4",
8b527be2 372 "mdc2",
34786bde 373 "module",
29df3061 374 "msan",
fa22f98f 375 "multiblock",
8b527be2 376 "nextprotoneg",
41999e7d 377 "pinshared",
8b527be2
RL		 378 "ocb",
379 "ocsp",
469ce8ff 380 "padlockeng",
ae48242c 381 "pic",
48f14845 382 "poly1305",
8b527be2
RL		 383 "posix-io",
384 "psk",
385 "rc2",
386 "rc4",
387 "rc5",
388 "rdrand",
389 "rfc3779",
8b527be2 390 "rmd160",
8b527be2 391 "scrypt",
8b527be2
RL		 392 "sctp",
393 "seed",
8b527be2 394 "shared",
3f5616d7 395 "siphash",
b1ceb439 396 "siv",
1bf2cc23 397 "sm2",
a0c3e4fa 398 "sm3",
f19a5ff9 399 "sm4",
8b527be2
RL		 400 "sock",
401 "srp",
402 "srtp",
403 "sse2",
404 "ssl",
8b527be2
RL		 405 "ssl-trace",
406 "static-engine",
407 "stdio",
93880ce1 408 "tests",
8b527be2
RL		 409 "threads",
410 "tls",
16a9d374 411 "trace",
1288f26f 412 "ts",
c38bb727 413 "ubsan",
48feaceb 414 "ui-console",
8b527be2 415 "unit-test",
5ded1ca6 416 "uplink",
8b527be2 417 "whirlpool",
8b1a5af3 418 "weak-ssl-ciphers",
8b527be2
RL		 419 "zlib",
420 "zlib-dynamic",
421 );
6b01bed2 422foreach my $proto ((@tls, @dtls))
84f32c84
DMSP		 423 {
424 push(@disablables, $proto);
425 push(@disablables, "$proto-method") unless $proto eq "tls1_3";
426 }
8b527be2 427
538f38db
RL		 428# Internal disablables, for aliasing purposes. They serve no special
429# purpose here, but allow scripts to get to know them through configdata.pm,
430# where these are merged with @disablables.
431# The actual aliasing mechanism is done via %disable_cascades
432my @disablables_int = qw(
433 crmf
434 );
435
2b1343b9
MC		 436my %deprecated_disablables = (
437 "ssl2" => undef,
438 "buf-freelists" => undef,
469ce8ff
RL		 439 "hw" => "hw", # causes cascade, but no macro
440 "hw-padlock" => "padlockeng",
48feaceb
RL		 441 "ripemd" => "rmd160",
442 "ui" => "ui-console",
31b6ed76 443 "dso" => undef,
0b45d8ee 444 "heartbeats" => undef,
e80381e1
RL		 445 );
446
094925de 447# All of the following are disabled by default:
c9a112f5 448
9e04edf2 449our %disabled = ( # "what" => "comment"
84f32c84
DMSP		 450 "asan" => "default",
451 "buildtest-c++" => "default",
452 "crypto-mdebug" => "default",
453 "crypto-mdebug-backtrace" => "default",
454 "devcryptoeng" => "default",
455 "ec_nistp_64_gcc_128" => "default",
456 "egd" => "default",
457 "external-tests" => "default",
458 "fuzz-libfuzzer" => "default",
459 "fuzz-afl" => "default",
84f32c84 460 "md2" => "default",
29df3061 461 "msan" => "default",
84f32c84
DMSP		 462 "rc5" => "default",
463 "sctp" => "default",
464 "ssl-trace" => "default",
465 "ssl3" => "default",
466 "ssl3-method" => "default",
467 "trace" => "default",
468 "ubsan" => "default",
469 "unit-test" => "default",
470 "weak-ssl-ciphers" => "default",
471 "zlib" => "default",
472 "zlib-dynamic" => "default",
473 "ktls" => "default",
474 );
c9a112f5 475
c569e206
RL		 476# Note: => pair form used for aesthetics, not to truly make a hash table
477my @disable_cascades = (
84f32c84 478 # "what" => [ "cascade", ... ]
7d130f68 479 sub { $config{processor} eq "386" }
84f32c84
DMSP		 480 => [ "sse2" ],
481 "ssl" => [ "ssl3" ],
482 "ssl3-method" => [ "ssl3" ],
483 "zlib" => [ "zlib-dynamic" ],
484 "des" => [ "mdc2" ],
dbc6268f 485 "ec" => [ "ecdsa", "ecdh", "sm2" ],
65dc5c3c
MC		 486 sub { $disabled{"ec"} && $disabled{"dh"} }
487 => [ "tls1_3" ],
84f32c84
DMSP		 488 "dgram" => [ "dtls", "sctp" ],
489 "sock" => [ "dgram" ],
490 "dtls" => [ @dtls ],
343a7467 491 sub { 0 == scalar grep { !$disabled{$_} } @dtls }
84f32c84 492 => [ "dtls" ],
c569e206 493
84f32c84 494 "tls" => [ @tls ],
343a7467 495 sub { 0 == scalar grep { !$disabled{$_} } @tls }
84f32c84 496 => [ "tls" ],
c569e206 497
ef8ca6bd 498 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
343ec2b0 499
34786bde
RL		 500 # If no modules, then no dynamic engines either
501 "module" => [ "dynamic-engine" ],
502
503 # Without shared libraries, dynamic engines aren't possible.
504 # This is due to them having to link with libcrypto and register features
505 # using the ENGINE functionality, and since that relies on global tables,
506 # those *have* to be exacty the same as the ones accessed from the app,
507 # which cannot be guaranteed if shared libraries aren't present.
508 # (note that even with shared libraries, both the app and dynamic engines
509 # must be linked with the same library)
5ded1ca6 510 "shared" => [ "dynamic-engine", "uplink" ],
34786bde
RL		 511 # Other modules don't necessarily have to link with libcrypto, so shared
512 # libraries do not have to be a condition to produce those.
513
514 # Without position independent code, there can be no shared libraries
515 # or modules.
516 "pic" => [ "shared", "module" ],
469ce8ff 517
d0308923 518 "module" => [ "fips", "legacy" ],
e7545517 519
469ce8ff
RL		 520 "engine" => [ grep /eng$/, @disablables ],
521 "hw" => [ "padlockeng" ],
d90a6beb
MC		 522
523 # no-autoalginit is only useful when building non-shared
524 "autoalginit" => [ "shared", "apps" ],
525
15a1bd0a 526 "stdio" => [ "apps", "capieng", "egd" ],
d90a6beb 527 "apps" => [ "tests" ],
302eba3f 528 "tests" => [ "external-tests" ],
3cf96e88 529 "comp" => [ "zlib" ],
98020023 530 "sm3" => [ "sm2" ],
b612799a 531 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
29df3061
EK		 532
533 sub { !$disabled{"msan"} } => [ "asm" ],
b1ceb439
TS		 534
535 sub { $disabled{cmac}; } => [ "siv" ],
d0308923 536 "legacy" => [ "md2" ],
538f38db
RL		 537
538 "cmp" => [ "crmf" ],
c569e206
RL		 539 );
540
541# Avoid protocol support holes. Also disable all versions below N, if version
542# N is disabled while N+1 is enabled.
543#
544my @list = (reverse @tls);
545while ((my $first, my $second) = (shift @list, shift @list)) {
546 last unless @list;
547 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
84f32c84 548 => [ @list ] );
c569e206
RL		 549 unshift @list, $second;
550}
551my @list = (reverse @dtls);
552while ((my $first, my $second) = (shift @list, shift @list)) {
553 last unless @list;
554 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
84f32c84 555 => [ @list ] );
c569e206
RL		 556 unshift @list, $second;
557}
558
7a762197 559# Explicit "no-..." options will be collected in %disabled along with the defaults.
e4ef2e25 560# To remove something from %disabled, use "enable-foo".
7a762197
BM		 561# For symmetry, "disable-foo" is a synonym for "no-foo".
562
462ba4f6 563&usage if ($#ARGV < 0);
d02b48c6 564
5b18235a
RL		 565# For the "make variables" CINCLUDES and CDEFINES, we support lists with
566# platform specific list separators. Users from those platforms should
567# recognise those separators from how you set up the PATH to find executables.
568# The default is the Unix like separator, :, but as an exception, we also
569# support the space as separator.
570my $list_separator_re =
571 { VMS => qr/(?<!\^),/,
572 MSWin32 => qr/(?<!\\);/ } -> {$^O} // qr/(?<!\\)[:\s]/;
573# All the "make variables" we support
f5846179
RL		 574# Some get pre-populated for the sake of backward compatibility
575# (we supported those before the change to "make variable" support.
5b18235a 576my %user = (
f5846179 577 AR => env('AR'),
5b18235a
RL		 578 ARFLAGS => [],
579 AS => undef,
580 ASFLAGS => [],
f5846179 581 CC => env('CC'),
8e7984e5 582 CFLAGS => [ env('CFLAGS') || () ],
f5846179 583 CXX => env('CXX'),
8e7984e5 584 CXXFLAGS => [ env('CXXFLAGS') || () ],
5b18235a 585 CPP => undef,
8e7984e5 586 CPPFLAGS => [ env('CPPFLAGS') || () ], # -D, -I, -Wp,
5b18235a
RL		 587 CPPDEFINES => [], # Alternative for -D
588 CPPINCLUDES => [], # Alternative for -I
f5846179
RL		 589 CROSS_COMPILE => env('CROSS_COMPILE'),
590 HASHBANGPERL=> env('HASHBANGPERL') || env('PERL'),
5b18235a 591 LD => undef,
8e7984e5
RL		 592 LDFLAGS => [ env('LDFLAGS') || () ], # -L, -Wl,
593 LDLIBS => [ env('LDLIBS') || () ], # -l
5b18235a
RL		 594 MT => undef,
595 MTFLAGS => [],
9e265322 596 PERL => env('PERL') || ($^O ne "VMS" ? $^X : "perl"),
f5846179
RL		 597 RANLIB => env('RANLIB'),
598 RC => env('RC') || env('WINDRES'),
0c4e984d 599 RCFLAGS => [ env('RCFLAGS') || () ],
5b18235a
RL		 600 RM => undef,
601 );
f729ba55
RL		 602# Info about what "make variables" may be prefixed with the cross compiler
603# prefix. This should NEVER mention any such variable with a list for value.
604my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
5b18235a
RL		 605# The same but for flags given as Configure options. These are *additional*
606# input, as opposed to the VAR=string option that override the corresponding
607# config target attributes
608my %useradd = (
609 CPPDEFINES => [],
610 CPPINCLUDES => [],
611 CPPFLAGS => [],
612 CFLAGS => [],
613 CXXFLAGS => [],
614 LDFLAGS => [],
615 LDLIBS => [],
0c4e984d 616 RCFLAGS => [],
5b18235a
RL		 617 );
618
619my %user_synonyms = (
620 HASHBANGPERL=> 'PERL',
621 RC => 'WINDRES',
622 );
abe256e7
RL		 623
624# Some target attributes have been renamed, this is the translation table
625my %target_attr_translate =(
626 ar => 'AR',
627 as => 'AS',
628 cc => 'CC',
629 cxx => 'CXX',
630 cpp => 'CPP',
631 hashbangperl => 'HASHBANGPERL',
632 ld => 'LD',
633 mt => 'MT',
634 ranlib => 'RANLIB',
635 rc => 'RC',
636 rm => 'RM',
5b18235a 637 );
5b18235a 638
2ab92ae9 639# Initialisers coming from 'config' scripts
ff455d99
AP		 640$config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ];
641$config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ];
642$config{cppflags} = [ env('__CNF_CPPFLAGS') || () ];
643$config{cflags} = [ env('__CNF_CFLAGS') || () ];
644$config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ];
645$config{lflags} = [ env('__CNF_LDFLAGS') || () ];
646$config{ex_libs} = [ env('__CNF_LDLIBS') || () ];
2ab92ae9 647
7d130f68 648$config{openssl_api_defines}=[];
7d130f68 649$config{openssl_sys_defines}=[];
e0bf7c01 650$config{openssl_feature_defines}=[];
3fa04f0d 651$config{options}="";
8864f0de 652$config{build_type} = "release";
5b18235a 653my $target="";
c59cb511 654
ac6ae8a9 655my %cmdvars = (); # Stores FOO='blah' type arguments
fe05264e 656my %unsupported_options = ();
e80381e1 657my %deprecated_options = ();
8389ec4b
RS		 658# If you change this, update apps/version.c
659my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
660my @seed_sources = ();
fad599f7 661while (@argvcopy)
84f32c84
DMSP		 662 {
663 $_ = shift @argvcopy;
664
665 # Support env variable assignments among the options
666 if (m|^(\w+)=(.+)?$|)
667 {
668 $cmdvars{$1} = $2;
669 # Every time a variable is given as a configuration argument,
670 # it acts as a reset if the variable.
671 if (exists $user{$1})
672 {
673 $user{$1} = ref $user{$1} eq "ARRAY" ? [] : undef;
674 }
675 #if (exists $useradd{$1})
676 # {
677 # $useradd{$1} = [];
678 # }
679 next;
680 }
681
682 # VMS is a case insensitive environment, and depending on settings
683 # out of our control, we may receive options uppercased. Let's
684 # downcase at least the part before any equal sign.
685 if ($^O eq "VMS")
686 {
687 s/^([^=]*)/lc($1)/e;
688 }
689
690 # some people just can't read the instructions, clang people have to...
691 s/^-no-(?!integrated-as)/no-/;
692
693 # rewrite some options in "enable-..." form
694 s /^-?-?shared$/enable-shared/;
695 s /^sctp$/enable-sctp/;
696 s /^threads$/enable-threads/;
697 s /^zlib$/enable-zlib/;
698 s /^zlib-dynamic$/enable-zlib-dynamic/;
c9a112f5 699
e4ef2e25 700 if (/^(no|disable|enable)-(.+)$/)
2b1343b9
MC		 701 {
702 my $word = $2;
469ce8ff
RL		 703 if ($word !~ m|hw(?:-.+)| # special treatment for hw regexp opt
704 && !exists $deprecated_disablables{$word}
705 && !grep { $word eq $_ } @disablables)
2b1343b9
MC		 706 {
707 $unsupported_options{$_} = 1;
708 next;
709 }
710 }
711 if (/^no-(.+)$/ || /^disable-(.+)$/)
712 {
e4ef2e25
RS		 713 foreach my $proto ((@tls, @dtls))
714 {
715 if ($1 eq "$proto-method")
716 {
717 $disabled{"$proto"} = "option($proto-method)";
718 last;
719 }
720 }
721 if ($1 eq "dtls")
722 {
723 foreach my $proto (@dtls)
724 {
725 $disabled{$proto} = "option(dtls)";
726 }
c5c7700c 727 $disabled{"dtls"} = "option(dtls)";
e4ef2e25
RS		 728 }
729 elsif ($1 eq "ssl")
730 {
731 # Last one of its kind
732 $disabled{"ssl3"} = "option(ssl)";
733 }
734 elsif ($1 eq "tls")
735 {
736 # XXX: Tests will fail if all SSL/TLS
737 # protocols are disabled.
738 foreach my $proto (@tls)
739 {
740 $disabled{$proto} = "option(tls)";
741 }
742 }
343ec2b0
RL		 743 elsif ($1 eq "static-engine")
744 {
19ab5790 745 delete $disabled{"dynamic-engine"};
343ec2b0
RL		 746 }
747 elsif ($1 eq "dynamic-engine")
748 {
19ab5790 749 $disabled{"dynamic-engine"} = "option";
343ec2b0 750 }
2b1343b9
MC		 751 elsif (exists $deprecated_disablables{$1})
752 {
753 $deprecated_options{$_} = 1;
754 if (defined $deprecated_disablables{$1})
755 {
756 $disabled{$deprecated_disablables{$1}} = "option";
757 }
758 }
469ce8ff
RL		 759 elsif ($1 =~ m|hw(?:-.+)|) # deprecate hw options in regexp form
760 {
761 $deprecated_options{$_} = 1;
762 }
e4ef2e25
RS		 763 else
764 {
765 $disabled{$1} = "option";
766 }
84f32c84
DMSP		 767 # No longer an automatic choice
768 $auto_threads = 0 if ($1 eq "threads");
769 }
770 elsif (/^enable-(.+)$/)
771 {
343ec2b0
RL		 772 if ($1 eq "static-engine")
773 {
19ab5790 774 $disabled{"dynamic-engine"} = "option";
343ec2b0
RL		 775 }
776 elsif ($1 eq "dynamic-engine")
777 {
19ab5790 778 delete $disabled{"dynamic-engine"};
343ec2b0 779 }
25004db7
RL		 780 elsif ($1 eq "zlib-dynamic")
781 {
782 delete $disabled{"zlib"};
783 }
84f32c84
DMSP		 784 my $algo = $1;
785 delete $disabled{$algo};
786
787 # No longer an automatic choice
788 $auto_threads = 0 if ($1 eq "threads");
789 }
790 elsif (/^--strict-warnings$/)
791 {
792 # Pretend that our strict flags is a C flag, and replace it
793 # with the proper flags later on
794 push @{$useradd{CFLAGS}}, '--ossl-strict-warnings';
84f32c84
DMSP		 795 $strict_warnings=1;
796 }
797 elsif (/^--debug$/)
798 {
799 $config{build_type} = "debug";
800 }
801 elsif (/^--release$/)
802 {
803 $config{build_type} = "release";
804 }
805 elsif (/^386$/)
806 { $config{processor}=386; }
807 elsif (/^fips$/)
808 {
809 die "FIPS mode not supported\n";
810 }
811 elsif (/^rsaref$/)
812 {
813 # No RSAref support any more since it's not needed.
814 # The check for the option is there so scripts aren't
815 # broken
816 }
817 elsif (/^nofipscanistercheck$/)
818 {
819 die "FIPS mode not supported\n";
820 }
821 elsif (/^[-+]/)
822 {
823 if (/^--prefix=(.*)$/)
824 {
825 $config{prefix}=$1;
826 die "Directory given with --prefix MUST be absolute\n"
827 unless file_name_is_absolute($config{prefix});
828 }
829 elsif (/^--api=(.*)$/)
830 {
831 $config{api}=$1;
832 }
833 elsif (/^--libdir=(.*)$/)
834 {
835 $config{libdir}=$1;
836 }
837 elsif (/^--openssldir=(.*)$/)
838 {
839 $config{openssldir}=$1;
840 }
841 elsif (/^--with-zlib-lib=(.*)$/)
842 {
843 $withargs{zlib_lib}=$1;
844 }
845 elsif (/^--with-zlib-include=(.*)$/)
846 {
847 $withargs{zlib_include}=$1;
848 }
849 elsif (/^--with-fuzzer-lib=(.*)$/)
850 {
851 $withargs{fuzzer_lib}=$1;
852 }
853 elsif (/^--with-fuzzer-include=(.*)$/)
854 {
855 $withargs{fuzzer_include}=$1;
856 }
857 elsif (/^--with-rand-seed=(.*)$/)
858 {
859 foreach my $x (split(m|,|, $1))
860 {
861 die "Unknown --with-rand-seed choice $x\n"
862 if ! grep { $x eq $_ } @known_seed_sources;
863 push @seed_sources, $x;
864 }
865 }
866 elsif (/^--cross-compile-prefix=(.*)$/)
867 {
868 $user{CROSS_COMPILE}=$1;
869 }
870 elsif (/^--config=(.*)$/)
871 {
872 read_config $1;
873 }
874 elsif (/^-l(.*)$/)
875 {
876 push @{$useradd{LDLIBS}}, $_;
877 }
878 elsif (/^-framework$/)
879 {
880 push @{$useradd{LDLIBS}}, $_, shift(@argvcopy);
881 }
882 elsif (/^-L(.*)$/ or /^-Wl,/)
883 {
884 push @{$useradd{LDFLAGS}}, $_;
885 }
886 elsif (/^-rpath$/ or /^-R$/)
887 # -rpath is the OSF1 rpath flag
888 # -R is the old Solaris rpath flag
889 {
890 my $rpath = shift(@argvcopy) || "";
891 $rpath .= " " if $rpath ne "";
892 push @{$useradd{LDFLAGS}}, $_, $rpath;
893 }
894 elsif (/^-static$/)
895 {
896 push @{$useradd{LDFLAGS}}, $_;
84f32c84
DMSP		 897 }
898 elsif (/^-D(.*)$/)
899 {
900 push @{$useradd{CPPDEFINES}}, $1;
901 }
902 elsif (/^-I(.*)$/)
903 {
904 push @{$useradd{CPPINCLUDES}}, $1;
905 }
906 elsif (/^-Wp,$/)
907 {
908 push @{$useradd{CPPFLAGS}}, $1;
909 }
910 else # common if (/^[-+]/), just pass down...
911 {
912 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
913 push @{$useradd{CFLAGS}}, $_;
914 push @{$useradd{CXXFLAGS}}, $_;
8389ec4b 915 }
84f32c84
DMSP		 916 }
917 else
918 {
919 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
920 $target=$_;
921 }
922 unless ($_ eq $target || /^no-/ || /^disable-/)
923 {
924 # "no-..." follows later after implied deactivations
925 # have been derived. (Don't take this too seriously,
926 # we really only write OPTIONS to the Makefile out of
927 # nostalgia.)
928
929 if ($config{options} eq "")
930 { $config{options} = $_; }
931 else
932 { $config{options} .= " ".$_; }
933 }
934 }
489eb740 935
ddbe700e 936if (defined($config{api}) && !exists $apitable->{$config{api}}) {
84f32c84 937 die "***** Unsupported api compatibility level: $config{api}\n",
ddbe700e 938}
98186eb4 939
ddbe700e 940if (keys %deprecated_options)
84f32c84
DMSP		 941 {
942 warn "***** Deprecated options: ",
943 join(", ", keys %deprecated_options), "\n";
944 }
ddbe700e 945if (keys %unsupported_options)
84f32c84
DMSP		 946 {
947 die "***** Unsupported options: ",
948 join(", ", keys %unsupported_options), "\n";
949 }
b6e4dac2 950
ac6ae8a9
RL		 951# If any %useradd entry has been set, we must check that the "make
952# variables" haven't been set. We start by checking of any %useradd entry
fb174faa 953# is set.
b9201360 954if (grep { scalar @$_ > 0 } values %useradd) {
fb174faa 955 # Hash of env / make variables names. The possible values are:
ac6ae8a9 956 # 1 - "make vars"
fb174faa
RL		 957 # 2 - %useradd entry set
958 # 3 - both set
ac6ae8a9 959 my %detected_vars =
fb174faa 960 map { my $v = 0;
ac6ae8a9 961 $v += 1 if $cmdvars{$_};
fb174faa
RL		 962 $v += 2 if @{$useradd{$_}};
963 $_ => $v }
964 keys %useradd;
965
ac6ae8a9
RL		 966 # If any of the corresponding "make variables" is set, we error
967 if (grep { $_ & 1 } values %detected_vars) {
968 my $names = join(', ', grep { $detected_vars{$_} > 0 }
969 sort keys %detected_vars);
b9201360 970 die <<"_____";
ac6ae8a9 971***** Mixing make variables and additional compiler/linker flags as
b9201360 972***** configure command line option is not permitted.
ac6ae8a9 973***** Affected make variables: $names
b9201360
RL		 974_____
975 }
976}
977
ac6ae8a9
RL		 978# Check through all supported command line variables to see if any of them
979# were set, and canonicalise the values we got. If no compiler or linker
980# flag or anything else that affects %useradd was set, we also check the
981# environment for values.
982my $anyuseradd =
983 grep { defined $_ && (ref $_ ne 'ARRAY' || @$_) } values %useradd;
5b18235a 984foreach (keys %user) {
ac6ae8a9
RL		 985 my $value = $cmdvars{$_};
986 $value //= env($_) unless $anyuseradd;
987 $value //=
988 defined $user_synonyms{$_} ? $cmdvars{$user_synonyms{$_}} : undef;
989 $value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef
990 unless $anyuseradd;
5b18235a
RL		 991
992 if (defined $value) {
993 if (ref $user{$_} eq 'ARRAY') {
994 $user{$_} = [ split /$list_separator_re/, $value ];
995 } elsif (!defined $user{$_}) {
996 $user{$_} = $value;
997 }
998 }
999}
1000
07e4dc34 1001if (grep { /-rpath\b/ } ($user{LDFLAGS} ? @{$user{LDFLAGS}} : ())
342a1a23
RL		 1002 && !$disabled{shared}
1003 && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
1004 die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
84f32c84 1005 "***** any of asan, msan or ubsan\n";
342a1a23
RL		 1006}
1007
71ef78d7
RL		 1008sub disable {
1009 my $disable_type = shift;
1010
1011 for (@_) {
1012 $disabled{$_} = $disable_type;
1013 }
1014
1015 my @tocheckfor = (@_ ? @_ : keys %disabled);
1016 while (@tocheckfor) {
1017 my %new_tocheckfor = ();
1018 my @cascade_copy = (@disable_cascades);
1019 while (@cascade_copy) {
1020 my ($test, $descendents) =
1021 (shift @cascade_copy, shift @cascade_copy);
1022 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
1023 foreach (grep { !defined($disabled{$_}) } @$descendents) {
1024 $new_tocheckfor{$_} = 1; $disabled{$_} = "cascade";
1025 }
84f32c84
DMSP		 1026 }
1027 }
71ef78d7 1028 @tocheckfor = (keys %new_tocheckfor);
c569e206 1029 }
c569e206 1030}
71ef78d7 1031disable(); # First cascade run
edc032b5 1032
d63c12c6 1033our $die = sub { die @_; };
436a376b 1034if ($target eq "TABLE") {
d63c12c6 1035 local $die = sub { warn @_; };
00ae96ca 1036 foreach (sort keys %table) {
84f32c84 1037 print_table_entry($_, "TABLE");
00ae96ca
RL		 1038 }
1039 exit 0;
436a376b
BM		 1040}
1041
10a926c1 1042if ($target eq "LIST") {
00ae96ca 1043 foreach (sort keys %table) {
84f32c84 1044 print $_,"\n" unless $table{$_}->{template};
00ae96ca
RL		 1045 }
1046 exit 0;
10a926c1
UM		 1047}
1048
aaf878cc 1049if ($target eq "HASH") {
d63c12c6 1050 local $die = sub { warn @_; };
00ae96ca
RL		 1051 print "%table = (\n";
1052 foreach (sort keys %table) {
84f32c84 1053 print_table_entry($_, "HASH");
00ae96ca
RL		 1054 }
1055 exit 0;
aaf878cc
RL		 1056}
1057
16942e08
DMSP		 1058print "Configuring OpenSSL version $config{full_version} ";
1059print "for target $target\n";
64119271 1060
51cf8e0b
RL		 1061if (scalar(@seed_sources) == 0) {
1062 print "Using os-specific seed configuration\n";
1063 push @seed_sources, 'os';
1064}
2805ee1e
RL		 1065if (scalar(grep { $_ eq 'none' } @seed_sources) > 0) {
1066 die "Cannot seed with none and anything else" if scalar(@seed_sources) > 1;
1067 warn <<_____ if scalar(@seed_sources) == 1;
2805ee1e 1068
caa85952
DMSP		 1069============================== WARNING ===============================
1070You have selected the --with-rand-seed=none option, which effectively
1071disables automatic reseeding of the OpenSSL random generator.
1072All operations depending on the random generator such as creating keys
1073will not work unless the random generator is seeded manually by the
1074application.
1075
1076Please read the 'Note on random number generation' section in the
1077INSTALL instructions and the RAND_DRBG(7) manual page for more details.
1078============================== WARNING ===============================
1079
2805ee1e
RL		 1080_____
1081}
e0bf7c01 1082push @{$config{openssl_feature_defines}},
51cf8e0b 1083 map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
84f32c84 1084 @seed_sources;
51cf8e0b 1085
00ae96ca 1086# Backward compatibility?
49e04548 1087if ($target =~ m/^CygWin32(-.*)$/) {
00ae96ca 1088 $target = "Cygwin".$1;
49e04548
RL		 1089}
1090
906eb3d0
RL		 1091# Support for legacy targets having a name starting with 'debug-'
1092my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1093if ($d) {
1094 $config{build_type} = "debug";
1095
1096 # If we do not find debug-foo in the table, the target is set to foo.
1097 if (!$table{$target}) {
84f32c84 1098 $target = $t;
906eb3d0
RL		 1099 }
1100}
4e360445
RL		 1101
1102&usage if !$table{$target} || $table{$target}->{template};
1103
906eb3d0
RL		 1104$config{target} = $target;
1105my %target = resolve_config($target);
1106
abe256e7
RL		 1107foreach (keys %target_attr_translate) {
1108 $target{$target_attr_translate{$_}} = $target{$_}
1109 if $target{$_};
1110 delete $target{$_};
1111}
1112
793077d0
RL		 1113%target = ( %{$table{DEFAULTS}}, %target );
1114
906eb3d0
RL		 1115my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
1116$config{conf_files} = [ sort keys %conf_files ];
906eb3d0 1117
71ef78d7
RL		 1118# Using sub disable within these loops may prove fragile, so we run
1119# a cascade afterwards
906eb3d0
RL		 1120foreach my $feature (@{$target{disable}}) {
1121 if (exists $deprecated_disablables{$feature}) {
1122 warn "***** config $target disables deprecated feature $feature\n";
1123 } elsif (!grep { $feature eq $_ } @disablables) {
1124 die "***** config $target disables unknown feature $feature\n";
1125 }
1126 $disabled{$feature} = 'config';
1127}
1128foreach my $feature (@{$target{enable}}) {
7a8a35ff 1129 if ("default" eq ($disabled{$feature} // "")) {
906eb3d0
RL		 1130 if (exists $deprecated_disablables{$feature}) {
1131 warn "***** config $target enables deprecated feature $feature\n";
1132 } elsif (!grep { $feature eq $_ } @disablables) {
1133 die "***** config $target enables unknown feature $feature\n";
1134 }
7a8a35ff 1135 delete $disabled{$feature};
906eb3d0
RL		 1136 }
1137}
b19fe714
RL		 1138
1139# If uplink_arch isn't defined, disable uplink
1140$disabled{uplink} = 'no uplink_arch' unless (defined $target{uplink_arch});
e6f98ae4
RL		 1141# If asm_arch isn't defined, disable asm
1142$disabled{asm} = 'no asm_arch' unless (defined $target{asm_arch});
b19fe714 1143
71ef78d7 1144disable(); # Run a cascade now
906eb3d0 1145
abe256e7
RL		 1146$target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
1147$target{cxxflags}//=$target{cflags} if $target{CXX};
9dd4ed28 1148$target{exe_extension}=".exe" if ($config{target} eq "DJGPP");
107b5792 1149$target{exe_extension}=".pm" if ($config{target} =~ /vos/);
e987f9f2 1150
9e265322
RL		 1151# Fill %config with values from %user, and in case those are undefined or
1152# empty, use values from %target (acting as a default).
5b18235a 1153foreach (keys %user) {
5b18235a
RL		 1154 my $ref_type = ref $user{$_};
1155
1156 # Temporary function. Takes an intended ref type (empty string or "ARRAY")
1157 # and a value that's to be coerced into that type.
1158 my $mkvalue = sub {
1159 my $type = shift;
1160 my $value = shift;
1161 my $undef_p = shift;
1162
1163 die "Too many arguments for \$mkvalue" if @_;
1164
1165 while (ref $value eq 'CODE') {
1166 $value = $value->();
1167 }
1168
1169 if ($type eq 'ARRAY') {
1170 return undef unless defined $value;
1171 return undef if ref $value ne 'ARRAY' && !$value;
1172 return undef if ref $value eq 'ARRAY' && !@$value;
1173 return [ $value ] unless ref $value eq 'ARRAY';
1174 }
1175 return undef unless $value;
1176 return $value;
1177 };
1178
abe256e7 1179 $config{$_} =
5b18235a 1180 $mkvalue->($ref_type, $user{$_})
abe256e7
RL		 1181 || $mkvalue->($ref_type, $target{$_});
1182 delete $config{$_} unless defined $config{$_};
5b18235a 1183}
aaf878cc 1184
c1a09254
RL		 1185# Finish up %config by appending things the user gave us on the command line
1186# apart from "make variables"
1187foreach (keys %useradd) {
1188 # The must all be lists, so we assert that here
1189 die "internal error: \$useradd{$_} isn't an ARRAY\n"
1190 unless ref $useradd{$_} eq 'ARRAY';
1191
1192 if (defined $config{$_}) {
1193 push @{$config{$_}}, @{$useradd{$_}};
1194 } else {
1195 $config{$_} = [ @{$useradd{$_}} ];
1196 }
1197}
1198# At this point, we can forget everything about %user and %useradd,
1199# because it's now all been merged into the corresponding $config entry
1200
8b5156d1 1201# Allow overriding the build file name
5b18235a 1202$config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
bd5192b1 1203
75d47db4
RL		 1204######################################################################
1205# Build up information for skipping certain directories depending on disabled
1206# features, as well as setting up macros for disabled features.
1207
1208# This is a tentative database of directories to skip. Some entries may not
1209# correspond to anything real, but that's ok, they will simply be ignored.
1210# The actual processing of these entries is done in the build.info lookup
1211# loop further down.
1212#
1213# The key is a Unix formated path in the source tree, the value is an index
1214# into %disabled_info, so any existing path gets added to a corresponding
1215# 'skipped' entry in there with the list of skipped directories.
1216my %skipdir = ();
ca372414
RL		 1217my %disabled_info = (); # For configdata.pm
1218foreach my $what (sort keys %disabled) {
469ce8ff
RL		 1219 # There are deprecated disablables that translate to themselves.
1220 # They cause disabling cascades, but should otherwise not regiter.
1221 next if $deprecated_disablables{$what};
1222
ca372414
RL		 1223 $config{options} .= " no-$what";
1224
e7545517
MC		 1225 if (!grep { $what eq $_ } ( 'buildtest-c++', 'fips', 'threads', 'shared',
1226 'module', 'pic', 'dynamic-engine', 'makedepend',
d0308923 1227 'zlib-dynamic', 'zlib', 'sse2', 'legacy' )) {
ca372414 1228 (my $WHAT = uc $what) =~ s|-|_|g;
75d47db4 1229 my $skipdir = $what;
ca372414
RL		 1230
1231 # fix-up crypto/directory name(s)
75d47db4
RL		 1232 $skipdir = "ripemd" if $what eq "rmd160";
1233 $skipdir = "whrlpool" if $what eq "whirlpool";
ca372414
RL		 1234
1235 my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
75d47db4 1236 push @{$config{openssl_feature_defines}}, $macro;
ca372414 1237
75d47db4
RL		 1238 $skipdir{engines} = $what if $what eq 'engine';
1239 $skipdir{"crypto/$skipdir"} = $what
1240 unless $what eq 'async' || $what eq 'err';
ca372414
RL		 1241 }
1242}
1243
291e94df
RL		 1244# Make sure build_scheme is consistent.
1245$target{build_scheme} = [ $target{build_scheme} ]
1246 if ref($target{build_scheme}) ne "ARRAY";
1247
ddf1847d
RL		 1248my ($builder, $builder_platform, @builder_opts) =
1249 @{$target{build_scheme}};
1250
d192a3aa
RL		 1251foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
1252 $builder_platform."-checker.pm")) {
1253 my $checker_path = catfile($srcdir, "Configurations", $checker);
1254 if (-f $checker_path) {
1255 my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1256 ? sub { warn $@; } : sub { die $@; };
1257 if (! do $checker_path) {
1258 if ($@) {
1259 $fn->($@);
1260 } elsif ($!) {
1261 $fn->($!);
1262 } else {
1263 $fn->("The detected tools didn't match the platform\n");
1264 }
1265 }
1266 last;
1267 }
1268}
1269
488e2b0f
RL		 1270push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
1271
abe256e7 1272if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
84f32c84
DMSP		 1273 {
1274 push @{$config{cflags}}, "-mno-cygwin";
1275 push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
1276 push @{$config{shared_ldflag}}, "-mno-cygwin";
1277 }
cbecd29a 1278
5b18235a 1279if ($target =~ /linux.*-mips/ && !$disabled{asm}
c1a09254 1280 && !grep { $_ !~ /-m(ips|arch=)/ } (@{$config{CFLAGS}})) {
84f32c84
DMSP		 1281 # minimally required architecture flags for assembly modules
1282 my $value;
1283 $value = '-mips2' if ($target =~ /mips32/);
1284 $value = '-mips3' if ($target =~ /mips64/);
1285 unshift @{$config{cflags}}, $value;
1286 unshift @{$config{cxxflags}}, $value if $config{CXX};
63d8834c
AP		 1287}
1288
9c62a279
RL		 1289# If threads aren't disabled, check how possible they are
1290unless ($disabled{threads}) {
1291 if ($auto_threads) {
1292 # Enabled by default, disable it forcibly if unavailable
1293 if ($target{thread_scheme} eq "(unknown)") {
71ef78d7 1294 disable("unavailable", 'threads');
9c62a279
RL		 1295 }
1296 } else {
8483a003 1297 # The user chose to enable threads explicitly, let's see
9c62a279
RL		 1298 # if there's a chance that's possible
1299 if ($target{thread_scheme} eq "(unknown)") {
1300 # If the user asked for "threads" and we don't have internal
1301 # knowledge how to do it, [s]he is expected to provide any
1302 # system-dependent compiler options that are necessary. We
1303 # can't truly check that the given options are correct, but
1304 # we expect the user to know what [s]He is doing.
c1a09254 1305 if (!@{$config{CFLAGS}} && !@{$config{CPPDEFINES}}) {
9c62a279
RL		 1306 die "You asked for multi-threading support, but didn't\n"
1307 ,"provide any system-specific compiler options\n";
1308 }
1309 }
1310 }
1311}
1312
bacc3081
RL		 1313# Find out if clang's sanitizers have been enabled with -fsanitize
1314# flags and ensure that the corresponding %disabled elements area
1315# removed to reflect that the sanitizers are indeed enabled.
1316my %detected_sanitizers = ();
1317foreach (grep /^-fsanitize=/, @{$config{CFLAGS} || []}) {
1318 (my $checks = $_) =~ s/^-fsanitize=//;
1319 foreach (split /,/, $checks) {
1320 my $d = { address => 'asan',
1321 undefined => 'ubsan',
1322 memory => 'msan' } -> {$_};
1323 next unless defined $d;
1324
1325 $detected_sanitizers{$d} = 1;
1326 if (defined $disabled{$d}) {
1327 die "***** Conflict between disabling $d and enabling $_ sanitizer"
1328 if $disabled{$d} ne "default";
1329 delete $disabled{$d};
1330 }
1331 }
1332}
1333
9c62a279
RL		 1334# If threads still aren't disabled, add a C macro to ensure the source
1335# code knows about it. Any other flag is taken care of by the configs.
1336unless($disabled{threads}) {
e0bf7c01 1337 push @{$config{openssl_feature_defines}}, "OPENSSL_THREADS";
9c62a279 1338}
e452de9d 1339
98186eb4
VD		 1340# With "deprecated" disable all deprecated features.
1341if (defined($disabled{"deprecated"})) {
107b5792 1342 $config{api} = $maxapi;
98186eb4 1343}
07c4c14c 1344
8c3bc594 1345my $no_shared_warn=0;
291e94df 1346if ($target{shared_target} eq "")
84f32c84
DMSP		 1347 {
1348 $no_shared_warn = 1
1349 if (!$disabled{shared} || !$disabled{"dynamic-engine"});
71ef78d7 1350 disable('no-shared-target', 'pic');
84f32c84 1351 }
b436a982 1352
19ab5790 1353if ($disabled{"dynamic-engine"}) {
e0bf7c01 1354 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
343ec2b0 1355 $config{dynamic_engines} = 0;
19ab5790 1356} else {
e0bf7c01 1357 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_STATIC_ENGINE";
19ab5790 1358 $config{dynamic_engines} = 1;
343ec2b0 1359}
ecd45314 1360
bacc3081 1361unless ($disabled{asan} || defined $detected_sanitizers{asan}) {
5b18235a 1362 push @{$config{cflags}}, "-fsanitize=address";
c38bb727
BL		 1363}
1364
bacc3081 1365unless ($disabled{ubsan} || defined $detected_sanitizers{ubsan}) {
f430ba31 1366 # -DPEDANTIC or -fnosanitize=alignment may also be required on some
c38bb727 1367 # platforms.
5b18235a 1368 push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all";
c38bb727
BL		 1369}
1370
bacc3081 1371unless ($disabled{msan} || defined $detected_sanitizers{msan}) {
5b18235a 1372 push @{$config{cflags}}, "-fsanitize=memory";
29df3061
EK		 1373}
1374
65cc6d5c 1375unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
29df3061 1376 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
5b18235a 1377 push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
abe256e7 1378 push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
c38bb727 1379}
c313e32a
AP		 1380#
1381# Platform fix-ups
1382#
ae48242c
RL		 1383
1384# This saves the build files from having to check
1385if ($disabled{pic})
84f32c84
DMSP		 1386 {
1387 foreach (qw(shared_cflag shared_cxxflag shared_cppflag
1388 shared_defines shared_includes shared_ldflag
1389 module_cflags module_cxxflags module_cppflags
1390 module_defines module_includes module_lflags))
1391 {
1392 delete $config{$_};
1393 $target{$_} = "";
1394 }
1395 }
4f16039e 1396else
84f32c84
DMSP		 1397 {
1398 push @{$config{lib_defines}}, "OPENSSL_PIC";
1399 }
ae48242c 1400
291e94df 1401if ($target{sys_id} ne "")
84f32c84
DMSP		 1402 {
1403 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1404 }
cf1b7d96 1405
00b0d663 1406unless ($disabled{asm}) {
9fe2bb77 1407 if ($target{sha1_asm_src}) {
84f32c84
DMSP		 1408 push @{$config{lib_defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1409 push @{$config{lib_defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1410 push @{$config{lib_defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
9e0724a1 1411 }
e4739e31 1412 if ($target{keccak1600_asm_src} ne $table{DEFAULTS}->{keccak1600_asm_src}) {
84f32c84 1413 push @{$config{lib_defines}}, "KECCAK1600_ASM";
e4739e31 1414 }
216e8d91 1415 if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
84f32c84 1416 push @{$config{lib_defines}}, "RC4_ASM";
216e8d91 1417 }
9fe2bb77 1418 if ($target{md5_asm_src}) {
84f32c84 1419 push @{$config{lib_defines}}, "MD5_ASM";
9e0724a1 1420 }
d2b2221a 1421 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
9fe2bb77 1422 if ($target{rmd160_asm_src}) {
84f32c84 1423 push @{$config{lib_defines}}, "RMD160_ASM";
9e0724a1 1424 }
9fe2bb77 1425 if ($target{aes_asm_src}) {
41525ed6
MC		 1426 if ($target{aes_asm_src} =~ m/\baes-/) {
1427 push @{$config{lib_defines}}, "AES_ASM";
1428 push @{$config{module_defines}}, "AES_ASM";
1429 }
84f32c84
DMSP		 1430 # aes-ctr.fake is not a real file, only indication that assembler
1431 # module implements AES_ctr32_encrypt...
41525ed6
MC		 1432 if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//) {
1433 push @{$config{lib_defines}}, "AES_CTR_ASM";
1434 push @{$config{module_defines}}, "AES_CTR_ASM";
1435 }
84f32c84 1436 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
41525ed6
MC		 1437 if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//) {
1438 push @{$config{lib_defines}}, "AES_XTS_ASM";
1439 push @{$config{module_defines}}, "AES_XTS_ASM";
1440 }
84f32c84 1441 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($disabled{sse2});
41525ed6
MC		 1442 if ($target{aes_asm_src} =~ m/vpaes/) {
1443 push @{$config{lib_defines}}, "VPAES_ASM";
1444 push @{$config{module_defines}}, "VPAES_ASM";
1445 }
1446 if ($target{aes_asm_src} =~ m/bsaes/) {
1447 push @{$config{lib_defines}}, "BSAES_ASM";
1448 push @{$config{module_defines}}, "BSAES_ASM";
1449 }
9e0724a1 1450 }
9fe2bb77 1451 if ($target{wp_asm_src} =~ /mmx/) {
46d4d865 1452 if ($config{processor} eq "386") {
84f32c84
DMSP		 1453 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1454 } elsif (!$disabled{"whirlpool"}) {
1455 push @{$config{lib_defines}}, "WHIRLPOOL_ASM";
1456 }
9e0724a1 1457 }
9fe2bb77 1458 if ($target{modes_asm_src} =~ /ghash-/) {
84f32c84 1459 push @{$config{lib_defines}}, "GHASH_ASM";
9e0724a1 1460 }
9fe2bb77 1461 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
84f32c84 1462 push @{$config{lib_defines}}, "ECP_NISTZ256_ASM";
9e0724a1 1463 }
0e5c8d56 1464 if ($target{ec_asm_src} =~ /x25519/) {
84f32c84 1465 push @{$config{lib_defines}}, "X25519_ASM";
0e5c8d56 1466 }
7b176a54 1467 if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
84f32c84 1468 push @{$config{dso_defines}}, "PADLOCK_ASM";
7b176a54 1469 }
9fe2bb77 1470 if ($target{poly1305_asm_src} ne "") {
84f32c84 1471 push @{$config{lib_defines}}, "POLY1305_ASM";
9e0724a1
RL		 1472 }
1473}
d02b48c6 1474
e373c70a
RL		 1475my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
1476my %predefined_CXX = $config{CXX}
1477 ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
1478 : ();
54cf3b98 1479
fe191b49 1480# Check for makedepend capabilities.
6d75a83c 1481if (!$disabled{makedepend}) {
fe191b49
RL		 1482 if ($config{target} =~ /^(VC|vms)-/) {
1483 # For VC- and vms- targets, there's nothing more to do here. The
1484 # functionality is hard coded in the corresponding build files for
1485 # cl (Windows) and CC/DECC (VMS).
e373c70a 1486 } elsif (($predefined_C{__GNUC__} // -1) >= 3
84f32c84 1487 && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
fe191b49 1488 # We know that GNU C version 3 and up as well as all clang
717f308e
TS		 1489 # versions support dependency generation, but Xcode did not
1490 # handle $cc -M before clang support (but claims __GNUC__ = 3)
abe256e7 1491 $config{makedepprog} = "\$(CROSS_COMPILE)$config{CC}";
6d75a83c 1492 } else {
fe191b49
RL		 1493 # In all other cases, we look for 'makedepend', and disable the
1494 # capability if not found.
6d75a83c 1495 $config{makedepprog} = which('makedepend');
71ef78d7 1496 disable('unavailable', 'makedepend') unless $config{makedepprog};
54cf3b98 1497 }
f1f07a23 1498}
8ed40b83 1499
e373c70a 1500if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
0ad4078c 1501 # probe for -Wa,--noexecstack option...
e373c70a 1502 if ($predefined_C{__clang__}) {
0ad4078c
AP		 1503 # clang has builtin assembler, which doesn't recognize --help,
1504 # but it apparently recognizes the option in question on all
1505 # supported platforms even when it's meaningless. In other words
1506 # probe would fail, but probed option always accepted...
1507 push @{$config{cflags}}, "-Wa,--noexecstack", "-Qunused-arguments";
8e5da579 1508 } else {
0ad4078c
AP		 1509 my $cc = $config{CROSS_COMPILE}.$config{CC};
1510 open(PIPE, "$cc -Wa,--help -c -o null.$$.o -x assembler /dev/null 2>&1 |");
1511 while(<PIPE>) {
1512 if (m/--noexecstack/) {
1513 push @{$config{cflags}}, "-Wa,--noexecstack";
1514 last;
1515 }
1516 }
1517 close(PIPE);
1518 unlink("null.$$.o");
1519 }
1520}
7d130f68
RL		 1521
1522# Deal with bn_ops ###################################################
1523
84f32c84
DMSP		 1524$config{bn_ll} =0;
1525$config{export_var_as_fn} =0;
7d130f68 1526my $def_int="unsigned int";
84f32c84 1527$config{rc4_int} =$def_int;
b4f35e5e 1528($config{b64l},$config{b64},$config{b32})=(0,0,1);
7d130f68 1529
94af0cd7 1530my $count = 0;
7d130f68 1531foreach (sort split(/\s+/,$target{bn_ops})) {
94af0cd7
RS		 1532 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1533 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
84f32c84
DMSP		 1534 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1535 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
94af0cd7 1536 ($config{b64l},$config{b64},$config{b32})
84f32c84 1537 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
94af0cd7 1538 ($config{b64l},$config{b64},$config{b32})
84f32c84 1539 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
94af0cd7 1540 ($config{b64l},$config{b64},$config{b32})
84f32c84 1541 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
7d130f68 1542}
94af0cd7
RS		 1543die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1544 if $count > 1;
7d130f68
RL		 1545
1546
1547# Hack cflags for better warnings (dev option) #######################
1548
fa153b57
RL		 1549# "Stringify" the C and C++ flags string. This permits it to be made part of
1550# a string and works as well on command lines.
5b18235a
RL		 1551$config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1552 @{$config{cflags}} ];
fa153b57 1553$config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
abe256e7 1554 @{$config{cxxflags}} ] if $config{CXX};
b436a982 1555
fcd2d5a6
RL		 1556$config{openssl_api_defines} = [
1557 "OPENSSL_MIN_API=".($apitable->{$config{api} // ""} // -1)
1558];
98186eb4 1559
3b437400 1560my @strict_warnings_collection=();
0c28f277 1561if ($strict_warnings)
84f32c84
DMSP		 1562 {
1563 my $wopt;
1564 my $gccver = $predefined_C{__GNUC__} // -1;
6d50589c 1565
84f32c84 1566 warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike"
6d50589c 1567 unless $gccver >= 4;
3b437400
RL		 1568 push @strict_warnings_collection, @gcc_devteam_warn;
1569 push @strict_warnings_collection, @clang_devteam_warn
1570 if (defined($predefined_C{__clang__}));
84f32c84 1571 }
4650d10f
RL		 1572
1573if (grep { $_ eq '-static' } @{$config{LDFLAGS}}) {
71ef78d7 1574 disable('static', 'pic', 'threads');
4650d10f
RL		 1575}
1576
3b437400
RL		 1577$config{CFLAGS} = [ map { $_ eq '--ossl-strict-warnings'
1578 ? @strict_warnings_collection
1579 : ( $_ ) }
1580 @{$config{CFLAGS}} ];
ef8ca6bd
RL		 1581
1582unless ($disabled{"crypto-mdebug-backtrace"})
84f32c84
DMSP		 1583 {
1584 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1585 {
1586 push @{$config{cflags}}, $wopt
1587 unless grep { $_ eq $wopt } @{$config{cflags}};
84f32c84
DMSP		 1588 }
1589 if ($target =~ /^BSD-/)
1590 {
1591 push @{$config{ex_libs}}, "-lexecinfo";
1592 }
1593 }
0c28f277 1594
c91a0a83
EK		 1595unless ($disabled{afalgeng}) {
1596 $config{afalgeng}="";
9e381e8a 1597 if (grep { $_ eq 'afalgeng' } @{$target{enable}}) {
79fff39d 1598 my $minver = 4*10000 + 1*100 + 0;
abe256e7 1599 if ($config{CROSS_COMPILE} eq "") {
79fff39d
RL		 1600 my $verstr = `uname -r`;
1601 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1602 ($mi2) = $mi2 =~ /(\d+)/;
1603 my $ver = $ma*10000 + $mi1*100 + $mi2;
1604 if ($ver < $minver) {
71ef78d7 1605 disable('too-old-kernel', 'afalgeng');
79fff39d
RL		 1606 } else {
1607 push @{$config{engdirs}}, "afalg";
1608 }
68dc37c1 1609 } else {
71ef78d7 1610 disable('cross-compiling', 'afalgeng');
6cba4a66 1611 }
79fff39d 1612 } else {
71ef78d7 1613 disable('not-linux', 'afalgeng');
7f458a48 1614 }
1615}
8da00a38 1616
e0bf7c01 1617push @{$config{openssl_feature_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
7f458a48 1618
69495e3d
BP		 1619unless ($disabled{ktls}) {
1620 $config{ktls}="";
1621 if ($target =~ m/^linux/) {
1622 my $usr = "/usr/$config{cross_compile_prefix}";
1623 chop($usr);
1624 if ($config{cross_compile_prefix} eq "") {
1625 $usr = "/usr";
1626 }
1627 my $minver = (4 << 16) + (13 << 8) + 0;
1628 my @verstr = split(" ",`cat $usr/include/linux/version.h | grep LINUX_VERSION_CODE`);
1629
1630 if ($verstr[2] < $minver) {
71ef78d7 1631 disable('too-old-kernel', 'ktls');
69495e3d
BP		 1632 }
1633 } else {
71ef78d7 1634 disable('not-linux', 'ktls');
69495e3d
BP		 1635 }
1636}
1637
1638push @{$config{openssl_other_defines}}, "OPENSSL_NO_KTLS" if ($disabled{ktls});
1639
8f0dd6d9
RL		 1640# Get the extra flags used when building shared libraries and modules. We
1641# do this late because some of them depend on %disabled.
1642
1643# Make the flags to build DSOs the same as for shared libraries unless they
1644# are already defined
1645$target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
1646$target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
1647$target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
1648{
1649 my $shared_info_pl =
1650 catfile(dirname($0), "Configurations", "shared-info.pl");
1651 my %shared_info = read_eval_file($shared_info_pl);
1652 push @{$target{_conf_fname_int}}, $shared_info_pl;
1653 my $si = $target{shared_target};
1654 while (ref $si ne "HASH") {
1655 last if ! defined $si;
1656 if (ref $si eq "CODE") {
1657 $si = $si->();
1658 } else {
1659 $si = $shared_info{$si};
1660 }
1661 }
1662
1663 # Some of the 'shared_target' values don't have any entries in
1664 # %shared_info. That's perfectly fine, AS LONG AS the build file
1665 # template knows how to handle this. That is currently the case for
1666 # Windows and VMS.
1667 if (defined $si) {
1668 # Just as above, copy certain shared_* attributes to the corresponding
1669 # module_ attribute unless the latter is already defined
1670 $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
1671 $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
1672 $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
1673 foreach (sort keys %$si) {
1674 $target{$_} = defined $target{$_}
1675 ? add($si->{$_})->($target{$_})
1676 : $si->{$_};
1677 }
1678 }
1679}
1680
1681# ALL MODIFICATIONS TO %disabled, %config and %target MUST BE DONE FROM HERE ON
5b18235a 1682
9fe2bb77
RL		 1683# If we use the unified build, collect information from build.info files
1684my %unified_info = ();
1685
2b6b606c 1686my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
ddf1847d 1687if ($builder eq "unified") {
9fe2bb77
RL		 1688 use with_fallback qw(Text::Template);
1689
9fe2bb77 1690 sub cleandir {
2e963849 1691 my $base = shift;
9fe2bb77 1692 my $dir = shift;
2e963849
RL		 1693 my $relativeto = shift || ".";
1694
1695 $dir = catdir($base,$dir) unless isabsolute($dir);
9fe2bb77 1696
ec182ef0
RL		 1697 # Make sure the directories we're building in exists
1698 mkpath($dir);
1699
2e963849 1700 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
9fe2bb77
RL		 1701 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1702 return $res;
1703 }
1704
1705 sub cleanfile {
2e963849 1706 my $base = shift;
9fe2bb77 1707 my $file = shift;
2e963849
RL		 1708 my $relativeto = shift || ".";
1709
1710 $file = catfile($base,$file) unless isabsolute($file);
1711
9fe2bb77
RL		 1712 my $d = dirname($file);
1713 my $f = basename($file);
1714
ec182ef0
RL		 1715 # Make sure the directories we're building in exists
1716 mkpath($d);
1717
2e963849 1718 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
9fe2bb77
RL		 1719 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1720 return $res;
1721 }
1722
1967a42e
RL		 1723 # Store the name of the template file we will build the build file from
1724 # in %config. This may be useful for the build file itself.
1725 my @build_file_template_names =
84f32c84
DMSP		 1726 ( $builder_platform."-".$target{build_file}.".tmpl",
1727 $target{build_file}.".tmpl" );
1967a42e
RL		 1728 my @build_file_templates = ();
1729
1730 # First, look in the user provided directory, if given
7ecdf18d 1731 if (defined env($local_config_envname)) {
84f32c84
DMSP		 1732 @build_file_templates =
1733 map {
1734 if ($^O eq 'VMS') {
1735 # VMS environment variables are logical names,
1736 # which can be used as is
1737 $local_config_envname . ':' . $_;
1738 } else {
1739 catfile(env($local_config_envname), $_);
1740 }
1741 }
1742 @build_file_template_names;
1967a42e
RL		 1743 }
1744 # Then, look in our standard directory
1745 push @build_file_templates,
84f32c84
DMSP		 1746 ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1747 @build_file_template_names );
1967a42e
RL		 1748
1749 my $build_file_template;
1750 for $_ (@build_file_templates) {
84f32c84 1751 $build_file_template = $_;
1967a42e
RL		 1752 last if -f $build_file_template;
1753
1754 $build_file_template = undef;
1755 }
1756 if (!defined $build_file_template) {
84f32c84 1757 die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1967a42e
RL		 1758 }
1759 $config{build_file_templates}
8258975c
RL		 1760 = [ cleanfile($srcdir, catfile("Configurations", "common0.tmpl"),
1761 $blddir),
1762 $build_file_template,
1967a42e
RL		 1763 cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1764 $blddir) ];
1765
7f73eafe 1766 my @build_dirs = ( [ ] ); # current directory
9fe2bb77 1767
2e0956ba
RL		 1768 $config{build_infos} = [ ];
1769
d201dbc9 1770 my %ordinals = ();
7f73eafe
RL		 1771 while (@build_dirs) {
1772 my @curd = @{shift @build_dirs};
1773 my $sourced = catdir($srcdir, @curd);
1774 my $buildd = catdir($blddir, @curd);
9fe2bb77 1775
75d47db4
RL		 1776 my $unixdir = join('/', @curd);
1777 if (exists $skipdir{$unixdir}) {
1778 my $what = $skipdir{$unixdir};
1779 push @{$disabled_info{$what}->{skipped}}, catdir(@curd);
1780 next;
1781 }
1782
dca99383 1783 mkpath($buildd);
9fe2bb77 1784
7f73eafe 1785 my $f = 'build.info';
9fe2bb77
RL		 1786 # The basic things we're trying to build
1787 my @programs = ();
1788 my @libraries = ();
1842f369 1789 my @modules = ();
9fe2bb77 1790 my @scripts = ();
9fe2bb77 1791
c91f24d4 1792 my %attributes = ();
9fe2bb77 1793 my %sources = ();
2a08d1a0 1794 my %shared_sources = ();
9fe2bb77 1795 my %includes = ();
b96ab5e6 1796 my %defines = ();
9fe2bb77 1797 my %depends = ();
ae4c7450 1798 my %generate = ();
9fe2bb77 1799
26fe9b07
RL		 1800 # Support for $variablename in build.info files.
1801 # Embedded perl code is the ultimate master, still. If its output
1802 # contains a dollar sign, it had better be escaped, or it will be
1803 # taken for a variable name prefix.
1804 my %variables = ();
1805 my $variable_re = qr/\$([[:alpha:]][[:alnum:]_]*)/;
1806 my $expand_variables = sub {
1807 my $value = '';
1808 my $value_rest = shift;
1809
1810 while ($value_rest =~ /(?<!\\)${variable_re}/) {
1811 $value .= $`;
1812 $value .= $variables{$1};
1813 $value_rest = $';
1814 }
1815 return $value . $value_rest;
1816 };
1817
846e4c4d
RL		 1818 # We want to detect configdata.pm in the source tree, so we
1819 # don't use it if the build tree is different.
1820 my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir);
1821
2e0956ba 1822 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
cb6afcd6
RL		 1823 my $template =
1824 Text::Template->new(TYPE => 'FILE',
1825 SOURCE => catfile($sourced, $f),
1826 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
9fe2bb77
RL		 1827 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1828 my @text =
1829 split /^/m,
1830 $template->fill_in(HASH => { config => \%config,
1831 target => \%target,
9e04edf2 1832 disabled => \%disabled,
f59d0131 1833 withargs => \%withargs,
9fe2bb77
RL		 1834 builddir => abs2rel($buildd, $blddir),
1835 sourcedir => abs2rel($sourced, $blddir),
1836 buildtop => abs2rel($blddir, $blddir),
1837 sourcetop => abs2rel($srcdir, $blddir) },
1838 DELIMITERS => [ "{-", "-}" ]);
1839
1840 # The top item of this stack has the following values
1841 # -2 positive already run and we found ELSE (following ELSIF should fail)
1842 # -1 positive already run (skip until ENDIF)
1843 # 0 negatives so far (if we're at a condition, check it)
1844 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1845 # 2 positive ELSE (following ELSIF should fail)
1846 my @skip = ();
1847 collect_information(
1848 collect_from_array([ @text ],
1849 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1850 $l1 =~ s/\\$//; $l1.$l2 }),
1851 # Info we're looking for
1852 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
635bd409 1853 => sub {
c5798e0e 1854 if (! @skip || $skip[$#skip] > 0) {
0ee7b9fe 1855 push @skip, !! $expand_variables->($1);
635bd409
RL		 1856 } else {
1857 push @skip, -1;
1858 }
1859 },
9fe2bb77
RL		 1860 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1861 => sub { die "ELSIF out of scope" if ! @skip;
1862 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1863 $skip[$#skip] = -1 if $skip[$#skip] != 0;
0ee7b9fe 1864 $skip[$#skip] = !! $expand_variables->($1)
9fe2bb77
RL		 1865 if $skip[$#skip] == 0; },
1866 qr/^\s*ELSE\s*$/
1867 => sub { die "ELSE out of scope" if ! @skip;
1868 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1869 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1870 qr/^\s*ENDIF\s*$/
1871 => sub { die "ENDIF out of scope" if ! @skip;
1872 pop @skip; },
26fe9b07
RL		 1873 qr/^\s*${variable_re}\s*=\s*(.*?)\s*$/
1874 => sub {
1875 if (!@skip || $skip[$#skip] > 0) {
0ee7b9fe
RL		 1876 my $n = $1;
1877 my $v = $2;
1878 $variables{$n} = $expand_variables->($v);
26fe9b07
RL		 1879 }
1880 },
7f73eafe
RL		 1881 qr/^\s*SUBDIRS\s*=\s*(.*)\s*$/
1882 => sub {
1883 if (!@skip || $skip[$#skip] > 0) {
26fe9b07 1884 foreach (tokenize($expand_variables->($1))) {
7f73eafe
RL		 1885 push @build_dirs, [ @curd, splitdir($_, 1) ];
1886 }
1887 }
1888 },
c91f24d4 1889 qr/^\s*PROGRAMS(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
7f5af797
RL		 1890 => sub {
1891 if (!@skip || $skip[$#skip] > 0) {
c91f24d4 1892 my @a = tokenize($1, qr|\s*,\s*|);
26fe9b07 1893 my @p = tokenize($expand_variables->($2));
c91f24d4
RL		 1894 push @programs, @p;
1895 foreach my $a (@a) {
1896 my $ak = $a;
1897 my $av = 1;
1898 if ($a =~ m|^(.*?)\s*=\s*(.*?)$|) {
1899 $ak = $1;
1900 $av = $2;
1901 }
1902 foreach my $p (@p) {
1903 $attributes{$p}->{$ak} = $av;
1904 }
1905 }
7f5af797
RL		 1906 }
1907 },
c91f24d4 1908 qr/^\s*LIBS(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
7f5af797
RL		 1909 => sub {
1910 if (!@skip || $skip[$#skip] > 0) {
c91f24d4 1911 my @a = tokenize($1, qr|\s*,\s*|);
26fe9b07 1912 my @l = tokenize($expand_variables->($2));
c91f24d4
RL		 1913 push @libraries, @l;
1914 foreach my $a (@a) {
1915 my $ak = $a;
1916 my $av = 1;
1917 if ($a =~ m|^(.*?)\s*=\s*(.*?)$|) {
1918 $ak = $1;
1919 $av = $2;
1920 }
1921 foreach my $l (@l) {
1922 $attributes{$l}->{$ak} = $av;
1923 }
1924 }
7f5af797
RL		 1925 }
1926 },
1842f369 1927 qr/^\s*MODULES(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
7f5af797
RL		 1928 => sub {
1929 if (!@skip || $skip[$#skip] > 0) {
c91f24d4 1930 my @a = tokenize($1, qr|\s*,\s*|);
26fe9b07 1931 my @m = tokenize($expand_variables->($2));
1842f369 1932 push @modules, @m;
c91f24d4
RL		 1933 foreach my $a (@a) {
1934 my $ak = $a;
1935 my $av = 1;
1936 if ($a =~ m|^(.*?)\s*=\s*(.*?)$|) {
1937 $ak = $1;
1938 $av = $2;
1939 }
1842f369
RL		 1940 foreach my $m (@m) {
1941 $attributes{$m}->{$ak} = $av;
c91f24d4
RL		 1942 }
1943 }
7f5af797
RL		 1944 }
1945 },
c91f24d4 1946 qr/^\s*SCRIPTS(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
7f5af797
RL		 1947 => sub {
1948 if (!@skip || $skip[$#skip] > 0) {
c91f24d4 1949 my @a = tokenize($1, qr|\s*,\s*|);
26fe9b07 1950 my @s = tokenize($expand_variables->($2));
c91f24d4
RL		 1951 push @scripts, @s;
1952 foreach my $a (@a) {
1953 my $ak = $a;
1954 my $av = 1;
1955 if ($a =~ m|^(.*?)\s*=\s*(.*?)$|) {
1956 $ak = $1;
1957 $av = $2;
1958 }
1959 foreach my $s (@s) {
1960 $attributes{$s}->{$ak} = $av;
1961 }
1962 }
7f5af797
RL		 1963 }
1964 },
9fe2bb77
RL		 1965
1966 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
26fe9b07 1967 => sub { push @{$ordinals{$1}}, tokenize($expand_variables->($2))
9fe2bb77
RL		 1968 if !@skip || $skip[$#skip] > 0 },
1969 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
26fe9b07 1970 => sub { push @{$sources{$1}}, tokenize($expand_variables->($2))
9fe2bb77 1971 if !@skip || $skip[$#skip] > 0 },
2a08d1a0 1972 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
26fe9b07
RL		 1973 => sub { push @{$shared_sources{$1}},
1974 tokenize($expand_variables->($2))
2a08d1a0 1975 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1976 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
26fe9b07 1977 => sub { push @{$includes{$1}}, tokenize($expand_variables->($2))
9fe2bb77 1978 if !@skip || $skip[$#skip] > 0 },
b96ab5e6 1979 qr/^\s*DEFINE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
26fe9b07 1980 => sub { push @{$defines{$1}}, tokenize($expand_variables->($2))
b96ab5e6 1981 if !@skip || $skip[$#skip] > 0 },
4f858293 1982 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
26fe9b07 1983 => sub { push @{$depends{$1}}, tokenize($expand_variables->($2))
9fe2bb77 1984 if !@skip || $skip[$#skip] > 0 },
ae4c7450
RL		 1985 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1986 => sub { push @{$generate{$1}}, $2
1987 if !@skip || $skip[$#skip] > 0 },
ab6e147c 1988 qr/^\s*(?:#.*)?$/ => sub { },
2b6b606c
RL		 1989 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1990 "BEFORE" => sub {
1991 if ($buildinfo_debug) {
1992 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1993 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1994 }
1995 },
1996 "AFTER" => sub {
1997 if ($buildinfo_debug) {
1998 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1999 }
2000 },
9fe2bb77
RL		 2001 );
2002 die "runaway IF?" if (@skip);
2003
1842f369
RL		 2004 if (grep { defined $attributes{$_}->{engine} } keys %attributes
2005 and !$config{dynamic_engines}) {
2006 die <<"EOF"
19ab5790 2007ENGINES can only be used if configured with 'dynamic-engine'.
9fe2bb77
RL		 2008This is usually a fault in a build.info file.
2009EOF
1842f369 2010 }
7f5af797 2011
c91f24d4
RL		 2012 foreach (keys %attributes) {
2013 my $dest = $_;
2014 my $ddest = cleanfile($buildd, $_, $blddir);
2015 foreach (keys %{$attributes{$dest} // {}}) {
2016 $unified_info{attributes}->{$ddest}->{$_} =
2017 $attributes{$dest}->{$_};
2018 }
9fe2bb77
RL		 2019 }
2020
c91f24d4
RL		 2021 {
2022 my %infos = ( programs => [ @programs ],
2023 libraries => [ @libraries ],
1842f369 2024 modules => [ @modules ],
da7e31e0 2025 scripts => [ @scripts ] );
c91f24d4
RL		 2026 foreach my $k (keys %infos) {
2027 foreach (@{$infos{$k}}) {
2028 my $item = cleanfile($buildd, $_, $blddir);
2029 $unified_info{$k}->{$item} = 1;
2030 }
2031 }
8a67946e
RL		 2032 }
2033
f5fb6f05
RL		 2034 # Check that we haven't defined any library as both shared and
2035 # explicitly static. That is forbidden.
2036 my @doubles = ();
2037 foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
2038 (my $l = $_) =~ s/\.a$//;
2039 push @doubles, $l if defined $unified_info{libraries}->{$l};
9fe2bb77 2040 }
f5fb6f05
RL		 2041 die "these libraries are both explicitly static and shared:\n ",
2042 join(" ", @doubles), "\n"
2043 if @doubles;
9fe2bb77 2044
9fe2bb77
RL		 2045 foreach (keys %sources) {
2046 my $dest = $_;
2e963849 2047 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77 2048 foreach (@{$sources{$dest}}) {
2e963849 2049 my $s = cleanfile($sourced, $_, $blddir);
9fe2bb77
RL		 2050
2051 # If it isn't in the source tree, we assume it's generated
2052 # in the build tree
846e4c4d 2053 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2e963849 2054 $s = cleanfile($buildd, $_, $blddir);
9fe2bb77 2055 }
ea241958
RL		 2056 # We recognise C++, C and asm files
2057 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2058 my $o = $_;
2059 $o =~ s/\.[csS]$/.o/; # C and assembler
2060 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2e963849 2061 $o = cleanfile($buildd, $o, $blddir);
bec2db18
RL		 2062 $unified_info{sources}->{$ddest}->{$o} = -1;
2063 $unified_info{sources}->{$o}->{$s} = -1;
83900628
RS		 2064 } elsif ($s =~ /\.rc$/) {
2065 # We also recognise resource files
2066 my $o = $_;
2067 $o =~ s/\.rc$/.res/; # Resource configuration
2068 my $o = cleanfile($buildd, $o, $blddir);
bec2db18
RL		 2069 $unified_info{sources}->{$ddest}->{$o} = -1;
2070 $unified_info{sources}->{$o}->{$s} = -1;
9fe2bb77
RL		 2071 } else {
2072 $unified_info{sources}->{$ddest}->{$s} = 1;
2073 }
2074 }
2075 }
2076
2a08d1a0
RL		 2077 foreach (keys %shared_sources) {
2078 my $dest = $_;
2079 my $ddest = cleanfile($buildd, $_, $blddir);
2a08d1a0
RL		 2080 foreach (@{$shared_sources{$dest}}) {
2081 my $s = cleanfile($sourced, $_, $blddir);
2082
2083 # If it isn't in the source tree, we assume it's generated
2084 # in the build tree
846e4c4d 2085 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2a08d1a0
RL		 2086 $s = cleanfile($buildd, $_, $blddir);
2087 }
ccce3e1d 2088
ea241958 2089 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
ccce3e1d 2090 # We recognise C++, C and asm files
ea241958
RL		 2091 my $o = $_;
2092 $o =~ s/\.[csS]$/.o/; # C and assembler
2093 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2a08d1a0 2094 $o = cleanfile($buildd, $o, $blddir);
bec2db18
RL		 2095 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2096 $unified_info{sources}->{$o}->{$s} = -1;
ccce3e1d
RL		 2097 } elsif ($s =~ /\.rc$/) {
2098 # We also recognise resource files
2099 my $o = $_;
2100 $o =~ s/\.rc$/.res/; # Resource configuration
2101 my $o = cleanfile($buildd, $o, $blddir);
bec2db18
RL		 2102 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2103 $unified_info{sources}->{$o}->{$s} = -1;
ef2dfc99
RL		 2104 } elsif ($s =~ /\.ld$/) {
2105 # We also recognise linker scripts (or corresponding)
ccce3e1d 2106 # We know they are generated files
05a72c28 2107 my $ld = cleanfile($buildd, $_, $blddir);
ef2dfc99 2108 $unified_info{shared_sources}->{$ddest}->{$ld} = 1;
2a08d1a0
RL		 2109 } else {
2110 die "unrecognised source file type for shared library: $s\n";
2111 }
2112 }
2113 }
2114
ae4c7450
RL		 2115 foreach (keys %generate) {
2116 my $dest = $_;
2117 my $ddest = cleanfile($buildd, $_, $blddir);
ae4c7450
RL		 2118 die "more than one generator for $dest: "
2119 ,join(" ", @{$generate{$_}}),"\n"
2120 if scalar @{$generate{$_}} > 1;
2121 my @generator = split /\s+/, $generate{$dest}->[0];
2122 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
2123 $unified_info{generate}->{$ddest} = [ @generator ];
2124 }
2125
9fe2bb77
RL		 2126 foreach (keys %depends) {
2127 my $dest = $_;
4f858293 2128 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
8d34daf0
RL		 2129
2130 # If the destination doesn't exist in source, it can only be
2131 # a generated file in the build tree.
846e4c4d 2132 if ($ddest ne "" && ($ddest eq $src_configdata || ! -f $ddest)) {
8d34daf0 2133 $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 2134 }
2135 foreach (@{$depends{$dest}}) {
2e963849 2136 my $d = cleanfile($sourced, $_, $blddir);
9fe2bb77 2137
e737d7b1
RL		 2138 # If we know it's generated, or assume it is because we can't
2139 # find it in the source tree, we set file we depend on to be
2140 # in the build tree rather than the source tree, and assume
2141 # and that there are lines to build it in a BEGINRAW..ENDRAW
2142 # section or in the Makefile template.
846e4c4d
RL		 2143 if ($d eq $src_configdata
2144 || ! -f $d
da1f2104
RL		 2145 || (grep { $d eq $_ }
2146 map { cleanfile($srcdir, $_, $blddir) }
4f858293 2147 grep { /\.h$/ } keys %{$unified_info{generate}})) {
2e963849 2148 $d = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 2149 }
2150 # Take note if the file to depend on is being renamed
186a31e5
RL		 2151 # Take extra care with files ending with .a, they should
2152 # be treated without that extension, and the extension
2153 # should be added back after treatment.
2154 $d =~ /(\.a)?$/;
2155 my $e = $1 // "";
f5fb6f05 2156 $d = $`.$e;
9fe2bb77 2157 $unified_info{depends}->{$ddest}->{$d} = 1;
9fe2bb77
RL		 2158 }
2159 }
2160
2161 foreach (keys %includes) {
2162 my $dest = $_;
8d34daf0
RL		 2163 my $ddest = cleanfile($sourced, $_, $blddir);
2164
2165 # If the destination doesn't exist in source, it can only be
2166 # a generated file in the build tree.
846e4c4d 2167 if ($ddest eq $src_configdata || ! -f $ddest) {
8d34daf0 2168 $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 2169 }
2170 foreach (@{$includes{$dest}}) {
4748f890
RL		 2171 my $is = cleandir($sourced, $_, $blddir);
2172 my $ib = cleandir($buildd, $_, $blddir);
2173 push @{$unified_info{includes}->{$ddest}->{source}}, $is
2174 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
2175 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
2176 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
9fe2bb77
RL		 2177 }
2178 }
b96ab5e6
RL		 2179
2180 foreach (keys %defines) {
2181 my $dest = $_;
2182 my $ddest = cleanfile($sourced, $_, $blddir);
2183
2184 # If the destination doesn't exist in source, it can only be
2185 # a generated file in the build tree.
2186 if (! -f $ddest) {
2187 $ddest = cleanfile($buildd, $_, $blddir);
2188 if ($unified_info{rename}->{$ddest}) {
2189 $ddest = $unified_info{rename}->{$ddest};
2190 }
2191 }
2192 foreach (@{$defines{$dest}}) {
2193 m|^([^=]*)(=.*)?$|;
2194 die "0 length macro name not permitted\n" if $1 eq "";
2195 die "$1 defined more than once\n"
2196 if defined $unified_info{defines}->{$ddest}->{$1};
2197 $unified_info{defines}->{$ddest}->{$1} = $2;
2198 }
2199 }
9fe2bb77
RL		 2200 }
2201
d201dbc9
RL		 2202 my $ordinals_text = join(', ', sort keys %ordinals);
2203 warn <<"EOF" if $ordinals_text;
2204
2205WARNING: ORDINALS were specified for $ordinals_text
2206They are ignored and should be replaced with a combination of GENERATE,
2207DEPEND and SHARED_SOURCE.
2208EOF
2209
51583cb8
RL		 2210
2211 # Go through the sources of all libraries and check that the same basename
2212 # doesn't appear more than once. Some static library archivers depend on
2213 # them being unique.
2214 {
2215 my $err = 0;
2216 foreach my $prod (keys %{$unified_info{libraries}}) {
2217 my @prod_sources =
2218 map { keys %{$unified_info{sources}->{$_}} }
2219 keys %{$unified_info{sources}->{$prod}};
2220 my %srccnt = ();
2221
2222 # Count how many times a given each source basename
2223 # appears for each product.
2224 foreach my $src (@prod_sources) {
2225 $srccnt{basename $src}++;
2226 }
2227
2228 foreach my $src (keys %srccnt) {
2229 if ((my $cnt = $srccnt{$src}) > 1) {
2230 print STDERR "$src appears $cnt times for the product $prod\n";
2231 $err++
2232 }
2233 }
2234 }
2235 die if $err > 0;
2236 }
2237
1b5ad51f
RL		 2238 # Massage the result
2239
e431bcfa
RL		 2240 # If we depend on a header file or a perl module, add an inclusion of
2241 # its directory to allow smoothe inclusion
2242 foreach my $dest (keys %{$unified_info{depends}}) {
2243 next if $dest eq "";
2244 foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2245 next unless $d =~ /\.(h|pm)$/;
906032d5
RL		 2246 my $i = dirname($d);
2247 my $spot =
2248 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2249 ? 'build' : 'source';
2250 push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2251 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
e431bcfa
RL		 2252 }
2253 }
2254
ef2dfc99 2255 # Go through all intermediary files and change their names to something that
bec2db18
RL		 2256 # reflects what they will be built for. Note that for some source files,
2257 # this leads to duplicate object files because they are used multiple times.
2258 # the goal is to rename all object files according to this scheme:
2259 # {productname}-{midfix}-{origobjname}.[o|res]
2260 # the {midfix} is a keyword indicating the type of product, which is mostly
2261 # valuable for libraries since they come in two forms.
2262 #
2263 # This also reorganises the {sources} and {shared_sources} so that the
2264 # former only contains ALL object files that are supposed to end up in
2265 # static libraries and programs, while the latter contains ALL object files
2266 # that are supposed to end up in shared libraries and DSOs.
2267 # The main reason for having two different source structures is to allow
2268 # the same name to be used for the static and the shared variants of a
2269 # library.
2270 {
2271 # Take copies so we don't get interference from added stuff
2272 my %unified_copy = ();
2273 foreach (('sources', 'shared_sources')) {
2274 $unified_copy{$_} = { %{$unified_info{$_}} }
2275 if defined($unified_info{$_});
2276 delete $unified_info{$_};
2277 }
1842f369 2278 foreach my $prodtype (('programs', 'libraries', 'modules', 'scripts')) {
bec2db18
RL		 2279 # $intent serves multi purposes:
2280 # - give a prefix for the new object files names
2281 # - in the case of libraries, rearrange the object files so static
2282 # libraries use the 'sources' structure exclusively, while shared
2283 # libraries use the 'shared_sources' structure exclusively.
2284 my $intent = {
2285 programs => { bin => { src => [ 'sources' ],
2286 dst => 'sources' } },
2287 libraries => { lib => { src => [ 'sources' ],
2288 dst => 'sources' },
2289 shlib => { prodselect =>
2290 sub { grep !/\.a$/, @_ },
2291 src => [ 'sources',
2292 'shared_sources' ],
2293 dst => 'shared_sources' } },
22b41467
RL		 2294 modules => { dso => { src => [ 'sources' ],
2295 dst => 'sources' } },
bec2db18
RL		 2296 scripts => { script => { src => [ 'sources' ],
2297 dst => 'sources' } }
2298 } -> {$prodtype};
2299 foreach my $kind (keys %$intent) {
856b1b65
RL		 2300 next if ($intent->{$kind}->{dst} eq 'shared_sources'
2301 && $disabled{shared});
2302
bec2db18
RL		 2303 my @src = @{$intent->{$kind}->{src}};
2304 my $dst = $intent->{$kind}->{dst};
2305 my $prodselect = $intent->{$kind}->{prodselect} // sub { @_ };
2306 foreach my $prod ($prodselect->(keys %{$unified_info{$prodtype}})) {
2307 # %prod_sources has all applicable objects as keys, and
2308 # their corresponding sources as values
2309 my %prod_sources =
2310 map { $_ => [ keys %{$unified_copy{sources}->{$_}} ] }
2311 map { keys %{$unified_copy{$_}->{$prod}} }
2312 @src;
2313 foreach (keys %prod_sources) {
ef2dfc99
RL		 2314 # Only affect object files and resource files,
2315 # the others simply get a new value
2316 # (+1 instead of -1)
bec2db18
RL		 2317 if ($_ =~ /\.(o|res)$/) {
2318 (my $prodname = $prod) =~ s|\.a$||;
2319 my $newobj =
2320 catfile(dirname($_),
2321 basename($prodname)
2322 . '-' . $kind
2323 . '-' . basename($_));
2324 $unified_info{$dst}->{$prod}->{$newobj} = 1;
2325 foreach my $src (@{$prod_sources{$_}}) {
2326 $unified_info{sources}->{$newobj}->{$src} = 1;
2327 }
2328 # Adjust dependencies
2329 foreach my $deps (keys %{$unified_info{depends}->{$_}}) {
2330 $unified_info{depends}->{$_}->{$deps} = -1;
2331 $unified_info{depends}->{$newobj}->{$deps} = 1;
2332 }
2333 # Adjust includes
2334 foreach my $k (('source', 'build')) {
2335 next unless
2336 defined($unified_info{includes}->{$_}->{$k});
2337 my @incs = @{$unified_info{includes}->{$_}->{$k}};
2338 $unified_info{includes}->{$newobj}->{$k} = [ @incs ];
2339 }
2340 } else {
2341 $unified_info{$dst}->{$prod}->{$_} = 1;
2342 }
2343 }
2344 }
2345 }
2346 }
2347 }
51583cb8 2348
bec2db18
RL		 2349 # At this point, we have a number of sources with the value -1. They
2350 # aren't part of the local build and are probably meant for a different
2351 # platform, and can therefore be cleaned away. That happens when making
2352 # %unified_info more efficient below.
2353
9fe2bb77
RL		 2354 ### Make unified_info a bit more efficient
2355 # One level structures
1842f369 2356 foreach (("programs", "libraries", "modules", "scripts")) {
9fe2bb77
RL		 2357 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2358 }
2359 # Two level structures
c91f24d4 2360 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends")) {
9fe2bb77 2361 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
bec2db18
RL		 2362 my @items =
2363 sort
2364 grep { $unified_info{$l1}->{$l2}->{$_} > 0 }
2365 keys %{$unified_info{$l1}->{$l2}};
2366 if (@items) {
2367 $unified_info{$l1}->{$l2} = [ @items ];
2368 } else {
2369 delete $unified_info{$l1}->{$l2};
2370 }
9fe2bb77
RL		 2371 }
2372 }
b96ab5e6
RL		 2373 # Defines
2374 foreach my $dest (sort keys %{$unified_info{defines}}) {
2375 $unified_info{defines}->{$dest}
2376 = [ map { $_.$unified_info{defines}->{$dest}->{$_} }
2377 sort keys %{$unified_info{defines}->{$dest}} ];
2378 }
4748f890
RL		 2379 # Includes
2380 foreach my $dest (sort keys %{$unified_info{includes}}) {
2381 if (defined($unified_info{includes}->{$dest}->{build})) {
e431bcfa
RL		 2382 my @source_includes = ();
2383 @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2384 if defined($unified_info{includes}->{$dest}->{source});
4748f890
RL		 2385 $unified_info{includes}->{$dest} =
2386 [ @{$unified_info{includes}->{$dest}->{build}} ];
2387 foreach my $inc (@source_includes) {
2388 push @{$unified_info{includes}->{$dest}}, $inc
2389 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2390 }
609e4be8 2391 } elsif (defined($unified_info{includes}->{$dest}->{source})) {
4748f890
RL		 2392 $unified_info{includes}->{$dest} =
2393 [ @{$unified_info{includes}->{$dest}->{source}} ];
609e4be8
RL		 2394 } else {
2395 delete $unified_info{includes}->{$dest};
4748f890
RL		 2396 }
2397 }
b6e66075
RL		 2398
2399 # For convenience collect information regarding directories where
2400 # files are generated, those generated files and the end product
2401 # they end up in where applicable. Then, add build rules for those
2402 # directories
2403 my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
1842f369 2404 "dso" => [ @{$unified_info{modules}} ],
b6e66075
RL		 2405 "bin" => [ @{$unified_info{programs}} ],
2406 "script" => [ @{$unified_info{scripts}} ] );
2407 foreach my $type (keys %loopinfo) {
2408 foreach my $product (@{$loopinfo{$type}}) {
2409 my %dirs = ();
2410 my $pd = dirname($product);
2411
3bed01a0 2412 foreach (@{$unified_info{sources}->{$product} // []},
b6e66075
RL		 2413 @{$unified_info{shared_sources}->{$product} // []}) {
2414 my $d = dirname($_);
2415
2416 # We don't want to create targets for source directories
2417 # when building out of source
2418 next if ($config{sourcedir} ne $config{builddir}
2419 && $d =~ m|^\Q$config{sourcedir}\E|);
2420 # We already have a "test" target, and the current directory
2421 # is just silly to make a target for
2422 next if $d eq "test" || $d eq ".";
2423
2424 $dirs{$d} = 1;
2425 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2426 if $d ne $pd;
2427 }
2428 foreach (keys %dirs) {
2429 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2430 $product;
2431 }
2432 }
2433 }
9fe2bb77
RL		 2434}
2435
2436# For the schemes that need it, we provide the old *_obj configs
2437# from the *_asm_obj ones
3a55c92b 2438foreach (grep /_(asm|aux)_src$/, keys %target) {
9fe2bb77 2439 my $src = $_;
3a55c92b 2440 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
ea241958
RL		 2441 $target{$obj} = $target{$src};
2442 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2443 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
9fe2bb77
RL		 2444}
2445
291e94df
RL		 2446# Write down our configuration where it fits #########################
2447
b1fafff6 2448print "Creating configdata.pm\n";
291e94df
RL		 2449open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
2450print OUT <<"EOF";
abe256e7 2451#! $config{HASHBANGPERL}
b1fafff6 2452
291e94df
RL		 2453package configdata;
2454
2455use strict;
2456use warnings;
2457
2458use Exporter;
2459#use vars qw(\@ISA \@EXPORT);
2460our \@ISA = qw(Exporter);
538f38db 2461our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables \@disablables_int);
291e94df
RL		 2462
2463EOF
2464print OUT "our %config = (\n";
2465foreach (sort keys %config) {
2466 if (ref($config{$_}) eq "ARRAY") {
84f32c84
DMSP		 2467 print OUT " ", $_, " => [ ", join(", ",
2468 map { quotify("perl", $_) }
2469 @{$config{$_}}), " ],\n";
7ecdf18d 2470 } elsif (ref($config{$_}) eq "HASH") {
84f32c84 2471 print OUT " ", $_, " => {";
7ecdf18d
RL		 2472 if (scalar keys %{$config{$_}} > 0) {
2473 print OUT "\n";
2474 foreach my $key (sort keys %{$config{$_}}) {
2475 print OUT " ",
2476 join(" => ",
2477 quotify("perl", $key),
2478 defined $config{$_}->{$key}
2479 ? quotify("perl", $config{$_}->{$key})
2480 : "undef");
2481 print OUT ",\n";
2482 }
2483 print OUT " ";
2484 }
2485 print OUT "},\n";
291e94df 2486 } else {
84f32c84 2487 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
291e94df
RL		 2488 }
2489}
2490print OUT <<"EOF";
2491);
2492
2493EOF
2494print OUT "our %target = (\n";
2495foreach (sort keys %target) {
2496 if (ref($target{$_}) eq "ARRAY") {
84f32c84
DMSP		 2497 print OUT " ", $_, " => [ ", join(", ",
2498 map { quotify("perl", $_) }
2499 @{$target{$_}}), " ],\n";
291e94df 2500 } else {
84f32c84 2501 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
291e94df
RL		 2502 }
2503}
2504print OUT <<"EOF";
2505);
2506
96d2d7bc
RL		 2507EOF
2508print OUT "our \%available_protocols = (\n";
2509print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2510print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2511print OUT <<"EOF";
2512);
2513
3850f8cb
RL		 2514EOF
2515print OUT "our \@disablables = (\n";
2516foreach (@disablables) {
2517 print OUT " ", quotify("perl", $_), ",\n";
2518}
2519print OUT <<"EOF";
2520);
2521
538f38db
RL		 2522EOF
2523print OUT "# The following come from Configure's @disablables_int\n";
2524print OUT "our \@disablables_int = (\n";
2525foreach (@disablables_int) {
2526 print OUT " ", quotify("perl", $_), ",\n";
2527}
2528print OUT <<"EOF";
2529);
2530
96d2d7bc
RL		 2531EOF
2532print OUT "our \%disabled = (\n";
2533foreach (sort keys %disabled) {
2534 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2535}
2536print OUT <<"EOF";
2537);
2538
291e94df 2539EOF
107b5792
RL		 2540print OUT "our %withargs = (\n";
2541foreach (sort keys %withargs) {
2542 if (ref($withargs{$_}) eq "ARRAY") {
84f32c84
DMSP		 2543 print OUT " ", $_, " => [ ", join(", ",
2544 map { quotify("perl", $_) }
2545 @{$withargs{$_}}), " ],\n";
107b5792 2546 } else {
84f32c84 2547 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
107b5792
RL		 2548 }
2549}
2550print OUT <<"EOF";
2551);
edd4d402 2552
107b5792 2553EOF
ddf1847d 2554if ($builder eq "unified") {
9fe2bb77
RL		 2555 my $recurse;
2556 $recurse = sub {
2557 my $indent = shift;
2558 foreach (@_) {
2559 if (ref $_ eq "ARRAY") {
2560 print OUT " "x$indent, "[\n";
2561 foreach (@$_) {
2562 $recurse->($indent + 4, $_);
2563 }
2564 print OUT " "x$indent, "],\n";
2565 } elsif (ref $_ eq "HASH") {
2566 my %h = %$_;
2567 print OUT " "x$indent, "{\n";
2568 foreach (sort keys %h) {
2569 if (ref $h{$_} eq "") {
2570 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2571 } else {
2572 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2573 $recurse->($indent + 8, $h{$_});
2574 }
2575 }
2576 print OUT " "x$indent, "},\n";
2577 } else {
2578 print OUT " "x$indent, quotify("perl", $_), ",\n";
2579 }
2580 }
2581 };
2582 print OUT "our %unified_info = (\n";
2583 foreach (sort keys %unified_info) {
2584 if (ref $unified_info{$_} eq "") {
2585 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2586 } else {
2587 print OUT " "x4, quotify("perl", $_), " =>\n";
2588 $recurse->(8, $unified_info{$_});
2589 }
2590 }
2591 print OUT <<"EOF";
2592);
2593
2594EOF
2595}
047f0292
RL		 2596print OUT
2597 "# The following data is only used when this files is use as a script\n";
abe256e7 2598print OUT "my \@makevars = (\n";
b1fafff6 2599foreach (sort keys %user) {
abe256e7 2600 print OUT " '",$_,"',\n";
b1fafff6
RL		 2601}
2602print OUT ");\n";
ca372414
RL		 2603print OUT "my \%disabled_info = (\n";
2604foreach my $what (sort keys %disabled_info) {
2605 print OUT " '$what' => {\n";
2606 foreach my $info (sort keys %{$disabled_info{$what}}) {
2607 if (ref $disabled_info{$what}->{$info} eq 'ARRAY') {
2608 print OUT " $info => [ ",
2609 join(', ', map { "'$_'" } @{$disabled_info{$what}->{$info}}),
2610 " ],\n";
2611 } else {
2612 print OUT " $info => '", $disabled_info{$what}->{$info},
2613 "',\n";
2614 }
2615 }
2616 print OUT " },\n";
2617}
2618print OUT ");\n";
f729ba55 2619print OUT 'my @user_crossable = qw( ', join (' ', @user_crossable), " );\n";
b1fafff6 2620print OUT << 'EOF';
b1fafff6
RL		 2621# If run directly, we can give some answers, and even reconfigure
2622unless (caller) {
2623 use Getopt::Long;
2624 use File::Spec::Functions;
2625 use File::Basename;
2626 use Pod::Usage;
2627
2628 my $here = dirname($0);
2629
2630 my $dump = undef;
2631 my $cmdline = undef;
ca372414 2632 my $options = undef;
50ea9d2b 2633 my $target = undef;
b1fafff6
RL		 2634 my $envvars = undef;
2635 my $makevars = undef;
2636 my $buildparams = undef;
2637 my $reconf = undef;
2638 my $verbose = undef;
2639 my $help = undef;
2640 my $man = undef;
2641 GetOptions('dump|d' => \$dump,
2642 'command-line|c' => \$cmdline,
ca372414 2643 'options|o' => \$options,
50ea9d2b 2644 'target|t' => \$target,
b1fafff6
RL		 2645 'environment|e' => \$envvars,
2646 'make-variables|m' => \$makevars,
2647 'build-parameters|b' => \$buildparams,
2648 'reconfigure|reconf|r' => \$reconf,
2649 'verbose|v' => \$verbose,
2650 'help' => \$help,
2651 'man' => \$man)
2652 or die "Errors in command line arguments\n";
2653
50ea9d2b 2654 unless ($dump || $cmdline || $options || $target || $envvars || $makevars
ca372414 2655 || $buildparams || $reconf || $verbose || $help || $man) {
b1fafff6
RL		 2656 print STDERR <<"_____";
2657You must give at least one option.
2658For more information, do '$0 --help'
2659_____
2660 exit(2);
2661 }
2662
2663 if ($help) {
2664 pod2usage(-exitval => 0,
2665 -verbose => 1);
2666 }
2667 if ($man) {
2668 pod2usage(-exitval => 0,
2669 -verbose => 2);
2670 }
2671 if ($dump || $cmdline) {
d5fa7035 2672 print "\nCommand line (with current working directory = $here):\n\n";
b1fafff6 2673 print ' ',join(' ',
9e265322 2674 $config{PERL},
b1fafff6
RL		 2675 catfile($config{sourcedir}, 'Configure'),
2676 @{$config{perlargv}}), "\n";
d5fa7035
RL		 2677 print "\nPerl information:\n\n";
2678 print ' ',$config{perl_cmd},"\n";
2679 print ' ',$config{perl_version},' for ',$config{perl_archname},"\n";
b1fafff6 2680 }
ca372414
RL		 2681 if ($dump || $options) {
2682 my $longest = 0;
0b80103b 2683 my $longest2 = 0;
ca372414
RL		 2684 foreach my $what (@disablables) {
2685 $longest = length($what) if $longest < length($what);
1d2c6b7d
RL		 2686 $longest2 = length($disabled{$what})
2687 if $disabled{$what} && $longest2 < length($disabled{$what});
ca372414
RL		 2688 }
2689 print "\nEnabled features:\n\n";
2690 foreach my $what (@disablables) {
2691 print " $what\n" unless $disabled{$what};
2692 }
2693 print "\nDisabled features:\n\n";
2694 foreach my $what (@disablables) {
2695 if ($disabled{$what}) {
2696 print " $what", ' ' x ($longest - length($what) + 1),
0b80103b 2697 "[$disabled{$what}]", ' ' x ($longest2 - length($disabled{$what}) + 1);
ca372414
RL		 2698 print $disabled_info{$what}->{macro}
2699 if $disabled_info{$what}->{macro};
2700 print ' (skip ',
2701 join(', ', @{$disabled_info{$what}->{skipped}}),
2702 ')'
2703 if $disabled_info{$what}->{skipped};
2704 print "\n";
2705 }
2706 }
2707 }
50ea9d2b
RL		 2708 if ($dump || $target) {
2709 print "\nConfig target attributes:\n\n";
2710 foreach (sort keys %target) {
2711 next if $_ =~ m|^_| || $_ eq 'template';
2712 my $quotify = sub {
2713 map { (my $x = $_) =~ s|([\\\$\@"])|\\$1|g; "\"$x\""} @_;
2714 };
2715 print ' ', $_, ' => ';
2716 if (ref($target{$_}) eq "ARRAY") {
2717 print '[ ', join(', ', $quotify->(@{$target{$_}})), " ],\n";
2718 } else {
2719 print $quotify->($target{$_}), ",\n"
2720 }
2721 }
2722 }
b1fafff6
RL		 2723 if ($dump || $envvars) {
2724 print "\nRecorded environment:\n\n";
2725 foreach (sort keys %{$config{perlenv}}) {
2726 print ' ',$_,' = ',($config{perlenv}->{$_} || ''),"\n";
2727 }
2728 }
2729 if ($dump || $makevars) {
2730 print "\nMakevars:\n\n";
abe256e7 2731 foreach my $var (@makevars) {
f729ba55 2732 my $prefix = '';
abe256e7 2733 $prefix = $config{CROSS_COMPILE}
f729ba55 2734 if grep { $var eq $_ } @user_crossable;
b700bc59 2735 $prefix //= '';
f729ba55 2736 print ' ',$var,' ' x (16 - length $var),'= ',
abe256e7
RL		 2737 (ref $config{$var} eq 'ARRAY'
2738 ? join(' ', @{$config{$var}})
2739 : $prefix.$config{$var}),
b1fafff6 2740 "\n"
abe256e7 2741 if defined $config{$var};
b1fafff6
RL		 2742 }
2743
2744 my @buildfile = ($config{builddir}, $config{build_file});
2745 unshift @buildfile, $here
2746 unless file_name_is_absolute($config{builddir});
2747 my $buildfile = canonpath(catdir(@buildfile));
2748 print <<"_____";
2749
2750NOTE: These variables only represent the configuration view. The build file
2751template may have processed these variables further, please have a look at the
2752build file for more exact data:
2753 $buildfile
2754_____
2755 }
2756 if ($dump || $buildparams) {
2757 my @buildfile = ($config{builddir}, $config{build_file});
2758 unshift @buildfile, $here
2759 unless file_name_is_absolute($config{builddir});
2760 print "\nbuild file:\n\n";
2761 print " ", canonpath(catfile(@buildfile)),"\n";
2762
2763 print "\nbuild file templates:\n\n";
2764 foreach (@{$config{build_file_templates}}) {
2765 my @tmpl = ($_);
2766 unshift @tmpl, $here
2767 unless file_name_is_absolute($config{sourcedir});
2768 print ' ',canonpath(catfile(@tmpl)),"\n";
2769 }
2770 }
2771 if ($reconf) {
2772 if ($verbose) {
2773 print 'Reconfiguring with: ', join(' ',@{$config{perlargv}}), "\n";
84f32c84
DMSP		 2774 foreach (sort keys %{$config{perlenv}}) {
2775 print ' ',$_,' = ',($config{perlenv}->{$_} || ""),"\n";
2776 }
b1fafff6
RL		 2777 }
2778
2779 chdir $here;
2780 exec $^X,catfile($config{sourcedir}, 'Configure'),'reconf';
2781 }
2782}
2783
27841;
2785
2786__END__
2787
2788=head1 NAME
2789
2790configdata.pm - configuration data for OpenSSL builds
2791
2792=head1 SYNOPSIS
2793
2794Interactive:
2795
2796 perl configdata.pm [options]
2797
2798As data bank module:
2799
2800 use configdata;
f2d4be3b 2801
b1fafff6
RL		 2802=head1 DESCRIPTION
2803
2804This module can be used in two modes, interactively and as a module containing
2805all the data recorded by OpenSSL's Configure script.
2806
2807When used interactively, simply run it as any perl script, with at least one
2808option, and you will get the information you ask for. See L</OPTIONS> below.
2809
2810When loaded as a module, you get a few databanks with useful information to
2811perform build related tasks. The databanks are:
2812
2813 %config Configured things.
2814 %target The OpenSSL config target with all inheritances
2815 resolved.
2816 %disabled The features that are disabled.
2817 @disablables The list of features that can be disabled.
2818 %withargs All data given through --with-THING options.
2819 %unified_info All information that was computed from the build.info
2820 files.
2821
2822=head1 OPTIONS
2823
2824=over 4
2825
2826=item B<--help>
2827
2828Print a brief help message and exit.
2829
2830=item B<--man>
2831
2832Print the manual page and exit.
2833
85d6ad34 2834=item B<--dump> | B<-d>
b1fafff6
RL		 2835
2836Print all relevant configuration data. This is equivalent to B<--command-line>
50ea9d2b
RL		 2837B<--options> B<--target> B<--environment> B<--make-variables>
2838B<--build-parameters>.
b1fafff6
RL		 2839
2840=item B<--command-line> | B<-c>
2841
2842Print the current configuration command line.
2843
ca372414
RL		 2844=item B<--options> | B<-o>
2845
2846Print the features, both enabled and disabled, and display defined macro and
2847skipped directories where applicable.
2848
50ea9d2b
RL		 2849=item B<--target> | B<-t>
2850
2851Print the config attributes for this config target.
2852
b1fafff6
RL		 2853=item B<--environment> | B<-e>
2854
2855Print the environment variables and their values at the time of configuration.
2856
2857=item B<--make-variables> | B<-m>
2858
2859Print the main make variables generated in the current configuration
2860
2861=item B<--build-parameters> | B<-b>
2862
2863Print the build parameters, i.e. build file and build file templates.
2864
2865=item B<--reconfigure> | B<--reconf> | B<-r>
2866
2867Redo the configuration.
2868
2869=item B<--verbose> | B<-v>
2870
2871Verbose output.
2872
2873=back
2874
2875=cut
2876
2877EOF
2878close(OUT);
2879if ($builder_platform eq 'unix') {
2880 my $mode = (0755 & ~umask);
2881 chmod $mode, 'configdata.pm'
2882 or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2883}
cba5068d 2884
88087414 2885my %builders = (
9fe2bb77 2886 unified => sub {
b1fafff6 2887 print 'Creating ',$target{build_file},"\n";
ddf1847d 2888 run_dofile(catfile($blddir, $target{build_file}),
1967a42e 2889 @{$config{build_file_templates}});
9fe2bb77 2890 },
88087414
RL		 2891 );
2892
ddf1847d 2893$builders{$builder}->($builder_platform, @builder_opts);
fce0ba5f 2894
8937a4ed
RL		 2895$SIG{__DIE__} = $orig_death_handler;
2896
9c62a279 2897print <<"EOF" if ($disabled{threads} eq "unavailable");
5f8d5c96
BM		 2898
2899The library could not be configured for supporting multi-threaded
2900applications as the compiler options required on this system are not known.
ff1b7e09 2901See file INSTALL for details if you need multi-threading.
ec577822
BM		 2902EOF
2903
76ffb43d 2904print <<"EOF" if ($no_shared_warn);
2964ba8c 2905
ae48242c
RL		 2906The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2907platform, so we will pretend you gave the option 'no-pic', which also disables
2908'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2909or position independent code, please let us know (but please first make sure
2910you have tried with a current version of OpenSSL).
2e31ef03
RS		 2911EOF
2912
820e414d
RL		 2913print <<"EOF";
2914
2915**********************************************************************
2916*** ***
41349b5e 2917*** OpenSSL has been successfully configured ***
820e414d 2918*** ***
41349b5e
DMSP		 2919*** If you encounter a problem while building, please open an ***
2920*** issue on GitHub <https://github.com/openssl/openssl/issues> ***
2921*** and include the output from the following command: ***
2922*** ***
2923*** perl configdata.pm --dump ***
2924*** ***
2925*** (If you are new to OpenSSL, you might want to consult the ***
2926*** 'Troubleshooting' section in the INSTALL file first) ***
820e414d
RL		 2927*** ***
2928**********************************************************************
2929EOF
2930
d02b48c6
RE		 2931exit(0);
2932
bd5192b1
RL		 2933######################################################################
2934#
2935# Helpers and utility functions
2936#
2937
8937a4ed
RL		 2938# Death handler, to print a helpful message in case of failure #######
2939#
2940sub death_handler {
eb807d53 2941 die @_ if $^S; # To prevent the added message in eval blocks
8937a4ed 2942 my $build_file = $target{build_file} // "build file";
eb807d53 2943 my @message = ( <<"_____", @_ );
8937a4ed
RL		 2944
2945Failure! $build_file wasn't produced.
2946Please read INSTALL and associated NOTES files. You may also have to look over
2947your available compiler tool chain or change your configuration.
2948
2949_____
eb807d53
RL		 2950
2951 # Dying is terminal, so it's ok to reset the signal handler here.
2952 $SIG{__DIE__} = $orig_death_handler;
2953 die @message;
8937a4ed
RL		 2954}
2955
bd5192b1
RL		 2956# Configuration file reading #########################################
2957
1f2e1cd5
RL		 2958# Note: All of the helper functions are for lazy evaluation. They all
2959# return a CODE ref, which will return the intended value when evaluated.
2960# Thus, whenever there's mention of a returned value, it's about that
2961# intended value.
2962
bd5192b1 2963# Helper function to implement conditional inheritance depending on the
00b0d663 2964# value of $disabled{asm}. Used in inherit_from values as follows:
bd5192b1
RL		 2965#
2966# inherit_from => [ "template", asm("asm_tmpl") ]
2967#
2968sub asm {
2969 my @x = @_;
2970 sub {
84f32c84 2971 $disabled{asm} ? () : @x;
bd5192b1
RL		 2972 }
2973}
2974
1f2e1cd5
RL		 2975# Helper function to implement conditional value variants, with a default
2976# plus additional values based on the value of $config{build_type}.
2977# Arguments are given in hash table form:
2978#
2979# picker(default => "Basic string: ",
2980# debug => "debug",
2981# release => "release")
2982#
2983# When configuring with --debug, the resulting string will be
2984# "Basic string: debug", and when not, it will be "Basic string: release"
2985#
2986# This can be used to create variants of sets of flags according to the
2987# build type:
2988#
2989# cflags => picker(default => "-Wall",
2990# debug => "-g -O0",
2991# release => "-O3")
2992#
2993sub picker {
2994 my %opts = @_;
2995 return sub { add($opts{default} || (),
2996 $opts{$config{build_type}} || ())->(); }
2997}
2998
2999# Helper function to combine several values of different types into one.
3000# This is useful if you want to combine a string with the result of a
3001# lazy function, such as:
3002#
3003# cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
3004#
3005sub combine {
3006 my @stuff = @_;
3007 return sub { add(@stuff)->(); }
3008}
3009
3010# Helper function to implement conditional values depending on the value
3011# of $disabled{threads}. Can be used as follows:
3012#
3013# cflags => combine("-Wall", threads("-pthread"))
3014#
3015sub threads {
3016 my @flags = @_;
3017 return sub { add($disabled{threads} ? () : @flags)->(); }
3018}
3019
60aa6c1a
AP		 3020sub shared {
3021 my @flags = @_;
3022 return sub { add($disabled{shared} ? () : @flags)->(); }
3023}
1f2e1cd5 3024
9c62a279 3025our $add_called = 0;
88087414
RL		 3026# Helper function to implement adding values to already existing configuration
3027# values. It handles elements that are ARRAYs, CODEs and scalars
3028sub _add {
3029 my $separator = shift;
3030
bcb1977b
RL		 3031 # If there's any ARRAY in the collection of values OR the separator
3032 # is undef, we will return an ARRAY of combined values, otherwise a
3033 # string of joined values with $separator as the separator.
3034 my $found_array = !defined($separator);
88087414
RL		 3035
3036 my @values =
84f32c84
DMSP		 3037 map {
3038 my $res = $_;
3039 while (ref($res) eq "CODE") {
3040 $res = $res->();
3041 }
3042 if (defined($res)) {
3043 if (ref($res) eq "ARRAY") {
3044 $found_array = 1;
3045 @$res;
3046 } else {
3047 $res;
3048 }
3049 } else {
3050 ();
3051 }
88087414
RL		 3052 } (@_);
3053
9c62a279
RL		 3054 $add_called = 1;
3055
88087414 3056 if ($found_array) {
84f32c84 3057 [ @values ];
88087414 3058 } else {
84f32c84 3059 join($separator, grep { defined($_) && $_ ne "" } @values);
88087414
RL		 3060 }
3061}
3062sub add_before {
bdcd83e1
RL		 3063 my $separator = " ";
3064 if (ref($_[$#_]) eq "HASH") {
3065 my $opts = pop;
3066 $separator = $opts->{separator};
3067 }
88087414
RL		 3068 my @x = @_;
3069 sub { _add($separator, @x, @_) };
3070}
3071sub add {
bdcd83e1
RL		 3072 my $separator = " ";
3073 if (ref($_[$#_]) eq "HASH") {
3074 my $opts = pop;
3075 $separator = $opts->{separator};
3076 }
88087414
RL		 3077 my @x = @_;
3078 sub { _add($separator, @_, @x) };
3079}
3080
3b6c4b07
RL		 3081sub read_eval_file {
3082 my $fname = shift;
3083 my $content;
3084 my @result;
3085
3086 open F, "< $fname" or die "Can't open '$fname': $!\n";
3087 {
3088 undef local $/;
3089 $content = <F>;
3090 }
3091 close F;
3092 {
3093 local $@;
3094
3095 @result = ( eval $content );
3096 warn $@ if $@;
3097 }
3098 return wantarray ? @result : $result[0];
3099}
3100
bd5192b1
RL		 3101# configuration reader, evaluates the input file as a perl script and expects
3102# it to fill %targets with target configurations. Those are then added to
3103# %table.
3104sub read_config {
3105 my $fname = shift;
3b6c4b07
RL		 3106 my %targets;
3107
bd5192b1 3108 {
84f32c84
DMSP		 3109 # Protect certain tables from tampering
3110 local %table = ();
bd5192b1 3111
84f32c84 3112 %targets = read_eval_file($fname);
bd5192b1 3113 }
225f980d
RL		 3114 my %preexisting = ();
3115 foreach (sort keys %targets) {
3116 $preexisting{$_} = 1 if $table{$_};
3117 }
3118 die <<"EOF",
3119The following config targets from $fname
3120shadow pre-existing config targets with the same name:
3121EOF
3122 map { " $_\n" } sort keys %preexisting
3123 if %preexisting;
3124
bd5192b1
RL		 3125
3126 # For each target, check that it's configured with a hash table.
3127 foreach (keys %targets) {
84f32c84
DMSP		 3128 if (ref($targets{$_}) ne "HASH") {
3129 if (ref($targets{$_}) eq "") {
3130 warn "Deprecated target configuration for $_, ignoring...\n";
3131 } else {
3132 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
3133 }
3134 delete $targets{$_};
3135 } else {
ee9b0bbb
RL		 3136 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
3137 }
bd5192b1
RL		 3138 }
3139
3140 %table = (%table, %targets);
3141
3142}
3143
8483a003
F		 3144# configuration resolver. Will only resolve all the lazy evaluation
3145# codeblocks for the chosen target and all those it inherits from,
bd5192b1
RL		 3146# recursively
3147sub resolve_config {
3148 my $target = shift;
3149 my @breadcrumbs = @_;
3150
c4718849 3151# my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
9c62a279 3152
bd5192b1 3153 if (grep { $_ eq $target } @breadcrumbs) {
84f32c84
DMSP		 3154 die "inherit_from loop! target backtrace:\n "
3155 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
bd5192b1
RL		 3156 }
3157
3158 if (!defined($table{$target})) {
84f32c84
DMSP		 3159 warn "Warning! target $target doesn't exist!\n";
3160 return ();
bd5192b1
RL		 3161 }
3162 # Recurse through all inheritances. They will be resolved on the
3163 # fly, so when this operation is done, they will all just be a
3164 # bunch of attributes with string values.
3165 # What we get here, though, are keys with references to lists of
3166 # the combined values of them all. We will deal with lists after
3167 # this stage is done.
3168 my %combined_inheritance = ();
3169 if ($table{$target}->{inherit_from}) {
84f32c84
DMSP		 3170 my @inherit_from =
3171 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
3172 foreach (@inherit_from) {
3173 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
3174
3175 # 'template' is a marker that's considered private to
3176 # the config that had it.
3177 delete $inherited_config{template};
3178
3179 foreach (keys %inherited_config) {
3180 if (!$combined_inheritance{$_}) {
3181 $combined_inheritance{$_} = [];
3182 }
3183 push @{$combined_inheritance{$_}}, $inherited_config{$_};
3184 }
3185 }
bd5192b1
RL		 3186 }
3187
3188 # We won't need inherit_from in this target any more, since we've
3189 # resolved all the inheritances that lead to this
3190 delete $table{$target}->{inherit_from};
3191
3192 # Now is the time to deal with those lists. Here's the place to
3193 # decide what shall be done with those lists, all based on the
3194 # values of the target we're currently dealing with.
3195 # - If a value is a coderef, it will be executed with the list of
3196 # inherited values as arguments.
3197 # - If the corresponding key doesn't have a value at all or is the
8483a003 3198 # empty string, the inherited value list will be run through the
bd5192b1
RL		 3199 # default combiner (below), and the result becomes this target's
3200 # value.
3201 # - Otherwise, this target's value is assumed to be a string that
3202 # will simply override the inherited list of values.
a26d8be9 3203 my $default_combiner = add();
bd5192b1
RL		 3204
3205 my %all_keys =
84f32c84
DMSP		 3206 map { $_ => 1 } (keys %combined_inheritance,
3207 keys %{$table{$target}});
b0b92a5b
RL		 3208
3209 sub process_values {
84f32c84
DMSP		 3210 my $object = shift;
3211 my $inherited = shift; # Always a [ list ]
3212 my $target = shift;
3213 my $entry = shift;
b0b92a5b 3214
9c62a279
RL		 3215 $add_called = 0;
3216
b0b92a5b
RL		 3217 while(ref($object) eq "CODE") {
3218 $object = $object->(@$inherited);
3219 }
3220 if (!defined($object)) {
3221 return ();
3222 }
3223 elsif (ref($object) eq "ARRAY") {
9c62a279 3224 local $add_called; # To make sure recursive calls don't affect it
b0b92a5b
RL		 3225 return [ map { process_values($_, $inherited, $target, $entry) }
3226 @$object ];
3227 } elsif (ref($object) eq "") {
3228 return $object;
3229 } else {
3230 die "cannot handle reference type ",ref($object)
3231 ," found in target ",$target," -> ",$entry,"\n";
3232 }
3233 }
3234
bd5192b1 3235 foreach (sort keys %all_keys) {
9c62a279 3236 my $previous = $combined_inheritance{$_};
bd5192b1 3237
84f32c84
DMSP		 3238 # Current target doesn't have a value for the current key?
3239 # Assign it the default combiner, the rest of this loop body
3240 # will handle it just like any other coderef.
3241 if (!exists $table{$target}->{$_}) {
3242 $table{$target}->{$_} = $default_combiner;
3243 }
bd5192b1 3244
84f32c84
DMSP		 3245 $table{$target}->{$_} = process_values($table{$target}->{$_},
3246 $combined_inheritance{$_},
3247 $target, $_);
b0b92a5b
RL		 3248 unless(defined($table{$target}->{$_})) {
3249 delete $table{$target}->{$_};
3250 }
c4718849
RL		 3251# if ($extra_checks &&
3252# $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
3253# warn "$_ got replaced in $target\n";
3254# }
bd5192b1
RL		 3255 }
3256
3257 # Finally done, return the result.
3258 return %{$table{$target}};
3259}
3260
462ba4f6 3261sub usage
84f32c84
DMSP		 3262 {
3263 print STDERR $usage;
3264 print STDERR "\npick os/compiler from:\n";
3265 my $j=0;
3266 my $i;
10a926c1 3267 my $k=0;
84f32c84
DMSP		 3268 foreach $i (sort keys %table)
3269 {
3270 next if $table{$i}->{template};
3271 next if $i =~ /^debug/;
3272 $k += length($i) + 1;
3273 if ($k > 78)
3274 {
3275 print STDERR "\n";
3276 $k=length($i);
3277 }
3278 print STDERR $i . " ";
3279 }
3280 foreach $i (sort keys %table)
3281 {
3282 next if $table{$i}->{template};
3283 next if $i !~ /^debug/;
3284 $k += length($i) + 1;
3285 if ($k > 78)
3286 {
3287 print STDERR "\n";
3288 $k=length($i);
3289 }
3290 print STDERR $i . " ";
3291 }
3292 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
3293 exit(1);
3294 }
d02b48c6 3295
01d99976 3296sub run_dofile
107b5792 3297{
107b5792 3298 my $out = shift;
9fe2bb77 3299 my @templates = @_;
107b5792 3300
ced2c2c5
RS		 3301 unlink $out || warn "Can't remove $out, $!"
3302 if -f $out;
9fe2bb77
RL		 3303 foreach (@templates) {
3304 die "Can't open $_, $!" unless -f $_;
3305 }
9e265322 3306 my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
f879d5ff 3307 my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
9fe2bb77
RL		 3308 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
3309 system($cmd);
107b5792
RL		 3310 exit 1 if $? != 0;
3311 rename("$out.new", $out) || die "Can't rename $out.new, $!";
3312}
3313
6d75a83c
RL		 3314sub compiler_predefined {
3315 state %predefined;
41d6e0f3 3316 my $cc = shift;
6d75a83c
RL		 3317
3318 return () if $^O eq 'VMS';
3319
41d6e0f3
AP		 3320 die 'compiler_predefined called without a compiler command'
3321 unless $cc;
6d75a83c 3322
41d6e0f3 3323 if (! $predefined{$cc}) {
6d75a83c 3324
41d6e0f3 3325 $predefined{$cc} = {};
6d75a83c
RL		 3326
3327 # collect compiler pre-defines from gcc or gcc-alike...
3328 open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
3329 while (my $l = <PIPE>) {
3330 $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
41d6e0f3 3331 $predefined{$cc}->{$1} = $2 // '';
6d75a83c
RL		 3332 }
3333 close(PIPE);
3334 }
3335
41d6e0f3 3336 return %{$predefined{$cc}};
6d75a83c
RL		 3337}
3338
656bbdc6
AP		 3339sub which
3340{
3341 my ($name)=@_;
3342
3343 if (eval { require IPC::Cmd; 1; }) {
3344 IPC::Cmd->import();
3345 return scalar IPC::Cmd::can_run($name);
3346 } else {
3347 # if there is $directories component in splitpath,
3348 # then it's not something to test with $PATH...
3349 return $name if (File::Spec->splitpath($name))[1];
3350
3351 foreach (File::Spec->path()) {
3352 my $fullpath = catfile($_, "$name$target{exe_extension}");
3353 if (-f $fullpath and -x $fullpath) {
3354 return $fullpath;
3355 }
3356 }
3357 }
3358}
3359
7ecdf18d
RL		 3360sub env
3361{
3362 my $name = shift;
ac6ae8a9 3363 my %opts = @_;
7ecdf18d 3364
ac6ae8a9
RL		 3365 unless ($opts{cacheonly}) {
3366 # Note that if $ENV{$name} doesn't exist or is undefined,
3367 # $config{perlenv}->{$name} will be created with the value
3368 # undef. This is intentional.
89bea083 3369
ac6ae8a9
RL		 3370 $config{perlenv}->{$name} = $ENV{$name}
3371 if ! exists $config{perlenv}->{$name};
3372 }
7ecdf18d
RL		 3373 return $config{perlenv}->{$name};
3374}
3375
00ae96ca
RL		 3376# Configuration printer ##############################################
3377
3378sub print_table_entry
3379{
f770d75b
AP		 3380 local $now_printing = shift;
3381 my %target = resolve_config($now_printing);
00ae96ca
RL		 3382 my $type = shift;
3383
3384 # Don't print the templates
3385 return if $target{template};
3386
3387 my @sequence = (
84f32c84
DMSP		 3388 "sys_id",
3389 "cpp",
3390 "cppflags",
3391 "defines",
3392 "includes",
3393 "cc",
3394 "cflags",
3395 "unistd",
3396 "ld",
3397 "lflags",
3398 "loutflag",
3399 "ex_libs",
3400 "bn_ops",
84f32c84
DMSP		 3401 "ec_asm_src",
3402 "des_asm_src",
3403 "aes_asm_src",
3404 "bf_asm_src",
3405 "md5_asm_src",
3406 "cast_asm_src",
3407 "sha1_asm_src",
3408 "rc4_asm_src",
3409 "rmd160_asm_src",
3410 "rc5_asm_src",
3411 "wp_asm_src",
3412 "cmll_asm_src",
3413 "modes_asm_src",
3414 "padlock_asm_src",
3415 "chacha_asm_src",
3416 "poly1035_asm_src",
3417 "thread_scheme",
3418 "perlasm_scheme",
3419 "dso_scheme",
3420 "shared_target",
3421 "shared_cflag",
3422 "shared_defines",
3423 "shared_ldflag",
3424 "shared_rcflag",
3425 "shared_extension",
3426 "dso_extension",
3427 "obj_extension",
3428 "exe_extension",
3429 "ranlib",
3430 "ar",
3431 "arflags",
3432 "aroutflag",
3433 "rc",
3434 "rcflags",
3435 "rcoutflag",
3436 "mt",
3437 "mtflags",
3438 "mtinflag",
3439 "mtoutflag",
3440 "multilib",
3441 "build_scheme",
3442 );
00ae96ca
RL		 3443
3444 if ($type eq "TABLE") {
84f32c84
DMSP		 3445 print "\n";
3446 print "*** $now_printing\n";
cb212f23
RL		 3447 foreach (@sequence) {
3448 if (ref($target{$_}) eq "ARRAY") {
3449 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3450 } else {
3451 printf "\$%-12s = %s\n", $_, $target{$_};
3452 }
3453 }
00ae96ca 3454 } elsif ($type eq "HASH") {
84f32c84
DMSP		 3455 my $largest =
3456 length((sort { length($a) <=> length($b) } @sequence)[-1]);
3457 print " '$now_printing' => {\n";
3458 foreach (@sequence) {
3459 if ($target{$_}) {
cb212f23
RL		 3460 if (ref($target{$_}) eq "ARRAY") {
3461 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3462 } else {
3463 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3464 }
84f32c84
DMSP		 3465 }
3466 }
3467 print " },\n";
00ae96ca
RL		 3468 }
3469}
3470
3471# Utility routines ###################################################
3472
2e963849
RL		 3473# On VMS, if the given file is a logical name, File::Spec::Functions
3474# will consider it an absolute path. There are cases when we want a
3475# purely syntactic check without checking the environment.
3476sub isabsolute {
3477 my $file = shift;
3478
3479 # On non-platforms, we just use file_name_is_absolute().
3480 return file_name_is_absolute($file) unless $^O eq "VMS";
3481
69687aa8 3482 # If the file spec includes a device or a directory spec,
2e963849
RL		 3483 # file_name_is_absolute() is perfectly safe.
3484 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3485
3486 # Here, we know the given file spec isn't absolute
3487 return 0;
3488}
3489
ec182ef0
RL		 3490# Makes a directory absolute and cleans out /../ in paths like foo/../bar
3491# On some platforms, this uses rel2abs(), while on others, realpath() is used.
3492# realpath() requires that at least all path components except the last is an
3493# existing directory. On VMS, the last component of the directory spec must
3494# exist.
3495sub absolutedir {
3496 my $dir = shift;
3497
3498 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
3499 # will return the volume name for the device, no matter what. Also,
3500 # it will return an incorrect directory spec if the argument is a
3501 # directory that doesn't exist.
3502 if ($^O eq "VMS") {
3503 return rel2abs($dir);
3504 }
3505
3506 # We use realpath() on Unix, since no other will properly clean out
3507 # a directory spec.
3508 use Cwd qw/realpath/;
3509
3510 return realpath($dir);
3511}
3512
fe05264e
RL		 3513sub quotify {
3514 my %processors = (
84f32c84
DMSP		 3515 perl => sub { my $x = shift;
3516 $x =~ s/([\\\$\@"])/\\$1/g;
3517 return '"'.$x.'"'; },
3518 maybeshell => sub { my $x = shift;
3519 (my $y = $x) =~ s/([\\\"])/\\$1/g;
3520 if ($x ne $y || $x =~ m|\s|) {
3521 return '"'.$y.'"';
3522 } else {
3523 return $x;
3524 }
3525 },
3526 );
fe05264e
RL		 3527 my $for = shift;
3528 my $processor =
84f32c84 3529 defined($processors{$for}) ? $processors{$for} : sub { shift; };
fe05264e 3530
2110febb 3531 return map { $processor->($_); } @_;
fe05264e 3532}
107b5792 3533
9fe2bb77
RL		 3534# collect_from_file($filename, $line_concat_cond_re, $line_concat)
3535# $filename is a file name to read from
3536# $line_concat_cond_re is a regexp detecting a line continuation ending
3537# $line_concat is a CODEref that takes care of concatenating two lines
3538sub collect_from_file {
3539 my $filename = shift;
3540 my $line_concat_cond_re = shift;
3541 my $line_concat = shift;
3542
3543 open my $fh, $filename || die "unable to read $filename: $!\n";
3544 return sub {
3545 my $saved_line = "";
3546 $_ = "";
3547 while (<$fh>) {
04f171c0 3548 s|\R$||;
9fe2bb77
RL		 3549 if (defined $line_concat) {
3550 $_ = $line_concat->($saved_line, $_);
3551 $saved_line = "";
3552 }
3553 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3554 $saved_line = $_;
3555 next;
3556 }
3557 return $_;
3558 }
3559 die "$filename ending with continuation line\n" if $_;
3560 close $fh;
3561 return undef;
3562 }
3563}
3564
3565# collect_from_array($array, $line_concat_cond_re, $line_concat)
3566# $array is an ARRAYref of lines
3567# $line_concat_cond_re is a regexp detecting a line continuation ending
3568# $line_concat is a CODEref that takes care of concatenating two lines
3569sub collect_from_array {
3570 my $array = shift;
3571 my $line_concat_cond_re = shift;
3572 my $line_concat = shift;
3573 my @array = (@$array);
3574
3575 return sub {
3576 my $saved_line = "";
3577 $_ = "";
3578 while (defined($_ = shift @array)) {
04f171c0 3579 s|\R$||;
9fe2bb77
RL		 3580 if (defined $line_concat) {
3581 $_ = $line_concat->($saved_line, $_);
3582 $saved_line = "";
3583 }
3584 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3585 $saved_line = $_;
3586 next;
3587 }
3588 return $_;
3589 }
3590 die "input text ending with continuation line\n" if $_;
3591 return undef;
3592 }
3593}
3594
3595# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3596# $lineiterator is a CODEref that delivers one line at a time.
107b5792
RL		 3597# All following arguments are regex/CODEref pairs, where the regexp detects a
3598# line and the CODEref does something with the result of the regexp.
3599sub collect_information {
9fe2bb77 3600 my $lineiterator = shift;
107b5792
RL		 3601 my %collectors = @_;
3602
9fe2bb77 3603 while(defined($_ = $lineiterator->())) {
04f171c0 3604 s|\R$||;
9fe2bb77 3605 my $found = 0;
2b6b606c
RL		 3606 if ($collectors{"BEFORE"}) {
3607 $collectors{"BEFORE"}->($_);
3608 }
9fe2bb77 3609 foreach my $re (keys %collectors) {
2b6b606c 3610 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
9fe2bb77
RL		 3611 $collectors{$re}->($lineiterator);
3612 $found = 1;
3613 };
3614 }
3615 if ($collectors{"OTHERWISE"}) {
3616 $collectors{"OTHERWISE"}->($lineiterator, $_)
3617 unless $found || !defined $collectors{"OTHERWISE"};
3618 }
2b6b606c
RL		 3619 if ($collectors{"AFTER"}) {
3620 $collectors{"AFTER"}->($_);
3621 }
107b5792 3622 }
107b5792 3623}
ce959812
RL		 3624
3625# tokenize($line)
5d3af259 3626# tokenize($line,$separator)
ce959812 3627# $line is a line of text to split up into tokens
5d3af259
RL		 3628# $separator [optional] is a regular expression that separates the tokens,
3629# the default being spaces. Do not use quotes of any kind as separators,
3630# that will give undefined results.
3631# Returns a list of tokens.
ce959812 3632#
5d3af259
RL		 3633# Tokens are divided by separator (spaces by default). If the tokens include
3634# the separators, they have to be quoted with single or double quotes.
3635# Double quotes inside a double quoted token must be escaped. Escaping is done
ce959812
RL		 3636# with backslash.
3637# Basically, the same quoting rules apply for " and ' as in any
3638# Unix shell.
3639sub tokenize {
3640 my $line = my $debug_line = shift;
5d3af259 3641 my $separator = shift // qr|\s+|;
ce959812
RL		 3642 my @result = ();
3643
5d3af259
RL		 3644 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3645 print STDERR "DEBUG[tokenize]: \$separator = $separator\n";
3646 }
3647
3648 while ($line =~ s|^${separator}||, $line ne "") {
ce959812 3649 my $token = "";
5d3af259
RL		 3650 again:
3651 $line =~ m/^(.*?)(${separator}|"|'|$)/;
3652 $token .= $1;
3653 $line = $2.$';
3654
3655 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3656 $token .= $1;
3657 $line = $';
3658 goto again;
3659 } elsif ($line =~ m/^'([^']*)'/) {
3660 $token .= $1;
3661 $line = $';
3662 goto again;
ce959812
RL		 3663 }
3664 push @result, $token;
3665 }
3666
3667 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
5d3af259
RL		 3668 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3669 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
ce959812
RL		 3670 }
3671 return @result;
3672}
A mirror of the official openssl repository