# code, so we just tell compiler to be pedantic about everything
# but 'long long' type.
-my $gcc_devteam_warn = "-DDEBUG_UNUSED"
- . " -DPEDANTIC -pedantic -Wno-long-long"
- . " -Wall"
- . " -Wextra"
- . " -Wno-unused-parameter"
- . " -Wno-missing-field-initializers"
- . " -Wswitch"
- . " -Wsign-compare"
- . " -Wmissing-prototypes"
- . " -Wstrict-prototypes"
- . " -Wshadow"
- . " -Wformat"
- . " -Wtype-limits"
- . " -Wundef"
- . " -Werror"
- ;
+my %gcc_devteam_warn = ();
+{
+ my @common = qw( -DDEBUG_UNUSED
+ -DPEDANTIC -pedantic -Wno-long-long
+ -Wall
+ -Wextra
+ -Wno-unused-parameter
+ -Wno-missing-field-initializers
+ -Wswitch
+ -Wsign-compare
+ -Wshadow
+ -Wformat
+ -Wtype-limits
+ -Wundef
+ -Werror );
+ %gcc_devteam_warn = (
+ CFLAGS => [ @common, qw( -Wmissing-prototypes
+ -Wstrict-prototypes ) ],
+ CXXFLAGS => [ @common ]
+ );
+}
# These are used in addition to $gcc_devteam_warn when the compiler is clang.
# TODO(openssl-team): fix problems and investigate if (at least) the
# -Wlanguage-extension-token -- no, we use asm()
# -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
# -Wextended-offsetof -- no, needed in CMS ASN1 code
-my $clang_devteam_warn = ""
- . " -Wswitch-default"
- . " -Wno-parentheses-equality"
- . " -Wno-language-extension-token"
- . " -Wno-extended-offsetof"
- . " -Wconditional-uninitialized"
- . " -Wincompatible-pointer-types-discards-qualifiers"
- . " -Wmissing-variable-declarations"
- . " -Wno-unknown-warning-option"
- ;
+my %clang_devteam_warn = ();
+{
+ my @common = qw( -Wswitch-default
+ -Wno-parentheses-equality
+ -Wno-language-extension-token
+ -Wno-extended-offsetof
+ -Wconditional-uninitialized
+ -Wincompatible-pointer-types-discards-qualifiers
+ -Wno-unknown-warning-option );
+ %clang_devteam_warn = (
+ CFLAGS => [ @common, qw( -Wmissing-variable-declarations ) ],
+ CXXFLAGS => [ @common ]
+ );
+}
# This adds backtrace information to the memory leak info. Is only used
# when crypto-mdebug-backtrace is enabled.
}
elsif (/^--strict-warnings$/)
{
- $strict_warnings = 1;
+ # Pretend that our strict flags is a C flag, and replace it
+ # with the proper flags later on
+ push @{$useradd{CFLAGS}}, '--ossl-strict-warnings';
+ push @{$useradd{CXXFLAGS}}, '--ossl-strict-warnings';
+ $strict_warnings=1;
}
elsif (/^--debug$/)
{
push @{$config{lib_defines}}, "X25519_ASM";
}
if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
- push @{$config{lib_defines}}, "PADLOCK_ASM";
+ push @{$config{dso_defines}}, "PADLOCK_ASM";
}
if ($target{poly1305_asm_src} ne "") {
push @{$config{lib_defines}}, "POLY1305_ASM";
}
}
-my %predefined = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
+my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
+my %predefined_CXX = $config{CXX}
+ ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
+ : ();
# Check for makedepend capabilities.
if (!$disabled{makedepend}) {
# For VC- and vms- targets, there's nothing more to do here. The
# functionality is hard coded in the corresponding build files for
# cl (Windows) and CC/DECC (VMS).
- } elsif (($predefined{__GNUC__} // -1) >= 3
- && !($predefined{__APPLE_CC__} && !$predefined{__clang__})) {
+ } elsif (($predefined_C{__GNUC__} // -1) >= 3
+ && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
# We know that GNU C version 3 and up as well as all clang
# versions support dependency generation, but Xcode did not
# handle $cc -M before clang support (but claims __GNUC__ = 3)
}
}
-if (!$disabled{asm} && !$predefined{__MACH__} && $^O ne 'VMS') {
+if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
# probe for -Wa,--noexecstack option...
- if ($predefined{__clang__}) {
+ if ($predefined_C{__clang__}) {
# clang has builtin assembler, which doesn't recognize --help,
# but it apparently recognizes the option in question on all
# supported platforms even when it's meaningless. In other words
"OPENSSL_MIN_API=".($apitable->{$config{api} // ""} // -1)
];
+my %strict_warnings_collection=( CFLAGS => [], CXXFLAGS => []);
if ($strict_warnings)
{
my $wopt;
- my $gccver = $predefined{__GNUC__} // -1;
+ my $gccver = $predefined_C{__GNUC__} // -1;
+ my $gxxver = $predefined_CXX{__GNUC__} // -1;
- die "ERROR --strict-warnings requires gcc[>=4] or gcc-alike"
+ warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike"
unless $gccver >= 4;
- foreach $wopt (split /\s+/, $gcc_devteam_warn)
+ warn "WARNING --strict-warnings requires g++[>=4] or g++-alike"
+ unless $gxxver >= 4;
+ foreach (qw(CFLAGS CXXFLAGS))
{
- push @{$config{cflags}}, $wopt
- unless grep { $_ eq $wopt } @{$config{cflags}};
- push @{$config{cxxflags}}, $wopt
- if ($config{CXX}
- && !grep { $_ eq $wopt } @{$config{cxxflags}});
- }
- if (defined($predefined{__clang__}))
- {
- foreach $wopt (split /\s+/, $clang_devteam_warn)
- {
- push @{$config{cflags}}, $wopt
- unless grep { $_ eq $wopt } @{$config{cflags}};
- push @{$config{cxxflags}}, $wopt
- if ($config{CXX}
- && !grep { $_ eq $wopt } @{$config{cxxflags}});
- }
+ push @{$strict_warnings_collection{$_}},
+ @{$gcc_devteam_warn{$_}};
}
+ push @{$strict_warnings_collection{CFLAGS}},
+ @{$clang_devteam_warn{CFLAGS}}
+ if (defined($predefined_C{__clang__}));
+ push @{$strict_warnings_collection{CXXFLAGS}},
+ @{$clang_devteam_warn{CXXFLAGS}}
+ if (defined($predefined_CXX{__clang__}));
}
+foreach my $idx (qw(CFLAGS CXXFLAGS))
+ {
+ $useradd{$idx} = [ map { $_ eq '--ossl-strict-warnings'
+ ? @{$strict_warnings_collection{$idx}}
+ : ( $_ ) }
+ @{$useradd{$idx}} ];
+ }
unless ($disabled{"crypto-mdebug-backtrace"})
{
# The basic things we're trying to build
my @programs = ();
my @libraries = ();
- my @engines = ();
+ my @modules = ();
my @scripts = ();
- my @intermediates = ();
my %attributes = ();
my %sources = ();
$attributes{$p}->{$ak} = $av;
}
}
- push @programs, @p;
}
},
qr/^\s*LIBS(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
$attributes{$l}->{$ak} = $av;
}
}
- push @libraries, @l;
}
},
- qr/^\s*ENGINES(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
+ qr/^\s*MODULES(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
=> sub {
if (!@skip || $skip[$#skip] > 0) {
my @a = tokenize($1, qr|\s*,\s*|);
- my @e = tokenize($2);
- push @engines, @e;
+ my @m = tokenize($2);
+ push @modules, @m;
foreach my $a (@a) {
my $ak = $a;
my $av = 1;
$ak = $1;
$av = $2;
}
- foreach my $e (@e) {
- $attributes{$e}->{$ak} = $av;
+ foreach my $m (@m) {
+ $attributes{$m}->{$ak} = $av;
}
}
- push @engines, @e;
}
},
qr/^\s*SCRIPTS(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
$attributes{$s}->{$ak} = $av;
}
}
- push @scripts, @s;
}
},
qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
=> sub { push @{$generate{$1}}, $2
if !@skip || $skip[$#skip] > 0 },
- qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
- => sub { warn "RENAME is no longer supported\n" },
- qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
- => sub { warn "SHARED_NAME is no longer supported\n" },
qr/^\s*(?:#.*)?$/ => sub { },
"OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
"BEFORE" => sub {
);
die "runaway IF?" if (@skip);
- die <<"EOF" if scalar @engines and !$config{dynamic_engines};
+ if (grep { defined $attributes{$_}->{engine} } keys %attributes
+ and !$config{dynamic_engines}) {
+ die <<"EOF"
ENGINES can only be used if configured with 'dynamic-engine'.
This is usually a fault in a build.info file.
EOF
+ }
foreach (keys %attributes) {
my $dest = $_;
{
my %infos = ( programs => [ @programs ],
libraries => [ @libraries ],
- engines => [ @engines ],
+ modules => [ @modules ],
scripts => [ @scripts ] );
foreach my $k (keys %infos) {
foreach (@{$infos{$k}}) {
if defined($unified_info{$_});
delete $unified_info{$_};
}
- foreach my $prodtype (('programs', 'libraries', 'engines', 'scripts')) {
+ foreach my $prodtype (('programs', 'libraries', 'modules', 'scripts')) {
# $intent serves multi purposes:
# - give a prefix for the new object files names
# - in the case of libraries, rearrange the object files so static
src => [ 'sources',
'shared_sources' ],
dst => 'shared_sources' } },
- engines => { dso => { src => [ 'sources',
+ modules => { dso => { src => [ 'sources',
'shared_sources' ],
dst => 'shared_sources' } },
scripts => { script => { src => [ 'sources' ],
### Make unified_info a bit more efficient
# One level structures
- foreach (("programs", "libraries", "engines", "scripts")) {
+ foreach (("programs", "libraries", "modules", "scripts")) {
$unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
}
# Two level structures
# they end up in where applicable. Then, add build rules for those
# directories
my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
- "dso" => [ @{$unified_info{engines}} ],
+ "dso" => [ @{$unified_info{modules}} ],
"bin" => [ @{$unified_info{programs}} ],
"script" => [ @{$unified_info{scripts}} ] );
foreach my $type (keys %loopinfo) {