3 # Copyright 2016-2019 The OpenSSL Project Authors. All Rights Reserved.
5 # Licensed under the OpenSSL license (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/;
19 use File::Path qw/mkpath/;
22 # see INSTALL for instructions.
24 my $orig_death_handler = $SIG{__DIE__};
25 $SIG{__DIE__} = \&death_handler;
27 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
31 # --config add the given configuration file, which will be read after
32 # any "Configurations*" files that are found in the same
33 # directory as this script.
34 # --prefix prefix for the OpenSSL installation, which includes the
35 # directories bin, lib, include, share/man, share/doc/openssl
36 # This becomes the value of INSTALLTOP in Makefile
37 # (Default: /usr/local)
38 # --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
39 # If it's a relative directory, it will be added on the directory
40 # given with --prefix.
41 # This becomes the value of OPENSSLDIR in Makefile and in C.
42 # (Default: PREFIX/ssl)
44 # --cross-compile-prefix Add specified prefix to binutils components.
46 # --api One of 0.9.8, 1.0.0 or 1.1.0. Do not compile support for
47 # interfaces deprecated as of the specified OpenSSL version.
49 # no-hw-xxx do not compile support for specific crypto hardware.
50 # Generic OpenSSL-style methods relating to this support
51 # are always compiled but return NULL if the hardware
52 # support isn't compiled.
53 # no-hw do not compile support for any crypto hardware.
54 # [no-]threads [don't] try to create a library that is suitable for
55 # multithreaded applications (default is "threads" if we
57 # [no-]shared [don't] try to create shared libraries when supported.
58 # [no-]pic [don't] try to build position independent code when supported.
59 # If disabled, it also disables shared and dynamic-engine.
60 # no-asm do not use assembler
61 # no-egd do not compile support for the entropy-gathering daemon APIs
62 # [no-]zlib [don't] compile support for zlib compression.
63 # zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
64 # library and will be loaded in run-time by the OpenSSL library.
65 # sctp include SCTP support
66 # enable-weak-ssl-ciphers
67 # Enable weak ciphers that are disabled by default.
68 # 386 generate 80386 code in assembly modules
69 # no-sse2 disables IA-32 SSE2 code in assembly modules, the above
70 # mentioned '386' option implies this one
71 # no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
72 # -<xxx> +<xxx> compiler options are passed through
73 # -static while -static is also a pass-through compiler option (and
74 # as such is limited to environments where it's actually
75 # meaningful), it triggers a number configuration options,
76 # namely no-pic, no-shared and no-threads. It is
77 # argued that the only reason to produce statically linked
78 # binaries (and in context it means executables linked with
79 # -static flag, and not just executables linked with static
80 # libcrypto.a) is to eliminate dependency on specific run-time,
81 # a.k.a. libc version. The mentioned config options are meant
82 # to achieve just that. Unfortunately on Linux it's impossible
83 # to eliminate the dependency completely for openssl executable
84 # because of getaddrinfo and gethostbyname calls, which can
85 # invoke dynamically loadable library facility anyway to meet
86 # the lookup requests. For this reason on Linux statically
87 # linked openssl executable has rather debugging value than
90 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
91 # provided to stack calls. Generates unique stack functions for
92 # each possible stack type.
93 # BN_LLONG use the type 'long long' in crypto/bn/bn.h
94 # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
95 # Following are set automatically by this script
97 # MD5_ASM use some extra md5 assembler,
98 # SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
99 # RMD160_ASM use some extra ripemd160 assembler,
100 # SHA256_ASM sha256_block is implemented in assembler
101 # SHA512_ASM sha512_block is implemented in assembler
102 # AES_ASM AES_[en|de]crypt is implemented in assembler
104 # Minimum warning options... any contributions to OpenSSL should at least get
107 # DEBUG_UNUSED enables __owur (warn unused result) checks.
108 # -DPEDANTIC complements -pedantic and is meant to mask code that
109 # is not strictly standard-compliant and/or implementation-specific,
110 # e.g. inline assembly, disregards to alignment requirements, such
111 # that -pedantic would complain about. Incidentally -DPEDANTIC has
112 # to be used even in sanitized builds, because sanitizer too is
113 # supposed to and does take notice of non-standard behaviour. Then
114 # -pedantic with pre-C9x compiler would also complain about 'long
115 # long' not being supported. As 64-bit algorithms are common now,
116 # it grew impossible to resolve this without sizeable additional
117 # code, so we just tell compiler to be pedantic about everything
118 # but 'long long' type.
120 my %gcc_devteam_warn = ();
122 my @common = qw( -DDEBUG_UNUSED
123 -DPEDANTIC -pedantic -Wno-long-long
126 -Wno-unused-parameter
127 -Wno-missing-field-initializers
135 %gcc_devteam_warn = (
136 CFLAGS => [ @common, qw( -Wmissing-prototypes
137 -Wstrict-prototypes ) ],
138 CXXFLAGS => [ @common ]
142 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
143 # TODO(openssl-team): fix problems and investigate if (at least) the
144 # following warnings can also be enabled:
146 # -Wunreachable-code -- no, too ugly/compiler-specific
147 # -Wlanguage-extension-token -- no, we use asm()
148 # -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
149 # -Wextended-offsetof -- no, needed in CMS ASN1 code
150 my %clang_devteam_warn = ();
152 my @common = qw( -Wswitch-default
153 -Wno-parentheses-equality
154 -Wno-language-extension-token
155 -Wno-extended-offsetof
156 -Wconditional-uninitialized
157 -Wincompatible-pointer-types-discards-qualifiers
158 -Wno-unknown-warning-option );
159 %clang_devteam_warn = (
160 CFLAGS => [ @common, qw( -Wmissing-variable-declarations ) ],
161 CXXFLAGS => [ @common ]
165 # This adds backtrace information to the memory leak info. Is only used
166 # when crypto-mdebug-backtrace is enabled.
167 my $memleak_devteam_backtrace = "-rdynamic";
169 my $strict_warnings = 0;
171 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
172 # which would cover all BSD flavors. -pthread applies to them all,
173 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
174 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
175 # which has to be accompanied by explicit -D_THREAD_SAFE and
176 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
177 # seems to be sufficient?
178 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
181 # API compatibility name to version number mapping.
183 my $maxapi = "1.1.0"; # API for "no-deprecated" builds
185 "1.1.0" => "0x10100000L",
186 "1.0.0" => "0x10000000L",
187 "0.9.8" => "0x00908000L",
193 our $now_printing; # set to current entry's name in print_table_entry
194 # (todo: right thing would be to encapsulate name
195 # into %target [class] and make print_table_entry
198 # Forward declarations ###############################################
200 # read_config(filename)
202 # Reads a configuration file and populates %table with the contents
203 # (which the configuration file places in %targets).
206 # resolve_config(target)
208 # Resolves all the late evaluations, inheritances and so on for the
209 # chosen target and any target it inherits from.
213 # Information collection #############################################
215 # Unified build supports separate build dir
216 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
217 my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
218 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
220 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
222 $config{sourcedir} = abs2rel($srcdir);
223 $config{builddir} = abs2rel($blddir);
225 # Collect reconfiguration information if needed
228 if (grep /^reconf(igure)?$/, @argvcopy) {
229 die "reconfiguring with other arguments present isn't supported"
230 if scalar @argvcopy > 1;
231 if (-f "./configdata.pm") {
232 my $file = "./configdata.pm";
233 unless (my $return = do $file) {
234 die "couldn't parse $file: $@" if $@;
235 die "couldn't do $file: $!" unless defined $return;
236 die "couldn't run $file" unless $return;
239 @argvcopy = defined($configdata::config{perlargv}) ?
240 @{$configdata::config{perlargv}} : ();
241 die "Incorrect data to reconfigure, please do a normal configuration\n"
242 if (grep(/^reconf/,@argvcopy));
243 $config{perlenv} = $configdata::config{perlenv} // {};
245 die "Insufficient data to reconfigure, please do a normal configuration\n";
249 $config{perlargv} = [ @argvcopy ];
251 # Collect version numbers
252 $config{version} = "unknown";
253 $config{version_num} = "unknown";
254 $config{shlib_version_number} = "unknown";
255 $config{shlib_version_history} = "unknown";
258 collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
259 qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
260 qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 },
261 qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 },
262 qr/SHLIB_VERSION_HISTORY *"([^"]*)"/ => sub { $config{shlib_version_history}=$1 }
264 if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
266 ($config{major}, $config{minor})
267 = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
268 ($config{shlib_major}, $config{shlib_minor})
269 = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
270 die "erroneous version information in opensslv.h: ",
271 "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
272 if ($config{major} eq "" || $config{minor} eq ""
273 || $config{shlib_major} eq "" || $config{shlib_minor} eq "");
275 # Collect target configurations
277 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
278 foreach (sort glob($pattern)) {
282 if (defined env($local_config_envname)) {
284 # VMS environment variables are logical names,
285 # which can be used as is
286 $pattern = $local_config_envname . ':' . '*.conf';
288 $pattern = catfile(env($local_config_envname), '*.conf');
291 foreach (sort glob($pattern)) {
296 # Save away perl command information
297 $config{perl_cmd} = $^X;
298 $config{perl_version} = $Config{version};
299 $config{perl_archname} = $Config{archname};
302 $config{openssldir}="";
303 $config{processor}="";
305 my $auto_threads=1; # enable threads automatically? true by default
308 # Top level directories to build
309 $config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "util", "tools", "fuzz" ];
310 # crypto/ subdirectories to build
313 "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2", "siphash", "sm3",
314 "des", "aes", "rc2", "rc4", "rc5", "idea", "aria", "bf", "cast", "camellia", "seed", "sm4", "chacha", "modes",
315 "bn", "ec", "rsa", "dsa", "dh", "sm2", "dso", "engine",
316 "buffer", "bio", "stack", "lhash", "rand", "err",
317 "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
318 "cms", "ts", "srp", "cmac", "ct", "async", "kdf", "store"
320 # test/ subdirectories to build
321 $config{tdirs} = [ "ossl_shim" ];
323 # Known TLS and DTLS protocols
324 my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
325 my @dtls = qw(dtls1 dtls1_2);
327 # Explicitly known options that are possible to disable. They can
328 # be regexps, and will be used like this: /^no-${option}$/
329 # For developers: keep it sorted alphabetically
350 "crypto-mdebug-backtrace",
364 "ec_nistp_64_gcc_128",
424 foreach my $proto ((@tls, @dtls))
426 push(@disablables, $proto);
427 push(@disablables, "$proto-method") unless $proto eq "tls1_3";
430 my %deprecated_disablables = (
432 "buf-freelists" => undef,
433 "ripemd" => "rmd160",
434 "ui" => "ui-console",
435 "dso" => "", # Empty string means we're silent about it
438 # All of the following are disabled by default:
440 our %disabled = ( # "what" => "comment"
442 "crypto-mdebug" => "default",
443 "crypto-mdebug-backtrace" => "default",
444 "devcryptoeng" => "default",
445 "ec_nistp_64_gcc_128" => "default",
447 "external-tests" => "default",
448 "fuzz-libfuzzer" => "default",
449 "fuzz-afl" => "default",
450 "heartbeats" => "default",
455 "ssl-trace" => "default",
457 "ssl3-method" => "default",
458 "ubsan" => "default",
459 "unit-test" => "default",
460 "weak-ssl-ciphers" => "default",
462 "zlib-dynamic" => "default",
465 # Note: => pair form used for aesthetics, not to truly make a hash table
466 my @disable_cascades = (
467 # "what" => [ "cascade", ... ]
468 sub { $config{processor} eq "386" }
471 "ssl3-method" => [ "ssl3" ],
472 "zlib" => [ "zlib-dynamic" ],
474 "ec" => [ "ecdsa", "ecdh" ],
476 "dgram" => [ "dtls", "sctp" ],
477 "sock" => [ "dgram" ],
479 sub { 0 == scalar grep { !$disabled{$_} } @dtls }
483 sub { 0 == scalar grep { !$disabled{$_} } @tls }
486 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
488 # Without position independent code, there can be no shared libraries or DSOs
489 "pic" => [ "shared" ],
490 "shared" => [ "dynamic-engine" ],
491 "engine" => [ "afalgeng", "devcryptoeng" ],
493 # no-autoalginit is only useful when building non-shared
494 "autoalginit" => [ "shared", "apps" ],
496 "stdio" => [ "apps", "capieng", "egd" ],
497 "apps" => [ "tests" ],
498 "tests" => [ "external-tests" ],
499 "comp" => [ "zlib" ],
500 "ec" => [ "tls1_3", "sm2" ],
502 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
504 sub { !$disabled{"msan"} } => [ "asm" ],
507 # Avoid protocol support holes. Also disable all versions below N, if version
508 # N is disabled while N+1 is enabled.
510 my @list = (reverse @tls);
511 while ((my $first, my $second) = (shift @list, shift @list)) {
513 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
515 unshift @list, $second;
517 my @list = (reverse @dtls);
518 while ((my $first, my $second) = (shift @list, shift @list)) {
520 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
522 unshift @list, $second;
525 # Explicit "no-..." options will be collected in %disabled along with the defaults.
526 # To remove something from %disabled, use "enable-foo".
527 # For symmetry, "disable-foo" is a synonym for "no-foo".
529 &usage if ($#ARGV < 0);
531 # For the "make variables" CINCLUDES and CDEFINES, we support lists with
532 # platform specific list separators. Users from those platforms should
533 # recognise those separators from how you set up the PATH to find executables.
534 # The default is the Unix like separator, :, but as an exception, we also
535 # support the space as separator.
536 my $list_separator_re =
537 { VMS => qr/(?<!\^),/,
538 MSWin32 => qr/(?<!\\);/ } -> {$^O} // qr/(?<!\\)[:\s]/;
539 # All the "make variables" we support
540 # Some get pre-populated for the sake of backward compatibility
541 # (we supported those before the change to "make variable" support.
548 CFLAGS => [ env('CFLAGS') || () ],
550 CXXFLAGS => [ env('CXXFLAGS') || () ],
552 CPPFLAGS => [ env('CPPFLAGS') || () ], # -D, -I, -Wp,
553 CPPDEFINES => [], # Alternative for -D
554 CPPINCLUDES => [], # Alternative for -I
555 CROSS_COMPILE => env('CROSS_COMPILE'),
556 HASHBANGPERL=> env('HASHBANGPERL') || env('PERL'),
558 LDFLAGS => [ env('LDFLAGS') || () ], # -L, -Wl,
559 LDLIBS => [ env('LDLIBS') || () ], # -l
562 PERL => env('PERL') || ($^O ne "VMS" ? $^X : "perl"),
563 RANLIB => env('RANLIB'),
564 RC => env('RC') || env('WINDRES'),
568 # Info about what "make variables" may be prefixed with the cross compiler
569 # prefix. This should NEVER mention any such variable with a list for value.
570 my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
571 # The same but for flags given as Configure options. These are *additional*
572 # input, as opposed to the VAR=string option that override the corresponding
573 # config target attributes
584 my %user_synonyms = (
585 HASHBANGPERL=> 'PERL',
589 # Some target attributes have been renamed, this is the translation table
590 my %target_attr_translate =(
596 hashbangperl => 'HASHBANGPERL',
604 # Initialisers coming from 'config' scripts
605 $config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ];
606 $config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ];
607 $config{cppflags} = [ env('__CNF_CPPFLAGS') || () ];
608 $config{cflags} = [ env('__CNF_CFLAGS') || () ];
609 $config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ];
610 $config{lflags} = [ env('__CNF_LDFLAGS') || () ];
611 $config{ex_libs} = [ env('__CNF_LDLIBS') || () ];
613 $config{openssl_api_defines}=[];
614 $config{openssl_algorithm_defines}=[];
615 $config{openssl_thread_defines}=[];
616 $config{openssl_sys_defines}=[];
617 $config{openssl_other_defines}=[];
619 $config{build_type} = "release";
622 my %cmdvars = (); # Stores FOO='blah' type arguments
623 my %unsupported_options = ();
624 my %deprecated_options = ();
625 # If you change this, update apps/version.c
626 my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
627 my @seed_sources = ();
630 $_ = shift @argvcopy;
632 # Support env variable assignments among the options
633 if (m|^(\w+)=(.+)?$|)
636 # Every time a variable is given as a configuration argument,
637 # it acts as a reset if the variable.
638 if (exists $user{$1})
640 $user{$1} = ref $user{$1} eq "ARRAY" ? [] : undef;
642 #if (exists $useradd{$1})
649 # VMS is a case insensitive environment, and depending on settings
650 # out of our control, we may receive options uppercased. Let's
651 # downcase at least the part before any equal sign.
657 # some people just can't read the instructions, clang people have to...
658 s/^-no-(?!integrated-as)/no-/;
660 # rewrite some options in "enable-..." form
661 s /^-?-?shared$/enable-shared/;
662 s /^sctp$/enable-sctp/;
663 s /^threads$/enable-threads/;
664 s /^zlib$/enable-zlib/;
665 s /^zlib-dynamic$/enable-zlib-dynamic/;
667 if (/^(no|disable|enable)-(.+)$/)
670 if (!exists $deprecated_disablables{$word}
671 && !grep { $word =~ /^${_}$/ } @disablables)
673 $unsupported_options{$_} = 1;
677 if (/^no-(.+)$/ || /^disable-(.+)$/)
679 foreach my $proto ((@tls, @dtls))
681 if ($1 eq "$proto-method")
683 $disabled{"$proto"} = "option($proto-method)";
689 foreach my $proto (@dtls)
691 $disabled{$proto} = "option(dtls)";
693 $disabled{"dtls"} = "option(dtls)";
697 # Last one of its kind
698 $disabled{"ssl3"} = "option(ssl)";
702 # XXX: Tests will fail if all SSL/TLS
703 # protocols are disabled.
704 foreach my $proto (@tls)
706 $disabled{$proto} = "option(tls)";
709 elsif ($1 eq "static-engine")
711 delete $disabled{"dynamic-engine"};
713 elsif ($1 eq "dynamic-engine")
715 $disabled{"dynamic-engine"} = "option";
717 elsif (exists $deprecated_disablables{$1})
719 if ($deprecated_disablables{$1} ne "")
721 $deprecated_options{$_} = 1;
722 if (defined $deprecated_disablables{$1})
724 $disabled{$deprecated_disablables{$1}} = "option";
730 $disabled{$1} = "option";
732 # No longer an automatic choice
733 $auto_threads = 0 if ($1 eq "threads");
735 elsif (/^enable-(.+)$/)
737 if ($1 eq "static-engine")
739 $disabled{"dynamic-engine"} = "option";
741 elsif ($1 eq "dynamic-engine")
743 delete $disabled{"dynamic-engine"};
745 elsif ($1 eq "zlib-dynamic")
747 delete $disabled{"zlib"};
750 delete $disabled{$algo};
752 # No longer an automatic choice
753 $auto_threads = 0 if ($1 eq "threads");
755 elsif (/^--strict-warnings$/)
757 # Pretend that our strict flags is a C flag, and replace it
758 # with the proper flags later on
759 push @{$useradd{CFLAGS}}, '--ossl-strict-warnings';
760 push @{$useradd{CXXFLAGS}}, '--ossl-strict-warnings';
765 $config{build_type} = "debug";
767 elsif (/^--release$/)
769 $config{build_type} = "release";
772 { $config{processor}=386; }
775 die "FIPS mode not supported\n";
779 # No RSAref support any more since it's not needed.
780 # The check for the option is there so scripts aren't
783 elsif (/^nofipscanistercheck$/)
785 die "FIPS mode not supported\n";
789 if (/^--prefix=(.*)$/)
792 die "Directory given with --prefix MUST be absolute\n"
793 unless file_name_is_absolute($config{prefix});
795 elsif (/^--api=(.*)$/)
799 elsif (/^--libdir=(.*)$/)
803 elsif (/^--openssldir=(.*)$/)
805 $config{openssldir}=$1;
807 elsif (/^--with-zlib-lib=(.*)$/)
809 $withargs{zlib_lib}=$1;
811 elsif (/^--with-zlib-include=(.*)$/)
813 $withargs{zlib_include}=$1;
815 elsif (/^--with-fuzzer-lib=(.*)$/)
817 $withargs{fuzzer_lib}=$1;
819 elsif (/^--with-fuzzer-include=(.*)$/)
821 $withargs{fuzzer_include}=$1;
823 elsif (/^--with-rand-seed=(.*)$/)
825 foreach my $x (split(m|,|, $1))
827 die "Unknown --with-rand-seed choice $x\n"
828 if ! grep { $x eq $_ } @known_seed_sources;
829 push @seed_sources, $x;
832 elsif (/^--cross-compile-prefix=(.*)$/)
834 $user{CROSS_COMPILE}=$1;
836 elsif (/^--config=(.*)$/)
842 push @{$useradd{LDLIBS}}, $_;
844 elsif (/^-framework$/)
846 push @{$useradd{LDLIBS}}, $_, shift(@argvcopy);
848 elsif (/^-L(.*)$/ or /^-Wl,/)
850 push @{$useradd{LDFLAGS}}, $_;
852 elsif (/^-rpath$/ or /^-R$/)
853 # -rpath is the OSF1 rpath flag
854 # -R is the old Solaris rpath flag
856 my $rpath = shift(@argvcopy) || "";
857 $rpath .= " " if $rpath ne "";
858 push @{$useradd{LDFLAGS}}, $_, $rpath;
862 push @{$useradd{LDFLAGS}}, $_;
866 push @{$useradd{CPPDEFINES}}, $1;
870 push @{$useradd{CPPINCLUDES}}, $1;
874 push @{$useradd{CPPFLAGS}}, $1;
876 else # common if (/^[-+]/), just pass down...
878 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
879 push @{$useradd{CFLAGS}}, $_;
880 push @{$useradd{CXXFLAGS}}, $_;
885 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
888 unless ($_ eq $target || /^no-/ || /^disable-/)
890 # "no-..." follows later after implied deactivations
891 # have been derived. (Don't take this too seriously,
892 # we really only write OPTIONS to the Makefile out of
895 if ($config{options} eq "")
896 { $config{options} = $_; }
898 { $config{options} .= " ".$_; }
902 if (defined($config{api}) && !exists $apitable->{$config{api}}) {
903 die "***** Unsupported api compatibility level: $config{api}\n",
906 if (keys %deprecated_options)
908 warn "***** Deprecated options: ",
909 join(", ", keys %deprecated_options), "\n";
911 if (keys %unsupported_options)
913 die "***** Unsupported options: ",
914 join(", ", keys %unsupported_options), "\n";
917 # If any %useradd entry has been set, we must check that the "make
918 # variables" haven't been set. We start by checking of any %useradd entry
920 if (grep { scalar @$_ > 0 } values %useradd) {
921 # Hash of env / make variables names. The possible values are:
923 # 2 - %useradd entry set
927 $v += 1 if $cmdvars{$_};
928 $v += 2 if @{$useradd{$_}};
932 # If any of the corresponding "make variables" is set, we error
933 if (grep { $_ & 1 } values %detected_vars) {
934 my $names = join(', ', grep { $detected_vars{$_} > 0 }
935 sort keys %detected_vars);
937 ***** Mixing make variables and additional compiler/linker flags as
938 ***** configure command line option is not permitted.
939 ***** Affected make variables: $names
944 # Check through all supported command line variables to see if any of them
945 # were set, and canonicalise the values we got. If no compiler or linker
946 # flag or anything else that affects %useradd was set, we also check the
947 # environment for values.
949 grep { defined $_ && (ref $_ ne 'ARRAY' || @$_) } values %useradd;
950 foreach (keys %user) {
951 my $value = $cmdvars{$_};
952 $value //= env($_) unless $anyuseradd;
954 defined $user_synonyms{$_} ? $cmdvars{$user_synonyms{$_}} : undef;
955 $value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef
958 if (defined $value) {
959 if (ref $user{$_} eq 'ARRAY') {
960 $user{$_} = [ split /$list_separator_re/, $value ];
961 } elsif (!defined $user{$_}) {
967 if (grep { /-rpath\b/ } ($user{LDFLAGS} ? @{$user{LDFLAGS}} : ())
968 && !$disabled{shared}
969 && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
970 die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
971 "***** any of asan, msan or ubsan\n";
974 my @tocheckfor = (keys %disabled);
975 while (@tocheckfor) {
976 my %new_tocheckfor = ();
977 my @cascade_copy = (@disable_cascades);
978 while (@cascade_copy) {
979 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
980 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
981 foreach(grep { !defined($disabled{$_}) } @$descendents) {
982 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
986 @tocheckfor = (keys %new_tocheckfor);
989 our $die = sub { die @_; };
990 if ($target eq "TABLE") {
991 local $die = sub { warn @_; };
992 foreach (sort keys %table) {
993 print_table_entry($_, "TABLE");
998 if ($target eq "LIST") {
999 foreach (sort keys %table) {
1000 print $_,"\n" unless $table{$_}->{template};
1005 if ($target eq "HASH") {
1006 local $die = sub { warn @_; };
1007 print "%table = (\n";
1008 foreach (sort keys %table) {
1009 print_table_entry($_, "HASH");
1014 print "Configuring OpenSSL version $config{version} ($config{version_num}) ";
1015 print "for $target\n";
1017 if (scalar(@seed_sources) == 0) {
1018 print "Using os-specific seed configuration\n";
1019 push @seed_sources, 'os';
1021 if (scalar(grep { $_ eq 'none' } @seed_sources) > 0) {
1022 die "Cannot seed with none and anything else" if scalar(@seed_sources) > 1;
1023 warn <<_____ if scalar(@seed_sources) == 1;
1025 ============================== WARNING ===============================
1026 You have selected the --with-rand-seed=none option, which effectively
1027 disables automatic reseeding of the OpenSSL random generator.
1028 All operations depending on the random generator such as creating keys
1029 will not work unless the random generator is seeded manually by the
1032 Please read the 'Note on random number generation' section in the
1033 INSTALL instructions and the RAND_DRBG(7) manual page for more details.
1034 ============================== WARNING ===============================
1038 push @{$config{openssl_other_defines}},
1039 map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
1042 # Backward compatibility?
1043 if ($target =~ m/^CygWin32(-.*)$/) {
1044 $target = "Cygwin".$1;
1047 # Support for legacy targets having a name starting with 'debug-'
1048 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1050 $config{build_type} = "debug";
1052 # If we do not find debug-foo in the table, the target is set to foo.
1053 if (!$table{$target}) {
1058 &usage if !$table{$target} || $table{$target}->{template};
1060 $config{target} = $target;
1061 my %target = resolve_config($target);
1063 foreach (keys %target_attr_translate) {
1064 $target{$target_attr_translate{$_}} = $target{$_}
1069 %target = ( %{$table{DEFAULTS}}, %target );
1071 # Make the flags to build DSOs the same as for shared libraries unless they
1072 # are already defined
1073 $target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
1074 $target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
1075 $target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
1077 my $shared_info_pl =
1078 catfile(dirname($0), "Configurations", "shared-info.pl");
1079 my %shared_info = read_eval_file($shared_info_pl);
1080 push @{$target{_conf_fname_int}}, $shared_info_pl;
1081 my $si = $target{shared_target};
1082 while (ref $si ne "HASH") {
1083 last if ! defined $si;
1084 if (ref $si eq "CODE") {
1087 $si = $shared_info{$si};
1091 # Some of the 'shared_target' values don't have any entried in
1092 # %shared_info. That's perfectly fine, AS LONG AS the build file
1093 # template knows how to handle this. That is currently the case for
1096 # Just as above, copy certain shared_* attributes to the corresponding
1097 # module_ attribute unless the latter is already defined
1098 $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
1099 $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
1100 $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
1101 foreach (sort keys %$si) {
1102 $target{$_} = defined $target{$_}
1103 ? add($si->{$_})->($target{$_})
1109 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
1110 $config{conf_files} = [ sort keys %conf_files ];
1112 foreach my $feature (@{$target{disable}}) {
1113 if (exists $deprecated_disablables{$feature}) {
1114 warn "***** config $target disables deprecated feature $feature\n";
1115 } elsif (!grep { $feature eq $_ } @disablables) {
1116 die "***** config $target disables unknown feature $feature\n";
1118 $disabled{$feature} = 'config';
1120 foreach my $feature (@{$target{enable}}) {
1121 if ("default" eq ($disabled{$feature} // "")) {
1122 if (exists $deprecated_disablables{$feature}) {
1123 warn "***** config $target enables deprecated feature $feature\n";
1124 } elsif (!grep { $feature eq $_ } @disablables) {
1125 die "***** config $target enables unknown feature $feature\n";
1127 delete $disabled{$feature};
1131 $target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
1132 $target{cxxflags}//=$target{cflags} if $target{CXX};
1133 $target{exe_extension}="";
1134 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
1135 || $config{target} =~ /^(?:Cygwin|mingw)/);
1136 $target{exe_extension}=".pm" if ($config{target} =~ /vos/);
1138 ($target{shared_extension_simple}=$target{shared_extension})
1139 =~ s|\.\$\(SHLIB_VERSION_NUMBER\)||
1140 unless defined($target{shared_extension_simple});
1141 $target{dso_extension}//=$target{shared_extension_simple};
1142 ($target{shared_import_extension}=$target{shared_extension_simple}.".a")
1143 if ($config{target} =~ /^(?:Cygwin|mingw)/);
1145 # Fill %config with values from %user, and in case those are undefined or
1146 # empty, use values from %target (acting as a default).
1147 foreach (keys %user) {
1148 my $ref_type = ref $user{$_};
1150 # Temporary function. Takes an intended ref type (empty string or "ARRAY")
1151 # and a value that's to be coerced into that type.
1155 my $undef_p = shift;
1157 die "Too many arguments for \$mkvalue" if @_;
1159 while (ref $value eq 'CODE') {
1160 $value = $value->();
1163 if ($type eq 'ARRAY') {
1164 return undef unless defined $value;
1165 return undef if ref $value ne 'ARRAY' && !$value;
1166 return undef if ref $value eq 'ARRAY' && !@$value;
1167 return [ $value ] unless ref $value eq 'ARRAY';
1169 return undef unless $value;
1174 $mkvalue->($ref_type, $user{$_})
1175 || $mkvalue->($ref_type, $target{$_});
1176 delete $config{$_} unless defined $config{$_};
1179 # Finish up %config by appending things the user gave us on the command line
1180 # apart from "make variables"
1181 foreach (keys %useradd) {
1182 # The must all be lists, so we assert that here
1183 die "internal error: \$useradd{$_} isn't an ARRAY\n"
1184 unless ref $useradd{$_} eq 'ARRAY';
1186 if (defined $config{$_}) {
1187 push @{$config{$_}}, @{$useradd{$_}};
1189 $config{$_} = [ @{$useradd{$_}} ];
1192 # At this point, we can forget everything about %user and %useradd,
1193 # because it's now all been merged into the corresponding $config entry
1195 # Allow overriding the build file name
1196 $config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
1198 my %disabled_info = (); # For configdata.pm
1199 foreach my $what (sort keys %disabled) {
1200 $config{options} .= " no-$what";
1202 if (!grep { $what eq $_ } ( 'threads', 'shared', 'pic',
1203 'dynamic-engine', 'makedepend',
1204 'zlib-dynamic', 'zlib', 'sse2' )) {
1205 (my $WHAT = uc $what) =~ s|-|_|g;
1207 # Fix up C macro end names
1208 $WHAT = "RMD160" if $what eq "ripemd";
1210 # fix-up crypto/directory name(s)
1211 $what = "ripemd" if $what eq "rmd160";
1212 $what = "whrlpool" if $what eq "whirlpool";
1214 my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
1216 if ((grep { $what eq $_ } @{$config{sdirs}})
1217 && $what ne 'async' && $what ne 'err') {
1218 @{$config{sdirs}} = grep { $what ne $_} @{$config{sdirs}};
1219 $disabled_info{$what}->{skipped} = [ catdir('crypto', $what) ];
1221 if ($what ne 'engine') {
1222 push @{$config{openssl_algorithm_defines}}, $macro;
1224 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
1225 push @{$disabled_info{engine}->{skipped}}, catdir('engines');
1226 push @{$config{openssl_other_defines}}, $macro;
1229 push @{$config{openssl_other_defines}}, $macro;
1235 # Make sure build_scheme is consistent.
1236 $target{build_scheme} = [ $target{build_scheme} ]
1237 if ref($target{build_scheme}) ne "ARRAY";
1239 my ($builder, $builder_platform, @builder_opts) =
1240 @{$target{build_scheme}};
1242 foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
1243 $builder_platform."-checker.pm")) {
1244 my $checker_path = catfile($srcdir, "Configurations", $checker);
1245 if (-f $checker_path) {
1246 my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1247 ? sub { warn $@; } : sub { die $@; };
1248 if (! do $checker_path) {
1254 $fn->("The detected tools didn't match the platform\n");
1261 push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
1263 if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
1265 push @{$config{cflags}}, "-mno-cygwin";
1266 push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
1267 push @{$config{shared_ldflag}}, "-mno-cygwin";
1270 if ($target =~ /linux.*-mips/ && !$disabled{asm}
1271 && !grep { $_ !~ /-m(ips|arch=)/ } (@{$config{CFLAGS}})) {
1272 # minimally required architecture flags for assembly modules
1274 $value = '-mips2' if ($target =~ /mips32/);
1275 $value = '-mips3' if ($target =~ /mips64/);
1276 unshift @{$config{cflags}}, $value;
1277 unshift @{$config{cxxflags}}, $value if $config{CXX};
1280 # If threads aren't disabled, check how possible they are
1281 unless ($disabled{threads}) {
1282 if ($auto_threads) {
1283 # Enabled by default, disable it forcibly if unavailable
1284 if ($target{thread_scheme} eq "(unknown)") {
1285 $disabled{threads} = "unavailable";
1288 # The user chose to enable threads explicitly, let's see
1289 # if there's a chance that's possible
1290 if ($target{thread_scheme} eq "(unknown)") {
1291 # If the user asked for "threads" and we don't have internal
1292 # knowledge how to do it, [s]he is expected to provide any
1293 # system-dependent compiler options that are necessary. We
1294 # can't truly check that the given options are correct, but
1295 # we expect the user to know what [s]He is doing.
1296 if (!@{$config{CFLAGS}} && !@{$config{CPPDEFINES}}) {
1297 die "You asked for multi-threading support, but didn't\n"
1298 ,"provide any system-specific compiler options\n";
1304 # If threads still aren't disabled, add a C macro to ensure the source
1305 # code knows about it. Any other flag is taken care of by the configs.
1306 unless($disabled{threads}) {
1307 push @{$config{openssl_thread_defines}}, "OPENSSL_THREADS";
1310 # With "deprecated" disable all deprecated features.
1311 if (defined($disabled{"deprecated"})) {
1312 $config{api} = $maxapi;
1315 my $no_shared_warn=0;
1316 if ($target{shared_target} eq "")
1319 if (!$disabled{shared} || !$disabled{"dynamic-engine"});
1320 $disabled{shared} = "no-shared-target";
1321 $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1325 if ($disabled{"dynamic-engine"}) {
1326 push @{$config{openssl_other_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1327 $config{dynamic_engines} = 0;
1329 push @{$config{openssl_other_defines}}, "OPENSSL_NO_STATIC_ENGINE";
1330 $config{dynamic_engines} = 1;
1333 unless ($disabled{asan}) {
1334 push @{$config{cflags}}, "-fsanitize=address";
1335 push @{$config{cxxflags}}, "-fsanitize=address" if $config{CXX};
1338 unless ($disabled{ubsan}) {
1339 # -DPEDANTIC or -fnosanitize=alignment may also be required on some
1341 push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all";
1342 push @{$config{cxxflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all"
1346 unless ($disabled{msan}) {
1347 push @{$config{cflags}}, "-fsanitize=memory";
1348 push @{$config{cxxflags}}, "-fsanitize=memory" if $config{CXX};
1351 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1352 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1353 push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
1354 push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
1360 # This saves the build files from having to check
1363 foreach (qw(shared_cflag shared_cxxflag shared_cppflag
1364 shared_defines shared_includes shared_ldflag
1365 module_cflags module_cxxflags module_cppflags
1366 module_defines module_includes module_lflags))
1374 push @{$config{lib_defines}}, "OPENSSL_PIC";
1377 if ($target{sys_id} ne "")
1379 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1382 unless ($disabled{asm}) {
1383 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
1384 push @{$config{lib_defines}}, "OPENSSL_CPUID_OBJ" if ($target{cpuid_asm_src} ne "mem_clr.c");
1386 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1388 # bn-586 is the only one implementing bn_*_part_words
1389 push @{$config{lib_defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1390 push @{$config{lib_defines}}, "OPENSSL_IA32_SSE2" if (!$disabled{sse2} && $target{bn_asm_src} =~ /86/);
1392 push @{$config{lib_defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1393 push @{$config{lib_defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1394 push @{$config{lib_defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1395 push @{$config{lib_defines}}, "BN_DIV3W" if ($target{bn_asm_src} =~ /-div3w/);
1397 if ($target{sha1_asm_src}) {
1398 push @{$config{lib_defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1399 push @{$config{lib_defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1400 push @{$config{lib_defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1402 if ($target{keccak1600_asm_src} ne $table{DEFAULTS}->{keccak1600_asm_src}) {
1403 push @{$config{lib_defines}}, "KECCAK1600_ASM";
1405 if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
1406 push @{$config{lib_defines}}, "RC4_ASM";
1408 if ($target{md5_asm_src}) {
1409 push @{$config{lib_defines}}, "MD5_ASM";
1411 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1412 if ($target{rmd160_asm_src}) {
1413 push @{$config{lib_defines}}, "RMD160_ASM";
1415 if ($target{aes_asm_src}) {
1416 push @{$config{lib_defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1417 # aes-ctr.fake is not a real file, only indication that assembler
1418 # module implements AES_ctr32_encrypt...
1419 push @{$config{lib_defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1420 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1421 push @{$config{lib_defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1422 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($disabled{sse2});
1423 push @{$config{lib_defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1424 push @{$config{lib_defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1426 if ($target{wp_asm_src} =~ /mmx/) {
1427 if ($config{processor} eq "386") {
1428 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1429 } elsif (!$disabled{"whirlpool"}) {
1430 push @{$config{lib_defines}}, "WHIRLPOOL_ASM";
1433 if ($target{modes_asm_src} =~ /ghash-/) {
1434 push @{$config{lib_defines}}, "GHASH_ASM";
1436 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1437 push @{$config{lib_defines}}, "ECP_NISTZ256_ASM";
1439 if ($target{ec_asm_src} =~ /x25519/) {
1440 push @{$config{lib_defines}}, "X25519_ASM";
1442 if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
1443 push @{$config{dso_defines}}, "PADLOCK_ASM";
1445 if ($target{poly1305_asm_src} ne "") {
1446 push @{$config{lib_defines}}, "POLY1305_ASM";
1450 my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
1451 my %predefined_CXX = $config{CXX}
1452 ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
1455 # Check for makedepend capabilities.
1456 if (!$disabled{makedepend}) {
1457 if ($config{target} =~ /^(VC|vms)-/) {
1458 # For VC- and vms- targets, there's nothing more to do here. The
1459 # functionality is hard coded in the corresponding build files for
1460 # cl (Windows) and CC/DECC (VMS).
1461 } elsif (($predefined_C{__GNUC__} // -1) >= 3
1462 && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
1463 # We know that GNU C version 3 and up as well as all clang
1464 # versions support dependency generation, but Xcode did not
1465 # handle $cc -M before clang support (but claims __GNUC__ = 3)
1466 $config{makedepprog} = "\$(CROSS_COMPILE)$config{CC}";
1468 # In all other cases, we look for 'makedepend', and disable the
1469 # capability if not found.
1470 $config{makedepprog} = which('makedepend');
1471 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
1475 if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
1476 # probe for -Wa,--noexecstack option...
1477 if ($predefined_C{__clang__}) {
1478 # clang has builtin assembler, which doesn't recognize --help,
1479 # but it apparently recognizes the option in question on all
1480 # supported platforms even when it's meaningless. In other words
1481 # probe would fail, but probed option always accepted...
1482 push @{$config{cflags}}, "-Wa,--noexecstack", "-Qunused-arguments";
1484 my $cc = $config{CROSS_COMPILE}.$config{CC};
1485 open(PIPE, "$cc -Wa,--help -c -o null.$$.o -x assembler /dev/null 2>&1 |");
1487 if (m/--noexecstack/) {
1488 push @{$config{cflags}}, "-Wa,--noexecstack";
1493 unlink("null.$$.o");
1497 # Deal with bn_ops ###################################################
1500 $config{export_var_as_fn} =0;
1501 my $def_int="unsigned int";
1502 $config{rc4_int} =$def_int;
1503 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1506 foreach (sort split(/\s+/,$target{bn_ops})) {
1507 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1508 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1509 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1510 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1511 ($config{b64l},$config{b64},$config{b32})
1512 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1513 ($config{b64l},$config{b64},$config{b32})
1514 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1515 ($config{b64l},$config{b64},$config{b32})
1516 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
1518 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1522 # Hack cflags for better warnings (dev option) #######################
1524 # "Stringify" the C and C++ flags string. This permits it to be made part of
1525 # a string and works as well on command lines.
1526 $config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1527 @{$config{cflags}} ];
1528 $config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1529 @{$config{cxxflags}} ] if $config{CXX};
1531 if (defined($config{api})) {
1532 $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1533 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1534 push @{$config{defines}}, $apiflag;
1537 my %strict_warnings_collection=( CFLAGS => [], CXXFLAGS => []);
1538 if ($strict_warnings)
1541 my $gccver = $predefined_C{__GNUC__} // -1;
1542 my $gxxver = $predefined_CXX{__GNUC__} // -1;
1544 warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike"
1545 unless $gccver >= 4;
1546 warn "WARNING --strict-warnings requires g++[>=4] or g++-alike"
1547 unless $gxxver >= 4;
1548 foreach (qw(CFLAGS CXXFLAGS))
1550 push @{$strict_warnings_collection{$_}},
1551 @{$gcc_devteam_warn{$_}};
1553 push @{$strict_warnings_collection{CFLAGS}},
1554 @{$clang_devteam_warn{CFLAGS}}
1555 if (defined($predefined_C{__clang__}));
1556 push @{$strict_warnings_collection{CXXFLAGS}},
1557 @{$clang_devteam_warn{CXXFLAGS}}
1558 if (defined($predefined_CXX{__clang__}));
1561 if (grep { $_ eq '-static' } @{$config{LDFLAGS}}) {
1562 $disabled{"pic"} = "forced";
1563 $disabled{"shared"} = "forced";
1564 $disabled{"threads"} = "forced";
1567 foreach my $idx (qw(CFLAGS CXXFLAGS))
1569 $config{$idx} = [ map { $_ eq '--ossl-strict-warnings'
1570 ? @{$strict_warnings_collection{$idx}}
1575 unless ($disabled{"crypto-mdebug-backtrace"})
1577 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1579 push @{$config{cflags}}, $wopt
1580 unless grep { $_ eq $wopt } @{$config{cflags}};
1581 push @{$config{cxxflags}}, $wopt
1583 && !grep { $_ eq $wopt } @{$config{cxxflags}});
1585 if ($target =~ /^BSD-/)
1587 push @{$config{ex_libs}}, "-lexecinfo";
1591 unless ($disabled{afalgeng}) {
1592 $config{afalgeng}="";
1593 if (grep { $_ eq 'afalgeng' } @{$target{enable}}) {
1594 my $minver = 4*10000 + 1*100 + 0;
1595 if ($config{CROSS_COMPILE} eq "") {
1596 my $verstr = `uname -r`;
1597 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1598 ($mi2) = $mi2 =~ /(\d+)/;
1599 my $ver = $ma*10000 + $mi1*100 + $mi2;
1600 if ($ver < $minver) {
1601 $disabled{afalgeng} = "too-old-kernel";
1603 push @{$config{engdirs}}, "afalg";
1606 $disabled{afalgeng} = "cross-compiling";
1609 $disabled{afalgeng} = "not-linux";
1613 push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
1615 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1617 # If we use the unified build, collect information from build.info files
1618 my %unified_info = ();
1620 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1621 if ($builder eq "unified") {
1622 use with_fallback qw(Text::Template);
1627 my $relativeto = shift || ".";
1629 $dir = catdir($base,$dir) unless isabsolute($dir);
1631 # Make sure the directories we're building in exists
1634 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1635 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1642 my $relativeto = shift || ".";
1644 $file = catfile($base,$file) unless isabsolute($file);
1646 my $d = dirname($file);
1647 my $f = basename($file);
1649 # Make sure the directories we're building in exists
1652 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1653 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1657 # Store the name of the template file we will build the build file from
1658 # in %config. This may be useful for the build file itself.
1659 my @build_file_template_names =
1660 ( $builder_platform."-".$target{build_file}.".tmpl",
1661 $target{build_file}.".tmpl" );
1662 my @build_file_templates = ();
1664 # First, look in the user provided directory, if given
1665 if (defined env($local_config_envname)) {
1666 @build_file_templates =
1669 # VMS environment variables are logical names,
1670 # which can be used as is
1671 $local_config_envname . ':' . $_;
1673 catfile(env($local_config_envname), $_);
1676 @build_file_template_names;
1678 # Then, look in our standard directory
1679 push @build_file_templates,
1680 ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1681 @build_file_template_names );
1683 my $build_file_template;
1684 for $_ (@build_file_templates) {
1685 $build_file_template = $_;
1686 last if -f $build_file_template;
1688 $build_file_template = undef;
1690 if (!defined $build_file_template) {
1691 die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1693 $config{build_file_templates}
1694 = [ cleanfile($srcdir, catfile("Configurations", "common0.tmpl"),
1696 $build_file_template,
1697 cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1700 my @build_infos = ( [ ".", "build.info" ] );
1701 foreach (@{$config{dirs}}) {
1702 push @build_infos, [ $_, "build.info" ]
1703 if (-f catfile($srcdir, $_, "build.info"));
1705 foreach (@{$config{sdirs}}) {
1706 push @build_infos, [ catdir("crypto", $_), "build.info" ]
1707 if (-f catfile($srcdir, "crypto", $_, "build.info"));
1709 foreach (@{$config{engdirs}}) {
1710 push @build_infos, [ catdir("engines", $_), "build.info" ]
1711 if (-f catfile($srcdir, "engines", $_, "build.info"));
1713 foreach (@{$config{tdirs}}) {
1714 push @build_infos, [ catdir("test", $_), "build.info" ]
1715 if (-f catfile($srcdir, "test", $_, "build.info"));
1718 $config{build_infos} = [ ];
1721 foreach (@build_infos) {
1722 my $sourced = catdir($srcdir, $_->[0]);
1723 my $buildd = catdir($blddir, $_->[0]);
1728 # The basic things we're trying to build
1730 my @programs_install = ();
1732 my @libraries_install = ();
1734 my @engines_install = ();
1736 my @scripts_install = ();
1739 my @intermediates = ();
1743 my %shared_sources = ();
1747 my %sharednames = ();
1750 # We want to detect configdata.pm in the source tree, so we
1751 # don't use it if the build tree is different.
1752 my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir);
1754 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1756 Text::Template->new(TYPE => 'FILE',
1757 SOURCE => catfile($sourced, $f),
1758 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
1759 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1762 $template->fill_in(HASH => { config => \%config,
1764 disabled => \%disabled,
1765 withargs => \%withargs,
1766 builddir => abs2rel($buildd, $blddir),
1767 sourcedir => abs2rel($sourced, $blddir),
1768 buildtop => abs2rel($blddir, $blddir),
1769 sourcetop => abs2rel($srcdir, $blddir) },
1770 DELIMITERS => [ "{-", "-}" ]);
1772 # The top item of this stack has the following values
1773 # -2 positive already run and we found ELSE (following ELSIF should fail)
1774 # -1 positive already run (skip until ENDIF)
1775 # 0 negatives so far (if we're at a condition, check it)
1776 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1777 # 2 positive ELSE (following ELSIF should fail)
1779 collect_information(
1780 collect_from_array([ @text ],
1781 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1782 $l1 =~ s/\\$//; $l1.$l2 }),
1783 # Info we're looking for
1784 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1786 if (! @skip || $skip[$#skip] > 0) {
1792 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1793 => sub { die "ELSIF out of scope" if ! @skip;
1794 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1795 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1796 $skip[$#skip] = !! $1
1797 if $skip[$#skip] == 0; },
1799 => sub { die "ELSE out of scope" if ! @skip;
1800 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1801 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1803 => sub { die "ENDIF out of scope" if ! @skip;
1805 qr/^\s*PROGRAMS(_NO_INST)?\s*=\s*(.*)\s*$/
1807 if (!@skip || $skip[$#skip] > 0) {
1809 my @x = tokenize($2);
1811 push @programs_install, @x unless $install;
1814 qr/^\s*LIBS(_NO_INST)?\s*=\s*(.*)\s*$/
1816 if (!@skip || $skip[$#skip] > 0) {
1818 my @x = tokenize($2);
1819 push @libraries, @x;
1820 push @libraries_install, @x unless $install;
1823 qr/^\s*ENGINES(_NO_INST)?\s*=\s*(.*)\s*$/
1825 if (!@skip || $skip[$#skip] > 0) {
1827 my @x = tokenize($2);
1829 push @engines_install, @x unless $install;
1832 qr/^\s*SCRIPTS(_NO_INST)?\s*=\s*(.*)\s*$/
1834 if (!@skip || $skip[$#skip] > 0) {
1836 my @x = tokenize($2);
1838 push @scripts_install, @x unless $install;
1841 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1842 => sub { push @extra, tokenize($1)
1843 if !@skip || $skip[$#skip] > 0 },
1844 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1845 => sub { push @overrides, tokenize($1)
1846 if !@skip || $skip[$#skip] > 0 },
1848 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1849 => sub { push @{$ordinals{$1}}, tokenize($2)
1850 if !@skip || $skip[$#skip] > 0 },
1851 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1852 => sub { push @{$sources{$1}}, tokenize($2)
1853 if !@skip || $skip[$#skip] > 0 },
1854 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1855 => sub { push @{$shared_sources{$1}}, tokenize($2)
1856 if !@skip || $skip[$#skip] > 0 },
1857 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1858 => sub { push @{$includes{$1}}, tokenize($2)
1859 if !@skip || $skip[$#skip] > 0 },
1860 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1861 => sub { push @{$depends{$1}}, tokenize($2)
1862 if !@skip || $skip[$#skip] > 0 },
1863 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1864 => sub { push @{$generate{$1}}, $2
1865 if !@skip || $skip[$#skip] > 0 },
1866 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1867 => sub { push @{$renames{$1}}, tokenize($2)
1868 if !@skip || $skip[$#skip] > 0 },
1869 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1870 => sub { push @{$sharednames{$1}}, tokenize($2)
1871 if !@skip || $skip[$#skip] > 0 },
1872 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1874 my $lineiterator = shift;
1875 my $target_kind = $1;
1876 while (defined $lineiterator->()) {
1878 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1879 die "ENDRAW doesn't match BEGINRAW"
1880 if $1 ne $target_kind;
1883 next if @skip && $skip[$#skip] <= 0;
1885 if ($target_kind eq $target{build_file}
1886 || $target_kind eq $target{build_file}."(".$builder_platform.")");
1889 qr/^\s*(?:#.*)?$/ => sub { },
1890 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1892 if ($buildinfo_debug) {
1893 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1894 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1898 if ($buildinfo_debug) {
1899 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1903 die "runaway IF?" if (@skip);
1905 foreach (keys %renames) {
1906 die "$_ renamed to more than one thing: "
1907 ,join(" ", @{$renames{$_}}),"\n"
1908 if scalar @{$renames{$_}} > 1;
1909 my $dest = cleanfile($buildd, $_, $blddir);
1910 my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1911 die "$dest renamed to more than one thing: "
1912 ,$unified_info{rename}->{$dest}, $to
1913 unless !defined($unified_info{rename}->{$dest})
1914 or $unified_info{rename}->{$dest} eq $to;
1915 $unified_info{rename}->{$dest} = $to;
1918 foreach (@programs) {
1919 my $program = cleanfile($buildd, $_, $blddir);
1920 if ($unified_info{rename}->{$program}) {
1921 $program = $unified_info{rename}->{$program};
1923 $unified_info{programs}->{$program} = 1;
1926 foreach (@programs_install) {
1927 my $program = cleanfile($buildd, $_, $blddir);
1928 if ($unified_info{rename}->{$program}) {
1929 $program = $unified_info{rename}->{$program};
1931 $unified_info{install}->{programs}->{$program} = 1;
1934 foreach (@libraries) {
1935 my $library = cleanfile($buildd, $_, $blddir);
1936 if ($unified_info{rename}->{$library}) {
1937 $library = $unified_info{rename}->{$library};
1939 $unified_info{libraries}->{$library} = 1;
1942 foreach (@libraries_install) {
1943 my $library = cleanfile($buildd, $_, $blddir);
1944 if ($unified_info{rename}->{$library}) {
1945 $library = $unified_info{rename}->{$library};
1947 $unified_info{install}->{libraries}->{$library} = 1;
1950 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1951 ENGINES can only be used if configured with 'dynamic-engine'.
1952 This is usually a fault in a build.info file.
1954 foreach (@engines) {
1955 my $library = cleanfile($buildd, $_, $blddir);
1956 if ($unified_info{rename}->{$library}) {
1957 $library = $unified_info{rename}->{$library};
1959 $unified_info{engines}->{$library} = 1;
1962 foreach (@engines_install) {
1963 my $library = cleanfile($buildd, $_, $blddir);
1964 if ($unified_info{rename}->{$library}) {
1965 $library = $unified_info{rename}->{$library};
1967 $unified_info{install}->{engines}->{$library} = 1;
1970 foreach (@scripts) {
1971 my $script = cleanfile($buildd, $_, $blddir);
1972 if ($unified_info{rename}->{$script}) {
1973 $script = $unified_info{rename}->{$script};
1975 $unified_info{scripts}->{$script} = 1;
1978 foreach (@scripts_install) {
1979 my $script = cleanfile($buildd, $_, $blddir);
1980 if ($unified_info{rename}->{$script}) {
1981 $script = $unified_info{rename}->{$script};
1983 $unified_info{install}->{scripts}->{$script} = 1;
1987 my $extra = cleanfile($buildd, $_, $blddir);
1988 $unified_info{extra}->{$extra} = 1;
1991 foreach (@overrides) {
1992 my $override = cleanfile($buildd, $_, $blddir);
1993 $unified_info{overrides}->{$override} = 1;
1996 push @{$unified_info{rawlines}}, @rawlines;
1998 unless ($disabled{shared}) {
1999 # Check sharednames.
2000 foreach (keys %sharednames) {
2001 my $dest = cleanfile($buildd, $_, $blddir);
2002 if ($unified_info{rename}->{$dest}) {
2003 $dest = $unified_info{rename}->{$dest};
2005 die "shared_name for $dest with multiple values: "
2006 ,join(" ", @{$sharednames{$_}}),"\n"
2007 if scalar @{$sharednames{$_}} > 1;
2008 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
2009 die "shared_name found for a library $dest that isn't defined\n"
2010 unless $unified_info{libraries}->{$dest};
2011 die "shared_name for $dest with multiple values: "
2012 ,$unified_info{sharednames}->{$dest}, ", ", $to
2013 unless !defined($unified_info{sharednames}->{$dest})
2014 or $unified_info{sharednames}->{$dest} eq $to;
2015 $unified_info{sharednames}->{$dest} = $to;
2018 # Additionally, we set up sharednames for libraries that don't
2019 # have any, as themselves. Only for libraries that aren't
2020 # explicitly static.
2021 foreach (grep !/\.a$/, keys %{$unified_info{libraries}}) {
2022 if (!defined $unified_info{sharednames}->{$_}) {
2023 $unified_info{sharednames}->{$_} = $_
2027 # Check that we haven't defined any library as both shared and
2028 # explicitly static. That is forbidden.
2030 foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
2031 (my $l = $_) =~ s/\.a$//;
2032 push @doubles, $l if defined $unified_info{sharednames}->{$l};
2034 die "these libraries are both explicitly static and shared:\n ",
2035 join(" ", @doubles), "\n"
2039 foreach (keys %sources) {
2041 my $ddest = cleanfile($buildd, $_, $blddir);
2042 if ($unified_info{rename}->{$ddest}) {
2043 $ddest = $unified_info{rename}->{$ddest};
2045 foreach (@{$sources{$dest}}) {
2046 my $s = cleanfile($sourced, $_, $blddir);
2048 # If it isn't in the source tree, we assume it's generated
2050 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2051 $s = cleanfile($buildd, $_, $blddir);
2053 # We recognise C++, C and asm files
2054 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2056 $o =~ s/\.[csS]$/.o/; # C and assembler
2057 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2058 $o = cleanfile($buildd, $o, $blddir);
2059 $unified_info{sources}->{$ddest}->{$o} = 1;
2060 $unified_info{sources}->{$o}->{$s} = 1;
2061 } elsif ($s =~ /\.rc$/) {
2062 # We also recognise resource files
2064 $o =~ s/\.rc$/.res/; # Resource configuration
2065 my $o = cleanfile($buildd, $o, $blddir);
2066 $unified_info{sources}->{$ddest}->{$o} = 1;
2067 $unified_info{sources}->{$o}->{$s} = 1;
2069 $unified_info{sources}->{$ddest}->{$s} = 1;
2074 foreach (keys %shared_sources) {
2076 my $ddest = cleanfile($buildd, $_, $blddir);
2077 if ($unified_info{rename}->{$ddest}) {
2078 $ddest = $unified_info{rename}->{$ddest};
2080 foreach (@{$shared_sources{$dest}}) {
2081 my $s = cleanfile($sourced, $_, $blddir);
2083 # If it isn't in the source tree, we assume it's generated
2085 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2086 $s = cleanfile($buildd, $_, $blddir);
2089 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2090 # We recognise C++, C and asm files
2092 $o =~ s/\.[csS]$/.o/; # C and assembler
2093 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2094 $o = cleanfile($buildd, $o, $blddir);
2095 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
2096 $unified_info{sources}->{$o}->{$s} = 1;
2097 } elsif ($s =~ /\.rc$/) {
2098 # We also recognise resource files
2100 $o =~ s/\.rc$/.res/; # Resource configuration
2101 my $o = cleanfile($buildd, $o, $blddir);
2102 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
2103 $unified_info{sources}->{$o}->{$s} = 1;
2104 } elsif ($s =~ /\.(def|map|opt)$/) {
2105 # We also recognise .def / .map / .opt files
2106 # We know they are generated files
2107 my $def = cleanfile($buildd, $s, $blddir);
2108 $unified_info{shared_sources}->{$ddest}->{$def} = 1;
2110 die "unrecognised source file type for shared library: $s\n";
2115 foreach (keys %generate) {
2117 my $ddest = cleanfile($buildd, $_, $blddir);
2118 if ($unified_info{rename}->{$ddest}) {
2119 $ddest = $unified_info{rename}->{$ddest};
2121 die "more than one generator for $dest: "
2122 ,join(" ", @{$generate{$_}}),"\n"
2123 if scalar @{$generate{$_}} > 1;
2124 my @generator = split /\s+/, $generate{$dest}->[0];
2125 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
2126 $unified_info{generate}->{$ddest} = [ @generator ];
2129 foreach (keys %depends) {
2131 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
2133 # If the destination doesn't exist in source, it can only be
2134 # a generated file in the build tree.
2135 if ($ddest ne "" && ($ddest eq $src_configdata || ! -f $ddest)) {
2136 $ddest = cleanfile($buildd, $_, $blddir);
2137 if ($unified_info{rename}->{$ddest}) {
2138 $ddest = $unified_info{rename}->{$ddest};
2141 foreach (@{$depends{$dest}}) {
2142 my $d = cleanfile($sourced, $_, $blddir);
2144 # If we know it's generated, or assume it is because we can't
2145 # find it in the source tree, we set file we depend on to be
2146 # in the build tree rather than the source tree, and assume
2147 # and that there are lines to build it in a BEGINRAW..ENDRAW
2148 # section or in the Makefile template.
2149 if ($d eq $src_configdata
2151 || (grep { $d eq $_ }
2152 map { cleanfile($srcdir, $_, $blddir) }
2153 grep { /\.h$/ } keys %{$unified_info{generate}})) {
2154 $d = cleanfile($buildd, $_, $blddir);
2156 # Take note if the file to depend on is being renamed
2157 # Take extra care with files ending with .a, they should
2158 # be treated without that extension, and the extension
2159 # should be added back after treatment.
2163 if ($unified_info{rename}->{$d}) {
2164 $d = $unified_info{rename}->{$d};
2167 $unified_info{depends}->{$ddest}->{$d} = 1;
2171 foreach (keys %includes) {
2173 my $ddest = cleanfile($sourced, $_, $blddir);
2175 # If the destination doesn't exist in source, it can only be
2176 # a generated file in the build tree.
2177 if ($ddest eq $src_configdata || ! -f $ddest) {
2178 $ddest = cleanfile($buildd, $_, $blddir);
2179 if ($unified_info{rename}->{$ddest}) {
2180 $ddest = $unified_info{rename}->{$ddest};
2183 foreach (@{$includes{$dest}}) {
2184 my $is = cleandir($sourced, $_, $blddir);
2185 my $ib = cleandir($buildd, $_, $blddir);
2186 push @{$unified_info{includes}->{$ddest}->{source}}, $is
2187 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
2188 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
2189 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
2194 my $ordinals_text = join(', ', sort keys %ordinals);
2195 warn <<"EOF" if $ordinals_text;
2197 WARNING: ORDINALS were specified for $ordinals_text
2198 They are ignored and should be replaced with a combination of GENERATE,
2199 DEPEND and SHARED_SOURCE.
2202 # Massage the result
2204 # If the user configured no-shared, we allow no shared sources
2205 if ($disabled{shared}) {
2206 foreach (keys %{$unified_info{shared_sources}}) {
2207 foreach (keys %{$unified_info{shared_sources}->{$_}}) {
2208 delete $unified_info{sources}->{$_};
2211 $unified_info{shared_sources} = {};
2214 # If we depend on a header file or a perl module, add an inclusion of
2215 # its directory to allow smoothe inclusion
2216 foreach my $dest (keys %{$unified_info{depends}}) {
2217 next if $dest eq "";
2218 foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2219 next unless $d =~ /\.(h|pm)$/;
2220 my $i = dirname($d);
2222 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2223 ? 'build' : 'source';
2224 push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2225 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
2229 # Trickle down includes placed on libraries, engines and programs to
2230 # their sources (i.e. object files)
2231 foreach my $dest (keys %{$unified_info{engines}},
2232 keys %{$unified_info{libraries}},
2233 keys %{$unified_info{programs}}) {
2234 foreach my $k (("source", "build")) {
2235 next unless defined($unified_info{includes}->{$dest}->{$k});
2236 my @incs = reverse @{$unified_info{includes}->{$dest}->{$k}};
2237 foreach my $obj (grep /\.o$/,
2238 (keys %{$unified_info{sources}->{$dest} // {}},
2239 keys %{$unified_info{shared_sources}->{$dest} // {}})) {
2240 foreach my $inc (@incs) {
2241 unshift @{$unified_info{includes}->{$obj}->{$k}}, $inc
2242 unless grep { $_ eq $inc } @{$unified_info{includes}->{$obj}->{$k}};
2246 delete $unified_info{includes}->{$dest};
2249 ### Make unified_info a bit more efficient
2250 # One level structures
2251 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
2252 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2254 # Two level structures
2255 foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
2256 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
2257 $unified_info{$l1}->{$l2} =
2258 [ sort keys %{$unified_info{$l1}->{$l2}} ];
2262 foreach my $dest (sort keys %{$unified_info{includes}}) {
2263 if (defined($unified_info{includes}->{$dest}->{build})) {
2264 my @source_includes = ();
2265 @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2266 if defined($unified_info{includes}->{$dest}->{source});
2267 $unified_info{includes}->{$dest} =
2268 [ @{$unified_info{includes}->{$dest}->{build}} ];
2269 foreach my $inc (@source_includes) {
2270 push @{$unified_info{includes}->{$dest}}, $inc
2271 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2274 $unified_info{includes}->{$dest} =
2275 [ @{$unified_info{includes}->{$dest}->{source}} ];
2279 # For convenience collect information regarding directories where
2280 # files are generated, those generated files and the end product
2281 # they end up in where applicable. Then, add build rules for those
2283 my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
2284 "dso" => [ @{$unified_info{engines}} ],
2285 "bin" => [ @{$unified_info{programs}} ],
2286 "script" => [ @{$unified_info{scripts}} ] );
2287 foreach my $type (keys %loopinfo) {
2288 foreach my $product (@{$loopinfo{$type}}) {
2290 my $pd = dirname($product);
2292 foreach (@{$unified_info{sources}->{$product} // []},
2293 @{$unified_info{shared_sources}->{$product} // []}) {
2294 my $d = dirname($_);
2296 # We don't want to create targets for source directories
2297 # when building out of source
2298 next if ($config{sourcedir} ne $config{builddir}
2299 && $d =~ m|^\Q$config{sourcedir}\E|);
2300 # We already have a "test" target, and the current directory
2301 # is just silly to make a target for
2302 next if $d eq "test" || $d eq ".";
2305 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2308 foreach (keys %dirs) {
2309 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2316 # For the schemes that need it, we provide the old *_obj configs
2317 # from the *_asm_obj ones
2318 foreach (grep /_(asm|aux)_src$/, keys %target) {
2320 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
2321 $target{$obj} = $target{$src};
2322 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2323 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2326 # Write down our configuration where it fits #########################
2328 print "Creating configdata.pm\n";
2329 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
2331 #! $config{HASHBANGPERL}
2339 #use vars qw(\@ISA \@EXPORT);
2340 our \@ISA = qw(Exporter);
2341 our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
2344 print OUT "our %config = (\n";
2345 foreach (sort keys %config) {
2346 if (ref($config{$_}) eq "ARRAY") {
2347 print OUT " ", $_, " => [ ", join(", ",
2348 map { quotify("perl", $_) }
2349 @{$config{$_}}), " ],\n";
2350 } elsif (ref($config{$_}) eq "HASH") {
2351 print OUT " ", $_, " => {";
2352 if (scalar keys %{$config{$_}} > 0) {
2354 foreach my $key (sort keys %{$config{$_}}) {
2357 quotify("perl", $key),
2358 defined $config{$_}->{$key}
2359 ? quotify("perl", $config{$_}->{$key})
2367 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
2374 print OUT "our %target = (\n";
2375 foreach (sort keys %target) {
2376 if (ref($target{$_}) eq "ARRAY") {
2377 print OUT " ", $_, " => [ ", join(", ",
2378 map { quotify("perl", $_) }
2379 @{$target{$_}}), " ],\n";
2381 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
2388 print OUT "our \%available_protocols = (\n";
2389 print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2390 print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2395 print OUT "our \@disablables = (\n";
2396 foreach (@disablables) {
2397 print OUT " ", quotify("perl", $_), ",\n";
2403 print OUT "our \%disabled = (\n";
2404 foreach (sort keys %disabled) {
2405 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2411 print OUT "our %withargs = (\n";
2412 foreach (sort keys %withargs) {
2413 if (ref($withargs{$_}) eq "ARRAY") {
2414 print OUT " ", $_, " => [ ", join(", ",
2415 map { quotify("perl", $_) }
2416 @{$withargs{$_}}), " ],\n";
2418 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
2425 if ($builder eq "unified") {
2430 if (ref $_ eq "ARRAY") {
2431 print OUT " "x$indent, "[\n";
2433 $recurse->($indent + 4, $_);
2435 print OUT " "x$indent, "],\n";
2436 } elsif (ref $_ eq "HASH") {
2438 print OUT " "x$indent, "{\n";
2439 foreach (sort keys %h) {
2440 if (ref $h{$_} eq "") {
2441 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2443 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2444 $recurse->($indent + 8, $h{$_});
2447 print OUT " "x$indent, "},\n";
2449 print OUT " "x$indent, quotify("perl", $_), ",\n";
2453 print OUT "our %unified_info = (\n";
2454 foreach (sort keys %unified_info) {
2455 if (ref $unified_info{$_} eq "") {
2456 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2458 print OUT " "x4, quotify("perl", $_), " =>\n";
2459 $recurse->(8, $unified_info{$_});
2468 "# The following data is only used when this files is use as a script\n";
2469 print OUT "my \@makevars = (\n";
2470 foreach (sort keys %user) {
2471 print OUT " '",$_,"',\n";
2474 print OUT "my \%disabled_info = (\n";
2475 foreach my $what (sort keys %disabled_info) {
2476 print OUT " '$what' => {\n";
2477 foreach my $info (sort keys %{$disabled_info{$what}}) {
2478 if (ref $disabled_info{$what}->{$info} eq 'ARRAY') {
2479 print OUT " $info => [ ",
2480 join(', ', map { "'$_'" } @{$disabled_info{$what}->{$info}}),
2483 print OUT " $info => '", $disabled_info{$what}->{$info},
2490 print OUT 'my @user_crossable = qw( ', join (' ', @user_crossable), " );\n";
2492 # If run directly, we can give some answers, and even reconfigure
2495 use File::Spec::Functions;
2499 my $here = dirname($0);
2502 my $cmdline = undef;
2503 my $options = undef;
2505 my $envvars = undef;
2506 my $makevars = undef;
2507 my $buildparams = undef;
2509 my $verbose = undef;
2512 GetOptions('dump|d' => \$dump,
2513 'command-line|c' => \$cmdline,
2514 'options|o' => \$options,
2515 'target|t' => \$target,
2516 'environment|e' => \$envvars,
2517 'make-variables|m' => \$makevars,
2518 'build-parameters|b' => \$buildparams,
2519 'reconfigure|reconf|r' => \$reconf,
2520 'verbose|v' => \$verbose,
2523 or die "Errors in command line arguments\n";
2525 unless ($dump || $cmdline || $options || $target || $envvars || $makevars
2526 || $buildparams || $reconf || $verbose || $help || $man) {
2527 print STDERR <<"_____";
2528 You must give at least one option.
2529 For more information, do '$0 --help'
2535 pod2usage(-exitval => 0,
2539 pod2usage(-exitval => 0,
2542 if ($dump || $cmdline) {
2543 print "\nCommand line (with current working directory = $here):\n\n";
2546 catfile($config{sourcedir}, 'Configure'),
2547 @{$config{perlargv}}), "\n";
2548 print "\nPerl information:\n\n";
2549 print ' ',$config{perl_cmd},"\n";
2550 print ' ',$config{perl_version},' for ',$config{perl_archname},"\n";
2552 if ($dump || $options) {
2555 foreach my $what (@disablables) {
2556 $longest = length($what) if $longest < length($what);
2557 $longest2 = length($disabled{$what})
2558 if $disabled{$what} && $longest2 < length($disabled{$what});
2560 print "\nEnabled features:\n\n";
2561 foreach my $what (@disablables) {
2562 print " $what\n" unless $disabled{$what};
2564 print "\nDisabled features:\n\n";
2565 foreach my $what (@disablables) {
2566 if ($disabled{$what}) {
2567 print " $what", ' ' x ($longest - length($what) + 1),
2568 "[$disabled{$what}]", ' ' x ($longest2 - length($disabled{$what}) + 1);
2569 print $disabled_info{$what}->{macro}
2570 if $disabled_info{$what}->{macro};
2572 join(', ', @{$disabled_info{$what}->{skipped}}),
2574 if $disabled_info{$what}->{skipped};
2579 if ($dump || $target) {
2580 print "\nConfig target attributes:\n\n";
2581 foreach (sort keys %target) {
2582 next if $_ =~ m|^_| || $_ eq 'template';
2584 map { (my $x = $_) =~ s|([\\\$\@"])|\\$1|g; "\"$x\""} @_;
2586 print ' ', $_, ' => ';
2587 if (ref($target{$_}) eq "ARRAY") {
2588 print '[ ', join(', ', $quotify->(@{$target{$_}})), " ],\n";
2590 print $quotify->($target{$_}), ",\n"
2594 if ($dump || $envvars) {
2595 print "\nRecorded environment:\n\n";
2596 foreach (sort keys %{$config{perlenv}}) {
2597 print ' ',$_,' = ',($config{perlenv}->{$_} || ''),"\n";
2600 if ($dump || $makevars) {
2601 print "\nMakevars:\n\n";
2602 foreach my $var (@makevars) {
2604 $prefix = $config{CROSS_COMPILE}
2605 if grep { $var eq $_ } @user_crossable;
2607 print ' ',$var,' ' x (16 - length $var),'= ',
2608 (ref $config{$var} eq 'ARRAY'
2609 ? join(' ', @{$config{$var}})
2610 : $prefix.$config{$var}),
2612 if defined $config{$var};
2615 my @buildfile = ($config{builddir}, $config{build_file});
2616 unshift @buildfile, $here
2617 unless file_name_is_absolute($config{builddir});
2618 my $buildfile = canonpath(catdir(@buildfile));
2621 NOTE: These variables only represent the configuration view. The build file
2622 template may have processed these variables further, please have a look at the
2623 build file for more exact data:
2627 if ($dump || $buildparams) {
2628 my @buildfile = ($config{builddir}, $config{build_file});
2629 unshift @buildfile, $here
2630 unless file_name_is_absolute($config{builddir});
2631 print "\nbuild file:\n\n";
2632 print " ", canonpath(catfile(@buildfile)),"\n";
2634 print "\nbuild file templates:\n\n";
2635 foreach (@{$config{build_file_templates}}) {
2637 unshift @tmpl, $here
2638 unless file_name_is_absolute($config{sourcedir});
2639 print ' ',canonpath(catfile(@tmpl)),"\n";
2644 print 'Reconfiguring with: ', join(' ',@{$config{perlargv}}), "\n";
2645 foreach (sort keys %{$config{perlenv}}) {
2646 print ' ',$_,' = ',($config{perlenv}->{$_} || ""),"\n";
2651 exec $^X,catfile($config{sourcedir}, 'Configure'),'reconf';
2661 configdata.pm - configuration data for OpenSSL builds
2667 perl configdata.pm [options]
2669 As data bank module:
2675 This module can be used in two modes, interactively and as a module containing
2676 all the data recorded by OpenSSL's Configure script.
2678 When used interactively, simply run it as any perl script, with at least one
2679 option, and you will get the information you ask for. See L</OPTIONS> below.
2681 When loaded as a module, you get a few databanks with useful information to
2682 perform build related tasks. The databanks are:
2684 %config Configured things.
2685 %target The OpenSSL config target with all inheritances
2687 %disabled The features that are disabled.
2688 @disablables The list of features that can be disabled.
2689 %withargs All data given through --with-THING options.
2690 %unified_info All information that was computed from the build.info
2699 Print a brief help message and exit.
2703 Print the manual page and exit.
2705 =item B<--dump> | B<-d>
2707 Print all relevant configuration data. This is equivalent to B<--command-line>
2708 B<--options> B<--target> B<--environment> B<--make-variables>
2709 B<--build-parameters>.
2711 =item B<--command-line> | B<-c>
2713 Print the current configuration command line.
2715 =item B<--options> | B<-o>
2717 Print the features, both enabled and disabled, and display defined macro and
2718 skipped directories where applicable.
2720 =item B<--target> | B<-t>
2722 Print the config attributes for this config target.
2724 =item B<--environment> | B<-e>
2726 Print the environment variables and their values at the time of configuration.
2728 =item B<--make-variables> | B<-m>
2730 Print the main make variables generated in the current configuration
2732 =item B<--build-parameters> | B<-b>
2734 Print the build parameters, i.e. build file and build file templates.
2736 =item B<--reconfigure> | B<--reconf> | B<-r>
2738 Redo the configuration.
2740 =item B<--verbose> | B<-v>
2750 if ($builder_platform eq 'unix') {
2751 my $mode = (0755 & ~umask);
2752 chmod $mode, 'configdata.pm'
2753 or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2758 print 'Creating ',$target{build_file},"\n";
2759 run_dofile(catfile($blddir, $target{build_file}),
2760 @{$config{build_file_templates}});
2764 $builders{$builder}->($builder_platform, @builder_opts);
2766 $SIG{__DIE__} = $orig_death_handler;
2768 print <<"EOF" if ($disabled{threads} eq "unavailable");
2770 The library could not be configured for supporting multi-threaded
2771 applications as the compiler options required on this system are not known.
2772 See file INSTALL for details if you need multi-threading.
2775 print <<"EOF" if ($no_shared_warn);
2777 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2778 platform, so we will pretend you gave the option 'no-pic', which also disables
2779 'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2780 or position independent code, please let us know (but please first make sure
2781 you have tried with a current version of OpenSSL).
2786 **********************************************************************
2788 *** OpenSSL has been successfully configured ***
2790 *** If you encounter a problem while building, please open an ***
2791 *** issue on GitHub <https://github.com/openssl/openssl/issues> ***
2792 *** and include the output from the following command: ***
2794 *** perl configdata.pm --dump ***
2796 *** (If you are new to OpenSSL, you might want to consult the ***
2797 *** 'Troubleshooting' section in the INSTALL file first) ***
2799 **********************************************************************
2804 ######################################################################
2806 # Helpers and utility functions
2809 # Death handler, to print a helpful message in case of failure #######
2812 die @_ if $^S; # To prevent the added message in eval blocks
2813 my $build_file = $target{build_file} // "build file";
2814 my @message = ( <<"_____", @_ );
2816 Failure! $build_file wasn't produced.
2817 Please read INSTALL and associated NOTES files. You may also have to look over
2818 your available compiler tool chain or change your configuration.
2822 # Dying is terminal, so it's ok to reset the signal handler here.
2823 $SIG{__DIE__} = $orig_death_handler;
2827 # Configuration file reading #########################################
2829 # Note: All of the helper functions are for lazy evaluation. They all
2830 # return a CODE ref, which will return the intended value when evaluated.
2831 # Thus, whenever there's mention of a returned value, it's about that
2834 # Helper function to implement conditional inheritance depending on the
2835 # value of $disabled{asm}. Used in inherit_from values as follows:
2837 # inherit_from => [ "template", asm("asm_tmpl") ]
2842 $disabled{asm} ? () : @x;
2846 # Helper function to implement conditional value variants, with a default
2847 # plus additional values based on the value of $config{build_type}.
2848 # Arguments are given in hash table form:
2850 # picker(default => "Basic string: ",
2852 # release => "release")
2854 # When configuring with --debug, the resulting string will be
2855 # "Basic string: debug", and when not, it will be "Basic string: release"
2857 # This can be used to create variants of sets of flags according to the
2860 # cflags => picker(default => "-Wall",
2861 # debug => "-g -O0",
2866 return sub { add($opts{default} || (),
2867 $opts{$config{build_type}} || ())->(); }
2870 # Helper function to combine several values of different types into one.
2871 # This is useful if you want to combine a string with the result of a
2872 # lazy function, such as:
2874 # cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2878 return sub { add(@stuff)->(); }
2881 # Helper function to implement conditional values depending on the value
2882 # of $disabled{threads}. Can be used as follows:
2884 # cflags => combine("-Wall", threads("-pthread"))
2888 return sub { add($disabled{threads} ? () : @flags)->(); }
2893 return sub { add($disabled{shared} ? () : @flags)->(); }
2896 our $add_called = 0;
2897 # Helper function to implement adding values to already existing configuration
2898 # values. It handles elements that are ARRAYs, CODEs and scalars
2900 my $separator = shift;
2902 # If there's any ARRAY in the collection of values OR the separator
2903 # is undef, we will return an ARRAY of combined values, otherwise a
2904 # string of joined values with $separator as the separator.
2905 my $found_array = !defined($separator);
2910 while (ref($res) eq "CODE") {
2913 if (defined($res)) {
2914 if (ref($res) eq "ARRAY") {
2930 join($separator, grep { defined($_) && $_ ne "" } @values);
2934 my $separator = " ";
2935 if (ref($_[$#_]) eq "HASH") {
2937 $separator = $opts->{separator};
2940 sub { _add($separator, @x, @_) };
2943 my $separator = " ";
2944 if (ref($_[$#_]) eq "HASH") {
2946 $separator = $opts->{separator};
2949 sub { _add($separator, @_, @x) };
2952 sub read_eval_file {
2957 open F, "< $fname" or die "Can't open '$fname': $!\n";
2966 @result = ( eval $content );
2969 return wantarray ? @result : $result[0];
2972 # configuration reader, evaluates the input file as a perl script and expects
2973 # it to fill %targets with target configurations. Those are then added to
2980 # Protect certain tables from tampering
2983 %targets = read_eval_file($fname);
2985 my %preexisting = ();
2986 foreach (sort keys %targets) {
2987 $preexisting{$_} = 1 if $table{$_};
2990 The following config targets from $fname
2991 shadow pre-existing config targets with the same name:
2993 map { " $_\n" } sort keys %preexisting
2997 # For each target, check that it's configured with a hash table.
2998 foreach (keys %targets) {
2999 if (ref($targets{$_}) ne "HASH") {
3000 if (ref($targets{$_}) eq "") {
3001 warn "Deprecated target configuration for $_, ignoring...\n";
3003 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
3005 delete $targets{$_};
3007 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
3011 %table = (%table, %targets);
3015 # configuration resolver. Will only resolve all the lazy evaluation
3016 # codeblocks for the chosen target and all those it inherits from,
3018 sub resolve_config {
3020 my @breadcrumbs = @_;
3022 # my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
3024 if (grep { $_ eq $target } @breadcrumbs) {
3025 die "inherit_from loop! target backtrace:\n "
3026 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
3029 if (!defined($table{$target})) {
3030 warn "Warning! target $target doesn't exist!\n";
3033 # Recurse through all inheritances. They will be resolved on the
3034 # fly, so when this operation is done, they will all just be a
3035 # bunch of attributes with string values.
3036 # What we get here, though, are keys with references to lists of
3037 # the combined values of them all. We will deal with lists after
3038 # this stage is done.
3039 my %combined_inheritance = ();
3040 if ($table{$target}->{inherit_from}) {
3042 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
3043 foreach (@inherit_from) {
3044 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
3046 # 'template' is a marker that's considered private to
3047 # the config that had it.
3048 delete $inherited_config{template};
3050 foreach (keys %inherited_config) {
3051 if (!$combined_inheritance{$_}) {
3052 $combined_inheritance{$_} = [];
3054 push @{$combined_inheritance{$_}}, $inherited_config{$_};
3059 # We won't need inherit_from in this target any more, since we've
3060 # resolved all the inheritances that lead to this
3061 delete $table{$target}->{inherit_from};
3063 # Now is the time to deal with those lists. Here's the place to
3064 # decide what shall be done with those lists, all based on the
3065 # values of the target we're currently dealing with.
3066 # - If a value is a coderef, it will be executed with the list of
3067 # inherited values as arguments.
3068 # - If the corresponding key doesn't have a value at all or is the
3069 # empty string, the inherited value list will be run through the
3070 # default combiner (below), and the result becomes this target's
3072 # - Otherwise, this target's value is assumed to be a string that
3073 # will simply override the inherited list of values.
3074 my $default_combiner = add();
3077 map { $_ => 1 } (keys %combined_inheritance,
3078 keys %{$table{$target}});
3080 sub process_values {
3082 my $inherited = shift; # Always a [ list ]
3088 while(ref($object) eq "CODE") {
3089 $object = $object->(@$inherited);
3091 if (!defined($object)) {
3094 elsif (ref($object) eq "ARRAY") {
3095 local $add_called; # To make sure recursive calls don't affect it
3096 return [ map { process_values($_, $inherited, $target, $entry) }
3098 } elsif (ref($object) eq "") {
3101 die "cannot handle reference type ",ref($object)
3102 ," found in target ",$target," -> ",$entry,"\n";
3106 foreach (sort keys %all_keys) {
3107 my $previous = $combined_inheritance{$_};
3109 # Current target doesn't have a value for the current key?
3110 # Assign it the default combiner, the rest of this loop body
3111 # will handle it just like any other coderef.
3112 if (!exists $table{$target}->{$_}) {
3113 $table{$target}->{$_} = $default_combiner;
3116 $table{$target}->{$_} = process_values($table{$target}->{$_},
3117 $combined_inheritance{$_},
3119 unless(defined($table{$target}->{$_})) {
3120 delete $table{$target}->{$_};
3122 # if ($extra_checks &&
3123 # $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
3124 # warn "$_ got replaced in $target\n";
3128 # Finally done, return the result.
3129 return %{$table{$target}};
3134 print STDERR $usage;
3135 print STDERR "\npick os/compiler from:\n";
3139 foreach $i (sort keys %table)
3141 next if $table{$i}->{template};
3142 next if $i =~ /^debug/;
3143 $k += length($i) + 1;
3149 print STDERR $i . " ";
3151 foreach $i (sort keys %table)
3153 next if $table{$i}->{template};
3154 next if $i !~ /^debug/;
3155 $k += length($i) + 1;
3161 print STDERR $i . " ";
3163 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
3172 unlink $out || warn "Can't remove $out, $!"
3174 foreach (@templates) {
3175 die "Can't open $_, $!" unless -f $_;
3177 my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
3178 my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
3179 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
3182 rename("$out.new", $out) || die "Can't rename $out.new, $!";
3185 sub compiler_predefined {
3189 return () if $^O eq 'VMS';
3191 die 'compiler_predefined called without a compiler command'
3194 if (! $predefined{$cc}) {
3196 $predefined{$cc} = {};
3198 # collect compiler pre-defines from gcc or gcc-alike...
3199 open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
3200 while (my $l = <PIPE>) {
3201 $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
3202 $predefined{$cc}->{$1} = $2 // '';
3207 return %{$predefined{$cc}};
3214 if (eval { require IPC::Cmd; 1; }) {
3216 return scalar IPC::Cmd::can_run($name);
3218 # if there is $directories component in splitpath,
3219 # then it's not something to test with $PATH...
3220 return $name if (File::Spec->splitpath($name))[1];
3222 foreach (File::Spec->path()) {
3223 my $fullpath = catfile($_, "$name$target{exe_extension}");
3224 if (-f $fullpath and -x $fullpath) {
3236 unless ($opts{cacheonly}) {
3237 # Note that if $ENV{$name} doesn't exist or is undefined,
3238 # $config{perlenv}->{$name} will be created with the value
3239 # undef. This is intentional.
3241 $config{perlenv}->{$name} = $ENV{$name}
3242 if ! exists $config{perlenv}->{$name};
3244 return $config{perlenv}->{$name};
3247 # Configuration printer ##############################################
3249 sub print_table_entry
3251 local $now_printing = shift;
3252 my %target = resolve_config($now_printing);
3255 # Don't print the templates
3256 return if $target{template};
3319 if ($type eq "TABLE") {
3321 print "*** $now_printing\n";
3322 foreach (@sequence) {
3323 if (ref($target{$_}) eq "ARRAY") {
3324 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3326 printf "\$%-12s = %s\n", $_, $target{$_};
3329 } elsif ($type eq "HASH") {
3331 length((sort { length($a) <=> length($b) } @sequence)[-1]);
3332 print " '$now_printing' => {\n";
3333 foreach (@sequence) {
3335 if (ref($target{$_}) eq "ARRAY") {
3336 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3338 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3346 # Utility routines ###################################################
3348 # On VMS, if the given file is a logical name, File::Spec::Functions
3349 # will consider it an absolute path. There are cases when we want a
3350 # purely syntactic check without checking the environment.
3354 # On non-platforms, we just use file_name_is_absolute().
3355 return file_name_is_absolute($file) unless $^O eq "VMS";
3357 # If the file spec includes a device or a directory spec,
3358 # file_name_is_absolute() is perfectly safe.
3359 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3361 # Here, we know the given file spec isn't absolute
3365 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
3366 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
3367 # realpath() requires that at least all path components except the last is an
3368 # existing directory. On VMS, the last component of the directory spec must
3373 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
3374 # will return the volume name for the device, no matter what. Also,
3375 # it will return an incorrect directory spec if the argument is a
3376 # directory that doesn't exist.
3378 return rel2abs($dir);
3381 # We use realpath() on Unix, since no other will properly clean out
3383 use Cwd qw/realpath/;
3385 return realpath($dir);
3390 perl => sub { my $x = shift;
3391 $x =~ s/([\\\$\@"])/\\$1/g;
3392 return '"'.$x.'"'; },
3393 maybeshell => sub { my $x = shift;
3394 (my $y = $x) =~ s/([\\\"])/\\$1/g;
3395 if ($x ne $y || $x =~ m|\s|) {
3404 defined($processors{$for}) ? $processors{$for} : sub { shift; };
3406 return map { $processor->($_); } @_;
3409 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
3410 # $filename is a file name to read from
3411 # $line_concat_cond_re is a regexp detecting a line continuation ending
3412 # $line_concat is a CODEref that takes care of concatenating two lines
3413 sub collect_from_file {
3414 my $filename = shift;
3415 my $line_concat_cond_re = shift;
3416 my $line_concat = shift;
3418 open my $fh, $filename || die "unable to read $filename: $!\n";
3420 my $saved_line = "";
3424 if (defined $line_concat) {
3425 $_ = $line_concat->($saved_line, $_);
3428 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3434 die "$filename ending with continuation line\n" if $_;
3440 # collect_from_array($array, $line_concat_cond_re, $line_concat)
3441 # $array is an ARRAYref of lines
3442 # $line_concat_cond_re is a regexp detecting a line continuation ending
3443 # $line_concat is a CODEref that takes care of concatenating two lines
3444 sub collect_from_array {
3446 my $line_concat_cond_re = shift;
3447 my $line_concat = shift;
3448 my @array = (@$array);
3451 my $saved_line = "";
3453 while (defined($_ = shift @array)) {
3455 if (defined $line_concat) {
3456 $_ = $line_concat->($saved_line, $_);
3459 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3465 die "input text ending with continuation line\n" if $_;
3470 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3471 # $lineiterator is a CODEref that delivers one line at a time.
3472 # All following arguments are regex/CODEref pairs, where the regexp detects a
3473 # line and the CODEref does something with the result of the regexp.
3474 sub collect_information {
3475 my $lineiterator = shift;
3476 my %collectors = @_;
3478 while(defined($_ = $lineiterator->())) {
3481 if ($collectors{"BEFORE"}) {
3482 $collectors{"BEFORE"}->($_);
3484 foreach my $re (keys %collectors) {
3485 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
3486 $collectors{$re}->($lineiterator);
3490 if ($collectors{"OTHERWISE"}) {
3491 $collectors{"OTHERWISE"}->($lineiterator, $_)
3492 unless $found || !defined $collectors{"OTHERWISE"};
3494 if ($collectors{"AFTER"}) {
3495 $collectors{"AFTER"}->($_);
3501 # $line is a line of text to split up into tokens
3502 # returns a list of tokens
3504 # Tokens are divided by spaces. If the tokens include spaces, they
3505 # have to be quoted with single or double quotes. Double quotes
3506 # inside a double quoted token must be escaped. Escaping is done
3508 # Basically, the same quoting rules apply for " and ' as in any
3511 my $line = my $debug_line = shift;
3514 while ($line =~ s|^\s+||, $line ne "") {
3516 while ($line ne "" && $line !~ m|^\s|) {
3517 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3520 } elsif ($line =~ m/^'([^']*)'/) {
3523 } elsif ($line =~ m/^(\S+)/) {
3528 push @result, $token;
3531 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3532 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3533 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";