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