Configure

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