3 # Copyright 2016-2022 The OpenSSL Project Authors. All Rights Reserved.
5 # Licensed under the Apache License 2.0 (the "License"). You may not use
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
10 ## Configure -- OpenSSL source tree configuration script
16 use lib "$FindBin::Bin/util/perl";
18 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs splitdir/;
19 use File::Path qw/mkpath/;
20 use OpenSSL::fallback "$FindBin::Bin/external/perl/MODULES.txt";
22 use OpenSSL::Template;
25 # see INSTALL.md for instructions.
27 my $orig_death_handler = $SIG{__DIE__};
28 $SIG{__DIE__} = \&death_handler;
30 my $usage="Usage: Configure [no-<feature> ...] [enable-<feature> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]thread-pool] [[no-]default-thread-pool] [[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";
34 **********************************************************************
36 *** OpenSSL has been successfully configured ***
38 *** If you encounter a problem while building, please open an ***
39 *** issue on GitHub <https://github.com/openssl/openssl/issues> ***
40 *** and include the output from the following command: ***
42 *** perl configdata.pm --dump ***
44 *** (If you are new to OpenSSL, you might want to consult the ***
45 *** 'Troubleshooting' section in the INSTALL.md file first) ***
47 **********************************************************************
52 # --config add the given configuration file, which will be read after
53 # any "Configurations*" files that are found in the same
54 # directory as this script.
55 # --prefix prefix for the OpenSSL installation, which includes the
56 # directories bin, lib, include, share/man, share/doc/openssl
57 # This becomes the value of INSTALLTOP in Makefile
58 # (Default: /usr/local)
59 # --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
60 # If it's a relative directory, it will be added on the directory
61 # given with --prefix.
62 # This becomes the value of OPENSSLDIR in Makefile and in C.
63 # (Default: PREFIX/ssl)
64 # --banner=".." Output specified text instead of default completion banner
66 # -w Don't wait after showing a Configure warning
68 # --cross-compile-prefix Add specified prefix to binutils components.
70 # --api One of 0.9.8, 1.0.0, 1.0.1, 1.0.2, 1.1.0, 1.1.1, or 3.0
71 # Define the public APIs as they were for that version
72 # including patch releases. If 'no-deprecated' is also
73 # given, do not compile support for interfaces deprecated
74 # up to and including the specified OpenSSL version.
76 # no-hw-xxx do not compile support for specific crypto hardware.
77 # Generic OpenSSL-style methods relating to this support
78 # are always compiled but return NULL if the hardware
79 # support isn't compiled.
80 # no-hw do not compile support for any crypto hardware.
81 # [no-]threads [don't] try to create a library that is suitable for
82 # multithreaded applications (default is "threads" if we
85 # [don't] allow thread pool functionality
86 # [no-]default-thread-pool
87 # [don't] allow default thread pool functionality
88 # [no-]shared [don't] try to create shared libraries when supported.
89 # [no-]pic [don't] try to build position independent code when supported.
90 # If disabled, it also disables shared and dynamic-engine.
91 # no-asm do not use assembler
92 # no-egd do not compile support for the entropy-gathering daemon APIs
93 # [no-]zlib [don't] compile support for zlib compression.
94 # zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
95 # library and will be loaded at run-time by the OpenSSL library.
96 # sctp include SCTP support
97 # enable-quic include QUIC support (currently just for developers as the
98 # implementation is by no means complete and usable)
99 # no-uplink Don't build support for UPLINK interface.
100 # enable-weak-ssl-ciphers
101 # Enable weak ciphers that are disabled by default.
102 # 386 generate 80386 code in assembly modules
103 # no-sse2 disables IA-32 SSE2 code in assembly modules, the above
104 # mentioned '386' option implies this one
105 # no-<cipher> build without specified algorithm (dsa, idea, rc5, ...)
106 # -<xxx> +<xxx> All options which are unknown to the 'Configure' script are
107 # /<xxx> passed through to the compiler. Unix-style options beginning
108 # with a '-' or '+' are recognized, as well as Windows-style
109 # options beginning with a '/'. If the option contains arguments
110 # separated by spaces, then the URL-style notation %20 can be
111 # used for the space character in order to avoid having to quote
112 # the option. For example, -opt%20arg gets expanded to -opt arg.
113 # In fact, any ASCII character can be encoded as %xx using its
114 # hexadecimal encoding.
115 # -static while -static is also a pass-through compiler option (and
116 # as such is limited to environments where it's actually
117 # meaningful), it triggers a number configuration options,
118 # namely no-pic, no-shared and no-threads. It is
119 # argued that the only reason to produce statically linked
120 # binaries (and in context it means executables linked with
121 # -static flag, and not just executables linked with static
122 # libcrypto.a) is to eliminate dependency on specific run-time,
123 # a.k.a. libc version. The mentioned config options are meant
124 # to achieve just that. Unfortunately on Linux it's impossible
125 # to eliminate the dependency completely for openssl executable
126 # because of getaddrinfo and gethostbyname calls, which can
127 # invoke dynamically loadable library facility anyway to meet
128 # the lookup requests. For this reason on Linux statically
129 # linked openssl executable has rather debugging value than
130 # production quality.
132 # BN_LLONG use the type 'long long' in crypto/bn/bn.h
133 # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
134 # Following are set automatically by this script
136 # MD5_ASM use some extra md5 assembler,
137 # SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
138 # RMD160_ASM use some extra ripemd160 assembler,
139 # SHA256_ASM sha256_block is implemented in assembler
140 # SHA512_ASM sha512_block is implemented in assembler
141 # AES_ASM AES_[en|de]crypt is implemented in assembler
143 # Minimum warning options... any contributions to OpenSSL should at least
144 # get past these. Note that we only use these with C compilers, not with
147 # -DPEDANTIC complements -pedantic and is meant to mask code that
148 # is not strictly standard-compliant and/or implementation-specific,
149 # e.g. inline assembly, disregards to alignment requirements, such
150 # that -pedantic would complain about. Incidentally -DPEDANTIC has
151 # to be used even in sanitized builds, because sanitizer too is
152 # supposed to and does take notice of non-standard behaviour. Then
153 # -pedantic with pre-C9x compiler would also complain about 'long
154 # long' not being supported. As 64-bit algorithms are common now,
155 # it grew impossible to resolve this without sizeable additional
156 # code, so we just tell compiler to be pedantic about everything
157 # but 'long long' type.
159 my @gcc_devteam_warn = qw(
160 -DPEDANTIC -pedantic -Wno-long-long -DUNUSEDRESULT_DEBUG
162 -Wmissing-declarations
164 -Wno-unused-parameter
165 -Wno-missing-field-initializers
171 -Wno-tautological-constant-out-of-range-compare
178 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
179 # TODO(openssl-team): fix problems and investigate if (at least) the
180 # following warnings can also be enabled:
182 # -Wunreachable-code -- no, too ugly/compiler-specific
183 # -Wlanguage-extension-token -- no, we use asm()
184 # -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
185 # -Wextended-offsetof -- no, needed in CMS ASN1 code
186 my @clang_devteam_warn = qw(
187 -Wno-unknown-warning-option
189 -Wno-parentheses-equality
190 -Wno-language-extension-token
191 -Wno-extended-offsetof
192 -Wconditional-uninitialized
193 -Wincompatible-pointer-types-discards-qualifiers
194 -Wmissing-variable-declarations
197 my @cl_devteam_warn = qw(
201 my $strict_warnings = 0;
203 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
204 # which would cover all BSD flavors. -pthread applies to them all,
205 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
206 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
207 # which has to be accompanied by explicit -D_THREAD_SAFE and
208 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
209 # seems to be sufficient?
210 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
213 # API compatibility name to version number mapping.
216 # This table expresses when API additions or changes can occur.
217 # The numbering used changes from 3.0 and on because we updated
218 # (solidified) our version numbering scheme at that point.
220 # From 3.0 and on, we internalise the given version number in decimal
221 # as MAJOR * 10000 + MINOR * 100 + 0
225 # Note that before 3.0, we didn't have the same version number scheme.
226 # Still, the numbering we use here covers what we need.
235 # For OpenSSL::config::get_platform
243 our $now_printing; # set to current entry's name in print_table_entry
244 # (todo: right thing would be to encapsulate name
245 # into %target [class] and make print_table_entry
248 # Forward declarations ###############################################
250 # read_config(filename)
252 # Reads a configuration file and populates %table with the contents
253 # (which the configuration file places in %targets).
256 # resolve_config(target)
258 # Resolves all the late evaluations, inheritances and so on for the
259 # chosen target and any target it inherits from.
263 # Information collection #############################################
265 # Unified build supports separate build dir
266 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
267 my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
269 # File::Spec::Unix doesn't detect case insensitivity, so we make sure to
270 # check if the source and build directory are really the same, and make
271 # them so. This avoids all kinds of confusion later on.
272 # We must check @File::Spec::ISA rather than using File::Spec->isa() to
273 # know if File::Spec ended up loading File::Spec::Unix.
275 if (grep(/::Unix$/, @File::Spec::ISA)
276 && samedir($srcdir, $blddir));
278 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
280 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
282 $config{sourcedir} = abs2rel($srcdir, $blddir);
283 $config{builddir} = abs2rel($blddir, $blddir);
284 # echo -n 'holy hand grenade of antioch' | openssl sha256
286 'f4556650ac31d35461610bac4ed81b1a181b2d8a43ea2854cbae22ca74560813';
288 # Collect reconfiguration information if needed
291 if (grep /^reconf(igure)?$/, @argvcopy) {
292 die "reconfiguring with other arguments present isn't supported"
293 if scalar @argvcopy > 1;
294 if (-f "./configdata.pm") {
295 my $file = "./configdata.pm";
296 unless (my $return = do $file) {
297 die "couldn't parse $file: $@" if $@;
298 die "couldn't do $file: $!" unless defined $return;
299 die "couldn't run $file" unless $return;
302 @argvcopy = defined($configdata::config{perlargv}) ?
303 @{$configdata::config{perlargv}} : ();
304 die "Incorrect data to reconfigure, please do a normal configuration\n"
305 if (grep(/^reconf/,@argvcopy));
306 $config{perlenv} = $configdata::config{perlenv} // {};
308 die "Insufficient data to reconfigure, please do a normal configuration\n";
312 $config{perlargv} = [ @argvcopy ];
314 # Historical: if known directories in crypto/ have been removed, it means
315 # that those sub-systems are disabled.
316 # (the other option would be to removed them from the SUBDIRS statement in
318 # We reverse the input list for cosmetic purely reasons, to compensate that
319 # 'unshift' adds at the front of the list (i.e. in reverse input order).
320 foreach ( reverse sort( 'aes', 'aria', 'bf', 'camellia', 'cast', 'des', 'dh',
321 'dsa', 'ec', 'hmac', 'idea', 'md2', 'md5', 'mdc2',
322 'rc2', 'rc4', 'rc5', 'ripemd', 'seed', 'sha',
323 'sm2', 'sm3', 'sm4') ) {
324 unshift @argvcopy, "no-$_" if ! -d catdir($srcdir, 'crypto', $_);
327 # Collect version numbers
331 collect_from_file(catfile($srcdir,'VERSION.dat')),
332 qr/\s*(\w+)\s*=\s*(.*?)\s*$/ =>
334 # Only define it if there is a value at all
338 # Some values are quoted. Trim the quotes
339 $v = $1 if $v =~ /^"(.*)"$/;
340 $version{uc $k} = $v;
344 sub { die "Something wrong with this line:\n$_\nin $srcdir/VERSION.dat" },
347 $config{major} = $version{MAJOR} // 'unknown';
348 $config{minor} = $version{MINOR} // 'unknown';
349 $config{patch} = $version{PATCH} // 'unknown';
350 $config{prerelease} =
351 defined $version{PRE_RELEASE_TAG} ? "-$version{PRE_RELEASE_TAG}" : '';
352 $config{build_metadata} =
353 defined $version{BUILD_METADATA} ? "+$version{BUILD_METADATA}" : '';
354 $config{shlib_version} = $version{SHLIB_VERSION} // 'unknown';
355 $config{release_date} = $version{RELEASE_DATE} // 'xx XXX xxxx';
357 $config{version} = "$config{major}.$config{minor}.$config{patch}";
358 $config{full_version} = "$config{version}$config{prerelease}$config{build_metadata}";
360 die "erroneous version information in VERSION.dat: ",
361 "$config{version}, $config{shlib_version}\n"
362 unless (defined $version{MAJOR}
363 && defined $version{MINOR}
364 && defined $version{PATCH}
365 && defined $version{SHLIB_VERSION});
367 # Collect target configurations
369 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
370 foreach (sort glob($pattern)) {
374 if (defined env($local_config_envname)) {
376 # VMS environment variables are logical names,
377 # which can be used as is
378 $pattern = $local_config_envname . ':' . '*.conf';
380 $pattern = catfile(env($local_config_envname), '*.conf');
383 foreach (sort glob($pattern)) {
388 # Save away perl command information
389 $config{perl_cmd} = $^X;
390 $config{perl_version} = $Config{version};
391 $config{perl_archname} = $Config{archname};
394 $config{openssldir}="";
395 $config{processor}="";
397 my $auto_threads=1; # enable threads automatically? true by default
400 # Known TLS and DTLS protocols
401 my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
402 my @dtls = qw(dtls1 dtls1_2);
404 # Explicitly known options that are possible to disable. They can
405 # be regexps, and will be used like this: /^no-${option}$/
406 # For developers: keep it sorted alphabetically
438 "default-thread-pool",
450 "ec_nistp_64_gcc_128",
460 "fips-securitychecks",
528 foreach my $proto ((@tls, @dtls))
530 push(@disablables, $proto);
531 push(@disablables, "$proto-method") unless $proto eq "tls1_3";
534 # Internal disablables, for aliasing purposes. They serve no special
535 # purpose here, but allow scripts to get to know them through configdata.pm,
536 # where these are merged with @disablables.
537 # The actual aliasing mechanism is done via %disable_cascades
538 my @disablables_int = qw(
542 my %deprecated_disablables = (
544 "buf-freelists" => undef,
545 "crypto-mdebug-backtrace" => undef,
546 "hw" => "hw", # causes cascade, but no macro
547 "hw-padlock" => "padlockeng",
548 "ripemd" => "rmd160",
549 "ui" => "ui-console",
550 "heartbeats" => undef,
553 # All of the following are disabled by default:
555 our %disabled = ( # "what" => "comment"
558 "brotli" => "default",
559 "brotli-dynamic" => "default",
560 "buildtest-c++" => "default",
561 "crypto-mdebug" => "default",
562 "crypto-mdebug-backtrace" => "default",
563 "devcryptoeng" => "default",
564 "ec_nistp_64_gcc_128" => "default",
566 "external-tests" => "default",
567 "fuzz-afl" => "default",
568 "fuzz-libfuzzer" => "default",
576 "ssl3-method" => "default",
578 "trace" => "default",
579 "ubsan" => "default",
580 "unit-test" => "default",
581 "weak-ssl-ciphers" => "default",
583 "zlib-dynamic" => "default",
585 "zstd-dynamic" => "default",
588 # Note: => pair form used for aesthetics, not to truly make a hash table
589 my @disable_cascades = (
590 # "what" => [ "cascade", ... ]
591 "bulk" => [ "shared", "dso",
592 "aria", "async", "autoload-config",
593 "blake2", "bf", "camellia", "cast", "chacha",
594 "cmac", "cms", "cmp", "comp", "ct",
595 "des", "dgram", "dh", "dsa",
599 "md4", "multiblock", "nextprotoneg",
600 "ocsp", "ocb", "poly1305", "psk",
601 "rc2", "rc4", "rmd160",
602 "seed", "siphash", "siv",
604 "srtp", "ssl3-method", "ssl-trace",
606 "ts", "ui-console", "whirlpool",
607 "fips-securitychecks" ],
608 sub { $config{processor} eq "386" }
611 "ssl3-method" => [ "ssl3" ],
612 "zlib" => [ "zlib-dynamic" ],
613 "brotli" => [ "brotli-dynamic" ],
614 "zstd" => [ "zstd-dynamic" ],
616 "ec" => [ "ec2m", "ecdsa", "ecdh", "sm2", "gost", "ecx" ],
617 "dgram" => [ "dtls", "quic", "sctp" ],
618 "sock" => [ "dgram", "tfo" ],
620 sub { 0 == scalar grep { !$disabled{$_} } @dtls }
624 sub { 0 == scalar grep { !$disabled{$_} } @tls }
627 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
629 # If no modules, then no dynamic engines either
630 "module" => [ "dynamic-engine" ],
632 # Without shared libraries, dynamic engines aren't possible.
633 # This is due to them having to link with libcrypto and register features
634 # using the ENGINE functionality, and since that relies on global tables,
635 # those *have* to be exactly the same as the ones accessed from the app,
636 # which cannot be guaranteed if shared libraries aren't present.
637 # (note that even with shared libraries, both the app and dynamic engines
638 # must be linked with the same library)
639 "shared" => [ "dynamic-engine", "uplink" ],
640 "dso" => [ "dynamic-engine", "module" ],
641 # Other modules don't necessarily have to link with libcrypto, so shared
642 # libraries do not have to be a condition to produce those.
644 # Without position independent code, there can be no shared libraries
646 "pic" => [ "shared", "module" ],
648 "module" => [ "fips", "dso" ],
650 "engine" => [ "dynamic-engine", grep(/eng$/, @disablables) ],
651 "dynamic-engine" => [ "loadereng" ],
652 "hw" => [ "padlockeng" ],
654 # no-autoalginit is only useful when building non-shared
655 "autoalginit" => [ "shared", "apps", "fips" ],
657 "stdio" => [ "apps", "capieng", "egd" ],
658 "apps" => [ "tests" ],
659 "tests" => [ "external-tests" ],
660 "comp" => [ "zlib", "brotli", "zstd" ],
662 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
664 sub { !$disabled{"msan"} } => [ "asm" ],
667 "legacy" => [ "md2" ],
671 "fips" => [ "fips-securitychecks", "acvp-tests" ],
673 "threads" => [ "thread-pool" ],
674 "thread-pool" => [ "default-thread-pool" ],
676 "blake2" => [ "argon2" ],
678 "deprecated-3.0" => [ "engine", "srp" ],
683 # Avoid protocol support holes. Also disable all versions below N, if version
684 # N is disabled while N+1 is enabled.
686 my @list = (reverse @tls);
687 while ((my $first, my $second) = (shift @list, shift @list)) {
689 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
691 unshift @list, $second;
693 my @list = (reverse @dtls);
694 while ((my $first, my $second) = (shift @list, shift @list)) {
696 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
698 unshift @list, $second;
701 # Explicit "no-..." options will be collected in %disabled along with the defaults.
702 # To remove something from %disabled, use "enable-foo".
703 # For symmetry, "disable-foo" is a synonym for "no-foo".
705 # For the "make variables" CPPINCLUDES and CPPDEFINES, we support lists with
706 # platform specific list separators. Users from those platforms should
707 # recognise those separators from how you set up the PATH to find executables.
708 # The default is the Unix like separator, :, but as an exception, we also
709 # support the space as separator.
710 my $list_separator_re =
711 { VMS => qr/(?<!\^),/,
712 MSWin32 => qr/(?<!\\);/ } -> {$^O} // qr/(?<!\\)[:\s]/;
713 # All the "make variables" we support
714 # Some get pre-populated for the sake of backward compatibility
715 # (we supported those before the change to "make variable" support.
722 CFLAGS => [ env('CFLAGS') || () ],
724 CXXFLAGS => [ env('CXXFLAGS') || () ],
726 CPPFLAGS => [ env('CPPFLAGS') || () ], # -D, -I, -Wp,
727 CPPDEFINES => [], # Alternative for -D
728 CPPINCLUDES => [], # Alternative for -I
729 CROSS_COMPILE => env('CROSS_COMPILE'),
730 HASHBANGPERL=> env('HASHBANGPERL') || env('PERL'),
732 LDFLAGS => [ env('LDFLAGS') || () ], # -L, -Wl,
733 LDLIBS => [ env('LDLIBS') || () ], # -l
736 PERL => env('PERL') || ($^O ne "VMS" ? $^X : "perl"),
737 RANLIB => env('RANLIB'),
738 RC => env('RC') || env('WINDRES'),
739 RCFLAGS => [ env('RCFLAGS') || () ],
742 # Info about what "make variables" may be prefixed with the cross compiler
743 # prefix. This should NEVER mention any such variable with a list for value.
744 my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
745 # The same but for flags given as Configure options. These are *additional*
746 # input, as opposed to the VAR=string option that override the corresponding
747 # config target attributes
760 my %user_synonyms = (
761 HASHBANGPERL=> 'PERL',
765 # Some target attributes have been renamed, this is the translation table
766 my %target_attr_translate =(
772 hashbangperl => 'HASHBANGPERL',
780 # Initialisers coming from 'config' scripts
781 $config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ];
782 $config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ];
783 $config{cppflags} = [ env('__CNF_CPPFLAGS') || () ];
784 $config{cflags} = [ env('__CNF_CFLAGS') || () ];
785 $config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ];
786 $config{lflags} = [ env('__CNF_LDFLAGS') || () ];
787 $config{ex_libs} = [ env('__CNF_LDLIBS') || () ];
789 $config{openssl_api_defines}=[];
790 $config{openssl_sys_defines}=[];
791 $config{openssl_feature_defines}=[];
793 $config{build_type} = "release";
796 my %cmdvars = (); # Stores FOO='blah' type arguments
797 my %unsupported_options = ();
798 my %deprecated_options = ();
799 # If you change this, update apps/version.c
800 my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
801 my @seed_sources = ();
804 $_ = shift @argvcopy;
806 # Support env variable assignments among the options
807 if (m|^(\w+)=(.+)?$|)
810 # Every time a variable is given as a configuration argument,
811 # it acts as a reset if the variable.
812 if (exists $user{$1})
814 $user{$1} = ref $user{$1} eq "ARRAY" ? [] : undef;
816 #if (exists $useradd{$1})
823 # VMS is a case insensitive environment, and depending on settings
824 # out of our control, we may receive options uppercased. Let's
825 # downcase at least the part before any equal sign.
831 # some people just can't read the instructions, clang people have to...
832 s/^-no-(?!integrated-as)/no-/;
834 # rewrite some options in "enable-..." form
835 s /^-?-?shared$/enable-shared/;
836 s /^sctp$/enable-sctp/;
837 s /^threads$/enable-threads/;
838 s /^zlib$/enable-zlib/;
839 s /^zlib-dynamic$/enable-zlib-dynamic/;
840 s /^fips$/enable-fips/;
842 if (/^(no|disable|enable)-(.+)$/)
845 if ($word !~ m|hw(?:-.+)| # special treatment for hw regexp opt
846 && !exists $deprecated_disablables{$word}
847 && !grep { $word eq $_ } @disablables)
849 $unsupported_options{$_} = 1;
853 if (/^no-(.+)$/ || /^disable-(.+)$/)
855 foreach my $proto ((@tls, @dtls))
857 if ($1 eq "$proto-method")
859 $disabled{"$proto"} = "option($proto-method)";
865 foreach my $proto (@dtls)
867 $disabled{$proto} = "option(dtls)";
869 $disabled{"dtls"} = "option(dtls)";
873 # Last one of its kind
874 $disabled{"ssl3"} = "option(ssl)";
878 # XXX: Tests will fail if all SSL/TLS
879 # protocols are disabled.
880 foreach my $proto (@tls)
882 $disabled{$proto} = "option(tls)";
885 elsif ($1 eq "static-engine")
887 delete $disabled{"dynamic-engine"};
889 elsif ($1 eq "dynamic-engine")
891 $disabled{"dynamic-engine"} = "option";
893 elsif (exists $deprecated_disablables{$1})
895 $deprecated_options{$_} = 1;
896 if (defined $deprecated_disablables{$1})
898 $disabled{$deprecated_disablables{$1}} = "option";
901 elsif ($1 =~ m|hw(?:-.+)|) # deprecate hw options in regexp form
903 $deprecated_options{$_} = 1;
907 $disabled{$1} = "option";
909 # No longer an automatic choice
910 $auto_threads = 0 if ($1 eq "threads");
912 elsif (/^enable-(.+)$/)
914 if ($1 eq "static-engine")
916 $disabled{"dynamic-engine"} = "option";
918 elsif ($1 eq "dynamic-engine")
920 delete $disabled{"dynamic-engine"};
922 elsif ($1 eq "zlib-dynamic")
924 delete $disabled{"zlib"};
926 elsif ($1 eq "brotli-dynamic")
928 delete $disabled{"brotli"};
930 elsif ($1 eq "zstd-dynamic")
932 delete $disabled{"zstd"};
935 delete $disabled{$algo};
937 # No longer an automatic choice
938 $auto_threads = 0 if ($1 eq "threads");
940 elsif (/^-d$/) # From older 'config'
942 $config{build_type} = "debug";
944 elsif (/^-v$/) # From older 'config'
946 $guess_opts{verbose} = 1;
950 $guess_opts{nowait} = 1;
952 elsif (/^-t$/) # From older 'config'
956 elsif (/^--strict-warnings$/)
958 # Pretend that our strict flags is a C flag, and replace it
959 # with the proper flags later on
960 push @{$useradd{CFLAGS}}, '--ossl-strict-warnings';
965 $config{build_type} = "debug";
967 elsif (/^--release$/)
969 $config{build_type} = "release";
972 { $config{processor}=386; }
975 # No RSAref support any more since it's not needed.
976 # The check for the option is there so scripts aren't
981 if (/^--prefix=(.*)$/)
984 die "Directory given with --prefix MUST be absolute\n"
985 unless file_name_is_absolute($config{prefix});
987 elsif (/^--api=(.*)$/)
990 die "Unknown API compatibility level $api"
991 unless defined $apitable->{$api};
992 $config{api}=$apitable->{$api};
994 elsif (/^--libdir=(.*)$/)
998 elsif (/^--openssldir=(.*)$/)
1000 $config{openssldir}=$1;
1002 elsif (/^--with-zlib-lib=(.*)$/)
1004 $withargs{zlib_lib}=$1;
1006 elsif (/^--with-zlib-include=(.*)$/)
1008 $withargs{zlib_include}=$1;
1010 elsif (/^--with-brotli-lib=(.*)$/)
1012 $withargs{brotli_lib}=$1;
1014 elsif (/^--with-brotli-include=(.*)$/)
1016 $withargs{brotli_include}=$1;
1018 elsif (/^--with-zstd-lib=(.*)$/)
1020 $withargs{zstd_lib}=$1;
1022 elsif (/^--with-zstd-include=(.*)$/)
1024 $withargs{zstd_include}=$1;
1026 elsif (/^--with-fuzzer-lib=(.*)$/)
1028 $withargs{fuzzer_lib}=$1;
1030 elsif (/^--with-fuzzer-include=(.*)$/)
1032 $withargs{fuzzer_include}=$1;
1034 elsif (/^--with-rand-seed=(.*)$/)
1036 foreach my $x (split(m|,|, $1))
1038 die "Unknown --with-rand-seed choice $x\n"
1039 if ! grep { $x eq $_ } @known_seed_sources;
1040 push @seed_sources, $x;
1043 elsif (/^--fips-key=(.*)$/)
1045 $user{FIPSKEY}=lc($1);
1046 die "Non-hex character in FIPS key\n"
1047 if $user{FIPSKEY} =~ /[^a-f0-9]/;
1048 die "FIPS key must have even number of characters\n"
1050 die "FIPS key too long (64 bytes max)\n"
1053 elsif (/^--banner=(.*)$/)
1055 $banner = $1 . "\n";
1057 elsif (/^--cross-compile-prefix=(.*)$/)
1059 $user{CROSS_COMPILE}=$1;
1061 elsif (/^--config=(.*)$/)
1067 push @{$useradd{LDLIBS}}, $_;
1069 elsif (/^-framework$/)
1071 push @{$useradd{LDLIBS}}, $_, shift(@argvcopy);
1073 elsif (/^-L(.*)$/ or /^-Wl,/)
1075 push @{$useradd{LDFLAGS}}, $_;
1077 elsif (/^-rpath$/ or /^-R$/)
1078 # -rpath is the OSF1 rpath flag
1079 # -R is the old Solaris rpath flag
1081 my $rpath = shift(@argvcopy) || "";
1082 $rpath .= " " if $rpath ne "";
1083 push @{$useradd{LDFLAGS}}, $_, $rpath;
1087 push @{$useradd{LDFLAGS}}, $_;
1089 elsif (m|^[-/]D(.*)$|)
1091 push @{$useradd{CPPDEFINES}}, $1;
1093 elsif (m|^[-/]I(.*)$|)
1095 push @{$useradd{CPPINCLUDES}}, $1;
1099 push @{$useradd{CPPFLAGS}}, $1;
1101 else # common if (/^[-+]/), just pass down...
1103 # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
1104 # This provides a simple way to pass options with arguments separated
1105 # by spaces without quoting (e.g. -opt%20arg translates to -opt arg).
1106 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
1107 push @{$useradd{CFLAGS}}, $_;
1108 push @{$useradd{CXXFLAGS}}, $_;
1113 # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
1114 # This provides a simple way to pass options with arguments separated
1115 # by spaces without quoting (e.g. /opt%20arg translates to /opt arg).
1116 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
1117 push @{$useradd{CFLAGS}}, $_;
1118 push @{$useradd{CXXFLAGS}}, $_;
1122 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
1125 unless ($_ eq $target || /^no-/ || /^disable-/)
1127 # "no-..." follows later after implied deactivations
1128 # have been derived. (Don't take this too seriously,
1129 # we really only write OPTIONS to the Makefile out of
1132 if ($config{options} eq "")
1133 { $config{options} = $_; }
1135 { $config{options} .= " ".$_; }
1139 if (keys %deprecated_options)
1141 warn "***** Deprecated options: ",
1142 join(", ", keys %deprecated_options), "\n";
1144 if (keys %unsupported_options)
1146 die "***** Unsupported options: ",
1147 join(", ", keys %unsupported_options), "\n";
1150 # If any %useradd entry has been set, we must check that the "make
1151 # variables" haven't been set. We start by checking of any %useradd entry
1153 if (grep { scalar @$_ > 0 } values %useradd) {
1154 # Hash of env / make variables names. The possible values are:
1156 # 2 - %useradd entry set
1160 $v += 1 if $cmdvars{$_};
1161 $v += 2 if @{$useradd{$_}};
1165 # If any of the corresponding "make variables" is set, we error
1166 if (grep { $_ & 1 } values %detected_vars) {
1167 my $names = join(', ', grep { $detected_vars{$_} > 0 }
1168 sort keys %detected_vars);
1170 ***** Mixing make variables and additional compiler/linker flags as
1171 ***** configure command line option is not permitted.
1172 ***** Affected make variables: $names
1177 # Check through all supported command line variables to see if any of them
1178 # were set, and canonicalise the values we got. If no compiler or linker
1179 # flag or anything else that affects %useradd was set, we also check the
1180 # environment for values.
1182 grep { defined $_ && (ref $_ ne 'ARRAY' || @$_) } values %useradd;
1183 foreach (keys %user) {
1184 my $value = $cmdvars{$_};
1185 $value //= env($_) unless $anyuseradd;
1187 defined $user_synonyms{$_} ? $cmdvars{$user_synonyms{$_}} : undef;
1188 $value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef
1191 if (defined $value) {
1192 if (ref $user{$_} eq 'ARRAY') {
1193 if ($_ eq 'CPPDEFINES' || $_ eq 'CPPINCLUDES') {
1194 $user{$_} = [ split /$list_separator_re/, $value ];
1196 $user{$_} = [ $value ];
1198 } elsif (!defined $user{$_}) {
1204 if (grep { /-rpath\b/ } ($user{LDFLAGS} ? @{$user{LDFLAGS}} : ())
1205 && !$disabled{shared}
1206 && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
1207 die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
1208 "***** any of asan, msan or ubsan\n";
1211 # If no target was given, try guessing.
1213 my %system_config = OpenSSL::config::get_platform(%guess_opts, %user);
1215 # The $system_config{disable} is used to populate %disabled with
1216 # entries that aren't already there.
1217 foreach ( @{$system_config{disable} // []} ) {
1218 $disabled{$_} = 'system' unless defined $disabled{$_};
1220 delete $system_config{disable};
1222 # Override config entries with stuff from the guesser.
1223 # It's assumed that this really is nothing new.
1224 %config = ( %config, %system_config );
1225 $target = $system_config{target};
1229 my $disable_type = shift;
1232 $disabled{$_} = $disable_type;
1235 my @tocheckfor = (@_ ? @_ : keys %disabled);
1236 while (@tocheckfor) {
1237 my %new_tocheckfor = ();
1238 my @cascade_copy = (@disable_cascades);
1239 while (@cascade_copy) {
1240 my ($test, $descendents) =
1241 (shift @cascade_copy, shift @cascade_copy);
1242 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
1243 foreach (grep { !defined($disabled{$_}) } @$descendents) {
1244 $new_tocheckfor{$_} = 1; $disabled{$_} = "cascade";
1248 @tocheckfor = (keys %new_tocheckfor);
1251 disable(); # First cascade run
1253 our $die = sub { die @_; };
1254 if ($target eq "TABLE") {
1255 local $die = sub { warn @_; };
1256 foreach (sort keys %table) {
1257 print_table_entry($_, "TABLE");
1262 if ($target eq "LIST") {
1263 foreach (sort keys %table) {
1264 print $_,"\n" unless $table{$_}->{template};
1269 if ($target eq "HASH") {
1270 local $die = sub { warn @_; };
1271 print "%table = (\n";
1272 foreach (sort keys %table) {
1273 print_table_entry($_, "HASH");
1278 print "Configuring OpenSSL version $config{full_version} ";
1279 print "for target $target\n";
1281 if (scalar(@seed_sources) == 0) {
1282 print "Using os-specific seed configuration\n";
1283 push @seed_sources, 'os';
1285 if (scalar(grep { $_ eq 'egd' } @seed_sources) > 0) {
1286 delete $disabled{'egd'};
1288 if (scalar(grep { $_ eq 'none' } @seed_sources) > 0) {
1289 die "Cannot seed with none and anything else" if scalar(@seed_sources) > 1;
1290 warn <<_____ if scalar(@seed_sources) == 1;
1292 ============================== WARNING ===============================
1293 You have selected the --with-rand-seed=none option, which effectively
1294 disables automatic reseeding of the OpenSSL random generator.
1295 All operations depending on the random generator such as creating keys
1296 will not work unless the random generator is seeded manually by the
1299 Please read the 'Note on random number generation' section in the
1300 INSTALL.md instructions and the RAND_DRBG(7) manual page for more
1302 ============================== WARNING ===============================
1306 push @{$config{openssl_feature_defines}},
1307 map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
1310 # Backward compatibility?
1311 if ($target =~ m/^CygWin32(-.*)$/) {
1312 $target = "Cygwin".$1;
1315 # Support for legacy targets having a name starting with 'debug-'
1316 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1318 $config{build_type} = "debug";
1320 # If we do not find debug-foo in the table, the target is set to foo.
1321 if (!$table{$target}) {
1327 # It's possible that we have different config targets for specific
1328 # toolchains, so we try to detect them, and go for the plain config
1331 foreach ( ( "$target-$user{CC}", "$target", undef ) ) {
1332 $found=$_ if $table{$_} && !$table{$_}->{template};
1337 # If we don't have a config target now, we try the C compiler as we
1339 my $cc = $user{CC} // 'cc';
1340 $target = $cc if $table{$cc} && !$table{$cc}->{template};
1343 &usage unless $target;
1345 exit 0 if $dryrun; # From older 'config'
1347 $config{target} = $target;
1348 my %target = resolve_config($target);
1350 foreach (keys %target_attr_translate) {
1351 $target{$target_attr_translate{$_}} = $target{$_}
1356 %target = ( %{$table{DEFAULTS}}, %target );
1358 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
1359 $config{conf_files} = [ sort keys %conf_files ];
1361 # Using sub disable within these loops may prove fragile, so we run
1362 # a cascade afterwards
1363 foreach my $feature (@{$target{disable}}) {
1364 if (exists $deprecated_disablables{$feature}) {
1365 warn "***** config $target disables deprecated feature $feature\n";
1366 } elsif (!grep { $feature eq $_ } @disablables) {
1367 die "***** config $target disables unknown feature $feature\n";
1369 $disabled{$feature} = 'config';
1371 foreach my $feature (@{$target{enable}}) {
1372 if ("default" eq ($disabled{$feature} // "")) {
1373 if (exists $deprecated_disablables{$feature}) {
1374 warn "***** config $target enables deprecated feature $feature\n";
1375 } elsif (!grep { $feature eq $_ } @disablables) {
1376 die "***** config $target enables unknown feature $feature\n";
1378 delete $disabled{$feature};
1382 # If uplink_arch isn't defined, disable uplink
1383 $disabled{uplink} = 'no uplink_arch' unless (defined $target{uplink_arch});
1384 # If asm_arch isn't defined, disable asm
1385 $disabled{asm} = 'no asm_arch' unless (defined $target{asm_arch});
1387 disable(); # Run a cascade now
1389 $target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
1390 $target{cxxflags}//=$target{cflags} if $target{CXX};
1391 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP");
1392 $target{exe_extension}=".pm" if ($config{target} =~ /vos/);
1394 # Fill %config with values from %user, and in case those are undefined or
1395 # empty, use values from %target (acting as a default).
1396 foreach (keys %user) {
1397 my $ref_type = ref $user{$_};
1399 # Temporary function. Takes an intended ref type (empty string or "ARRAY")
1400 # and a value that's to be coerced into that type.
1404 my $undef_p = shift;
1406 die "Too many arguments for \$mkvalue" if @_;
1408 while (ref $value eq 'CODE') {
1409 $value = $value->();
1412 if ($type eq 'ARRAY') {
1413 return undef unless defined $value;
1414 return undef if ref $value ne 'ARRAY' && !$value;
1415 return undef if ref $value eq 'ARRAY' && !@$value;
1416 return [ $value ] unless ref $value eq 'ARRAY';
1418 return undef unless $value;
1423 $mkvalue->($ref_type, $user{$_})
1424 || $mkvalue->($ref_type, $target{$_});
1425 delete $config{$_} unless defined $config{$_};
1428 # Finish up %config by appending things the user gave us on the command line
1429 # apart from "make variables"
1430 foreach (keys %useradd) {
1431 # The must all be lists, so we assert that here
1432 die "internal error: \$useradd{$_} isn't an ARRAY\n"
1433 unless ref $useradd{$_} eq 'ARRAY';
1435 if (defined $config{$_}) {
1436 push @{$config{$_}}, @{$useradd{$_}};
1438 $config{$_} = [ @{$useradd{$_}} ];
1441 # At this point, we can forget everything about %user and %useradd,
1442 # because it's now all been merged into the corresponding $config entry
1444 if (grep { $_ =~ /(?:^|\s)-static(?:\s|$)/ } @{$config{LDFLAGS}}) {
1445 disable('static', 'pic', 'threads');
1448 # Allow overriding the build file name
1449 $config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
1451 # Make sure build_scheme is consistent.
1452 $target{build_scheme} = [ $target{build_scheme} ]
1453 if ref($target{build_scheme}) ne "ARRAY";
1455 my ($builder, $builder_platform, @builder_opts) =
1456 @{$target{build_scheme}};
1458 foreach my $checker (($builder_platform."-".$config{build_file}."-checker.pm",
1459 $builder_platform."-checker.pm")) {
1460 my $checker_path = catfile($srcdir, "Configurations", $checker);
1461 if (-f $checker_path) {
1462 my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1463 ? sub { warn $@; } : sub { die $@; };
1464 if (! do $checker_path) {
1470 $fn->("The detected tools didn't match the platform\n");
1477 push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
1479 if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
1481 push @{$config{cflags}}, "-mno-cygwin";
1482 push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
1483 push @{$config{shared_ldflag}}, "-mno-cygwin";
1486 if ($target =~ /linux.*-mips/ && !$disabled{asm}
1487 && !grep { $_ =~ /-m(ips|arch=)/ } (@{$config{CFLAGS}})) {
1488 # minimally required architecture flags for assembly modules
1490 $value = '-mips2' if ($target =~ /mips32/);
1491 $value = '-mips3' if ($target =~ /mips64/);
1492 unshift @{$config{cflags}}, $value;
1493 unshift @{$config{cxxflags}}, $value if $config{CXX};
1496 # If threads aren't disabled, check how possible they are
1497 unless ($disabled{threads}) {
1498 if ($auto_threads) {
1499 # Enabled by default, disable it forcibly if unavailable
1500 if ($target{thread_scheme} eq "(unknown)") {
1501 disable("unavailable", 'threads');
1504 # The user chose to enable threads explicitly, let's see
1505 # if there's a chance that's possible
1506 if ($target{thread_scheme} eq "(unknown)") {
1507 # If the user asked for "threads" and we don't have internal
1508 # knowledge how to do it, [s]he is expected to provide any
1509 # system-dependent compiler options that are necessary. We
1510 # can't truly check that the given options are correct, but
1511 # we expect the user to know what [s]He is doing.
1512 if (!@{$config{CFLAGS}} && !@{$config{CPPDEFINES}}) {
1513 die "You asked for multi-threading support, but didn't\n"
1514 ,"provide any system-specific compiler options\n";
1520 # Find out if clang's sanitizers have been enabled with -fsanitize
1521 # flags and ensure that the corresponding %disabled elements area
1522 # removed to reflect that the sanitizers are indeed enabled.
1523 my %detected_sanitizers = ();
1524 foreach (grep /^-fsanitize=/, @{$config{CFLAGS} || []}) {
1525 (my $checks = $_) =~ s/^-fsanitize=//;
1526 foreach (split /,/, $checks) {
1527 my $d = { address => 'asan',
1528 undefined => 'ubsan',
1529 memory => 'msan' } -> {$_};
1530 next unless defined $d;
1532 $detected_sanitizers{$d} = 1;
1533 if (defined $disabled{$d}) {
1534 die "***** Conflict between disabling $d and enabling $_ sanitizer"
1535 if $disabled{$d} ne "default";
1536 delete $disabled{$d};
1541 # If threads still aren't disabled, add a C macro to ensure the source
1542 # code knows about it. Any other flag is taken care of by the configs.
1543 unless($disabled{threads}) {
1544 push @{$config{openssl_feature_defines}}, "OPENSSL_THREADS";
1547 my $no_shared_warn=0;
1548 if (($target{shared_target} // '') eq "")
1551 if (!$disabled{shared} || !$disabled{"dynamic-engine"});
1552 disable('no-shared-target', 'pic');
1555 if ($disabled{"dynamic-engine"}) {
1556 $config{dynamic_engines} = 0;
1558 $config{dynamic_engines} = 1;
1561 unless ($disabled{asan} || defined $detected_sanitizers{asan}) {
1562 push @{$config{cflags}}, "-fsanitize=address";
1565 unless ($disabled{ubsan} || defined $detected_sanitizers{ubsan}) {
1566 push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all", "-DPEDANTIC";
1569 unless ($disabled{msan} || defined $detected_sanitizers{msan}) {
1570 push @{$config{cflags}}, "-fsanitize=memory";
1573 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1574 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1575 push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
1576 push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
1582 # This saves the build files from having to check
1585 foreach (qw(shared_cflag shared_cxxflag shared_cppflag
1586 shared_defines shared_includes shared_ldflag
1587 module_cflags module_cxxflags module_cppflags
1588 module_defines module_includes module_lflags))
1596 push @{$config{lib_defines}}, "OPENSSL_PIC";
1599 if ($target{sys_id} ne "")
1601 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1604 my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
1605 my %predefined_CXX = $config{CXX}
1606 ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
1609 unless ($disabled{asm}) {
1610 # big endian systems can use ELFv2 ABI
1611 if ($target eq "linux-ppc64" || $target eq "BSD-ppc64") {
1612 $target{perlasm_scheme} = "linux64v2" if ($predefined_C{_CALL_ELF} == 2);
1616 # Check for makedepend capabilities.
1617 if (!$disabled{makedepend}) {
1618 # If the attribute makedep_scheme is defined, then we assume that the
1619 # config target and its associated build file are programmed to deal
1621 # If makedep_scheme is undefined, we go looking for GCC compatible
1622 # dependency making, and if that's not available, we try to fall back
1624 if ($target{makedep_scheme}) {
1625 $config{makedep_scheme} = $target{makedep_scheme};
1626 # If the makedepcmd attribute is defined, copy it. If not, the
1627 # build files will have to fend for themselves.
1628 $config{makedepcmd} = $target{makedepcmd} if $target{makedepcmd};
1629 } elsif (($predefined_C{__GNUC__} // -1) >= 3
1630 && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
1631 # We know that GNU C version 3 and up as well as all clang
1632 # versions support dependency generation, but Xcode did not
1633 # handle $cc -M before clang support (but claims __GNUC__ = 3)
1634 $config{makedep_scheme} = 'gcc';
1636 # In all other cases, we look for 'makedepend', and set the
1637 # makedep_scheme value if we found it.
1638 $config{makedepcmd} = which('makedepend');
1639 $config{makedep_scheme} = 'makedepend' if $config{makedepcmd};
1642 # If no depend scheme is set, we disable makedepend
1643 disable('unavailable', 'makedepend') unless $config{makedep_scheme};
1646 if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
1647 # probe for -Wa,--noexecstack option...
1648 if ($predefined_C{__clang__}) {
1649 # clang has builtin assembler, which doesn't recognize --help,
1650 # but it apparently recognizes the option in question on all
1651 # supported platforms even when it's meaningless. In other words
1652 # probe would fail, but probed option always accepted...
1653 push @{$config{cflags}}, "-Wa,--noexecstack", "-Qunused-arguments";
1655 my $cc = $config{CROSS_COMPILE}.$config{CC};
1656 open(PIPE, "$cc -Wa,--help -c -o null.$$.o -x assembler /dev/null 2>&1 |");
1658 if (m/--noexecstack/) {
1659 push @{$config{cflags}}, "-Wa,--noexecstack";
1664 unlink("null.$$.o");
1668 # Deal with bn_ops ###################################################
1671 my $def_int="unsigned int";
1672 $config{rc4_int} =$def_int;
1673 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1676 foreach (sort split(/\s+/,$target{bn_ops})) {
1677 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1678 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1679 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1680 ($config{b64l},$config{b64},$config{b32})
1681 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1682 ($config{b64l},$config{b64},$config{b32})
1683 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1684 ($config{b64l},$config{b64},$config{b32})
1685 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
1687 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1690 $config{api} = $config{major} * 10000 + $config{minor} * 100
1691 unless $config{api};
1692 foreach (keys %$apitable) {
1693 $disabled{"deprecated-$_"} = "deprecation"
1694 if $disabled{deprecated} && $config{api} >= $apitable->{$_};
1697 disable(); # Run a cascade now
1699 # Hack cflags for better warnings (dev option) #######################
1701 # "Stringify" the C and C++ flags string. This permits it to be made part of
1702 # a string and works as well on command lines.
1703 $config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1704 @{$config{cflags}} ];
1705 $config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1706 @{$config{cxxflags}} ] if $config{CXX};
1708 $config{openssl_api_defines} = [
1709 "OPENSSL_CONFIGURED_API=".$config{api},
1712 my @strict_warnings_collection=();
1713 if ($strict_warnings)
1716 my $gccver = $predefined_C{__GNUC__} // -1;
1720 push @strict_warnings_collection, @gcc_devteam_warn;
1721 push @strict_warnings_collection, @clang_devteam_warn
1722 if (defined($predefined_C{__clang__}));
1724 elsif ($config{target} =~ /^VC-/)
1726 push @strict_warnings_collection, @cl_devteam_warn;
1730 warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike, or MSVC"
1734 $config{CFLAGS} = [ map { $_ eq '--ossl-strict-warnings'
1735 ? @strict_warnings_collection
1737 @{$config{CFLAGS}} ];
1739 unless ($disabled{afalgeng}) {
1740 $config{afalgeng}="";
1741 if (grep { $_ eq 'afalgeng' } @{$target{enable}}) {
1742 push @{$config{engdirs}}, "afalg";
1744 disable('not-linux', 'afalgeng');
1748 unless ($disabled{devcryptoeng}) {
1749 if ($target =~ m/^BSD/) {
1750 my $maxver = 5*100 + 7;
1751 my $sysstr = `uname -s`;
1752 my $verstr = `uname -r`;
1755 my ($ma, $mi, @rest) = split m|\.|, $verstr;
1756 my $ver = $ma*100 + $mi;
1757 if ($sysstr eq 'OpenBSD' && $ver >= $maxver) {
1758 disable('too-new-kernel', 'devcryptoeng');
1763 unless ($disabled{ktls}) {
1765 my $cc = $config{CROSS_COMPILE}.$config{CC};
1766 if ($target =~ m/^linux/) {
1767 system("printf '#include <sys/types.h>\n#include <linux/tls.h>' | $cc -E - >/dev/null 2>&1");
1769 disable('too-old-kernel', 'ktls');
1771 } elsif ($target =~ m/^BSD/) {
1772 system("printf '#include <sys/types.h>\n#include <sys/ktls.h>' | $cc -E - >/dev/null 2>&1");
1774 disable('too-old-freebsd', 'ktls');
1777 disable('not-linux-or-freebsd', 'ktls');
1781 unless ($disabled{winstore}) {
1782 unless ($target =~ /^(?:Cygwin|mingw|VC-|BC-)/) {
1783 disable('not-windows', 'winstore');
1787 push @{$config{openssl_other_defines}}, "OPENSSL_NO_KTLS" if ($disabled{ktls});
1789 # Get the extra flags used when building shared libraries and modules. We
1790 # do this late because some of them depend on %disabled.
1792 # Make the flags to build DSOs the same as for shared libraries unless they
1793 # are already defined
1794 $target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
1795 $target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
1796 $target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
1798 my $shared_info_pl =
1799 catfile(dirname($0), "Configurations", "shared-info.pl");
1800 my %shared_info = read_eval_file($shared_info_pl);
1801 push @{$target{_conf_fname_int}}, $shared_info_pl;
1802 my $si = $target{shared_target};
1803 while (ref $si ne "HASH") {
1804 last if ! defined $si;
1805 if (ref $si eq "CODE") {
1808 $si = $shared_info{$si};
1812 # Some of the 'shared_target' values don't have any entries in
1813 # %shared_info. That's perfectly fine, AS LONG AS the build file
1814 # template knows how to handle this. That is currently the case for
1817 # Just as above, copy certain shared_* attributes to the corresponding
1818 # module_ attribute unless the latter is already defined
1819 $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
1820 $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
1821 $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
1822 foreach (sort keys %$si) {
1823 $target{$_} = defined $target{$_}
1824 ? add($si->{$_})->($target{$_})
1830 # ALL MODIFICATIONS TO %disabled, %config and %target MUST BE DONE FROM HERE ON
1832 ######################################################################
1833 # Build up information for skipping certain directories depending on disabled
1834 # features, as well as setting up macros for disabled features.
1836 # This is a tentative database of directories to skip. Some entries may not
1837 # correspond to anything real, but that's ok, they will simply be ignored.
1838 # The actual processing of these entries is done in the build.info lookup
1839 # loop further down.
1841 # The key is a Unix formatted path in the source tree, the value is an index
1842 # into %disabled_info, so any existing path gets added to a corresponding
1843 # 'skipped' entry in there with the list of skipped directories.
1845 my %disabled_info = (); # For configdata.pm
1846 foreach my $what (sort keys %disabled) {
1847 # There are deprecated disablables that translate to themselves.
1848 # They cause disabling cascades, but should otherwise not register.
1849 next if $deprecated_disablables{$what};
1850 # The generated $disabled{"deprecated-x.y"} entries are special
1851 # and treated properly elsewhere
1852 next if $what =~ m|^deprecated-|;
1854 $config{options} .= " no-$what";
1856 if (!grep { $what eq $_ } ( 'buildtest-c++', 'fips', 'threads', 'shared',
1857 'module', 'pic', 'dynamic-engine', 'makedepend',
1858 'sse2', 'legacy' )) {
1859 (my $WHAT = uc $what) =~ s|-|_|g;
1860 my $skipdir = $what;
1862 # fix-up crypto/directory name(s)
1863 $skipdir = "ripemd" if $what eq "rmd160";
1864 $skipdir = "whrlpool" if $what eq "whirlpool";
1866 my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
1867 push @{$config{openssl_feature_defines}}, $macro;
1869 $skipdir{engines} = $what if $what eq 'engine';
1870 $skipdir{"crypto/$skipdir"} = $what
1871 unless $what eq 'async' || $what eq 'err' || $what eq 'dso';
1875 if ($disabled{"dynamic-engine"}) {
1876 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1878 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_STATIC_ENGINE";
1881 # If we use the unified build, collect information from build.info files
1882 my %unified_info = ();
1884 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1885 if ($builder eq "unified") {
1886 use Text::Template 1.46;
1891 my $relativeto = shift || ".";
1893 $dir = catdir($base,$dir) unless isabsolute($dir);
1895 # Make sure the directories we're building in exists
1898 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1899 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1906 my $relativeto = shift || ".";
1908 $file = catfile($base,$file) unless isabsolute($file);
1910 my $d = dirname($file);
1911 my $f = basename($file);
1913 # Make sure the directories we're building in exists
1916 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1917 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1921 # Store the name of the template file we will build the build file from
1922 # in %config. This may be useful for the build file itself.
1923 my @build_file_template_names =
1924 ( $builder_platform."-".$config{build_file}.".tmpl",
1925 $config{build_file}.".tmpl" );
1926 my @build_file_templates = ();
1928 # First, look in the user provided directory, if given
1929 if (defined env($local_config_envname)) {
1930 @build_file_templates =
1933 # VMS environment variables are logical names,
1934 # which can be used as is
1935 $local_config_envname . ':' . $_;
1937 catfile(env($local_config_envname), $_);
1940 @build_file_template_names;
1942 # Then, look in our standard directory
1943 push @build_file_templates,
1944 ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1945 @build_file_template_names );
1947 my $build_file_template;
1948 for $_ (@build_file_templates) {
1949 $build_file_template = $_;
1950 last if -f $build_file_template;
1952 $build_file_template = undef;
1954 if (!defined $build_file_template) {
1955 die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1957 $config{build_file_templates}
1958 = [ cleanfile($srcdir, catfile("Configurations", "common0.tmpl"),
1960 $build_file_template ];
1962 my @build_dirs = ( [ ] ); # current directory
1964 $config{build_infos} = [ ];
1966 # We want to detect configdata.pm in the source tree, so we
1967 # don't use it if the build tree is different.
1968 my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir);
1970 # Any source file that we recognise is placed in this hash table, with
1971 # the list of its intended destinations as value. When everything has
1972 # been collected, there's a routine that checks that these source files
1973 # exist, or if they are generated, that the generator exists.
1974 my %check_exist = ();
1975 my %check_generate = ();
1978 while (@build_dirs) {
1979 my @curd = @{shift @build_dirs};
1980 my $sourced = catdir($srcdir, @curd);
1981 my $buildd = catdir($blddir, @curd);
1983 my $unixdir = join('/', @curd);
1984 if (exists $skipdir{$unixdir}) {
1985 my $what = $skipdir{$unixdir};
1986 push @{$disabled_info{$what}->{skipped}}, catdir(@curd);
1992 my $f = 'build.info';
1993 # The basic things we're trying to build
2000 my %shared_sources = ();
2009 # Support for $variablename in build.info files.
2010 # Embedded perl code is the ultimate master, still. If its output
2011 # contains a dollar sign, it had better be escaped, or it will be
2012 # taken for a variable name prefix.
2014 # Variable name syntax
2015 my $variable_name_re = qr/(?P<VARIABLE>[[:alpha:]][[:alnum:]_]*)/;
2016 # Value modifier syntaxes
2017 my $variable_subst_re = qr/\/(?P<RE>(?:\\\/|.)*?)\/(?P<SUBST>.*?)/;
2018 # Variable reference
2019 my $variable_simple_re = qr/(?<!\\)\$${variable_name_re}/;
2020 my $variable_w_mod_re =
2021 qr/(?<!\\)\$\{${variable_name_re}(?P<MOD>(?:\\\/|.)*?)\}/;
2022 # Tie it all together
2023 my $variable_re = qr/${variable_simple_re}|${variable_w_mod_re}/;
2025 my $expand_variables = sub {
2027 my $value_rest = shift;
2029 if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
2031 "DEBUG[\$expand_variables] Parsed '$value_rest' ...\n"
2034 while ($value_rest =~ /${variable_re}/) {
2035 # We must save important regexp values, because the next
2036 # regexp clears them
2038 my $variable_value = $variables{$+{VARIABLE}};
2043 # Process modifier expressions, if present
2045 if ($mod =~ /^${variable_subst_re}$/) {
2047 my $subst = $+{SUBST};
2049 $variable_value =~ s/\Q$re\E/$subst/g;
2051 if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
2053 "DEBUG[\$expand_variables] ... and substituted ",
2054 "'$re' with '$subst'\n";
2059 $value .= $variable_value;
2061 if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
2063 "DEBUG[\$expand_variables] ... into: '$value$value_rest'\n";
2065 return $value . $value_rest;
2068 # Support for attributes in build.info files
2069 my %attributes = ();
2070 my $handle_attributes = sub {
2071 my $attr_str = shift;
2075 return unless defined $attr_str;
2077 my @a = tokenize($attr_str, qr|\s*,\s*|);
2078 foreach my $a (@a) {
2082 if ($a =~ m|^(!)?(.*?)\s* = \s*(.*?)$|x) {
2087 foreach my $g (@goals) {
2089 $$ref->{$g}->{$ak} = $av;
2091 delete $$ref->{$g}->{$ak};
2097 # Support for pushing values on multiple indexes of a given hash
2100 my $valueref = shift;
2101 my $index_str = shift; # May be undef or empty
2102 my $attrref = shift; # May be undef
2103 my $attr_str = shift;
2106 if (defined $index_str) {
2107 my @indexes = ( '' );
2108 if ($index_str !~ m|^\s*$|) {
2109 @indexes = tokenize($index_str);
2111 foreach (@indexes) {
2112 push @{$valueref->{$_}}, @values;
2113 if (defined $attrref) {
2114 $handle_attributes->($attr_str, \$$attrref->{$_},
2119 push @$valueref, @values;
2120 $handle_attributes->($attr_str, $attrref, @values)
2121 if defined $attrref;
2125 if ($buildinfo_debug) {
2126 print STDERR "DEBUG: Reading ",catfile($sourced, $f),"\n";
2128 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
2130 Text::Template->new(TYPE => 'FILE',
2131 SOURCE => catfile($sourced, $f),
2132 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
2133 die "Something went wrong with $sourced/$f: $!\n" unless $template;
2136 $template->fill_in(HASH => { config => \%config,
2138 disabled => \%disabled,
2139 withargs => \%withargs,
2140 builddir => abs2rel($buildd, $blddir),
2141 sourcedir => abs2rel($sourced, $blddir),
2142 buildtop => abs2rel($blddir, $blddir),
2143 sourcetop => abs2rel($srcdir, $blddir) },
2144 DELIMITERS => [ "{-", "-}" ]);
2146 # The top item of this stack has the following values
2147 # -2 positive already run and we found ELSE (following ELSIF should fail)
2148 # -1 positive already run (skip until ENDIF)
2149 # 0 negatives so far (if we're at a condition, check it)
2150 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
2151 # 2 positive ELSE (following ELSIF should fail)
2154 # A few useful generic regexps
2155 my $index_re = qr/\[\s*(?P<INDEX>(?:\\.|.)*?)\s*\]/;
2156 my $cond_re = qr/\[\s*(?P<COND>(?:\\.|.)*?)\s*\]/;
2157 my $attribs_re = qr/(?:\{\s*(?P<ATTRIBS>(?:\\.|.)*?)\s*\})?/;
2158 my $value_re = qr/(?P<VALUE>.*?)/;
2159 collect_information(
2160 collect_from_array([ @text ],
2161 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
2162 $l1 =~ s/\\$//; $l1.$l2 }),
2163 # Info we're looking for
2164 qr/^\s* IF ${cond_re} \s*$/x
2166 if (! @skip || $skip[$#skip] > 0) {
2167 push @skip, !! $expand_variables->($+{COND});
2172 qr/^\s* ELSIF ${cond_re} \s*$/x
2173 => sub { die "ELSIF out of scope" if ! @skip;
2174 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
2175 $skip[$#skip] = -1 if $skip[$#skip] != 0;
2176 $skip[$#skip] = !! $expand_variables->($+{COND})
2177 if $skip[$#skip] == 0; },
2179 => sub { die "ELSE out of scope" if ! @skip;
2180 $skip[$#skip] = -2 if $skip[$#skip] != 0;
2181 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
2182 qr/^\s* ENDIF \s*$/x
2183 => sub { die "ENDIF out of scope" if ! @skip;
2185 qr/^\s* ${variable_re} \s* = \s* ${value_re} \s* $/x
2187 if (!@skip || $skip[$#skip] > 0) {
2188 $variables{$+{VARIABLE}} = $expand_variables->($+{VALUE});
2191 qr/^\s* SUBDIRS \s* = \s* ${value_re} \s* $/x
2193 if (!@skip || $skip[$#skip] > 0) {
2194 foreach (tokenize($expand_variables->($+{VALUE}))) {
2195 push @build_dirs, [ @curd, splitdir($_, 1) ];
2199 qr/^\s* PROGRAMS ${attribs_re} \s* = \s* ${value_re} \s* $/x
2200 => sub { $push_to->(\@programs, undef,
2201 \$attributes{programs}, $+{ATTRIBS},
2202 tokenize($expand_variables->($+{VALUE})))
2203 if !@skip || $skip[$#skip] > 0; },
2204 qr/^\s* LIBS ${attribs_re} \s* = \s* ${value_re} \s* $/x
2205 => sub { $push_to->(\@libraries, undef,
2206 \$attributes{libraries}, $+{ATTRIBS},
2207 tokenize($expand_variables->($+{VALUE})))
2208 if !@skip || $skip[$#skip] > 0; },
2209 qr/^\s* MODULES ${attribs_re} \s* = \s* ${value_re} \s* $/x
2210 => sub { $push_to->(\@modules, undef,
2211 \$attributes{modules}, $+{ATTRIBS},
2212 tokenize($expand_variables->($+{VALUE})))
2213 if !@skip || $skip[$#skip] > 0; },
2214 qr/^\s* SCRIPTS ${attribs_re} \s* = \s* ${value_re} \s* $/x
2215 => sub { $push_to->(\@scripts, undef,
2216 \$attributes{scripts}, $+{ATTRIBS},
2217 tokenize($expand_variables->($+{VALUE})))
2218 if !@skip || $skip[$#skip] > 0; },
2219 qr/^\s* IMAGEDOCS ${index_re} \s* = \s* ${value_re} \s* $/x
2220 => sub { $push_to->(\%imagedocs, $expand_variables->($+{INDEX}),
2222 tokenize($expand_variables->($+{VALUE})))
2223 if !@skip || $skip[$#skip] > 0; },
2224 qr/^\s* HTMLDOCS ${index_re} \s* = \s* ${value_re} \s* $/x
2225 => sub { $push_to->(\%htmldocs, $expand_variables->($+{INDEX}),
2227 tokenize($expand_variables->($+{VALUE})))
2228 if !@skip || $skip[$#skip] > 0; },
2229 qr/^\s* MANDOCS ${index_re} \s* = \s* ${value_re} \s* $/x
2230 => sub { $push_to->(\%mandocs, $expand_variables->($+{INDEX}),
2232 tokenize($expand_variables->($+{VALUE})))
2233 if !@skip || $skip[$#skip] > 0; },
2234 qr/^\s* SOURCE ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2235 => sub { $push_to->(\%sources, $expand_variables->($+{INDEX}),
2236 \$attributes{sources}, $+{ATTRIBS},
2237 tokenize($expand_variables->($+{VALUE})))
2238 if !@skip || $skip[$#skip] > 0; },
2239 qr/^\s* SHARED_SOURCE ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2240 => sub { $push_to->(\%shared_sources, $expand_variables->($+{INDEX}),
2241 \$attributes{sources}, $+{ATTRIBS},
2242 tokenize($expand_variables->($+{VALUE})))
2243 if !@skip || $skip[$#skip] > 0; },
2244 qr/^\s* INCLUDE ${index_re} \s* = \s* ${value_re} \s* $/x
2245 => sub { $push_to->(\%includes, $expand_variables->($+{INDEX}),
2247 tokenize($expand_variables->($+{VALUE})))
2248 if !@skip || $skip[$#skip] > 0; },
2249 qr/^\s* DEFINE ${index_re} \s* = \s* ${value_re} \s* $/x
2250 => sub { $push_to->(\%defines, $expand_variables->($+{INDEX}),
2252 tokenize($expand_variables->($+{VALUE})))
2253 if !@skip || $skip[$#skip] > 0; },
2254 qr/^\s* DEPEND ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2255 => sub { $push_to->(\%depends, $expand_variables->($+{INDEX}),
2256 \$attributes{depends}, $+{ATTRIBS},
2257 tokenize($expand_variables->($+{VALUE})))
2258 if !@skip || $skip[$#skip] > 0; },
2259 qr/^\s* GENERATE ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2260 => sub { $push_to->(\%generate, $expand_variables->($+{INDEX}),
2261 \$attributes{generate}, $+{ATTRIBS},
2262 $expand_variables->($+{VALUE}))
2263 if !@skip || $skip[$#skip] > 0; },
2264 qr/^\s* (?:\#.*)? $/x => sub { },
2265 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
2267 if ($buildinfo_debug) {
2268 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
2269 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2273 if ($buildinfo_debug) {
2274 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2278 die "runaway IF?" if (@skip);
2280 if (grep { defined $attributes{modules}->{$_}->{engine} } keys %attributes
2281 and !$config{dynamic_engines}) {
2283 ENGINES can only be used if configured with 'dynamic-engine'.
2284 This is usually a fault in a build.info file.
2289 my %infos = ( programs => [ @programs ],
2290 libraries => [ @libraries ],
2291 modules => [ @modules ],
2292 scripts => [ @scripts ] );
2293 foreach my $k (keys %infos) {
2294 foreach (@{$infos{$k}}) {
2295 my $item = cleanfile($buildd, $_, $blddir);
2296 $unified_info{$k}->{$item} = 1;
2298 # Fix up associated attributes
2299 $unified_info{attributes}->{$k}->{$item} =
2300 $attributes{$k}->{$_}
2301 if defined $attributes{$k}->{$_};
2306 # Check that we haven't defined any library as both shared and
2307 # explicitly static. That is forbidden.
2309 foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
2310 (my $l = $_) =~ s/\.a$//;
2311 push @doubles, $l if defined $unified_info{libraries}->{$l};
2313 die "these libraries are both explicitly static and shared:\n ",
2314 join(" ", @doubles), "\n"
2317 foreach (keys %sources) {
2319 my $ddest = cleanfile($buildd, $_, $blddir);
2320 foreach (@{$sources{$dest}}) {
2321 my $s = cleanfile($sourced, $_, $blddir);
2323 # If it's generated or we simply don't find it in the source
2324 # tree, we assume it's in the build tree.
2325 if ($s eq $src_configdata || $generate{$_} || ! -f $s) {
2326 $s = cleanfile($buildd, $_, $blddir);
2329 # We recognise C++, C and asm files
2330 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2331 push @{$check_exist{$s}}, $ddest;
2332 $o =~ s/\.[csS]$/.o/; # C and assembler
2333 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2334 $o = cleanfile($buildd, $o, $blddir);
2335 $unified_info{sources}->{$ddest}->{$o} = -1;
2336 $unified_info{sources}->{$o}->{$s} = -1;
2337 } elsif ($s =~ /\.rc$/) {
2338 # We also recognise resource files
2339 push @{$check_exist{$s}}, $ddest;
2340 $o =~ s/\.rc$/.res/; # Resource configuration
2341 $o = cleanfile($buildd, $o, $blddir);
2342 $unified_info{sources}->{$ddest}->{$o} = -1;
2343 $unified_info{sources}->{$o}->{$s} = -1;
2345 push @{$check_exist{$s}}, $ddest;
2346 $unified_info{sources}->{$ddest}->{$s} = 1;
2348 # Fix up associated attributes
2350 $unified_info{attributes}->{sources}->{$ddest}->{$o} =
2351 $unified_info{attributes}->{sources}->{$o}->{$s} =
2352 $attributes{sources}->{$dest}->{$_}
2353 if defined $attributes{sources}->{$dest}->{$_};
2355 $unified_info{attributes}->{sources}->{$ddest}->{$s} =
2356 $attributes{sources}->{$dest}->{$_}
2357 if defined $attributes{sources}->{$dest}->{$_};
2362 foreach (keys %shared_sources) {
2364 my $ddest = cleanfile($buildd, $_, $blddir);
2365 foreach (@{$shared_sources{$dest}}) {
2366 my $s = cleanfile($sourced, $_, $blddir);
2368 # If it's generated or we simply don't find it in the source
2369 # tree, we assume it's in the build tree.
2370 if ($s eq $src_configdata || $generate{$_} || ! -f $s) {
2371 $s = cleanfile($buildd, $_, $blddir);
2375 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2376 # We recognise C++, C and asm files
2377 push @{$check_exist{$s}}, $ddest;
2378 $o =~ s/\.[csS]$/.o/; # C and assembler
2379 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2380 $o = cleanfile($buildd, $o, $blddir);
2381 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2382 $unified_info{sources}->{$o}->{$s} = -1;
2383 } elsif ($s =~ /\.rc$/) {
2384 # We also recognise resource files
2385 push @{$check_exist{$s}}, $ddest;
2386 $o =~ s/\.rc$/.res/; # Resource configuration
2387 $o = cleanfile($buildd, $o, $blddir);
2388 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2389 $unified_info{sources}->{$o}->{$s} = -1;
2390 } elsif ($s =~ /\.ld$/) {
2391 # We also recognise linker scripts (or corresponding)
2392 # We know they are generated files
2393 push @{$check_exist{$s}}, $ddest;
2394 $o = cleanfile($buildd, $_, $blddir);
2395 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
2397 die "unrecognised source file type for shared library: $s\n";
2399 # Fix up associated attributes
2401 $unified_info{attributes}->{shared_sources}->{$ddest}->{$o} =
2402 $unified_info{attributes}->{sources}->{$o}->{$s} =
2403 $attributes{sources}->{$dest}->{$_}
2404 if defined $attributes{sources}->{$dest}->{$_};
2406 $unified_info{attributes}->{shared_sources}->{$ddest}->{$o} =
2407 $attributes{sources}->{$dest}->{$_}
2408 if defined $attributes{sources}->{$dest}->{$_};
2413 foreach (keys %generate) {
2415 my $ddest = cleanfile($buildd, $_, $blddir);
2416 die "more than one generator for $dest: "
2417 ,join(" ", @{$generate{$_}}),"\n"
2418 if scalar @{$generate{$_}} > 1;
2419 my @generator = split /\s+/, $generate{$dest}->[0];
2420 my $gen = $generator[0];
2421 $generator[0] = cleanfile($sourced, $gen, $blddir);
2423 # If the generator is itself generated, it's in the build tree
2424 if ($generate{$gen} || ! -f $generator[0]) {
2425 $generator[0] = cleanfile($buildd, $gen, $blddir);
2427 $check_generate{$ddest}->{$generator[0]}++;
2429 $unified_info{generate}->{$ddest} = [ @generator ];
2430 # Fix up associated attributes
2431 $unified_info{attributes}->{generate}->{$ddest} =
2432 $attributes{generate}->{$dest}->{$gen}
2433 if defined $attributes{generate}->{$dest}->{$gen};
2436 foreach (keys %depends) {
2440 if ($dest =~ /^\|(.*)\|$/) {
2441 # Collect the raw target
2442 $unified_info{targets}->{$1} = 1;
2444 } elsif ($dest eq '') {
2447 $ddest = cleanfile($sourced, $dest, $blddir);
2449 # If the destination doesn't exist in source, it can only be
2450 # a generated file in the build tree.
2451 if ($ddest eq $src_configdata || ! -f $ddest) {
2452 $ddest = cleanfile($buildd, $dest, $blddir);
2455 foreach my $f (@{$depends{$dest}}) {
2456 # If the dependency destination is generated, dependencies
2457 # may have an extra syntax to separate the intended inclusion
2458 # directory from the module to be loaded: a | instead of a
2459 # / as directory separator.
2460 # Do note that this has to be handled in the build file
2462 # $i = inclusion path in source directory
2463 # $i2 = inclusion path in build directory
2464 # $m = module path (within the inclusion path)
2465 # $i = full module path in source directory
2466 # $i2 = full module path in build directory
2467 my $i; my $i2; my $m; my $d; my $d2;
2468 if ($unified_info{generate}->{$ddest}
2469 && $f =~ m/^(.*?)\|(.*)$/) {
2472 $i = cleanfile($sourced, $i, $blddir);
2473 $i2 = cleanfile($buildd, $i, $blddir);
2474 $d = cleanfile($sourced, "$i/$m", $blddir);
2475 $d2 = cleanfile($buildd, "$i/$m", $blddir);
2477 $d = cleanfile($sourced, $f, $blddir);
2478 $d2 = cleanfile($buildd, $f, $blddir);
2481 # If we know it's generated, or assume it is because we can't
2482 # find it in the source tree, we set file we depend on to be
2483 # in the build tree rather than the source tree.
2484 if ($d eq $src_configdata
2485 || (grep { $d2 eq $_ }
2486 keys %{$unified_info{generate}})
2492 # Put together the computed inclusion dir with the
2493 # original module name. Do note that we conserve the
2494 # Unixly path syntax for the module path.
2497 $unified_info{depends}->{$ddest}->{$d} = 1;
2499 # Fix up associated attributes
2500 $unified_info{attributes}->{depends}->{$ddest}->{$d} =
2501 $attributes{depends}->{$dest}->{$f}
2502 if defined $attributes{depends}->{$dest}->{$f};
2506 foreach (keys %includes) {
2508 my $ddest = cleanfile($sourced, $_, $blddir);
2510 # If the destination doesn't exist in source, it can only be
2511 # a generated file in the build tree.
2512 if ($ddest eq $src_configdata || ! -f $ddest) {
2513 $ddest = cleanfile($buildd, $_, $blddir);
2515 foreach (@{$includes{$dest}}) {
2516 my $is = cleandir($sourced, $_, $blddir);
2517 my $ib = cleandir($buildd, $_, $blddir);
2518 push @{$unified_info{includes}->{$ddest}->{source}}, $is
2519 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
2520 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
2521 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
2525 foreach my $dest (keys %defines) {
2529 $ddest = cleanfile($sourced, $dest, $blddir);
2531 # If the destination doesn't exist in source, it can only
2532 # be a generated file in the build tree.
2534 $ddest = cleanfile($buildd, $dest, $blddir);
2537 foreach my $v (@{$defines{$dest}}) {
2538 $v =~ m|^([^=]*)(=.*)?$|;
2539 die "0 length macro name not permitted\n" if $1 eq "";
2541 die "$1 defined more than once\n"
2542 if defined $unified_info{defines}->{$ddest}->{$1};
2543 $unified_info{defines}->{$ddest}->{$1} = $2;
2545 die "$1 defined more than once\n"
2546 if grep { $v eq $_ } @{$config{defines}};
2547 push @{$config{defines}}, $v;
2552 foreach my $section (keys %imagedocs) {
2553 foreach (@{$imagedocs{$section}}) {
2554 my $imagedocs = cleanfile($buildd, $_, $blddir);
2555 $unified_info{imagedocs}->{$section}->{$imagedocs} = 1;
2559 foreach my $section (keys %htmldocs) {
2560 foreach (@{$htmldocs{$section}}) {
2561 my $htmldocs = cleanfile($buildd, $_, $blddir);
2562 $unified_info{htmldocs}->{$section}->{$htmldocs} = 1;
2566 foreach my $section (keys %mandocs) {
2567 foreach (@{$mandocs{$section}}) {
2568 my $mandocs = cleanfile($buildd, $_, $blddir);
2569 $unified_info{mandocs}->{$section}->{$mandocs} = 1;
2574 my $ordinals_text = join(', ', sort keys %ordinals);
2575 warn <<"EOF" if $ordinals_text;
2577 WARNING: ORDINALS were specified for $ordinals_text
2578 They are ignored and should be replaced with a combination of GENERATE,
2579 DEPEND and SHARED_SOURCE.
2582 # Check that each generated file is only generated once
2583 my $ambiguous_generation = 0;
2584 foreach (sort keys %check_generate) {
2585 my @generators = sort keys %{$check_generate{$_}};
2586 my $generators_txt = join(', ', @generators);
2587 if (scalar @generators > 1) {
2588 warn "$_ is GENERATEd by more than one generator ($generators_txt)\n";
2589 $ambiguous_generation++;
2591 if ($check_generate{$_}->{$generators[0]} > 1) {
2592 warn "INFO: $_ has more than one GENERATE declaration (same generator)\n"
2595 die "There are ambiguous source file generations\n"
2596 if $ambiguous_generation > 0;
2598 # All given source files should exist, or if generated, their
2599 # generator should exist. This loop ensures this is true.
2601 foreach my $orig (sort keys %check_exist) {
2602 foreach my $dest (@{$check_exist{$orig}}) {
2603 if ($orig ne $src_configdata) {
2604 if ($orig =~ /\.a$/) {
2605 # Static library names may be used as sources, so we
2606 # need to detect those and give them special treatment.
2607 unless (grep { $_ eq $orig }
2608 keys %{$unified_info{libraries}}) {
2609 warn "$orig is given as source for $dest, but no such library is built\n";
2613 # A source may be generated, and its generator may be
2614 # generated as well. We therefore loop to dig out the
2618 while (my @next = keys %{$check_generate{$gen}}) {
2623 if ($gen ne $orig) {
2625 warn "$orig is given as source for $dest, but its generator (leading to $gen) is missing\n";
2628 warn "$orig is given as source for $dest, but is missing\n";
2635 die "There are files missing\n" if $missing > 0;
2637 # Go through the sources of all libraries and check that the same basename
2638 # doesn't appear more than once. Some static library archivers depend on
2639 # them being unique.
2642 foreach my $prod (keys %{$unified_info{libraries}}) {
2644 map { keys %{$unified_info{sources}->{$_}} }
2645 keys %{$unified_info{sources}->{$prod}};
2648 # Count how many times a given each source basename
2649 # appears for each product.
2650 foreach my $src (@prod_sources) {
2651 $srccnt{basename $src}++;
2654 foreach my $src (keys %srccnt) {
2655 if ((my $cnt = $srccnt{$src}) > 1) {
2656 print STDERR "$src appears $cnt times for the product $prod\n";
2664 # Massage the result
2666 # If we depend on a header file or a perl module, add an inclusion of
2667 # its directory to allow smoothe inclusion
2668 foreach my $dest (keys %{$unified_info{depends}}) {
2669 next if $dest eq "";
2670 foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2671 next unless $d =~ /\.(h|pm)$/;
2672 # Take into account when a dependency uses the inclusion|module
2674 my $i = $d =~ m/\|/ ? $` : dirname($d);
2676 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2677 ? 'build' : 'source';
2678 push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2679 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
2683 # Go through all intermediary files and change their names to something that
2684 # reflects what they will be built for. Note that for some source files,
2685 # this leads to duplicate object files because they are used multiple times.
2686 # the goal is to rename all object files according to this scheme:
2687 # {productname}-{midfix}-{origobjname}.[o|res]
2688 # the {midfix} is a keyword indicating the type of product, which is mostly
2689 # valuable for libraries since they come in two forms.
2691 # This also reorganises the {sources} and {shared_sources} so that the
2692 # former only contains ALL object files that are supposed to end up in
2693 # static libraries and programs, while the latter contains ALL object files
2694 # that are supposed to end up in shared libraries and DSOs.
2695 # The main reason for having two different source structures is to allow
2696 # the same name to be used for the static and the shared variants of a
2699 # Take copies so we don't get interference from added stuff
2700 my %unified_copy = ();
2701 foreach (('sources', 'shared_sources')) {
2702 $unified_copy{$_} = { %{$unified_info{$_}} }
2703 if defined($unified_info{$_});
2704 delete $unified_info{$_};
2706 foreach my $prodtype (('programs', 'libraries', 'modules', 'scripts')) {
2707 # $intent serves multi purposes:
2708 # - give a prefix for the new object files names
2709 # - in the case of libraries, rearrange the object files so static
2710 # libraries use the 'sources' structure exclusively, while shared
2711 # libraries use the 'shared_sources' structure exclusively.
2713 programs => { bin => { src => [ 'sources' ],
2714 dst => 'sources' } },
2715 libraries => { lib => { src => [ 'sources' ],
2717 shlib => { prodselect =>
2718 sub { grep !/\.a$/, @_ },
2721 dst => 'shared_sources' } },
2722 modules => { dso => { src => [ 'sources' ],
2723 dst => 'sources' } },
2724 scripts => { script => { src => [ 'sources' ],
2725 dst => 'sources' } }
2727 foreach my $kind (keys %$intent) {
2728 next if ($intent->{$kind}->{dst} eq 'shared_sources'
2729 && $disabled{shared});
2731 my @src = @{$intent->{$kind}->{src}};
2732 my $dst = $intent->{$kind}->{dst};
2733 my $prodselect = $intent->{$kind}->{prodselect} // sub { @_ };
2734 foreach my $prod ($prodselect->(keys %{$unified_info{$prodtype}})) {
2735 # %prod_sources has all applicable objects as keys, and
2736 # their corresponding sources as values
2738 map { $_ => [ keys %{$unified_copy{sources}->{$_}} ] }
2739 map { keys %{$unified_copy{$_}->{$prod}} }
2741 foreach (keys %prod_sources) {
2742 # Only affect object files and resource files,
2743 # the others simply get a new value
2744 # (+1 instead of -1)
2745 if ($_ =~ /\.(o|res)$/) {
2746 (my $prodname = $prod) =~ s|\.a$||;
2748 catfile(dirname($_),
2751 . '-' . basename($_));
2752 $unified_info{$dst}->{$prod}->{$newobj} = 1;
2753 foreach my $src (@{$prod_sources{$_}}) {
2754 $unified_info{sources}->{$newobj}->{$src} = 1;
2755 # Adjust source attributes
2756 my $attrs = $unified_info{attributes}->{sources};
2757 if (defined $attrs->{$prod}
2758 && defined $attrs->{$prod}->{$_}) {
2759 $attrs->{$prod}->{$newobj} =
2760 $attrs->{$prod}->{$_};
2761 delete $attrs->{$prod}->{$_};
2763 foreach my $objsrc (keys %{$attrs->{$_} // {}}) {
2764 $attrs->{$newobj}->{$objsrc} =
2765 $attrs->{$_}->{$objsrc};
2766 delete $attrs->{$_}->{$objsrc};
2769 # Adjust dependencies
2770 foreach my $deps (keys %{$unified_info{depends}->{$_}}) {
2771 $unified_info{depends}->{$_}->{$deps} = -1;
2772 $unified_info{depends}->{$newobj}->{$deps} = 1;
2775 foreach my $k (('source', 'build')) {
2777 defined($unified_info{includes}->{$_}->{$k});
2778 my @incs = @{$unified_info{includes}->{$_}->{$k}};
2779 $unified_info{includes}->{$newobj}->{$k} = [ @incs ];
2782 $unified_info{$dst}->{$prod}->{$_} = 1;
2790 # At this point, we have a number of sources with the value -1. They
2791 # aren't part of the local build and are probably meant for a different
2792 # platform, and can therefore be cleaned away. That happens when making
2793 # %unified_info more efficient below.
2795 ### Make unified_info a bit more efficient
2796 # One level structures
2797 foreach (("programs", "libraries", "modules", "scripts", "targets")) {
2798 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2800 # Two level structures
2801 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends",
2802 "imagedocs", "htmldocs", "mandocs")) {
2803 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
2806 grep { $unified_info{$l1}->{$l2}->{$_} > 0 }
2807 keys %{$unified_info{$l1}->{$l2}};
2809 $unified_info{$l1}->{$l2} = [ @items ];
2811 delete $unified_info{$l1}->{$l2};
2816 foreach my $dest (sort keys %{$unified_info{defines}}) {
2817 $unified_info{defines}->{$dest}
2818 = [ map { $_.$unified_info{defines}->{$dest}->{$_} }
2819 sort keys %{$unified_info{defines}->{$dest}} ];
2822 foreach my $dest (sort keys %{$unified_info{includes}}) {
2823 if (defined($unified_info{includes}->{$dest}->{build})) {
2824 my @source_includes = ();
2825 @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2826 if defined($unified_info{includes}->{$dest}->{source});
2827 $unified_info{includes}->{$dest} =
2828 [ @{$unified_info{includes}->{$dest}->{build}} ];
2829 foreach my $inc (@source_includes) {
2830 push @{$unified_info{includes}->{$dest}}, $inc
2831 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2833 } elsif (defined($unified_info{includes}->{$dest}->{source})) {
2834 $unified_info{includes}->{$dest} =
2835 [ @{$unified_info{includes}->{$dest}->{source}} ];
2837 delete $unified_info{includes}->{$dest};
2841 # For convenience collect information regarding directories where
2842 # files are generated, those generated files and the end product
2843 # they end up in where applicable. Then, add build rules for those
2845 my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
2846 "dso" => [ @{$unified_info{modules}} ],
2847 "bin" => [ @{$unified_info{programs}} ],
2848 "script" => [ @{$unified_info{scripts}} ],
2849 "docs" => [ (map { @{$unified_info{imagedocs}->{$_} // []} }
2850 keys %{$unified_info{imagedocs} // {}}),
2851 (map { @{$unified_info{htmldocs}->{$_} // []} }
2852 keys %{$unified_info{htmldocs} // {}}),
2853 (map { @{$unified_info{mandocs}->{$_} // []} }
2854 keys %{$unified_info{mandocs} // {}}) ] );
2855 foreach my $type (sort keys %loopinfo) {
2856 foreach my $product (@{$loopinfo{$type}}) {
2858 my $pd = dirname($product);
2860 foreach (@{$unified_info{sources}->{$product} // []},
2861 @{$unified_info{shared_sources}->{$product} // []}) {
2862 my $d = dirname($_);
2864 # We don't want to create targets for source directories
2865 # when building out of source
2866 next if ($config{sourcedir} ne $config{builddir}
2867 && $d =~ m|^\Q$config{sourcedir}\E|);
2868 # We already have a "test" target, and the current directory
2869 # is just silly to make a target for
2870 next if $d eq "test" || $d eq ".";
2873 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2876 foreach (sort keys %dirs) {
2877 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2884 # For the schemes that need it, we provide the old *_obj configs
2885 # from the *_asm_obj ones
2886 foreach (grep /_(asm|aux)_src$/, keys %target) {
2888 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
2889 $target{$obj} = $target{$src};
2890 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2891 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2894 # Write down our configuration where it fits #########################
2896 my %template_vars = (
2899 disablables => \@disablables,
2900 disablables_int => \@disablables_int,
2901 disabled => \%disabled,
2902 withargs => \%withargs,
2903 unified_info => \%unified_info,
2906 makevars => [ sort keys %user ],
2907 disabled_info => \%disabled_info,
2908 user_crossable => \@user_crossable,
2910 my $configdata_outname = 'configdata.pm';
2911 open CONFIGDATA, ">$configdata_outname.new"
2912 or die "Trying to create $configdata_outname.new: $!";
2913 my $configdata_tmplname = cleanfile($srcdir, "configdata.pm.in", $blddir);
2914 my $configdata_tmpl =
2915 OpenSSL::Template->new(TYPE => 'FILE', SOURCE => $configdata_tmplname);
2916 $configdata_tmpl->fill_in(
2917 FILENAME => $configdata_tmplname,
2918 OUTPUT => \*CONFIGDATA,
2919 HASH => { %template_vars,
2921 'WARNING: do not edit!',
2922 "Generated by Configure from $configdata_tmplname",
2924 ) or die $Text::Template::ERROR;
2927 rename "$configdata_outname.new", $configdata_outname;
2928 if ($builder_platform eq 'unix') {
2929 my $mode = (0755 & ~umask);
2930 chmod $mode, 'configdata.pm'
2931 or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2933 print "Created $configdata_outname\n";
2935 print "Running $configdata_outname\n";
2936 my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
2937 my $cmd = "$perlcmd $configdata_outname";
2938 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2942 $SIG{__DIE__} = $orig_death_handler;
2944 print <<"EOF" if ($disabled{threads} eq "unavailable");
2946 The library could not be configured for supporting multi-threaded
2947 applications as the compiler options required on this system are not known.
2948 See file INSTALL.md for details if you need multi-threading.
2951 print <<"EOF" if ($no_shared_warn);
2953 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2954 platform, so we will pretend you gave the option 'no-pic', which also disables
2955 'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2956 or position independent code, please let us know (but please first make sure
2957 you have tried with a current version of OpenSSL).
2964 ######################################################################
2966 # Helpers and utility functions
2969 # Death handler, to print a helpful message in case of failure #######
2972 die @_ if $^S; # To prevent the added message in eval blocks
2973 my $build_file = $config{build_file} // "build file";
2974 my @message = ( <<"_____", @_ );
2976 Failure! $build_file wasn't produced.
2977 Please read INSTALL.md and associated NOTES-* files. You may also have to
2978 look over your available compiler tool chain or change your configuration.
2982 # Dying is terminal, so it's ok to reset the signal handler here.
2983 $SIG{__DIE__} = $orig_death_handler;
2987 # Configuration file reading #########################################
2989 # Note: All of the helper functions are for lazy evaluation. They all
2990 # return a CODE ref, which will return the intended value when evaluated.
2991 # Thus, whenever there's mention of a returned value, it's about that
2994 # Helper function to implement conditional value variants, with a default
2995 # plus additional values based on the value of $config{build_type}.
2996 # Arguments are given in hash table form:
2998 # picker(default => "Basic string: ",
3000 # release => "release")
3002 # When configuring with --debug, the resulting string will be
3003 # "Basic string: debug", and when not, it will be "Basic string: release"
3005 # This can be used to create variants of sets of flags according to the
3008 # cflags => picker(default => "-Wall",
3009 # debug => "-g -O0",
3014 return sub { add($opts{default} || (),
3015 $opts{$config{build_type}} || ())->(); }
3018 # Helper function to combine several values of different types into one.
3019 # This is useful if you want to combine a string with the result of a
3020 # lazy function, such as:
3022 # cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
3026 return sub { add(@stuff)->(); }
3029 # Helper function to implement conditional values depending on the value
3030 # of $disabled{threads}. Can be used as follows:
3032 # cflags => combine("-Wall", threads("-pthread"))
3036 return sub { add($disabled{threads} ? () : @flags)->(); }
3041 return sub { add($disabled{shared} ? () : @flags)->(); }
3044 our $add_called = 0;
3045 # Helper function to implement adding values to already existing configuration
3046 # values. It handles elements that are ARRAYs, CODEs and scalars
3048 my $separator = shift;
3050 # If there's any ARRAY in the collection of values OR the separator
3051 # is undef, we will return an ARRAY of combined values, otherwise a
3052 # string of joined values with $separator as the separator.
3053 my $found_array = !defined($separator);
3058 while (ref($res) eq "CODE") {
3061 if (defined($res)) {
3062 if (ref($res) eq "ARRAY") {
3078 join($separator, grep { defined($_) && $_ ne "" } @values);
3082 my $separator = " ";
3083 if (ref($_[$#_]) eq "HASH") {
3085 $separator = $opts->{separator};
3088 sub { _add($separator, @x, @_) };
3091 my $separator = " ";
3092 if (ref($_[$#_]) eq "HASH") {
3094 $separator = $opts->{separator};
3097 sub { _add($separator, @_, @x) };
3100 sub read_eval_file {
3105 open F, "< $fname" or die "Can't open '$fname': $!\n";
3114 @result = ( eval $content );
3117 return wantarray ? @result : $result[0];
3120 # configuration reader, evaluates the input file as a perl script and expects
3121 # it to fill %targets with target configurations. Those are then added to
3128 # Protect certain tables from tampering
3131 %targets = read_eval_file($fname);
3133 my %preexisting = ();
3134 foreach (sort keys %targets) {
3135 $preexisting{$_} = 1 if $table{$_};
3138 The following config targets from $fname
3139 shadow pre-existing config targets with the same name:
3141 map { " $_\n" } sort keys %preexisting
3145 # For each target, check that it's configured with a hash table.
3146 foreach (keys %targets) {
3147 if (ref($targets{$_}) ne "HASH") {
3148 if (ref($targets{$_}) eq "") {
3149 warn "Deprecated target configuration for $_, ignoring...\n";
3151 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
3153 delete $targets{$_};
3155 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
3159 %table = (%table, %targets);
3163 # configuration resolver. Will only resolve all the lazy evaluation
3164 # codeblocks for the chosen target and all those it inherits from,
3166 sub resolve_config {
3168 my @breadcrumbs = @_;
3170 # my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
3172 if (grep { $_ eq $target } @breadcrumbs) {
3173 die "inherit_from loop! target backtrace:\n "
3174 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
3177 if (!defined($table{$target})) {
3178 warn "Warning! target $target doesn't exist!\n";
3181 # Recurse through all inheritances. They will be resolved on the
3182 # fly, so when this operation is done, they will all just be a
3183 # bunch of attributes with string values.
3184 # What we get here, though, are keys with references to lists of
3185 # the combined values of them all. We will deal with lists after
3186 # this stage is done.
3187 my %combined_inheritance = ();
3188 if ($table{$target}->{inherit_from}) {
3190 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
3191 foreach (@inherit_from) {
3192 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
3194 # 'template' is a marker that's considered private to
3195 # the config that had it.
3196 delete $inherited_config{template};
3198 foreach (keys %inherited_config) {
3199 if (!$combined_inheritance{$_}) {
3200 $combined_inheritance{$_} = [];
3202 push @{$combined_inheritance{$_}}, $inherited_config{$_};
3207 # We won't need inherit_from in this target any more, since we've
3208 # resolved all the inheritances that lead to this
3209 delete $table{$target}->{inherit_from};
3211 # Now is the time to deal with those lists. Here's the place to
3212 # decide what shall be done with those lists, all based on the
3213 # values of the target we're currently dealing with.
3214 # - If a value is a coderef, it will be executed with the list of
3215 # inherited values as arguments.
3216 # - If the corresponding key doesn't have a value at all or is the
3217 # empty string, the inherited value list will be run through the
3218 # default combiner (below), and the result becomes this target's
3220 # - Otherwise, this target's value is assumed to be a string that
3221 # will simply override the inherited list of values.
3222 my $default_combiner = add();
3225 map { $_ => 1 } (keys %combined_inheritance,
3226 keys %{$table{$target}});
3228 sub process_values {
3230 my $inherited = shift; # Always a [ list ]
3236 while(ref($object) eq "CODE") {
3237 $object = $object->(@$inherited);
3239 if (!defined($object)) {
3242 elsif (ref($object) eq "ARRAY") {
3243 local $add_called; # To make sure recursive calls don't affect it
3244 return [ map { process_values($_, $inherited, $target, $entry) }
3246 } elsif (ref($object) eq "") {
3249 die "cannot handle reference type ",ref($object)
3250 ," found in target ",$target," -> ",$entry,"\n";
3254 foreach my $key (sort keys %all_keys) {
3255 my $previous = $combined_inheritance{$key};
3257 # Current target doesn't have a value for the current key?
3258 # Assign it the default combiner, the rest of this loop body
3259 # will handle it just like any other coderef.
3260 if (!exists $table{$target}->{$key}) {
3261 $table{$target}->{$key} = $default_combiner;
3264 $table{$target}->{$key} = process_values($table{$target}->{$key},
3265 $combined_inheritance{$key},
3267 unless(defined($table{$target}->{$key})) {
3268 delete $table{$target}->{$key};
3270 # if ($extra_checks &&
3271 # $previous && !($add_called || $previous ~~ $table{$target}->{$key})) {
3272 # warn "$key got replaced in $target\n";
3276 # Finally done, return the result.
3277 return %{$table{$target}};
3282 print STDERR $usage;
3283 print STDERR "\npick os/compiler from:\n";
3287 foreach $i (sort keys %table)
3289 next if $table{$i}->{template};
3290 next if $i =~ /^debug/;
3291 $k += length($i) + 1;
3297 print STDERR $i . " ";
3299 foreach $i (sort keys %table)
3301 next if $table{$i}->{template};
3302 next if $i !~ /^debug/;
3303 $k += length($i) + 1;
3309 print STDERR $i . " ";
3314 sub compiler_predefined {
3318 return () if $^O eq 'VMS';
3320 die 'compiler_predefined called without a compiler command'
3323 if (! $predefined{$cc}) {
3325 $predefined{$cc} = {};
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;
3331 $predefined{$cc}->{$1} = $2 // '';
3336 return %{$predefined{$cc}};
3343 if (eval { require IPC::Cmd; 1; }) {
3345 return scalar IPC::Cmd::can_run($name);
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];
3351 foreach (File::Spec->path()) {
3352 my $fullpath = catfile($_, "$name$target{exe_extension}");
3353 if (-f $fullpath and -x $fullpath) {
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.
3370 $config{perlenv}->{$name} = $ENV{$name}
3371 if ! exists $config{perlenv}->{$name};
3373 return $config{perlenv}->{$name};
3376 # Configuration printer ##############################################
3378 sub print_table_entry
3380 local $now_printing = shift;
3381 my %target = resolve_config($now_printing);
3384 # Don't print the templates
3385 return if $target{template};
3430 if ($type eq "TABLE") {
3432 print "*** $now_printing\n";
3433 foreach (@sequence) {
3434 if (ref($target{$_}) eq "ARRAY") {
3435 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3437 printf "\$%-12s = %s\n", $_, $target{$_};
3440 } elsif ($type eq "HASH") {
3442 length((sort { length($a) <=> length($b) } @sequence)[-1]);
3443 print " '$now_printing' => {\n";
3444 foreach (@sequence) {
3446 if (ref($target{$_}) eq "ARRAY") {
3447 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3449 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3457 # Utility routines ###################################################
3459 # On VMS, if the given file is a logical name, File::Spec::Functions
3460 # will consider it an absolute path. There are cases when we want a
3461 # purely syntactic check without checking the environment.
3465 # On non-platforms, we just use file_name_is_absolute().
3466 return file_name_is_absolute($file) unless $^O eq "VMS";
3468 # If the file spec includes a device or a directory spec,
3469 # file_name_is_absolute() is perfectly safe.
3470 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3472 # Here, we know the given file spec isn't absolute
3476 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
3477 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
3478 # realpath() requires that at least all path components except the last is an
3479 # existing directory. On VMS, the last component of the directory spec must
3484 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
3485 # will return the volume name for the device, no matter what. Also,
3486 # it will return an incorrect directory spec if the argument is a
3487 # directory that doesn't exist.
3489 return rel2abs($dir);
3492 # We use realpath() on Unix, since no other will properly clean out
3494 use Cwd qw/realpath/;
3496 return realpath($dir);
3499 # Check if all paths are one and the same, using stat. They must both exist
3500 # We need this for the cases when File::Spec doesn't detect case insensitivity
3501 # (File::Spec::Unix assumes case sensitivity)
3503 die "samedir expects two arguments\n" unless scalar @_ == 2;
3505 my @stat0 = stat($_[0]); # First argument
3506 my @stat1 = stat($_[1]); # Second argument
3508 die "Couldn't stat $_[0]" unless @stat0;
3509 die "Couldn't stat $_[1]" unless @stat1;
3511 # Compare device number
3512 return 0 unless ($stat0[0] == $stat1[0]);
3513 # Compare "inode". The perl manual recommends comparing as
3514 # string rather than as number.
3515 return 0 unless ($stat0[1] eq $stat1[1]);
3517 return 1; # All the same
3522 perl => sub { my $x = shift;
3523 $x =~ s/([\\\$\@"])/\\$1/g;
3524 return '"'.$x.'"'; },
3525 maybeshell => sub { my $x = shift;
3526 (my $y = $x) =~ s/([\\\"])/\\$1/g;
3527 if ($x ne $y || $x =~ m|\s|) {
3536 defined($processors{$for}) ? $processors{$for} : sub { shift; };
3538 return map { $processor->($_); } @_;
3541 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
3542 # $filename is a file name to read from
3543 # $line_concat_cond_re is a regexp detecting a line continuation ending
3544 # $line_concat is a CODEref that takes care of concatenating two lines
3545 sub collect_from_file {
3546 my $filename = shift;
3547 my $line_concat_cond_re = shift;
3548 my $line_concat = shift;
3550 open my $fh, $filename || die "unable to read $filename: $!\n";
3552 my $saved_line = "";
3556 if (defined $line_concat) {
3557 $_ = $line_concat->($saved_line, $_);
3560 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3566 die "$filename ending with continuation line\n" if $_;
3572 # collect_from_array($array, $line_concat_cond_re, $line_concat)
3573 # $array is an ARRAYref of lines
3574 # $line_concat_cond_re is a regexp detecting a line continuation ending
3575 # $line_concat is a CODEref that takes care of concatenating two lines
3576 sub collect_from_array {
3578 my $line_concat_cond_re = shift;
3579 my $line_concat = shift;
3580 my @array = (@$array);
3583 my $saved_line = "";
3585 while (defined($_ = shift @array)) {
3587 if (defined $line_concat) {
3588 $_ = $line_concat->($saved_line, $_);
3591 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3597 die "input text ending with continuation line\n" if $_;
3602 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3603 # $lineiterator is a CODEref that delivers one line at a time.
3604 # All following arguments are regex/CODEref pairs, where the regexp detects a
3605 # line and the CODEref does something with the result of the regexp.
3606 sub collect_information {
3607 my $lineiterator = shift;
3608 my %collectors = @_;
3610 while(defined($_ = $lineiterator->())) {
3613 if ($collectors{"BEFORE"}) {
3614 $collectors{"BEFORE"}->($_);
3616 foreach my $re (keys %collectors) {
3617 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
3618 $collectors{$re}->($lineiterator);
3622 if ($collectors{"OTHERWISE"}) {
3623 $collectors{"OTHERWISE"}->($lineiterator, $_)
3624 unless $found || !defined $collectors{"OTHERWISE"};
3626 if ($collectors{"AFTER"}) {
3627 $collectors{"AFTER"}->($_);
3633 # tokenize($line,$separator)
3634 # $line is a line of text to split up into tokens
3635 # $separator [optional] is a regular expression that separates the tokens,
3636 # the default being spaces. Do not use quotes of any kind as separators,
3637 # that will give undefined results.
3638 # Returns a list of tokens.
3640 # Tokens are divided by separator (spaces by default). If the tokens include
3641 # the separators, they have to be quoted with single or double quotes.
3642 # Double quotes inside a double quoted token must be escaped. Escaping is done
3644 # Basically, the same quoting rules apply for " and ' as in any
3647 my $line = my $debug_line = shift;
3648 my $separator = shift // qr|\s+|;
3651 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3652 print STDERR "DEBUG[tokenize]: \$separator = $separator\n";
3655 while ($line =~ s|^${separator}||, $line ne "") {
3658 $line =~ m/^(.*?)(${separator}|"|'|$)/;
3662 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3666 } elsif ($line =~ m/^'([^']*)'/) {
3671 push @result, $token;
3674 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3675 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3676 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";