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