}
}
+# Save away perl command information
+$config{perl_cmd} = $^X;
+$config{perl_version} = $Config{version};
+$config{perl_archname} = $Config{archname};
+
$config{prefix}="";
$config{openssldir}="";
$config{processor}="";
$config{libdir}="";
-$config{cross_compile_prefix}="";
my $auto_threads=1; # enable threads automatically? true by default
my $default_ranlib;
CPPFLAGS => [], # -D, -I, -Wp,
CPPDEFINES => [], # Alternative for -D
CPPINCLUDES => [], # Alternative for -I
+ CROSS_COMPILE => undef,
HASHBANGPERL=> undef,
LD => undef,
LDFLAGS => [], # -L, -Wl,
RCFLAGS => [],
RM => undef,
);
+# Info about what "make variables" may be prefixed with the cross compiler
+# prefix. This should NEVER mention any such variable with a list for value.
+my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
# The same but for flags given as Configure options. These are *additional*
# input, as opposed to the VAR=string option that override the corresponding
# config target attributes
HASHBANGPERL=> 'PERL',
RC => 'WINDRES',
);
-my %user_to_target = (
- # If not given here, the value is the lc of the key
- CPPDEFINES => 'defines',
- CPPINCLUDES => 'includes',
- LDFLAGS => 'lflags',
- LDLIBS => 'ex_libs',
+
+# Some target attributes have been renamed, this is the translation table
+my %target_attr_translate =(
+ ar => 'AR',
+ as => 'AS',
+ cc => 'CC',
+ cxx => 'CXX',
+ cpp => 'CPP',
+ hashbangperl => 'HASHBANGPERL',
+ ld => 'LD',
+ mt => 'MT',
+ ranlib => 'RANLIB',
+ rc => 'RC',
+ rm => 'RM',
);
+# Initialisers coming from 'config' scripts
+$config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ],
+$config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ],
+$config{cppflags} = [ env('__CNF_CPPFLAGS') || () ],
+$config{cflags} = [ env('__CNF_CFLAGS') || () ],
+$config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ],
+$config{lflags} = [ env('__CNF_LDFLAGS') || () ],
+$config{ex_libs} = [ env('__CNF_LDLIBS') || () ],
+
$config{openssl_api_defines}=[];
$config{openssl_algorithm_defines}=[];
$config{openssl_thread_defines}=[];
{
$user{$1} = ref $user{$1} eq "ARRAY" ? [] : undef;
}
- if (exists $useradd{$1})
- {
- $useradd{$1} = [];
- }
+ #if (exists $useradd{$1})
+ # {
+ # $useradd{$1} = [];
+ # }
next;
}
}
elsif (/^--cross-compile-prefix=(.*)$/)
{
- $config{cross_compile_prefix}=$1;
+ $user{CROSS_COMPILE}=$1;
}
elsif (/^--config=(.*)$/)
{
}
}
+# If any %useradd entry has been set, we must check that the environment
+# variables haven't been set. We start by checking of any %useradd entry
+# is set.
+if (grep { scalar @$_ > 0 } values %useradd) {
+ # Hash of env / make variables names. The possible values are:
+ # 1 - environment set
+ # 2 - %useradd entry set
+ # 3 - both set
+ my %detected_env =
+ map { my $v = 0;
+ $v += 1 if env($_);
+ $v += 2 if @{$useradd{$_}};
+ $_ => $v }
+ keys %useradd;
+
+ # If any of the corresponding environment variables is set, we error
+ if (grep { $_ & 1 } values %detected_env) {
+ my $names = join(', ', grep { $detected_env{$_} > 0 }
+ sort keys %detected_env);
+ die <<"_____";
+***** Mixing env / make variables and additional compiler/linker flags as
+***** configure command line option is not permitted.
+***** Affected env / make variables: $names
+_____
+ }
+}
+
foreach (keys %user) {
my $value = env($_);
$value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef;
&usage if (!%target || $target{template});
+foreach (keys %target_attr_translate) {
+ $target{$target_attr_translate{$_}} = $target{$_}
+ if $target{$_};
+ delete $target{$_};
+}
+
%target = ( %{$table{DEFAULTS}}, %target );
# Make the flags to build DSOs the same as for shared libraries unless they
# are already defined
-$target{dso_cflags} = $target{shared_cflag} unless defined $target{dso_cflags};
-$target{dso_cxxflags} = $target{shared_cxxflag} unless defined $target{dso_cxxflags};
-$target{dso_lflags} = $target{shared_ldflag} unless defined $target{dso_lflags};
+$target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
+$target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
+$target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
{
my $shared_info_pl =
catfile(dirname($0), "Configurations", "shared-info.pl");
# Windows and VMS.
if (defined $si) {
# Just as above, copy certain shared_* attributes to the corresponding
- # dso_ attribute unless the latter is already defined
- $si->{dso_cflags} = $si->{shared_cflag} unless defined $si->{dso_cflags};
- $si->{dso_cxxflags} = $si->{shared_cxxflag} unless defined $si->{dso_cxxflags};
- $si->{dso_lflags} = $si->{shared_ldflag} unless defined $si->{dso_lflags};
+ # module_ attribute unless the latter is already defined
+ $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
+ $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
+ $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
foreach (sort keys %$si) {
$target{$_} = defined $target{$_}
? add($si->{$_})->($target{$_})
}
}
-$target{cxxflags}//=$target{cflags} if $target{cxx};
+$target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
+$target{cxxflags}//=$target{cflags} if $target{CXX};
$target{exe_extension}="";
$target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
|| $config{target} =~ /^(?:Cygwin|mingw)/);
($target{shared_import_extension}=$target{shared_extension_simple}.".a")
if ($config{target} =~ /^(?:Cygwin|mingw)/);
-
-$config{cross_compile_prefix} = env('CROSS_COMPILE')
- if $config{cross_compile_prefix} eq "";
-
# Allow overriding the names of some tools. USE WITH CARE
# Note: only Unix cares about HASHBANGPERL... that explains
# the default string.
$config{perl} = ($^O ne "VMS" ? $^X : "perl");
foreach (keys %user) {
- my $target_key = $user_to_target{$_} // lc $_;
my $ref_type = ref $user{$_};
# Temporary function. Takes an intended ref type (empty string or "ARRAY")
return $value;
};
- $config{$target_key} =
+ $config{$_} =
$mkvalue->($ref_type, $user{$_})
- || $mkvalue->($ref_type, $target{$target_key});
- delete $config{$target_key} unless defined $config{$target_key};
+ || $mkvalue->($ref_type, $target{$_});
+ delete $config{$_} unless defined $config{$_};
}
-$config{plib_lflags} = [ $target{plib_lflags} ];
# Allow overriding the build file name
$config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
-if ($target =~ /^mingw/ && `$config{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
+if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
{
push @{$config{cflags}}, "-mno-cygwin";
- push @{$config{cxxflags}}, "-mno-cygwin" if $config{cxx};
+ push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
push @{$config{shared_ldflag}}, "-mno-cygwin";
}
$value = '-mips2' if ($target =~ /mips32/);
$value = '-mips3' if ($target =~ /mips64/);
unshift @{$config{cflags}}, $value;
- unshift @{$config{cxxflags}}, $value if $config{cxx};
+ unshift @{$config{cxxflags}}, $value if $config{CXX};
}
# The DSO code currently always implements all functions so that no
unless ($disabled{asan}) {
push @{$config{cflags}}, "-fsanitize=address";
- push @{$config{cxxflags}}, "-fsanitize=address" if $config{cxx};
+ push @{$config{cxxflags}}, "-fsanitize=address" if $config{CXX};
}
unless ($disabled{ubsan}) {
# platforms.
push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all";
push @{$config{cxxflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all"
- if $config{cxx};
+ if $config{CXX};
}
unless ($disabled{msan}) {
push @{$config{cflags}}, "-fsanitize=memory";
- push @{$config{cxxflags}}, "-fsanitize=memory" if $config{cxx};
+ push @{$config{cxxflags}}, "-fsanitize=memory" if $config{CXX};
}
unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
&& $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
- push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{cxx};
+ push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
}
#
# Platform fix-ups
if ($disabled{pic})
{
foreach (qw(shared_cflag shared_cxxflag shared_cppflag
- shared_defines shared_includes shared_ldflag
- dso_cflags dso_cxxflags dso_cppflags
- dso_defines dso_includes dso_lflags))
+ shared_defines shared_includes shared_ldflag
+ module_cflags module_cxxflags module_cppflags
+ module_defines module_includes module_lflags))
{
delete $config{$_};
$target{$_} = "";
if ($target{ec_asm_src} =~ /ecp_nistz256/) {
push @{$config{defines}}, "ECP_NISTZ256_ASM";
}
+ if ($target{ec_asm_src} =~ /x25519/) {
+ push @{$config{defines}}, "X25519_ASM";
+ }
if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
push @{$config{defines}}, "PADLOCK_ASM";
}
}
}
-my %predefined = compiler_predefined($config{cc});
+my %predefined = compiler_predefined($config{CC});
# Check for makedepend capabilities.
if (!$disabled{makedepend}) {
} elsif ($predefined{__GNUC__} >= 3) {
# We know that GNU C version 3 and up as well as all clang
# versions support dependency generation
- $config{makedepprog} = "\$(CROSS_COMPILE)$config{cc}";
+ $config{makedepprog} = "\$(CROSS_COMPILE)$config{CC}";
} else {
# In all other cases, we look for 'makedepend', and disable the
# capability if not found.
$config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
@{$config{cflags}} ];
$config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
- @{$config{cxxflags}} ] if $config{cxx};
+ @{$config{cxxflags}} ] if $config{CXX};
if (defined($config{api})) {
$config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
if (defined($predefined{__clang__}) && !$disabled{asm}) {
push @{$config{cflags}}, "-Qunused-arguments";
- push @{$config{cxxflags}}, "-Qunused-arguments" if $config{cxx};
+ push @{$config{cxxflags}}, "-Qunused-arguments" if $config{CXX};
}
if ($strict_warnings)
push @{$config{cflags}}, $wopt
unless grep { $_ eq $wopt } @{$config{cflags}};
push @{$config{cxxflags}}, $wopt
- if ($config{cxx}
+ if ($config{CXX}
&& !grep { $_ eq $wopt } @{$config{cxxflags}});
}
if (defined($predefined{__clang__}))
push @{$config{cflags}}, $wopt
unless grep { $_ eq $wopt } @{$config{cflags}};
push @{$config{cxxflags}}, $wopt
- if ($config{cxx}
+ if ($config{CXX}
&& !grep { $_ eq $wopt } @{$config{cxxflags}});
}
}
push @{$config{cflags}}, $wopt
unless grep { $_ eq $wopt } @{$config{cflags}};
push @{$config{cxxflags}}, $wopt
- if ($config{cxx}
+ if ($config{CXX}
&& !grep { $_ eq $wopt } @{$config{cxxflags}});
}
if ($target =~ /^BSD-/)
$config{afalgeng}="";
if ($target =~ m/^linux/) {
my $minver = 4*10000 + 1*100 + 0;
- if ($config{cross_compile_prefix} eq "") {
+ if ($config{CROSS_COMPILE} eq "") {
my $verstr = `uname -r`;
my ($ma, $mi1, $mi2) = split("\\.", $verstr);
($mi2) = $mi2 =~ /(\d+)/;
die "internal error: \$useradd{$_} isn't an ARRAY\n"
unless ref $useradd{$_} eq 'ARRAY';
- my $target_key = $user_to_target{$_} // lc $_;
-
- if (defined $config{$target_key}) {
- push @{$config{$target_key}}, @{$useradd{$_}};
+ if (defined $config{$_}) {
+ push @{$config{$_}}, @{$useradd{$_}};
} else {
- $config{$target_key} = [ @{$useradd{$_}} ];
+ $config{$_} = [ @{$useradd{$_}} ];
}
}
print "Creating configdata.pm\n";
open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
print OUT <<"EOF";
-#! $config{hashbangperl}
+#! $config{HASHBANGPERL}
package configdata;
EOF
}
-print OUT "my \%makevars = (\n";
+print OUT
+ "# The following data is only used when this files is use as a script\n";
+print OUT "my \@makevars = (\n";
foreach (sort keys %user) {
- print OUT ' ',$_,' ' x (20 - length $_),'=> ',
- "'",$user_to_target{$_} || lc $_,"',\n";
+ print OUT " '",$_,"',\n";
}
print OUT ");\n";
print OUT "my \%disabled_info = (\n";
print OUT " },\n";
}
print OUT ");\n";
+print OUT 'my @user_crossable = qw( ', join (' ', @user_crossable), " );\n";
print OUT << 'EOF';
# If run directly, we can give some answers, and even reconfigure
unless (caller) {
-verbose => 2);
}
if ($dump || $cmdline) {
- print "\n(with current working directory = $here)";
- print "\nCommand line:\n\n";
+ print "\nCommand line (with current working directory = $here):\n\n";
print ' ',join(' ',
$config{perl},
catfile($config{sourcedir}, 'Configure'),
@{$config{perlargv}}), "\n";
+ print "\nPerl information:\n\n";
+ print ' ',$config{perl_cmd},"\n";
+ print ' ',$config{perl_version},' for ',$config{perl_archname},"\n";
}
if ($dump || $options) {
my $longest = 0;
my $longest2 = 0;
foreach my $what (@disablables) {
$longest = length($what) if $longest < length($what);
- $longest2 = length($disabled{$what}) if $longest2 < length($disabled{$what});
+ $longest2 = length($disabled{$what})
+ if $disabled{$what} && $longest2 < length($disabled{$what});
}
print "\nEnabled features:\n\n";
foreach my $what (@disablables) {
}
if ($dump || $makevars) {
print "\nMakevars:\n\n";
- foreach (sort keys %makevars) {
- print ' ',$_,' ' x (16 - length $_),'= ',
- (ref $config{$makevars{$_}} eq 'ARRAY'
- ? join(' ', @{$config{$makevars{$_}}})
- : $config{$makevars{$_}}),
+ foreach my $var (@makevars) {
+ my $prefix = '';
+ $prefix = $config{CROSS_COMPILE}
+ if grep { $var eq $_ } @user_crossable;
+ $prefix //= '';
+ print ' ',$var,' ' x (16 - length $var),'= ',
+ (ref $config{$var} eq 'ARRAY'
+ ? join(' ', @{$config{$var}})
+ : $prefix.$config{$var}),
"\n"
- if defined $config{$makevars{$_}};
+ if defined $config{$var};
}
my @buildfile = ($config{builddir}, $config{build_file});
$builders{$builder}->($builder_platform, @builder_opts);
-# Show a note on the use of configdata.pm, but ONLY for release 1.1.1
-# (i.e. this message disappears with the following update, 1.1.1a)
-print <<"EOF" if ($config{version_num} =~ m|^0x1010100.L$|);
-
-NOTE: Starting with OpenSSL 1.1.1, 'Configure' doesn't display all the disabled
-options or the "make variables" with their values. Instead, you must use
-'configdata.pm' as a script to get a display of the configuration data. For
-help, please do this:
-
- perl configdata.pm --help
-EOF
print <<"EOF" if ($disabled{threads} eq "unavailable");
The library could not be configured for supporting multi-threaded
configuration.
EOF
+print <<"EOF";
+
+**********************************************************************
+*** ***
+*** If you want to report a building issue, please include the ***
+*** output from this command: ***
+*** ***
+*** perl configdata.pm --dump ***
+*** ***
+**********************************************************************
+EOF
+
exit(0);
######################################################################
return () if $^O eq 'VMS';
- die 'compiler_predefines called without a default compiler'
+ die 'compiler_predefined called without a default compiler'
unless $default_compiler;
if (! $predefined{$default_compiler}) {
- my $cc = "$config{cross_compile_prefix}$default_compiler";
+ my $cc = "$config{CROSS_COMPILE}$default_compiler";
$predefined{$default_compiler} = {};
"ld",
"lflags",
"loutflag",
- "plib_lflags",
"ex_libs",
"bn_ops",
"apps_aux_src",
projects / openssl.git / blobdiff